/*
* Copyright (C) 2012-2014 NXP Semiconductors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef NXP_HW_SELF_TEST
#include <phNxpNciHal_SelfTest.h>
#include <phNxpLog.h>
#include <pthread.h>
#include <phOsalNfc_Timer.h>
#include <phNxpConfig.h>
#define HAL_WRITE_RSP_TIMEOUT (2000) /* Timeout value to wait for response from PN54X */
#define HAL_WRITE_MAX_RETRY (10)
/******************* Structures and definitions *******************************/
typedef uint8_t (*st_validator_t)(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
phAntenna_St_Resp_t phAntenna_resp;
typedef struct nci_test_data
{
nci_data_t cmd;
nci_data_t exp_rsp;
nci_data_t exp_ntf;
st_validator_t rsp_validator;
st_validator_t ntf_validator;
}nci_test_data_t;
/******************* Global variables *****************************************/
static int thread_running = 0;
static uint32_t timeoutTimerId = 0;
static int hal_write_timer_fired = 0;
/* TML Context */
extern phTmlNfc_Context_t *gpphTmlNfc_Context;
/* Global HAL Ref */
extern phNxpNciHal_Control_t nxpncihal_ctrl;
/* Driver parameters */
phLibNfc_sConfig_t gDrvCfg;
NFCSTATUS gtxldo_status = NFCSTATUS_FAILED;
NFCSTATUS gagc_value_status = NFCSTATUS_FAILED;
NFCSTATUS gagc_nfcld_status = NFCSTATUS_FAILED;
NFCSTATUS gagc_differential_status = NFCSTATUS_FAILED;
static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_null(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_testSWP1_vltg(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_testAntenna_Txldo(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_testAntenna_AgcVal(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static uint8_t st_validator_testAntenna_AgcVal_Differential(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
#if(NFC_NXP_CHIP_TYPE != PN547C2)
NFCSTATUS phNxpNciHal_getPrbsCmd (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len);
#else
NFCSTATUS phNxpNciHal_getPrbsCmd (uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len);
#endif
/* Test data to validate SWP line 2*/
static nci_test_data_t swp2_test_data[] = {
{
{
0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */
#else
0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00}
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 }
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x03, {0x2F,0x02,0x00} /* cmd */
},
{
0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x04, {0x2F,0x3E,0x01,0x01} /* cmd */
},
{
0x04, {0x4F,0x3E,0x01,0x00} /* exp_rsp */
},
{
0x04, {0x6F,0x3E,0x02,0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_testEquals
},
};
/* Test data to validate SWP line 1*/
static nci_test_data_t swp1_test_data[] = {
{
{
0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */
#else
0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00}
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 }
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x03, {0x2F,0x02,0x00} /* cmd */
},
{
0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x04, {0x2F,0x3E,0x01,0x00} /* cmd */
},
{
0x04, {0x4F,0x3E,0x01,0x00} /* exp_rsp */
},
{
0x04, {0x6F,0x3E,0x02,0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_testSWP1_vltg
},
};
static nci_test_data_t prbs_test_data[] = {
{
{
0x04, {0x20,0x00,0x01,0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
#else
0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00} /* cmd */
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#if(NFC_NXP_CHIP_TYPE != PN547C2)
},
{
{
0x04, {0x2F,0x00,0x01,0x00} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#endif
}
};
/* for rf field test, first requires to disable the standby mode */
static nci_test_data_t rf_field_on_test_data[] = {
{
{
0x04, {0x20,0x00,0x01,0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
#else
0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00} /* cmd */
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#if(NFC_NXP_CHIP_TYPE != PN547C2)
{
{
0x03, {0x2F,0x02,0x00} /* cmd */
},
{
0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x04, {0x2F,0x00,0x01,0x00} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#endif
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x2F,0x3D,0x02,0x20,0x01} /* cmd */
#else
0x08, {0x2F,0x3D,0x05,0x20,0x01,0x00,0x00,0x00} /* cmd */
#endif
},
{
0x04, {0x4F,0x3D,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#if(NFC_NXP_CHIP_TYPE != PN547C2)
},
{
{
0x04, {0x2F,0x00,0x01,0x01} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#endif
}
};
static nci_test_data_t rf_field_off_test_data[] = {
{
{
0x04, {0x20,0x00,0x01,0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
#else
0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00} /* cmd */
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#if(NFC_NXP_CHIP_TYPE != PN547C2)
{
{
0x03, {0x2F,0x02,0x00} /* cmd */
},
{
0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x04, {0x2F,0x00,0x01,0x00} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#endif
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x2F,0x3D,0x02,0x20,0x00} /* cmd */
#else
0x08, {0x2F,0x3D,0x05,0x20,0x00,0x00,0x00,0x00} /* cmd */
#endif
},
{
0x04, {0x4F,0x3D,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#if(NFC_NXP_CHIP_TYPE != PN547C2)
},
{
{
0x04, {0x2F,0x00,0x01,0x01} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#endif
}
};
/* Download pin test data 1 */
static nci_test_data_t download_pin_test_data1[] = {
{
{
0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */
#else
0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
};
/* Download pin test data 2 */
static nci_test_data_t download_pin_test_data2[] = {
{
{
0x08, {0x00, 0x04, 0xD0, 0x11, 0x00, 0x00, 0x5B, 0x46} /* cmd */
},
{
0x08, {0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x87, 0x16} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
};
/* Antenna self test data*/
static nci_test_data_t antenna_self_test_data[] = {
{
{
0x04, {0x20,0x00,0x01,0x00} /* cmd */
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x06, {0x40,0x00,0x03,0x00,0x11,0x00} /* exp_rsp */
#else
0x06, {0x40,0x00,0x03,0x00,0x10,0x00} /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x05, {0x20,0x01,0x02,0x00,0x00} /* cmd */
#else
0x03, {0x20,0x01,0x00} /* cmd */
#endif
},
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x4, {0x40,0x01,0x19,0x00 } /* exp_rsp */
#else
0x4, {0x40,0x01,0x17,0x00 } /* exp_rsp */
#endif
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
{
{
0x03, {0x2F,0x02,0x00} /* cmd */
},
{
0x04, {0x4F,0x02,0x05,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#if(NFC_NXP_CHIP_TYPE != PN547C2)
{
{
0x04, {0x2F,0x00,0x01,0x00} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
},
#endif
{
{
0x05, {0x2F, 0x3D, 0x02, 0x01, 0x80} /* TxLDO cureent measurement cmd */
},
{
0x03, {0x4F, 0x3D, 05} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testAntenna_Txldo,
st_validator_null
},
{
{
#if(NFC_NXP_CHIP_TYPE != PN547C2)
0x07, {0x2F, 0x3D, 0x04, 0x02, 0xC8, 0x60, 0x03} /* AGC measurement cmd */
#else
0x07, {0x2F, 0x3D, 0x04, 0x02, 0xCD, 0x60, 0x03} /* AGC measurement cmd */
#endif
},
{
0x03, {0x4F, 0x3D, 05} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testAntenna_AgcVal,
st_validator_null
},
{
{
0x07, {0x2F, 0x3D, 0x04, 0x04, 0x20, 0x08, 0x20} /* AGC with NFCLD measurement cmd */
},
{
0x03, {0x4F, 0x3D, 05} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testAntenna_AgcVal_FixedNfcLd,
st_validator_null
},
{
{
0x07, {0x2F, 0x3D, 0x04, 0x08, 0x8C, 0x60, 0x03} /* AGC with NFCLD measurement cmd */
},
{
0x03, {0x4F, 0x3D, 05} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testAntenna_AgcVal_Differential,
st_validator_null
#if(NFC_NXP_CHIP_TYPE != PN547C2)
},
{
{
0x04, {0x2F,0x00,0x01,0x01} /* cmd */
},
{
0x04, {0x4F,0x00,0x01,0x00} /* exp_rsp */
},
{
0x00, {0x00} /* ext_ntf */
},
st_validator_testEquals, /* validator */
st_validator_null
#endif
}
};
/************** Self test functions ***************************************/
static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act);
static void hal_write_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo);
static void hal_write_rsp_timeout_cb(uint32_t TimerId, void *pContext);
static void hal_read_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo);
/*******************************************************************************
**
** Function st_validator_null
**
** Description Null Validator
**
** Returns One
**
*******************************************************************************/
static uint8_t st_validator_null(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
UNUSED(exp);
UNUSED(act);
return 1;
}
/*******************************************************************************
**
** Function st_validator_testSWP1_vltg
**
** Description Validator function to validate swp1 connection.
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testSWP1_vltg(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
if(NULL == exp || NULL == act)
{
return result;
}
if( (act->wLength == 0x05) &&
(memcmp(exp->p_data,act->pBuff,exp->len) == 0))
{
if(act->pBuff[4] == 0x01 || act->pBuff[4] == 0x02)
{
result = 1;
}
}
return result;
}
/*******************************************************************************
**
** Function st_validator_testAntenna_Txldo
**
** Description Validator function to validate Antenna TxLDO current measurement.
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testAntenna_Txldo(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
uint8_t mesuredrange =0;
long measured_val = 0;
int tolerance = 0;
if(NULL == exp || NULL == act)
{
return result;
}
NXPLOG_NCIHAL_D("st_validator_testAntenna_Txldo = 0x%x", act->pBuff[3]);
if (0x05 == act->pBuff[2])
{
if (NFCSTATUS_SUCCESS == act->pBuff[3])
{
result = 1;
NXPLOG_NCIHAL_D("Antenna: TxLDO current measured raw value in mA : 0x%x", act->pBuff[4]);
if(0x00 == act->pBuff[5])
{
NXPLOG_NCIHAL_D("Measured range : 0x00 = 50 - 100 mA");
measured_val = ((0.40 * act->pBuff[4]) + 50);
NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", measured_val);
}
else
{
NXPLOG_NCIHAL_D("Measured range : 0x01 = 20 - 70 mA");
measured_val = ((0.40 * act->pBuff[4]) + 20);
NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", measured_val);
}
tolerance = (phAntenna_resp.wTxdoMeasuredRangeMax *
phAntenna_resp.wTxdoMeasuredTolerance)/100;
if ((measured_val <= phAntenna_resp.wTxdoMeasuredRangeMax + tolerance))
{
tolerance = (phAntenna_resp.wTxdoMeasuredRangeMin *
phAntenna_resp.wTxdoMeasuredTolerance)/100;
if((measured_val >= phAntenna_resp.wTxdoMeasuredRangeMin - tolerance))
{
gtxldo_status = NFCSTATUS_SUCCESS;
NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement PASS");
}
else
{
gtxldo_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL");
}
}
else
{
gtxldo_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL");
}
}
else
{
gtxldo_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement failed: Invalid status");
}
}
else
{
gtxldo_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement failed: Invalid payload length");
}
return result;
}
/*******************************************************************************
**
** Function st_validator_testAntenna_AgcVal
**
** Description Validator function reads AGC value of antenna and print the info
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testAntenna_AgcVal(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
int agc_tolerance = 0;
long agc_val = 0;
if(NULL == exp || NULL == act)
{
return result;
}
if (0x05 == act->pBuff[2])
{
if (NFCSTATUS_SUCCESS == act->pBuff[3])
{
result = 1;
agc_tolerance = (phAntenna_resp.wAgcValue * phAntenna_resp.wAgcValueTolerance)/100;
agc_val = ((act->pBuff[5] << 8) | (act->pBuff[4]));
NXPLOG_NCIHAL_D("AGC value : %ld", agc_val);
if(((phAntenna_resp.wAgcValue - agc_tolerance) <= agc_val) &&
(agc_val <= (phAntenna_resp.wAgcValue + agc_tolerance)))
{
gagc_value_status = NFCSTATUS_SUCCESS;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values PASS");
}
else
{
gagc_value_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL");
}
}
else
{
gagc_value_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL");
}
}
else
{
gagc_value_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC value failed: Invalid payload length");
}
return result;
}
/*******************************************************************************
**
** Function st_validator_testAntenna_AgcVal_FixedNfcLd
**
** Description Validator function reads and print AGC value of
** antenna with fixed NFCLD
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
int agc_nfcld_tolerance = 0;
long agc_nfcld = 0;
if(NULL == exp || NULL == act)
{
return result;
}
if(0x05 == act->pBuff[2])
{
if(NFCSTATUS_SUCCESS == act->pBuff[3])
{
result = 1;
agc_nfcld_tolerance = (phAntenna_resp.wAgcValuewithfixedNFCLD *
phAntenna_resp.wAgcValuewithfixedNFCLDTolerance)/100;
agc_nfcld = ((act->pBuff[5] << 8) | (act->pBuff[4]));
NXPLOG_NCIHAL_D("AGC value with Fixed Nfcld : %ld", agc_nfcld);
if(((phAntenna_resp.wAgcValuewithfixedNFCLD - agc_nfcld_tolerance) <= agc_nfcld) &&
(agc_nfcld <= (phAntenna_resp.wAgcValuewithfixedNFCLD + agc_nfcld_tolerance)))
{
gagc_nfcld_status = NFCSTATUS_SUCCESS;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD PASS");
}
else
{
gagc_nfcld_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD FAIL");
}
}
else
{
gagc_nfcld_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD failed: Invalid status");
}
}
else
{
gagc_nfcld_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC value with fixed NFCLD failed: Invalid payload length");
}
return result;
}
/*******************************************************************************
**
** Function st_validator_testAntenna_AgcVal_Differential
**
** Description Reads the AGC value with open/short RM from buffer and print
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testAntenna_AgcVal_Differential(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
int agc_toleranceopne1 = 0;
int agc_toleranceopne2 = 0;
long agc_differentialOpne1 = 0;
long agc_differentialOpne2 = 0;
if(NULL == exp || NULL == act)
{
return result;
}
if (0x05 == act->pBuff[2])
{
if (NFCSTATUS_SUCCESS == act->pBuff[3])
{
result = 1;
agc_toleranceopne1=(phAntenna_resp.wAgcDifferentialWithOpen1 *
phAntenna_resp.wAgcDifferentialWithOpenTolerance1)/100;
agc_toleranceopne2=(phAntenna_resp.wAgcDifferentialWithOpen2 *
phAntenna_resp.wAgcDifferentialWithOpenTolerance2)/100;
agc_differentialOpne1 = ((act->pBuff[5] << 8) | (act->pBuff[4]));
agc_differentialOpne2 = ((act->pBuff[7] << 8) | (act->pBuff[6]));
NXPLOG_NCIHAL_D("AGC value differential Opne 1 : %ld", agc_differentialOpne1);
NXPLOG_NCIHAL_D("AGC value differentialOpne 2 : %ld", agc_differentialOpne2);
if(((agc_differentialOpne1 >= phAntenna_resp.wAgcDifferentialWithOpen1 - agc_toleranceopne1) &&
(agc_differentialOpne1 <= phAntenna_resp.wAgcDifferentialWithOpen1 + agc_toleranceopne1)) &&
((agc_differentialOpne2 >= phAntenna_resp.wAgcDifferentialWithOpen2 - agc_toleranceopne2) &&
(agc_differentialOpne2 <= phAntenna_resp.wAgcDifferentialWithOpen2 + agc_toleranceopne2)))
{
gagc_differential_status = NFCSTATUS_SUCCESS;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential Open PASS");
}
else
{
gagc_differential_status = NFCSTATUS_FAILED;
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential Open FAIL");
}
}
else
{
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential failed: Invalid status");
gagc_differential_status = NFCSTATUS_FAILED;
}
}
else
{
NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential failed: Invalid payload length");
gagc_differential_status = NFCSTATUS_FAILED;
}
return result;
}
/*******************************************************************************
**
** Function st_validator_testEquals
**
** Description Validator function to validate for equality between actual
** and expected values.
**
** Returns One if successful otherwise Zero.
**
*******************************************************************************/
static uint8_t st_validator_testEquals(nci_data_t *exp, phTmlNfc_TransactInfo_t *act)
{
uint8_t result = 0;
if(NULL == exp || NULL == act)
{
return result;
}
if(exp->len <= act->wLength &&
(memcmp(exp->p_data,act->pBuff,exp->len) == 0))
{
result = 1;
}
return result;
}
/*******************************************************************************
**
** Function hal_write_rsp_timeout_cb
**
** Description Callback function for hal write response timer.
**
** Returns None
**
*******************************************************************************/
static void hal_write_rsp_timeout_cb(uint32_t timerId, void *pContext)
{
UNUSED(timerId);
NXPLOG_NCIHAL_E("hal_write_rsp_timeout_cb - write timeout!!!");
hal_write_timer_fired = 1;
hal_read_cb(pContext,NULL);
}
/*******************************************************************************
**
** Function hal_write_cb
**
** Description Callback function for hal write.
**
** Returns None
**
*******************************************************************************/
static void hal_write_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
if (pInfo->wStatus == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("write successful status = 0x%x", pInfo->wStatus);
}
else
{
NXPLOG_NCIHAL_E("write error status = 0x%x", pInfo->wStatus);
}
p_cb_data->status = pInfo->wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function hal_read_cb
**
** Description Callback function for hal read.
**
** Returns None
**
*******************************************************************************/
static void hal_read_cb(void *pContext, phTmlNfc_TransactInfo_t *pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS status;
if(hal_write_timer_fired == 1)
{
NXPLOG_NCIHAL_D("hal_read_cb - response timeout occurred");
hal_write_timer_fired = 0;
p_cb_data->status = NFCSTATUS_RESPONSE_TIMEOUT;
status = phTmlNfc_ReadAbort();
}
else
{
NFCSTATUS status = phOsalNfc_Timer_Stop(timeoutTimerId);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_NCIHAL_D("Response timer stopped");
}
else
{
NXPLOG_NCIHAL_E("Response timer stop ERROR!!!");
p_cb_data->status = NFCSTATUS_FAILED;
}
if (pInfo == NULL)
{
NXPLOG_NCIHAL_E ("Empty TransactInfo");
p_cb_data->status = NFCSTATUS_FAILED;
}
else
{
if (pInfo->wStatus == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D ("hal_read_cb successful status = 0x%x", pInfo->wStatus);
p_cb_data->status = NFCSTATUS_SUCCESS;
}
else
{
NXPLOG_NCIHAL_E ("hal_read_cb error status = 0x%x", pInfo->wStatus);
p_cb_data->status = NFCSTATUS_FAILED;
}
p_cb_data->status = pInfo->wStatus;
nci_test_data_t *test_data = (nci_test_data_t*) p_cb_data->pContext;
if (test_data->exp_rsp.len == 0)
{
/* Compare the actual notification with expected notification.*/
if(test_data->ntf_validator (&(test_data->exp_ntf), pInfo) == 1 )
{
p_cb_data->status = NFCSTATUS_SUCCESS;
}
else
{
p_cb_data->status = NFCSTATUS_FAILED;
}
}
/* Compare the actual response with expected response.*/
else if (test_data->rsp_validator (&(test_data->exp_rsp), pInfo) == 1)
{
p_cb_data->status = NFCSTATUS_SUCCESS;
}
else
{
p_cb_data->status = NFCSTATUS_FAILED;
}
test_data->exp_rsp.len = 0;
}
}
SEM_POST (p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_test_rx_thread
**
** Description Thread to fetch and process messages from message queue.
**
** Returns NULL
**
*******************************************************************************/
static void *phNxpNciHal_test_rx_thread(void *arg)
{
phLibNfc_Message_t msg;
UNUSED(arg);
NXPLOG_NCIHAL_D("Self test thread started");
thread_running = 1;
while (thread_running == 1)
{
/* Fetch next message from the NFC stack message queue */
if (phDal4Nfc_msgrcv(gDrvCfg.nClientId,
&msg, 0, 0) == -1)
{
NXPLOG_NCIHAL_E("Received bad message");
continue;
}
if(thread_running == 0)
{
break;
}
switch (msg.eMsgType)
{
case PH_LIBNFC_DEFERREDCALL_MSG:
{
phLibNfc_DeferredCall_t *deferCall =
(phLibNfc_DeferredCall_t *) (msg.pMsgData);
REENTRANCE_LOCK();
deferCall->pCallback(deferCall->pParameter);
REENTRANCE_UNLOCK();
break;
}
}
}
NXPLOG_NCIHAL_D("Self test thread stopped");
return NULL;
}
/*******************************************************************************
**
** Function phNxpNciHal_readLocked
**
** Description Reads response and notification from NFCC and waits for
** read completion, for a definitive timeout value.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout.
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_readLocked(nci_test_data_t *pData )
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
uint16_t read_len = 16;
/* RX Buffer */
uint32_t rx_data[NCI_MAX_DATA_LEN];
/* Create the local semaphore */
if (phNxpNciHal_init_cb_data(&cb_data, pData) != NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phTmlNfc_Read Create cb data failed");
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* call read pending */
status = phTmlNfc_Read(
(uint8_t *) rx_data,
(uint16_t) read_len,
(pphTmlNfc_TransactCompletionCb_t) &hal_read_cb,
&cb_data);
if (status != NFCSTATUS_PENDING)
{
NXPLOG_NCIHAL_E("TML Read status error status = %x", status);
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
status = phOsalNfc_Timer_Start(timeoutTimerId,
HAL_WRITE_RSP_TIMEOUT,
&hal_write_rsp_timeout_cb,
&cb_data);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_NCIHAL_D("Response timer started");
}
else
{
NXPLOG_NCIHAL_E("Response timer not started");
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_NCIHAL_E("phTmlNfc_Read semaphore error");
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
if(cb_data.status == NFCSTATUS_RESPONSE_TIMEOUT)
{
NXPLOG_NCIHAL_E("Response timeout!!!");
status = NFCSTATUS_RESPONSE_TIMEOUT;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_E("phTmlNfc_Read failed ");
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_writeLocked
**
** Description Send command to NFCC and waits for cmd write completion, for
** a definitive timeout value.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout.
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_writeLocked(nci_test_data_t *pData )
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
int retryCnt = 0;
/* Create the local semaphore */
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phTmlNfc_Write Create cb data failed");
goto clean_and_return;
}
retry:
status = phTmlNfc_Write(pData->cmd.p_data, pData->cmd.len,
(pphTmlNfc_TransactCompletionCb_t) &hal_write_cb, &cb_data);
if (status != NFCSTATUS_PENDING)
{
NXPLOG_NCIHAL_E("phTmlNfc_Write status error");
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_NCIHAL_E("write_unlocked semaphore error");
status = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS && retryCnt < HAL_WRITE_MAX_RETRY)
{
retryCnt++;
NXPLOG_NCIHAL_E("write_unlocked failed - PN54X Maybe in Standby Mode - Retry %d",retryCnt);
goto retry;
}
status = cb_data.status;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_performTest
**
** Description Performs a single cycle of command,response and
** notification.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED,
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_performTest(nci_test_data_t *pData )
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if(NULL == pData)
{
return NFCSTATUS_FAILED;
}
CONCURRENCY_LOCK();
status = phNxpNciHal_writeLocked(pData);
if(status == NFCSTATUS_RESPONSE_TIMEOUT)
{
goto clean_and_return;
}
if(status != NFCSTATUS_SUCCESS)
{
goto clean_and_return;
}
status = phNxpNciHal_readLocked(pData);
if(status != NFCSTATUS_SUCCESS)
{
goto clean_and_return;
}
if(0 != pData->exp_ntf.len)
{
status = phNxpNciHal_readLocked(pData);
if(status != NFCSTATUS_SUCCESS)
{
goto clean_and_return;
}
}
clean_and_return:
CONCURRENCY_UNLOCK();
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_TestMode_open
**
** Description It opens the physical connection with NFCC (PN54X) and
** creates required client thread for operation.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_TestMode_open (void)
{
/* Thread */
pthread_t test_rx_thread;
phOsalNfc_Config_t tOsalConfig;
phTmlNfc_Config_t tTmlConfig;
char *nfc_dev_node = NULL;
const uint16_t max_len = 260;
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint16_t read_len = 255;
int8_t ret_val = 0x00;
/* initialize trace level */
phNxpLog_InitializeLogLevel();
if (phNxpNciHal_init_monitor() == NULL)
{
NXPLOG_NCIHAL_E("Init monitor failed");
return NFCSTATUS_FAILED;
}
CONCURRENCY_LOCK();
memset(&tOsalConfig, 0x00, sizeof(tOsalConfig));
memset(&tTmlConfig, 0x00, sizeof(tTmlConfig));
/* Read the nfc device node name */
nfc_dev_node = (char*) malloc (max_len * sizeof (char*));
if (nfc_dev_node == NULL)
{
NXPLOG_NCIHAL_E ("malloc of nfc_dev_node failed ");
goto clean_and_return;
}
else if (!GetNxpStrValue (NAME_NXP_NFC_DEV_NODE, nfc_dev_node, sizeof (nfc_dev_node)))
{
NXPLOG_NCIHAL_E ("Invalid nfc device node name keeping the default device node /dev/pn544");
strcpy (nfc_dev_node, "/dev/pn544");
}
gDrvCfg.nClientId = phDal4Nfc_msgget(0, 0600);
gDrvCfg.nLinkType = ENUM_LINK_TYPE_I2C;/* For PN54X */
tTmlConfig.pDevName = (int8_t *) nfc_dev_node;
tOsalConfig.dwCallbackThreadId = (uintptr_t) gDrvCfg.nClientId;
tOsalConfig.pLogFile = NULL;
tTmlConfig.dwGetMsgThreadId = (uintptr_t) gDrvCfg.nClientId;
nxpncihal_ctrl.gDrvCfg.nClientId = (uintptr_t) gDrvCfg.nClientId;
/* Initialize TML layer */
status = phTmlNfc_Init(&tTmlConfig);
if (status != NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_E("phTmlNfc_Init Failed");
goto clean_and_return;
}
else
{
if (nfc_dev_node != NULL)
{
free (nfc_dev_node);
nfc_dev_node = NULL;
}
}
pthread_attr_t attr;
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
ret_val = pthread_create (&test_rx_thread, &attr,
phNxpNciHal_test_rx_thread, NULL);
pthread_attr_destroy (&attr);
if (ret_val != 0)
{
NXPLOG_NCIHAL_E("pthread_create failed");
phTmlNfc_Shutdown();
goto clean_and_return;
}
timeoutTimerId = phOsalNfc_Timer_Create();
if(timeoutTimerId == 0xFFFF)
{
NXPLOG_NCIHAL_E("phOsalNfc_Timer_Create failed");
}
else
{
NXPLOG_NCIHAL_D("phOsalNfc_Timer_Create SUCCESS");
}
CONCURRENCY_UNLOCK();
return NFCSTATUS_SUCCESS;
clean_and_return:
CONCURRENCY_UNLOCK ();
if (nfc_dev_node != NULL)
{
free (nfc_dev_node);
nfc_dev_node = NULL;
}
phNxpNciHal_cleanup_monitor ();
return NFCSTATUS_FAILED;
}
/*******************************************************************************
**
** Function phNxpNciHal_TestMode_close
**
** Description This function close the NFCC interface and free all
** resources.
**
** Returns None.
**
*******************************************************************************/
void phNxpNciHal_TestMode_close ()
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
CONCURRENCY_LOCK();
if (NULL != gpphTmlNfc_Context->pDevHandle)
{
/* Abort any pending read and write */
status = phTmlNfc_ReadAbort();
status = phTmlNfc_WriteAbort();
phOsalNfc_Timer_Cleanup();
status = phTmlNfc_Shutdown();
NXPLOG_NCIHAL_D("phNxpNciHal_close return status = %d", status);
thread_running = 0;
phDal4Nfc_msgrelease(gDrvCfg.nClientId);
status = phOsalNfc_Timer_Delete(timeoutTimerId);
}
CONCURRENCY_UNLOCK();
phNxpNciHal_cleanup_monitor();
/* Return success always */
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_SwpTest
**
** Description Test function to validate the SWP line. SWP line number is
** is sent as parameter to the API.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_SwpTest(uint8_t swp_line)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
int len = 0;
int cnt = 0;
NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - start\n");
if(swp_line == 0x01)
{
len = (sizeof(swp1_test_data)/sizeof(swp1_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(swp1_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
status == NFCSTATUS_FAILED
)
{
break;
}
}
}
else if(swp_line == 0x02)
{
len = (sizeof(swp2_test_data)/sizeof(swp2_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(swp2_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
status == NFCSTATUS_FAILED
)
{
break;
}
}
}
else
{
status = NFCSTATUS_FAILED;
}
if( status == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - SUCCESSS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - end\n");
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_PrbsTestStart
**
** Description Test function start RF generation for RF technology and bit
** rate. RF technology and bit rate are sent as parameter to
** the API.
**
** Returns NFCSTATUS_SUCCESS if RF generation successful,
** otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
#if(NFC_NXP_CHIP_TYPE != PN547C2)
NFCSTATUS phNxpNciHal_PrbsTestStart (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
phNxpNfc_Tech_t tech, phNxpNfc_Bitrate_t bitrate)
#else
NFCSTATUS phNxpNciHal_PrbsTestStart (phNxpNfc_Tech_t tech, phNxpNfc_Bitrate_t bitrate)
#endif
{
NFCSTATUS status = NFCSTATUS_FAILED;
nci_test_data_t prbs_cmd_data;
#if(NFC_NXP_CHIP_TYPE != PN547C2)
uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00};
prbs_cmd_data.cmd.len = 0x09;
#else
uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00};
prbs_cmd_data.cmd.len = 0x07;
#endif
memcpy(prbs_cmd_data.exp_rsp.p_data, &rsp_cmd_info[0], sizeof(rsp_cmd_info));
prbs_cmd_data.exp_rsp.len = sizeof(rsp_cmd_info);
//prbs_cmd_data.exp_rsp.len = 0x00;
prbs_cmd_data.exp_ntf.len = 0x00;
prbs_cmd_data.rsp_validator = st_validator_testEquals;
prbs_cmd_data.ntf_validator = st_validator_null;
uint8_t len = 0;
uint8_t cnt = 0;
// [NCI] -> [0x2F 0x30 0x04 0x00 0x00 0x01 0xFF]
#if(NFC_NXP_CHIP_TYPE != PN547C2)
status = phNxpNciHal_getPrbsCmd(prbs_type, hw_prbs_type, tech, bitrate,
prbs_cmd_data.cmd.p_data,prbs_cmd_data.cmd.len);
#else
status = phNxpNciHal_getPrbsCmd(tech, bitrate,prbs_cmd_data.cmd.p_data,prbs_cmd_data.cmd.len);
#endif
if( status == NFCSTATUS_FAILED)
{
//Invalid Param.
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - INVALID_PARAM\n");
goto clean_and_return;
}
len = (sizeof(prbs_test_data)/sizeof(prbs_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(prbs_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT ||
status == NFCSTATUS_FAILED
)
{
break;
}
}
/* Ignoring status, as there will be no response - Applicable till FW version 8.1.1*/
status = phNxpNciHal_performTest(&prbs_cmd_data);
clean_and_return:
if( status == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - SUCCESSS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - end\n");
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_PrbsTestStop
**
** Description Test function stop RF generation for RF technology started
** by phNxpNciHal_PrbsTestStart.
**
** Returns NFCSTATUS_SUCCESS if operation successful,
** otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_PrbsTestStop ()
{
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - Start\n");
NFCSTATUS status = NFCSTATUS_SUCCESS;
status = phTmlNfc_IoCtl(phTmlNfc_e_ResetDevice);
if(NFCSTATUS_SUCCESS == status)
{
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - SUCCESS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - end\n");
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_getPrbsCmd
**
** Description Test function frames the PRBS command.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
#if(NFC_NXP_CHIP_TYPE != PN547C2)
NFCSTATUS phNxpNciHal_getPrbsCmd (phNxpNfc_PrbsType_t prbs_type, phNxpNfc_PrbsHwType_t hw_prbs_type,
uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len)
#else
NFCSTATUS phNxpNciHal_getPrbsCmd (uint8_t tech, uint8_t bitrate, uint8_t *prbs_cmd, uint8_t prbs_cmd_len)
#endif
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
int position_tech_param = 0;
int position_bit_param = 0;
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - tech 0x%x bitrate = 0x%x", tech, bitrate);
if(NULL == prbs_cmd ||
#if(NFC_NXP_CHIP_TYPE != PN547C2)
prbs_cmd_len != 0x09)
#else
prbs_cmd_len != 0x07)
#endif
{
return status;
}
prbs_cmd[0] = 0x2F;
prbs_cmd[1] = 0x30;
#if(NFC_NXP_CHIP_TYPE != PN547C2)
prbs_cmd[2] = 0x06;
prbs_cmd[3] = (uint8_t)prbs_type;
//0xFF Error value used for validation.
prbs_cmd[4] = (uint8_t)hw_prbs_type;
prbs_cmd[5] = 0xFF;//TECH
prbs_cmd[6] = 0xFF;//BITRATE
prbs_cmd[7] = 0x01;
prbs_cmd[8] = 0xFF;
position_tech_param = 5;
position_bit_param = 6;
#else
prbs_cmd[2] = 0x04;
//0xFF Error value used for validation.
prbs_cmd[3] = 0xFF;//TECH
//0xFF Error value used for validation.
prbs_cmd[4] = 0xFF;//BITRATE
prbs_cmd[5] = 0x01;
prbs_cmd[6] = 0xFF;
position_tech_param = 3;
position_bit_param = 4;
#endif
switch (tech) {
case NFC_RF_TECHNOLOGY_A:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_A");
prbs_cmd[position_tech_param] = 0x00;
break;
case NFC_RF_TECHNOLOGY_B:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_B");
prbs_cmd[position_tech_param] = 0x01;
break;
case NFC_RF_TECHNOLOGY_F:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_F");
prbs_cmd[position_tech_param] = 0x02;
break;
default:
break;
}
switch (bitrate)
{
case NFC_BIT_RATE_106:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_106");
if(prbs_cmd[position_tech_param] != 0x02)
{
prbs_cmd[position_bit_param] = 0x00;
}
break;
case NFC_BIT_RATE_212:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_212");
prbs_cmd[position_bit_param] = 0x01;
break;
case NFC_BIT_RATE_424:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_424");
prbs_cmd[position_bit_param] = 0x02;
break;
case NFC_BIT_RATE_848:
NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_848");
if(prbs_cmd[position_tech_param] != 0x02)
{
prbs_cmd[position_bit_param] = 0x03;
}
break;
default:
break;
}
if(prbs_cmd[position_tech_param] == 0xFF || prbs_cmd[position_bit_param] == 0xFF)
{
//Invalid Param.
status = NFCSTATUS_FAILED;
}
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_RfFieldTest
**
** Description Test function performs RF filed test.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_RfFieldTest (uint8_t on)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
int len = 0;
int cnt = 0;
NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - start %x\n",on);
if(on == 0x01)
{
len = (sizeof(rf_field_on_test_data)/sizeof(rf_field_on_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(rf_field_on_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
{
break;
}
}
}
else if(on == 0x00)
{
len = (sizeof(rf_field_off_test_data)/sizeof(rf_field_off_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(rf_field_off_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
{
break;
}
}
}
else
{
status = NFCSTATUS_FAILED;
}
if( status == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - SUCCESSS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - end\n");
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_AntennaTest
**
** Description
**
** Returns
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_AntennaTest ()
{
NFCSTATUS status = NFCSTATUS_FAILED;
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_DownloadPinTest
**
** Description Test function to validate the FW download pin connection.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_DownloadPinTest(void)
{
NFCSTATUS status = NFCSTATUS_FAILED;
int len = 0;
int cnt = 0;
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - start\n");
len = (sizeof(download_pin_test_data1)/sizeof(download_pin_test_data1[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(download_pin_test_data1[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
{
break;
}
}
if (status != NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
return status;
}
status = NFCSTATUS_FAILED;
status = phTmlNfc_IoCtl(phTmlNfc_e_EnableDownloadMode);
if (NFCSTATUS_SUCCESS != status)
{
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
return status;
}
status = NFCSTATUS_FAILED;
len = (sizeof(download_pin_test_data2)/sizeof(download_pin_test_data2[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(download_pin_test_data2[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
{
break;
}
}
if( status == NFCSTATUS_SUCCESS)
{
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - SUCCESSS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - end\n");
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_AntennaSelfTest
**
** Description Test function to validate the Antenna's discrete
** components connection.
**
** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED.
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_AntennaSelfTest(phAntenna_St_Resp_t * phAntenna_St_Resp )
{
NFCSTATUS status = NFCSTATUS_FAILED;
NFCSTATUS antenna_st_status = NFCSTATUS_FAILED;
int len = 0;
int cnt = 0;
NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - start\n");
memcpy(&phAntenna_resp, phAntenna_St_Resp, sizeof(phAntenna_St_Resp_t));
len = (sizeof(antenna_self_test_data)/sizeof(antenna_self_test_data[0]));
for(cnt = 0; cnt < len; cnt++)
{
status = phNxpNciHal_performTest(&(antenna_self_test_data[cnt]));
if(status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED)
{
NXPLOG_NCIHAL_E("phNxpNciHal_AntennaSelfTest: commnad execution - FAILED\n");
break;
}
}
if(status == NFCSTATUS_SUCCESS)
{
if((gtxldo_status == NFCSTATUS_SUCCESS) && (gagc_value_status == NFCSTATUS_SUCCESS) &&
(gagc_nfcld_status == NFCSTATUS_SUCCESS) && (gagc_differential_status == NFCSTATUS_SUCCESS))
{
antenna_st_status = NFCSTATUS_SUCCESS;
NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - SUCESS\n");
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n");
}
}
else
{
NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n");
}
NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - end\n");
return antenna_st_status;
}
#endif /*#ifdef NXP_HW_SELF_TEST*/