2143 lines
71 KiB
Plaintext
2143 lines
71 KiB
Plaintext
/*----------------------------------------------------------------------------*/
|
|
/* Copyright 2019-2023 NXP */
|
|
/* */
|
|
/* NXP Confidential. This software is owned or controlled by NXP and may only */
|
|
/* be used strictly in accordance with the applicable license terms. */
|
|
/* By expressly accepting such terms or by downloading, installing, */
|
|
/* activating and/or otherwise using the software, you are agreeing that you */
|
|
/* have read, and that you agree to comply with and are bound by, such */
|
|
/* license terms. If you do not agree to be bound by the applicable license */
|
|
/* terms, then you may not retain, install, activate or otherwise use the */
|
|
/* software. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/** \file
|
|
* PN5190 HAL Instruction layer.
|
|
*
|
|
* $Author$
|
|
* $Revision$ (v07.10.00)
|
|
* $Date$
|
|
*/
|
|
|
|
#include <ph_RefDefs.h>
|
|
#include <ph_Status.h>
|
|
#include <phhalHw.h>
|
|
#include <phDriver.h>
|
|
|
|
#ifdef _WIN32
|
|
|
|
#define PH_DRIVER_SET_LOW 0
|
|
#define PH_DRIVER_SET_HIGH 1
|
|
|
|
#define RESET_POWERDOWN_LEVEL PH_DRIVER_SET_LOW
|
|
#define RESET_POWERUP_LEVEL PH_DRIVER_SET_HIGH
|
|
|
|
#endif
|
|
|
|
#ifdef NXPBUILD__PHHAL_HW_PN5190
|
|
#include "phhalHw_Pn5190.h"
|
|
#include "phhalHw_Pn5190_InstrMngr.h"
|
|
#include <phhalHw_Pn5190_Instr.h>
|
|
#include "phhalHw_Pn5190_Int.h"
|
|
#include <phhalHw_Pn5190_Reg.h>
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_WriteRegister(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRegister,
|
|
uint32_t dwValue
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[5] = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address is valid. */
|
|
if (bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS)
|
|
{
|
|
if((bRegister < PHHAL_HW_PN5190_REG_START_ADDRESS_EXPERT) ||
|
|
(bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS_EXPERT))
|
|
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_WRITE_REGISTER;
|
|
|
|
sCmdParams.bQueue = true;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bRegister;
|
|
aInstrBuffer[bIndex++] = (uint8_t)(dwValue & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwValue >> 8U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwValue >> 16U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwValue >> 24U) & 0xFFU);
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_WriteRegisterOrMask(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRegister,
|
|
uint32_t dwMask
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[5] = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address is valid. */
|
|
if (bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS)
|
|
{
|
|
if((bRegister < PHHAL_HW_PN5190_REG_START_ADDRESS_EXPERT) ||
|
|
(bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS_EXPERT))
|
|
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_WRITE_REGISTER_OR_MASK;
|
|
|
|
sCmdParams.bQueue = true;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bRegister;
|
|
aInstrBuffer[bIndex++] = (uint8_t)(dwMask & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 8U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 16U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 24U) & 0xFFU);
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_WriteRegisterAndMask(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRegister,
|
|
uint32_t dwMask
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[5] = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address is valid. */
|
|
if (bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS)
|
|
{
|
|
if((bRegister < PHHAL_HW_PN5190_REG_START_ADDRESS_EXPERT) ||
|
|
(bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS_EXPERT))
|
|
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_WRITE_REGISTER_AND_MASK;
|
|
|
|
sCmdParams.bQueue = true;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bRegister;
|
|
aInstrBuffer[bIndex++] = (uint8_t)(dwMask & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 8U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 16U) & 0xFFU);
|
|
aInstrBuffer[bIndex++] = (uint8_t)((dwMask >> 24U) & 0xFFU);
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_WriteRegisterMultiple(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t * pRegTypeValueSets,
|
|
uint16_t wSizeOfRegTypeValueSets
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if (((pDataParams == NULL)) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate
|
|
* pRegTypeValueSets
|
|
* wSizeOfRegTypeValueSets
|
|
* wSizeOfRegTypeValueSets for modulus of 6. One set of write register is of 6 byte*/
|
|
|
|
if ((NULL == pRegTypeValueSets)
|
|
|| (wSizeOfRegTypeValueSets > PHHAL_HW_PN5190_MAX_REGISTER_TYPE_VALUE_SET)
|
|
|| (wSizeOfRegTypeValueSets < PHHAL_HW_PN5190_MIN_REGISTER_TYPE_VALUE_SET)
|
|
|| ( (wSizeOfRegTypeValueSets % PHHAL_HW_PN5190_MIN_REGISTER_TYPE_VALUE_SET) != 0U))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Build the command frame */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_WRITE_REGISTER_MULTIPLE;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pRegTypeValueSets;
|
|
sCmdParams.wTxDataLength = wSizeOfRegTypeValueSets;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ReadRegister(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRegister,
|
|
uint32_t * pValue
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[1] = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address and input parameter is valid. */
|
|
if (bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS)
|
|
{
|
|
if((bRegister < PHHAL_HW_PN5190_REG_START_ADDRESS_EXPERT) ||
|
|
(bRegister > PHHAL_HW_PN5190_REG_END_ADDRESS_EXPERT))
|
|
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
if (pValue == NULL)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_READ_REGISTER;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
aInstrBuffer[bIndex++] = bRegister;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
*pValue = pRxData[0];
|
|
*pValue |= (((uint32_t) pRxData[1]) << 8U);
|
|
*pValue |= (((uint32_t) pRxData[2]) << 16U);
|
|
*pValue |= (((uint32_t) pRxData[3]) << 24U);
|
|
}
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ReadRegisterMultiple(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t * pRegisters,
|
|
uint8_t bNumOfRegisters,
|
|
uint8_t ** ppValues
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM bNumExpBytes = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check input parameters. */
|
|
if ((ppValues == NULL) || (pRegisters == NULL) ||
|
|
(bNumOfRegisters > PHHAL_HW_PN5190_REG_END_ADDRESS))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
bNumExpBytes = bNumOfRegisters * PHHAL_HW_PN5190_BYTES_PER_REGISTER;
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_READ_REGISTER_MULTIPLE;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pRegisters;
|
|
sCmdParams.wTxDataLength = bNumOfRegisters;
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
wRxLen = *sCmdParams.pRxLength;
|
|
|
|
/* Validate the response length */
|
|
if (wRxLen != bNumExpBytes)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INTERNAL_ERROR, PH_COMP_HAL);
|
|
}
|
|
*ppValues = *sCmdParams.ppRxBuffer;
|
|
}
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_WriteE2Prom(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wE2PromAddress,
|
|
uint8_t * pDataToWrite,
|
|
uint16_t wDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aAddnBuffer[2U] = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address is valid. */
|
|
if (((wE2PromAddress + wDataLength) > PHHAL_HW_PN5190_EEPROM_END_ADDRS) ||
|
|
(wDataLength == 0U))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_WRITE_E2PROM;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pDataToWrite;
|
|
sCmdParams.wTxDataLength = wDataLength;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
aAddnBuffer[0] = (uint8_t)wE2PromAddress;
|
|
aAddnBuffer[1] = (uint8_t)(wE2PromAddress >> 8);
|
|
sCmdParams.wAddnDataLen = 2U;
|
|
sCmdParams.pAddnData = &aAddnBuffer[0];
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ReadE2Prom(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wE2PromAddress,
|
|
uint8_t * pReadData,
|
|
uint16_t wDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[4] = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check if the Register address is valid. */
|
|
if (((wE2PromAddress + wDataLength) > PHHAL_HW_PN5190_EEPROM_END_ADDRS) ||
|
|
(pReadData == NULL))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_READ_E2PROM;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
aInstrBuffer[bIndex++] = (uint8_t) wE2PromAddress ;
|
|
aInstrBuffer[bIndex++] = (uint8_t)(wE2PromAddress >> (8U));
|
|
aInstrBuffer[bIndex++] = (uint8_t) wDataLength;
|
|
aInstrBuffer[bIndex++] = (uint8_t) (wDataLength >> 8U);
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.ppRxBuffer = &pReadData;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);;
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ReadCRCUserAreaE2Prom(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint32_t * pValue
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
if (pValue == NULL)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_GET_CRC_USER_AREA_EEPROM;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = NULL;
|
|
sCmdParams.wTxDataLength = 0U;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
*pValue = pRxData[0];
|
|
*pValue |= (((uint32_t) pRxData[1]) << 8U);
|
|
*pValue |= (((uint32_t) pRxData[2]) << 16U);
|
|
*pValue |= (((uint32_t) pRxData[3]) << 24U);
|
|
}
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_TransmitRFData(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wOption,
|
|
uint8_t bTxLastBits,
|
|
uint8_t * pTxBuffer,
|
|
uint16_t wTxBufferLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aAddnBuffer[2] = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate transmission buffer length
|
|
* To validate bNumberOfValidBits indicate the exact data length to be transmitted.
|
|
* */
|
|
if (((pTxBuffer == NULL) && (wTxBufferLength != 0U) && ((wOption & PH_TRANSMIT_PREV_FRAME) == 0))||
|
|
(wTxBufferLength > PHHAL_HW_PN5190_TX_DATA_MAX_LENGTH) ||
|
|
(bTxLastBits > PHHAL_HW_PN5190_MAX_NUM_OF_BITS_FOR_LAST_BYTE))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
if ((0U == (wOption & (PH_TRANSMIT_LEAVE_BUFFER_BIT | PH_TRANSMIT_PREV_FRAME))))
|
|
{
|
|
/* clear internal buffer if requested */
|
|
pDataParams->wTxBufLen = 0U;
|
|
pDataParams->wTxBufStartPos = 0U;
|
|
pDataParams->wTxFwDataLen = 0U;
|
|
}
|
|
|
|
aAddnBuffer[bIndex++] = bTxLastBits;
|
|
aAddnBuffer[bIndex++] = 0;
|
|
|
|
sCmdParams.pAddnData = &aAddnBuffer[0];
|
|
sCmdParams.wAddnDataLen = bIndex;
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_TRANSMIT_RF_DATA;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pTxBuffer;
|
|
sCmdParams.wTxDataLength = wTxBufferLength;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
wOption);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_RetrieveRFData(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t ** pRxBuffer,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * pTmpRxBuffer = 0U;
|
|
uint16_t wTmpRxBufferLen = 0U;
|
|
uint16_t wTmpRxBufferSize = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters. */
|
|
if ((pRxBuffer == NULL) ||
|
|
(pRxDataLength == NULL))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
phhalHw_Pn5190_Int_GetRxBuffer(pDataParams,
|
|
&pTmpRxBuffer,
|
|
&wTmpRxBufferLen,
|
|
&wTmpRxBufferSize);
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_RETRIEVE_RF_DATA;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = NULL;
|
|
sCmdParams.wTxDataLength = 0;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pTmpRxBuffer;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if (status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
*pRxBuffer = *sCmdParams.ppRxBuffer;
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_RetrieveRFFeliCaEMDData(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRetrieveConfigMask,
|
|
uint8_t ** pRxBuffer,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * pTmpRxBuffer = 0U;
|
|
uint16_t wTmpRxBufferLen = 0U;
|
|
uint16_t wTmpRxBufferSize = 0U;
|
|
uint8_t bInstrData = bRetrieveConfigMask;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters. */
|
|
if ((pRxBuffer == NULL) ||
|
|
(pRxDataLength == NULL))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
phhalHw_Pn5190_Int_GetRxBuffer(pDataParams,
|
|
&pTmpRxBuffer,
|
|
&wTmpRxBufferLen,
|
|
&wTmpRxBufferSize);
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_RETRIEVE_RF_FELICA_EMD_DATA;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &bInstrData;
|
|
sCmdParams.wTxDataLength = 1;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pTmpRxBuffer;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if (status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
*pRxBuffer = *sCmdParams.ppRxBuffer;
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ReceiveRFData(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRespConfigMask,
|
|
uint8_t ** ppRxBuffer,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * pTmpRxBuffer = 0U;
|
|
uint8_t bInstrData = bRespConfigMask;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters. */
|
|
if ((ppRxBuffer == NULL) ||
|
|
(pRxDataLength == NULL))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_RECEIVE_RF_DATA;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &bInstrData;
|
|
sCmdParams.wTxDataLength = 1;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pTmpRxBuffer;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_RECEIVE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
*ppRxBuffer = *sCmdParams.ppRxBuffer;
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ExchangeRFData(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wOption,
|
|
uint8_t bTxLastBits,
|
|
uint8_t bRespControl,
|
|
uint8_t * pTxData,
|
|
uint16_t wTxDataLength,
|
|
uint8_t ** ppRxData,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_INTERNAL_ERROR;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[2] = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters */
|
|
if (((pTxData == NULL) && (wTxDataLength != 0U)) ||
|
|
(wTxDataLength > PHHAL_HW_PN5190_TX_DATA_MAX_LENGTH) ||
|
|
(bTxLastBits > PHHAL_HW_PN5190_MAX_NUM_OF_BITS_FOR_LAST_BYTE))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_EXCHANGE_RF_DATA;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pTxData;
|
|
sCmdParams.wTxDataLength = wTxDataLength;
|
|
|
|
if ((0U == ((wOption & PH_EXCHANGE_LEAVE_BUFFER_BIT))))
|
|
{
|
|
/* clear internal buffer if requested */
|
|
pDataParams->wTxBufLen = 0U;
|
|
pDataParams->wTxBufStartPos = 0U;
|
|
pDataParams->wTxFwDataLen = 0U;
|
|
}
|
|
|
|
aInstrBuffer[bIndex++] = bTxLastBits;
|
|
aInstrBuffer[bIndex++] = bRespControl;
|
|
|
|
sCmdParams.pAddnData = &aInstrBuffer[0];
|
|
sCmdParams.wAddnDataLen = bIndex;
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
wOption);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
if (ppRxData != NULL)
|
|
{
|
|
*ppRxData = *sCmdParams.ppRxBuffer;
|
|
}
|
|
if (pRxDataLength != NULL)
|
|
{
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeStandby(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bConfigMask,
|
|
uint16_t wWakeupCounterInMs
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_INTERNAL_ERROR;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[3] = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aInstrBuffer[bIndex++] = bConfigMask;
|
|
aInstrBuffer[bIndex++] = (uint8_t)wWakeupCounterInMs;
|
|
aInstrBuffer[bIndex++] = (uint8_t)(wWakeupCounterInMs >> 8);
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_SWITCH_MODE_STANDBY;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if( status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
pDataParams->dwExpectedEvent = PH_PN5190_EVT_BOOT;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_LPCD_SetConfig(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wConfig,
|
|
uint32_t dwValue
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM statusTmp = PH_ERR_PN5190_SUCCESS;
|
|
|
|
switch(wConfig)
|
|
{
|
|
|
|
case PHHAL_HW_CONFIG_SET_LPCD_WAKEUPTIME_MS:
|
|
{
|
|
/* Value should be greater than 3ms */
|
|
if(dwValue >= 0x03U)
|
|
{
|
|
pDataParams->wLPCDWakeupCounterInMs = dwValue;
|
|
}
|
|
else
|
|
{
|
|
pDataParams->wLPCDWakeupCounterInMs = 0x03U;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_MODE:
|
|
if((dwValue == PHHAL_HW_PN5190_LPCD_MODE_DEFAULT) || (dwValue == PHHAL_HW_PN5190_LPCD_MODE_POWERDOWN))
|
|
{
|
|
pDataParams->bLpcdMode = (uint8_t)dwValue;
|
|
}
|
|
else
|
|
{
|
|
statusTmp = PH_ERR_PN5190_INVALID_PARAMETER;
|
|
}
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_CONFIG:
|
|
if ((dwValue <= PHHAL_HW_PN5190_LPCD_CTRL_SINGLEMODE_LPCD) ||
|
|
(dwValue == PHHAL_HW_PN5190_LPCD_CTRL_SINGLEMODE_CALIB))
|
|
{
|
|
pDataParams->bLpcdConfig = (uint8_t)dwValue;
|
|
}
|
|
else
|
|
{
|
|
statusTmp = PH_ERR_PN5190_INVALID_PARAMETER;
|
|
}
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_WAKEUP_CTRL:
|
|
pDataParams->bLpcdWakeUpCtrl = (uint8_t)dwValue;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_REF_VAL:
|
|
pDataParams->dwLpcdRefVal = dwValue;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_HFATT_VAL:
|
|
pDataParams->bHFATTVal = (uint8_t)dwValue;
|
|
break;
|
|
|
|
default:
|
|
statusTmp = PH_ERR_PN5190_UNSUPPORTED_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(statusTmp, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_LPCD_GetConfig(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint16_t wConfig,
|
|
uint32_t * pValue
|
|
)
|
|
{
|
|
switch(wConfig)
|
|
{
|
|
case PHHAL_HW_CONFIG_SET_LPCD_WAKEUPTIME_MS:
|
|
*pValue = pDataParams->wLPCDWakeupCounterInMs;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_MODE:
|
|
*pValue = pDataParams->bLpcdMode;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_WAKEUP_CTRL:
|
|
*pValue = pDataParams->bLpcdWakeUpCtrl;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_REF_VAL:
|
|
*pValue = pDataParams->dwLpcdRefVal;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_RETRIEVE_EVENT_STATUS:
|
|
*pValue = pDataParams->dwEventStatus;
|
|
break;
|
|
|
|
case PHHAL_HW_CONFIG_LPCD_HFATT_VAL:
|
|
*pValue = pDataParams->bHFATTVal;
|
|
break;
|
|
|
|
default:
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_UNSUPPORTED_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
return PH_ERR_PN5190_SUCCESS;
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeLpcd(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bLpcdMode,
|
|
uint8_t bWakeUpCntrlHwLpcd,
|
|
uint32_t dwLpcdRefValue,
|
|
uint16_t wWakeupCounterInMs
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_INTERNAL_ERROR;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[8] = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aInstrBuffer[bIndex++] = bLpcdMode;
|
|
aInstrBuffer[bIndex++] = bWakeUpCntrlHwLpcd;
|
|
aInstrBuffer[bIndex++] = (uint8_t) dwLpcdRefValue;
|
|
aInstrBuffer[bIndex++] = (uint8_t) (dwLpcdRefValue >> 8);
|
|
aInstrBuffer[bIndex++] = (uint8_t) (dwLpcdRefValue >> 16);
|
|
aInstrBuffer[bIndex++] = (uint8_t) (dwLpcdRefValue >> 24);
|
|
aInstrBuffer[bIndex++] = (uint8_t) wWakeupCounterInMs;
|
|
aInstrBuffer[bIndex++] = (uint8_t) (wWakeupCounterInMs >> 8);
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_SWITCH_MODE_LPCD;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeAutocoll(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRfTechnologyMask,
|
|
uint8_t bAutocollMode
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[2] = {0U, 0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
if(0U == bRfTechnologyMask)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_SWITCH_MODE_AUTOCOLL;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
aInstrBuffer[bIndex++] = bRfTechnologyMask;
|
|
aInstrBuffer[bIndex++] = bAutocollMode;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams, &sCmdParams, PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeBootNormal(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams
|
|
)
|
|
{
|
|
uint8_t PH_MEMLOC_REM aCmd[4] = {0};
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aCmd[0] = PHHAL_HW_PN5190_INT_SPI_WRITE;
|
|
aCmd[1] = 0x20;
|
|
aCmd[2] = 0x01;
|
|
aCmd[3] = 0x00;
|
|
|
|
return phhalHw_Pn5190_Send(pDataParams,&aCmd[0], 4, PH_OFF);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeNormal(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams
|
|
)
|
|
{
|
|
uint8_t PH_MEMLOC_REM aCmd[4] = {0};
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_INTERNAL_ERROR;
|
|
uint32_t PH_MEMLOC_REM dwEventReceived = 0x0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aCmd[0] = PHHAL_HW_PN5190_INT_SPI_WRITE;
|
|
aCmd[1] = 0x20;
|
|
aCmd[2] = 0x00;
|
|
aCmd[3] = 0x00;
|
|
|
|
PH_CHECK_SUCCESS_FCT(status, phhalHw_Pn5190_Send(pDataParams,&aCmd[0], 4, PH_ON));
|
|
|
|
/*Wait for event*/
|
|
status = phhalHw_Pn5190_Int_EventWait(
|
|
pDataParams,
|
|
PH_PN5190_EVT_IDLE | PH_PN5190_EVT_GENERAL_ERROR,
|
|
PHOSAL_MAX_DELAY,
|
|
true,
|
|
&dwEventReceived);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeIdle(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams
|
|
)
|
|
{
|
|
uint8_t PH_MEMLOC_REM aCmd[4] = {0};
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_INTERNAL_ERROR;
|
|
uint32_t PH_MEMLOC_REM dwEventReceived = 0x0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aCmd[0] = PHHAL_HW_PN5190_INT_SPI_WRITE;
|
|
aCmd[1] = 0x20;
|
|
aCmd[2] = 0x02;
|
|
aCmd[3] = 0x00;
|
|
|
|
PH_CHECK_SUCCESS_FCT(status, phhalHw_Pn5190_Send(pDataParams, &aCmd[0], 4, PH_ON));
|
|
|
|
/*Wait for event*/
|
|
status = phhalHw_Pn5190_Int_EventWait(
|
|
pDataParams,
|
|
PH_PN5190_EVT_IDLE | PH_PN5190_EVT_GENERAL_ERROR,
|
|
PHOSAL_MAX_DELAY,
|
|
true,
|
|
&dwEventReceived);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_MifareAuthenticate(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t * pKey,
|
|
uint8_t bKeyType,
|
|
uint8_t bBlockNo,
|
|
uint8_t * pUid
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM statusTmp;
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint16_t PH_MEMLOC_REM wDataLenTmp;
|
|
uint16_t PH_MEMLOC_REM wBufferLength = 0;
|
|
|
|
uint8_t PH_MEMLOC_BUF aCmdBuffer[13];
|
|
uint8_t * PH_MEMLOC_BUF aRspBuffer;
|
|
uint32_t dwRegister;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters */
|
|
if ((NULL == pKey) ||
|
|
(NULL == pUid) ||
|
|
((bKeyType != PHHAL_HW_MFC_KEYA) && (bKeyType != PHHAL_HW_MFC_KEYB)))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Build the command frame */
|
|
wBufferLength = 0U;
|
|
|
|
/* Write Tx Data */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_MFC_AUTHENTICATE;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Copy the data to be transmitted*/
|
|
(void)memcpy(&aCmdBuffer[wBufferLength], pKey, PHHAL_HW_MFC_KEY_LENGTH);
|
|
wBufferLength += PHHAL_HW_MFC_KEY_LENGTH;
|
|
|
|
if(bKeyType == PHHAL_HW_MFC_KEYA)
|
|
{
|
|
aCmdBuffer[wBufferLength++] = PHHAL_HW_PN5190_INSTR_MFC_AUTHENTICATE_KEY_TYPE_A;
|
|
}
|
|
else
|
|
{
|
|
aCmdBuffer[wBufferLength++] = PHHAL_HW_PN5190_INSTR_MFC_AUTHENTICATE_KEY_TYPE_B;
|
|
}
|
|
|
|
aCmdBuffer[wBufferLength++] = bBlockNo;
|
|
(void)memcpy(&aCmdBuffer[wBufferLength], pUid, PHHAL_HW_PN5190_MFC_UID_LEN);
|
|
wBufferLength += PHHAL_HW_PN5190_MFC_UID_LEN;
|
|
|
|
sCmdParams.pTxDataBuff = &aCmdBuffer[0];
|
|
sCmdParams.wTxDataLength = wBufferLength;
|
|
sCmdParams.ppRxBuffer = &aRspBuffer;
|
|
sCmdParams.pRxLength = &wDataLenTmp;
|
|
|
|
/* Send it to the chip */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
/* Validate the response */
|
|
if(PH_ERR_PN5190_SUCCESS == status)
|
|
{
|
|
/* Check auth success */
|
|
PH_CHECK_SUCCESS_FCT(statusTmp, phhalHw_Pn5190_Instr_ReadRegister(pDataParams, SYSTEM_CONFIG, &dwRegister));
|
|
if((0U == ((dwRegister & SYSTEM_CONFIG_MFC_CRYPTO_ON_MASK))))
|
|
{
|
|
status = PH_ERR_AUTH_ERROR;
|
|
pDataParams->bMfcCryptoEnabled = PH_OFF;
|
|
}
|
|
else
|
|
{
|
|
pDataParams->bMfcCryptoEnabled = PH_ON;
|
|
}
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_EpcGen2Inventory(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t * pSelectCommand,
|
|
uint8_t bSelectCommandLength,
|
|
uint8_t bSelectCommandBitsInLastByte,
|
|
uint8_t * pBeginRoundCommand,
|
|
uint8_t bTimeslotProcessingBehavior,
|
|
uint8_t ** ppRxBuffer,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
|
|
phStatus_t PH_MEMLOC_REM statusTmp;
|
|
uint16_t PH_MEMLOC_REM wBufferLength = 0;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
uint8_t * pTmpRxBuffer = 0U;
|
|
uint16_t wTmpRxBufferLen = 0U;
|
|
uint16_t wTmpRxBufferSize = 0U;
|
|
|
|
uint8_t PH_MEMLOC_BUF aCmdBuffer[46];
|
|
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/*
|
|
Validate pBeginRoundCommand
|
|
Validate bTimeslotProcessingBehavior */
|
|
if ((NULL == pBeginRoundCommand)
|
|
|| (bTimeslotProcessingBehavior > PHHAL_HW_PN5190_MAX_EPC_GEN2_TIMESLOT))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate the parameters of Select command */
|
|
if (0U != (bSelectCommandLength))
|
|
{
|
|
/* Validate pSelectCommand
|
|
Validate bSelectCommandLength
|
|
Validate bSelectCommandBitsInLastByte */
|
|
if ( \
|
|
(NULL == pSelectCommand) \
|
|
|| (bSelectCommandLength > PHHAL_HW_PN5190_MAX_SELECT_COMMAND_LENGTH) \
|
|
|| (bSelectCommandBitsInLastByte > PHHAL_HW_PN5190_MAX_NUM_OF_BITS_FOR_LAST_BYTE) \
|
|
)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
}
|
|
|
|
/* Build the command frame */
|
|
wBufferLength = 0U;
|
|
|
|
phhalHw_Pn5190_Int_GetRxBuffer(pDataParams,
|
|
&pTmpRxBuffer,
|
|
&wTmpRxBufferLen,
|
|
&wTmpRxBufferSize);
|
|
|
|
/* Write Tx Data */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_EPC_GEN2_INVENTORY;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
aCmdBuffer[wBufferLength++] = 0x00; /* ResumeInventory */
|
|
aCmdBuffer[wBufferLength++] = bSelectCommandLength;
|
|
/*
|
|
No Select command is set prior to BeginRound command.
|
|
'Valid Bits in last Byte' field and 'Select command' field shall not be present.
|
|
*/
|
|
if(0U != (bSelectCommandLength))
|
|
{
|
|
aCmdBuffer[wBufferLength++] = bSelectCommandBitsInLastByte;
|
|
|
|
/* Copy the Instruction payload and update the buffer length*/
|
|
(void)memcpy(&aCmdBuffer[wBufferLength], pSelectCommand, bSelectCommandLength);
|
|
wBufferLength+= bSelectCommandLength;
|
|
}
|
|
/* Copy the Instruction payload and update the buffer length*/
|
|
(void)memcpy(&aCmdBuffer[wBufferLength], pBeginRoundCommand, PHHAL_HW_PN5190_BEGIN_COMMAND_LENGTH);
|
|
wBufferLength+= PHHAL_HW_PN5190_BEGIN_COMMAND_LENGTH;
|
|
|
|
aCmdBuffer[wBufferLength++] = bTimeslotProcessingBehavior;
|
|
|
|
sCmdParams.pTxDataBuff = &aCmdBuffer[0];
|
|
sCmdParams.wTxDataLength = wBufferLength;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pTmpRxBuffer;
|
|
|
|
/* Send it to the chip */
|
|
statusTmp = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if (statusTmp == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
/* copy the RX buffer and length and send it to the upper layer */
|
|
*ppRxBuffer = *sCmdParams.ppRxBuffer;
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(statusTmp, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_EpcGen2ResumeInventory(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t ** ppRxBuffer,
|
|
uint16_t * pRxDataLength
|
|
)
|
|
{
|
|
|
|
phStatus_t PH_MEMLOC_REM statusTmp;
|
|
uint16_t PH_MEMLOC_REM wBufferLength = 0;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
uint8_t * pTmpRxBuffer = 0U;
|
|
uint16_t wTmpRxBufferLen = 0U;
|
|
uint16_t wTmpRxBufferSize = 0U;
|
|
|
|
uint8_t PH_MEMLOC_BUF aCmdBuffer[2];
|
|
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
|
|
if ((NULL == pDataParams) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Build the command frame */
|
|
wBufferLength = 0U;
|
|
|
|
phhalHw_Pn5190_Int_GetRxBuffer(pDataParams,
|
|
&pTmpRxBuffer,
|
|
&wTmpRxBufferLen,
|
|
&wTmpRxBufferSize);
|
|
|
|
/* Write Tx Data */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_EPC_GEN2_INVENTORY;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
aCmdBuffer[wBufferLength++] = 0x01; /* ResumeInventory */
|
|
|
|
sCmdParams.pTxDataBuff = &aCmdBuffer[0];
|
|
sCmdParams.wTxDataLength = wBufferLength;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pTmpRxBuffer;
|
|
|
|
/* Send it to the chip */
|
|
statusTmp = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if (statusTmp == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
/* copy the RX buffer and length and send it to the upper layer */
|
|
*ppRxBuffer = *sCmdParams.ppRxBuffer;
|
|
*pRxDataLength = *sCmdParams.pRxLength;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(statusTmp, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_LoadRfConfiguration(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRfTxConfiguration,
|
|
uint8_t bRfRxConfiguration
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[2U] = {0};
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if (((pDataParams == NULL)) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Check TX and RX configuration parameters. */
|
|
if (((bRfTxConfiguration > PHHAL_HW_PN5190_MAX_RF_TX_CONFIGURATION_INDEX) && (bRfTxConfiguration != 0xFFU)) ||
|
|
((bRfRxConfiguration > 0x9DU) && (bRfRxConfiguration != 0xFFU)) ||
|
|
(bRfRxConfiguration < 0x80U))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* If "no change" needed for TX and RX configuration, return success. */
|
|
if ((bRfTxConfiguration == 0xFFU) && (bRfRxConfiguration == 0xFFU))
|
|
{
|
|
return PH_ERR_PN5190_SUCCESS;
|
|
}
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_LOAD_RF_CONFIGURATION;
|
|
|
|
sCmdParams.bQueue = true;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bRfTxConfiguration;
|
|
aInstrBuffer[bIndex++] = bRfRxConfiguration;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_UpdateRfConfiguration(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t * pRfConfiguration,
|
|
uint8_t bRfConfigurationSize
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters.
|
|
* bRfConfigurationSize is not a multiple of PHHAL_HW_PN5190_RF_CONFIGURATION_SIZE
|
|
* bRfConfigurationSize is greater than PHHAL_HW_PN5190_MAX_RF_CONFIGURATION_SIZE
|
|
* */
|
|
if ((NULL == pRfConfiguration) ||
|
|
(bRfConfigurationSize > PHHAL_HW_PN5190_MAX_RF_CONFIGURATION_SIZE) ||
|
|
(0U != (bRfConfigurationSize % PHHAL_HW_PN5190_RF_CONFIGURATION_SIZE)))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Build the command frame */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_UPDATE_RF_CONFIGURATION;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = pRfConfiguration;
|
|
sCmdParams.wTxDataLength = bRfConfigurationSize;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_RetrieveRfConfiguration(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRfConfiguration,
|
|
uint8_t * pRfConfBuf,
|
|
uint16_t * pRfConfBufSize
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameters.
|
|
* bRfRxConfiguration is greater than the maximum RF RX configuration
|
|
* bRfRxConfiguration is not the PHHAL_HW_PN5190_CURRENT_RF_CONFIGURATION_INDEX
|
|
* */
|
|
if (((bRfConfiguration < PHHAL_HW_PN5190_MIN_RF_RX_CONFIGURATION_INDEX)
|
|
&& (bRfConfiguration > PHHAL_HW_PN5190_MAX_RF_TX_CONFIGURATION_INDEX)) ||
|
|
(bRfConfiguration > PHHAL_HW_PN5190_MAX_RF_RX_CONFIGURATION_INDEX) ||
|
|
(*pRfConfBufSize < PHHAL_HW_PN5190_MIN_RF_CONFIGURATION_BUFFER_SIZE))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Build the command frame */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_GET_RF_CONFIGURATION;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &bRfConfiguration;
|
|
sCmdParams.wTxDataLength = 1;
|
|
sCmdParams.pRxLength = pRfConfBufSize;
|
|
sCmdParams.ppRxBuffer = &pRfConfBuf;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_RfOn(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bRfOnConfig
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[2U] = {0};
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate RF ON parameter */
|
|
if (bRfOnConfig > 3U)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_FIELD_ON;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bRfOnConfig;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_RfOff(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_FIELD_OFF;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = NULL;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ConfigureTestBusDigital(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bSignalIndex,
|
|
uint8_t bBitIndex,
|
|
uint8_t bPadIndex
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[3U] = {0};
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CONFIGURE_TESTBUS_DIGITAL;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bSignalIndex;
|
|
aInstrBuffer[bIndex++] = bBitIndex;
|
|
aInstrBuffer[bIndex++] = bPadIndex;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ConfigureMulTestBusDigital(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bTestBusReset,
|
|
uint8_t bSignalIndex1,
|
|
uint8_t bBitIndex1,
|
|
uint8_t bPadIndex1,
|
|
uint8_t bSignalIndex2,
|
|
uint8_t bBitIndex2,
|
|
uint8_t bPadIndex2
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[6U] = {0};
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CONFIGURE_MUL_TESTBUS_DIGITAL;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
if (bTestBusReset == PH_OFF)
|
|
{
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bSignalIndex1;
|
|
aInstrBuffer[bIndex++] = bBitIndex1;
|
|
aInstrBuffer[bIndex++] = bPadIndex1;
|
|
aInstrBuffer[bIndex++] = bSignalIndex2;
|
|
aInstrBuffer[bIndex++] = bBitIndex2;
|
|
aInstrBuffer[bIndex++] = bPadIndex2;
|
|
}
|
|
else
|
|
{
|
|
/* Payload not exchanged, FW performs Digital Test bus RESET internally. */
|
|
}
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_ConfigureTestBusAnalog(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bConfig,
|
|
uint8_t bCombinedMode,
|
|
uint8_t bTBIndex0,
|
|
uint8_t bTBIndex1,
|
|
uint8_t bShiftIndex0,
|
|
uint8_t bShiftIndex1,
|
|
uint8_t bMask0,
|
|
uint8_t bMask1
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[8U] = {0};
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CONFIGURE_TESTBUS_ANALOG;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Value */
|
|
aInstrBuffer[bIndex++] = bConfig;
|
|
aInstrBuffer[bIndex++] = bCombinedMode;
|
|
aInstrBuffer[bIndex++] = bTBIndex0;
|
|
aInstrBuffer[bIndex++] = bTBIndex1;
|
|
aInstrBuffer[bIndex++] = bShiftIndex0;
|
|
aInstrBuffer[bIndex++] = bShiftIndex1;
|
|
aInstrBuffer[bIndex++] = bMask0;
|
|
aInstrBuffer[bIndex++] = bMask1;
|
|
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_CtsEnable(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bOption
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if (((pDataParams == NULL)) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate Option parameter */
|
|
if ((bOption != PH_OFF) && (bOption != PH_ON))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CTS_ENABLE;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = &bOption;
|
|
sCmdParams.wTxDataLength = 0x01U;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
pDataParams->dwExpectedEvent = PH_PN5190_EVT_CTS;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_CtsConfig(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
phhalHw_Pn5190_Instr_CtsConfig_t * pCtsConfig
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status;
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if (((pDataParams == NULL)) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameter */
|
|
if (pCtsConfig == NULL)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Command Type */
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CTS_CONFIGURE;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Value */
|
|
sCmdParams.pTxDataBuff = (uint8_t *) pCtsConfig;
|
|
sCmdParams.wTxDataLength = sizeof(phhalHw_Pn5190_Instr_CtsConfig_t);
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
/* Send command */
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_CtsRetrieveLog(
|
|
phhalHw_Pn5190_DataParams_t * pDataParams,
|
|
uint8_t bChunkSize,
|
|
uint8_t * pLogData,
|
|
uint8_t * bLogDataSize
|
|
)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if (((pDataParams == NULL)) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameter */
|
|
if ((pLogData == NULL) || (bLogDataSize == NULL))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
if (pDataParams->bCTSEvent == PH_OFF)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_NO_CTS_EVENT, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_CTS_RETRIEVE_LOG;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
/* Value */
|
|
sCmdParams.pTxDataBuff = &bChunkSize;
|
|
sCmdParams.wTxDataLength = 0x01U;
|
|
sCmdParams.ppRxBuffer = &pLogData;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if ((status == PH_ERR_PN5190_SUCCESS) || (status == PH_ERR_PN5190_SUCCESS_CHAINING))
|
|
{
|
|
*bLogDataSize = wRxLen;
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_GetDieId(phhalHw_Pn5190_DataParams_t *pDataParams,
|
|
uint8_t *pDieIdValue)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameter */
|
|
if (pDieIdValue == NULL)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_GET_DIE_ID;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = NULL;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pDieIdValue;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(wRxLen != 16)
|
|
{
|
|
status = PH_ERR_LENGTH_ERROR;
|
|
}
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_GetVersion(phhalHw_Pn5190_DataParams_t *pDataParams,
|
|
phhalHw_Pn5190_Version_t *pVersion)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint8_t aVersionInfo[4] = {0};
|
|
uint8_t * pVersionInfo;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
|
|
pVersionInfo = &aVersionInfo[0];
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
/* Validate input parameter */
|
|
if (pVersion == NULL)
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_PARAMETER, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_GET_VERSION;
|
|
|
|
sCmdParams.bQueue = false;
|
|
|
|
sCmdParams.pTxDataBuff = NULL;
|
|
sCmdParams.ppRxBuffer = &pVersionInfo;
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
if(status == PH_ERR_PN5190_SUCCESS)
|
|
{
|
|
pVersion->bHw_Version = aVersionInfo[0];
|
|
pVersion->bROM_Version = aVersionInfo[1];
|
|
pVersion->wFW_Version = (uint16_t)(aVersionInfo[2] | (aVersionInfo[3] << 8));
|
|
}
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_SwitchModeDownload(phhalHw_Pn5190_DataParams_t *pDataParams)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
phhalHw_InstMngr_CmdParams_t sCmdParams = {0U};
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_SWITCH_MODE_DOWNLOAD;
|
|
sCmdParams.bQueue = false;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
phStatus_t phhalHw_Pn5190_Instr_PrbsTest(phhalHw_Pn5190_DataParams_t *pDataParams, uint8_t bPrbs_type)
|
|
{
|
|
phStatus_t PH_MEMLOC_REM status = PH_ERR_PN5190_SUCCESS;
|
|
uint8_t PH_MEMLOC_REM aInstrBuffer[1] = {0};
|
|
phhalHw_InstMngr_CmdParams_t PH_MEMLOC_REM sCmdParams = {0U};
|
|
uint8_t PH_MEMLOC_REM bIndex = 0U;
|
|
uint16_t PH_MEMLOC_REM wRxLen = 0U;
|
|
uint8_t * PH_MEMLOC_REM pRxData = NULL;
|
|
|
|
/* Check data parameters. */
|
|
if ((pDataParams == NULL) ||
|
|
(PH_GET_COMPCODE(pDataParams) != PH_COMP_HAL) ||
|
|
(PH_GET_COMPID(pDataParams) != PHHAL_HW_PN5190_ID))
|
|
{
|
|
return PH_ADD_COMPCODE_FIXED(PH_ERR_PN5190_INVALID_DATA_PARAMS, PH_COMP_HAL);
|
|
}
|
|
|
|
aInstrBuffer[bIndex++] = bPrbs_type;
|
|
|
|
sCmdParams.pRxLength = &wRxLen;
|
|
sCmdParams.ppRxBuffer = &pRxData;
|
|
|
|
sCmdParams.bCmd = PHHAL_HW_PN5190_INSTR_PRBS_TEST;
|
|
sCmdParams.bQueue = false;
|
|
sCmdParams.pTxDataBuff = &aInstrBuffer[0];
|
|
sCmdParams.wTxDataLength = bIndex;
|
|
|
|
status = phhalHw_Pn5190_InstMngr_HandleCmd(
|
|
pDataParams,
|
|
&sCmdParams,
|
|
PH_EXCHANGE_DEFAULT);
|
|
|
|
return PH_ADD_COMPCODE(status, PH_COMP_HAL);
|
|
}
|
|
|
|
#endif /* NXPBUILD__PHHAL_HW_PN5190 */
|