Mirrors/unleashed-firmware
2
0
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware synced 2024-11-27 15:00:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
unleashed-firmware/lib/ST25RFAL002/source/rfal_nfcDep.c
あく 389ff92cc1
Naming and coding style convention, new linter tool. (#945) 
* Makefile, Scripts: new linter
* About: remove ID from IC
* Firmware: remove double define for DIVC/DIVR
* Scripts: check folder names too. Docker: replace syntax check with make lint.
* Reformat Sources and Migrate to new file naming convention
* Docker: symlink clang-format-12 to clang-format
* Add coding style guide
2022-01-05 19:10:18 +03:00

2730 lines
106 KiB
C
Raw Blame History

/******************************************************************************
* \attention
*
* <h2><center>&copy; COPYRIGHT 2020 STMicroelectronics</center></h2>
*
* Licensed under ST MYLIBERTY SOFTWARE LICENSE AGREEMENT (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* www.st.com/myliberty
*
* 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,
* AND SPECIFICALLY DISCLAIMING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/*
* PROJECT: NFCC firmware
* LANGUAGE: ISO C99
*/
/*! \file rfal_nfcDep.c
*
* \author Gustavo Patricio
*
* \brief Implementation of NFC-DEP protocol
*
* NFC-DEP is also known as NFCIP - Near Field Communication
* Interface and Protocol
*
* This implementation was based on the following specs:
* - NFC Forum Digital 1.1
* - ECMA 340 3rd Edition 2013
*
*/
/*
******************************************************************************
* INCLUDES
******************************************************************************
*/
#include "rfal_nfcDep.h"
#include "rfal_nfcf.h"
#include "utils.h"
/*
******************************************************************************
* ENABLE SWITCH
******************************************************************************
*/
#if RFAL_FEATURE_NFC_DEP
/* Check for valid Block/Payload length Digital 2.0 Table 90*/
#if((RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN != 64) && (RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN != 128) && \
(RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN != 192) && (RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN != 254))
#error \
" RFAL: Invalid NFC-DEP Block Max length. Please change RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN. "
#endif
/* Check for valid PDU length */
#if((RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN < RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN))
#error " RFAL: Invalid NFC-DEP PDU Max length. Please change RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN. "
#endif
/*
******************************************************************************
* DEFINES
******************************************************************************
*/
#define NFCIP_ATR_RETRY_MAX 2U /*!< Max consecutive retrys of an ATR REQ with transm error*/
#define NFCIP_PSLPAY_LEN (2U) /*!< PSL Payload length (BRS + FSL) */
#define NFCIP_PSLREQ_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< PSL REQ length (incl LEN) */
#define NFCIP_PSLRES_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< PSL RES length (incl LEN) */
#define NFCIP_ATRREQ_BUF_LEN \
(RFAL_NFCDEP_ATRREQ_MAX_LEN + RFAL_NFCDEP_LEN_LEN) /*!< ATR REQ max length (incl LEN) */
#define NFCIP_ATRRES_BUF_LEN \
(RFAL_NFCDEP_ATRRES_MAX_LEN + RFAL_NFCDEP_LEN_LEN) /*!< ATR RES max length (incl LEN) */
#define NFCIP_RLSREQ_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< RLS REQ length (incl LEN) */
#define NFCIP_RLSRES_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< RSL RES length (incl LEN) */
#define NFCIP_RLSRES_MIN \
(2U + RFAL_NFCDEP_LEN_LEN) /*!< Minimum length for a RLS RES (incl LEN) */
#define NFCIP_DSLREQ_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< DSL REQ length (incl LEN) */
#define NFCIP_DSLRES_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< DSL RES length (incl LEN) */
#define NFCIP_DSLRES_MIN \
(2U + RFAL_NFCDEP_LEN_LEN) /*!< Minimum length for a DSL RES (incl LEN) */
#define NFCIP_DSLRES_MAX_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< Maximum length for a DSL RES (incl LEN) */
#define NFCIP_RLSRES_MAX_LEN \
(3U + RFAL_NFCDEP_LEN_LEN) /*!< Minimum length for a RLS RES (incl LEN) */
#define NFCIP_TARGET_RES_MAX \
(MAX(NFCIP_RLSRES_MAX_LEN, NFCIP_DSLRES_MAX_LEN)) /*!< Max target control res length */
#define NFCIP_NO_FWT RFAL_FWT_NONE /*!< No FWT value - Target Mode */
#define NFCIP_INIT_MIN_RTOX 1U /*!< Minimum RTOX value Digital 1.0 14.8.4.1 */
#define NFCIP_INIT_MAX_RTOX 59U /*!< Maximum RTOX value Digital 1.0 14.8.4.1 */
#define NFCIP_TARG_MIN_RTOX 1U /*!< Minimum target RTOX value Digital 1.0 14.8.4.1 */
#define NFCIP_TARG_MAX_RTOX 59U /*!< Maximum target RTOX value Digital 1.0 14.8.4.1 */
#define NFCIP_TRECOV 1280U /*!< Digital 1.0 A.10 Trecov */
#define NFCIP_TIMEOUT_ADJUSTMENT \
3072U /*!< Timeout Adjustment to compensate timing from end of Tx to end of frame */
#define NFCIP_RWT_ACTIVATION \
(0x1000001U + \
NFCIP_TIMEOUT_ADJUSTMENT) /*!< Digital 2.2 B.11 RWT ACTIVATION 2^24 + RWT Delta + Adjustment*/
#define NFCIP_RWT_ACM_ACTIVATION \
(0x200001U + \
NFCIP_TIMEOUT_ADJUSTMENT) /*!< Digital 2.2 B.11 RWT ACTIVATION 2^21 + RWT Delta + Adjustment*/
#define RFAL_NFCDEP_HEADER_PAD \
(RFAL_NFCDEP_DEPREQ_HEADER_LEN - \
RFAL_NFCDEP_LEN_MIN) /*!< Difference between expected rcvd header len and max foreseen */
#ifndef RFAL_NFCDEP_MAX_TX_RETRYS
#define RFAL_NFCDEP_MAX_TX_RETRYS \
(uint8_t)3U /*!< Number of retransmit retyrs */
#endif /* RFAL_NFCDEP_MAX_TX_RETRYS */
#ifndef RFAL_NFCDEP_TO_RETRYS
#define RFAL_NFCDEP_TO_RETRYS \
(uint8_t)3U /*!< Number of retrys for Timeout */
#endif /* RFAL_NFCDEP_TO_RETRYS */
#ifndef RFAL_NFCDEP_MAX_RTOX_RETRYS
#define RFAL_NFCDEP_MAX_RTOX_RETRYS \
(uint8_t)10U /*!< Number of retrys for RTOX Digital 2.0 17.12.4.3 */
#endif /* RFAL_NFCDEP_MAX_RTOX_RETRYS */
#ifndef RFAL_NFCDEP_MAX_NACK_RETRYS
#define RFAL_NFCDEP_MAX_NACK_RETRYS \
(uint8_t)3U /*!< Number of retrys for NACK */
#endif /* RFAL_NFCDEP_MAX_NACK_RETRYS */
#ifndef RFAL_NFCDEP_MAX_ATN_RETRYS
#define RFAL_NFCDEP_MAX_ATN_RETRYS \
(uint8_t)3U /*!< Number of retrys for ATN */
#endif /* RFAL_NFCDEP_MAX_ATN_RETRYS */
#define NFCIP_MIN_TXERROR_LEN \
4U /*!< Minimum frame length with error to be ignored Digital 1.0 14.12.5.4 */
#define NFCIP_REQ (uint8_t)0xD4U /*!<NFCIP REQuest code */
#define NFCIP_RES (uint8_t)0xD5U /*!<NFCIP RESponce code */
#define NFCIP_BS_MASK 0x0FU /*!< Bit mask for BS value on a ATR REQ/RES */
#define NFCIP_BR_MASK NFCIP_BS_MASK /*!< Bit mask for BR value on a ATR REQ/RES */
#define NFCIP_PP_GB_MASK 0x02U /*!< Bit mask for GB value in PP byte on a ATR REQ/RES */
#define NFCIP_PP_NAD_MASK 0x01U /*!< Bit mask for NAD value in PP byte on a ATR REQ/RES */
#define NFCIP_PFB_xPDU_MASK 0xE0U /*!< Bit mask for PDU type */
#define NFCIP_PFB_IPDU 0x00U /*!< Bit mask indicating a Information PDU */
#define NFCIP_PFB_RPDU 0x40U /*!< Bit mask indicating a Response PDU */
#define NFCIP_PFB_SPDU 0x80U /*!< Bit mask indicating a Supervisory PDU */
#define NFCIP_PFB_MI_BIT 0x10U /*!< Bit mask for the chaining bit (MI) of PFB */
#define NFCIP_PFB_DID_BIT 0x04U /*!< Bit mask for the DID presence bit of PFB */
#define NFCIP_PFB_NAD_BIT 0x08U /*!< Bit mask for the NAD presence bit of PFB */
#define NFCIP_PFB_PNI_MASK 0x03U /*!< Bit mask for the Packet Number Information */
#define NFCIP_PFB_Rx_MASK 0x10U /*!< Bit mask for the R-PDU type */
#define NFCIP_PFB_ACK 0x00U /*!< Bit mask for R-PDU indicating ACK */
#define NFCIP_PFB_NACK 0x10U /*!< Bit mask for R-PDU indicating NAK */
#define NFCIP_PFB_Sx_MASK 0x10U /*!< Bit mask for the R-PDU type */
#define NFCIP_PFB_ATN 0x00U /*!< Bit mask for R-PDU indicating ACK */
#define NFCIP_PFB_TO 0x10U /*!< Bit mask for R-PDU indicating NAK */
#define NFCIP_PFB_INVALID 0xFFU /*!< Invalid PFB value */
/*
******************************************************************************
* MACROS
******************************************************************************
*/
#define nfcipIsTransmissionError(e) \
(((e) == ERR_CRC) || ((e) == ERR_FRAMING) || \
((e) == ERR_PAR)) /*!< Checks if is a Trasmission error */
#define nfcipConv1FcToMs(v) \
(rfalConv1fcToMs((v)) + 1U) /*!< Converts value v 1fc into milliseconds (fc=13.56) */
#define nfcipCmdIsReq(cmd) \
(((uint8_t)(cmd) % 2U) == 0U) /*!< Checks if the nfcip cmd is a REQ */
#define nfcip_PFBhasDID(pfb) \
(((pfb)&NFCIP_PFB_DID_BIT) == \
NFCIP_PFB_DID_BIT) /*!< Checks if pfb is signalling DID */
#define nfcip_PFBhasNAD(pfb) \
(((pfb)&NFCIP_PFB_NAD_BIT) == \
NFCIP_PFB_NAD_BIT) /*!< Checks if pfb is signalling NAD */
#define nfcip_PFBisIPDU(pfb) \
(((pfb)&NFCIP_PFB_xPDU_MASK) == \
NFCIP_PFB_IPDU) /*!< Checks if pfb is a Information PDU */
#define nfcip_PFBisRPDU(pfb) \
(((pfb)&NFCIP_PFB_xPDU_MASK) == \
NFCIP_PFB_RPDU) /*!< Checks if pfb is Response PDU */
#define nfcip_PFBisSPDU(pfb) \
(((pfb)&NFCIP_PFB_xPDU_MASK) == \
NFCIP_PFB_SPDU) /*!< Checks if pfb is a Supervisory PDU */
#define nfcip_PFBisIMI(pfb) \
(nfcip_PFBisIPDU(pfb) && \
(((pfb)&NFCIP_PFB_MI_BIT) == \
NFCIP_PFB_MI_BIT)) /*!< Checks if pfb is a Information PDU indicating MI chaining */
#define nfcip_PFBisRNACK(pfb) \
(nfcip_PFBisRPDU(pfb) && (((pfb)&NFCIP_PFB_Rx_MASK) == \
NFCIP_PFB_NACK)) /*!< Checks if pfb is a R-PDU indicating NACK */
#define nfcip_PFBisRACK(pfb) \
(nfcip_PFBisRPDU(pfb) && (((pfb)&NFCIP_PFB_Rx_MASK) == \
NFCIP_PFB_ACK)) /*!< Checks if pfb is a R-PDU indicating ACK */
#define nfcip_PFBisSATN(pfb) \
(nfcip_PFBisSPDU(pfb) && (((pfb)&NFCIP_PFB_Sx_MASK) == \
NFCIP_PFB_ATN)) /*!< Checks if pfb is a R-PDU indicating ATN */
#define nfcip_PFBisSTO(pfb) \
(nfcip_PFBisSPDU(pfb) && (((pfb)&NFCIP_PFB_Sx_MASK) == \
NFCIP_PFB_TO)) /*!< Checks if pfb is a R-PDU indicating TO */
#define nfcip_PFBIPDU(pni) \
((uint8_t)(0x00U | NFCIP_PFB_IPDU | ((pni)&NFCIP_PFB_PNI_MASK))) /*!< Returns a PFB I-PDU with the given packet number (pni) */
#define nfcip_PFBIPDU_MI(pni) \
((uint8_t)(isoDep_PCBIBlock(pni) | NFCIP_PFB_MI_BIT)) /*!< Returns a PFB I-PDU with the given packet number (pni) indicating chaing */
#define nfcip_PFBRPDU(pni) \
((uint8_t)(0x00U | NFCIP_PFB_RPDU | ((pni)&NFCIP_PFB_PNI_MASK))) /*!< Returns a PFB R-PDU with the given packet number (pni) */
#define nfcip_PFBRPDU_NACK(pni) \
((uint8_t)(nfcip_PFBRPDU(pni) | NFCIP_PFB_NACK)) /*!< Returns a PFB R-PDU with the given packet number (pni) indicating NACK */
#define nfcip_PFBRPDU_ACK(pni) \
((uint8_t)(nfcip_PFBRPDU(pni) | NFCIP_PFB_ACK)) /*!< Returns a PFB R-PDU with the given packet number (pni) indicating ACK */
#define nfcip_PFBSPDU() \
((uint8_t)(0x00U | NFCIP_PFB_SPDU)) /*!< Returns a PFB S-PDU */
#define nfcip_PFBSPDU_ATN() \
((uint8_t)(nfcip_PFBSPDU() | NFCIP_PFB_ATN)) /*!< Returns a PFB S-PDU indicating ATN */
#define nfcip_PFBSPDU_TO() \
((uint8_t)(nfcip_PFBSPDU() | NFCIP_PFB_TO)) /*!< Returns a PFB S-PDU indicating TO */
#define nfcip_PNIInc(pni) \
((uint8_t)(((pni) + 1U) & NFCIP_PFB_PNI_MASK)) /*!< Returns a incremented PNI from the given (pni) */
#define nfcip_PNIDec(pni) \
((uint8_t)(((pni)-1U) & NFCIP_PFB_PNI_MASK)) /*!< Returns a decremented PNI from the given (pni) */
#define nfcip_PBF_PNI(pfb) \
((uint8_t)(( \
pfb)&NFCIP_PFB_PNI_MASK)) /*!< Returns the Packet Number Information (pni) */
#define nfcip_PPwGB(lr) \
(rfalNfcDepLR2PP(lr) | \
NFCIP_PP_GB_MASK) /*!< Returns a PP byte containing the given PP value indicating GB */
#define nfcip_DIDMax(did) \
(MIN( \
(did), \
RFAL_NFCDEP_DID_MAX)) /*!< Ensures that the given did has proper value Digital 14.6.2.3 DID [0 14] */
#define nfcip_RTOXTargMax(wt) \
(uint8_t)(MIN( \
(RFAL_NFCDEP_RWT_TRG_MAX / rfalNfcDepWT2RWT(wt)), \
NFCIP_TARG_MAX_RTOX)) /*!< Calculates the Maximum RTOX value for the given wt as a Target */
#define nfcipIsInitiator(st) \
(((st) >= NFCIP_ST_INIT_IDLE) && \
((st) <= \
NFCIP_ST_INIT_RLS)) /*!< Checks if module is set as Initiator */
#define nfcipIsTarget(st) \
(!nfcipIsInitiator( \
st)) /*!< Checks if module is set as Target */
#define nfcipIsBRAllowed(br, mBR) \
(((1U << (br)) & (mBR)) != \
0U) /*!< Checks bit rate is allowed by given mask */
#define nfcipIsEmptyDEPEnabled(op) \
(!nfcipIsEmptyDEPDisabled( \
op)) /*!< Checks if empty payload is allowed by operation config NCI 1.0 Table 81 */
#define nfcipIsEmptyDEPDisabled(op) \
(((op)&RFAL_NFCDEP_OPER_EMPTY_DEP_DIS) != \
0U) /*!< Checks if empty payload is not allowed by operation config NCI 1.0 Table 81 */
#define nfcipIsRTOXReqEnabled(op) \
(!nfcipIsRTOXReqDisabled( \
op)) /*!< Checks if send a RTOX_REQ is allowed by operation config NCI 1.0 Table 81 */
#define nfcipIsRTOXReqDisabled(op) \
(((op)&RFAL_NFCDEP_OPER_RTOX_REQ_DIS) != \
0U) /*!< Checks if send a RTOX_REQ is not allowed by operation config NCI 1.0 Table 81 */
/*! Checks if isDeactivating callback is set and calls it, otherwise returns false */
#define nfcipIsDeactivationPending() \
((gNfcip.isDeactivating == NULL) ? false : gNfcip.isDeactivating())
/*! Returns the RWT Activation according to the current communication mode */
#define nfcipRWTActivation() \
((gNfcip.cfg.commMode == RFAL_NFCDEP_COMM_ACTIVE) ? NFCIP_RWT_ACM_ACTIVATION : \
NFCIP_RWT_ACTIVATION)
#define nfcipRTOXAdjust(v) \
((v) - ((v) >> 3)) /*!< Adjust RTOX timer value to a percentage of the total, current 88% */
/*******************************************************************************/
// timerPollTimeoutValue is necessary after timerCalculateTimeout so that system will wake up upon timer timeout.
#define nfcipTimerStart(timer, time_ms) \
do { \
platformTimerDestroy(timer); \
(timer) = platformTimerCreate((uint16_t)(time_ms)); \
} while(0) /*!< Configures and starts the RTOX timer */
#define nfcipTimerisExpired(timer) \
platformTimerIsExpired(timer) /*!< Checks RTOX timer has expired */
#define nfcipTimerDestroy(timer) \
platformTimerDestroy(timer) /*!< Destroys RTOX timer */
#define nfcipLogE(...) /*!< Macro for the error log method */
#define nfcipLogW(...) /*!< Macro for the warning log method */
#define nfcipLogI(...) /*!< Macro for the info log method */
#define nfcipLogD(...) /*!< Macro for the debug log method */
/*! Digital 1.1 - 16.12.5.2 The Target SHALL NOT attempt any error recovery and remains in Rx mode upon Transmission or a Protocol Error */
#define nfcDepReEnableRx(rxB, rxBL, rxL) \
rfalTransceiveBlockingTx( \
NULL, \
0, \
(rxB), \
(rxBL), \
(rxL), \
(RFAL_TXRX_FLAGS_DEFAULT | (uint32_t)RFAL_TXRX_FLAGS_NFCIP1_ON), \
RFAL_FWT_NONE)
/*
******************************************************************************
* LOCAL DATA TYPES
******************************************************************************
*/
/*! Struct that holds all DEP parameters/configs for the following communications */
typedef struct {
uint8_t did; /*!< Device ID (DID) to be used */
uint8_t* txBuf; /*!< Pointer to the Tx buffer to be sent */
uint16_t txBufLen; /*!< Length of the data in the txBuf */
uint8_t txBufPaylPos; /*!< Position inside txBuf where data starts */
bool txChaining; /*!< Flag indicating chaining on transmission */
uint8_t* rxBuf; /*!< Pointer to the Rx buffer for incoming data */
uint16_t rxBufLen; /*!< Length of the data in the rxBuf */
uint8_t rxBufPaylPos; /*!< Position inside rxBuf where data is to be placed*/
uint32_t fwt; /*!< Frame Waiting Time (FWT) to be used */
uint32_t dFwt; /*!< Delta Frame Waiting Time (dFWT) to be used */
uint16_t fsc; /*!< Frame Size (FSC) to be used */
} rfalNfcDepDEPParams;
/*! NFCIP module states */
typedef enum {
NFCIP_ST_IDLE,
NFCIP_ST_INIT_IDLE,
NFCIP_ST_INIT_ATR,
NFCIP_ST_INIT_PSL,
NFCIP_ST_INIT_DEP_IDLE,
NFCIP_ST_INIT_DEP_TX,
NFCIP_ST_INIT_DEP_RX,
NFCIP_ST_INIT_DEP_ATN,
NFCIP_ST_INIT_DSL,
NFCIP_ST_INIT_RLS,
NFCIP_ST_TARG_WAIT_ATR,
NFCIP_ST_TARG_WAIT_ACTV,
NFCIP_ST_TARG_DEP_IDLE,
NFCIP_ST_TARG_DEP_RX,
NFCIP_ST_TARG_DEP_RTOX,
NFCIP_ST_TARG_DEP_TX,
NFCIP_ST_TARG_DEP_SLEEP
} rfalNfcDepState;
/*! NFCIP commands (Request, Response) */
typedef enum {
NFCIP_CMD_ATR_REQ = 0x00,
NFCIP_CMD_ATR_RES = 0x01,
NFCIP_CMD_WUP_REQ = 0x02,
NFCIP_CMD_WUP_RES = 0x03,
NFCIP_CMD_PSL_REQ = 0x04,
NFCIP_CMD_PSL_RES = 0x05,
NFCIP_CMD_DEP_REQ = 0x06,
NFCIP_CMD_DEP_RES = 0x07,
NFCIP_CMD_DSL_REQ = 0x08,
NFCIP_CMD_DSL_RES = 0x09,
NFCIP_CMD_RLS_REQ = 0x0A,
NFCIP_CMD_RLS_RES = 0x0B
} rfalNfcDepCmd;
/*! Struct that holds all NFCIP data */
typedef struct {
rfalNfcDepConfigs cfg; /*!< Holds the current configuration to be used */
rfalNfcDepState state; /*!< Current state of the NFCIP module */
uint8_t pni; /*!< Packet Number Information (PNI) counter */
uint8_t lastCmd; /*!< Last command sent */
uint8_t lastPFB; /*!< Last PFB sent */
uint8_t lastPFBnATN; /*!< Last PFB sent (excluding ATN) */
uint8_t lastRTOX; /*!< Last RTOX value sent */
uint8_t cntTxRetrys; /*!< Retransmissions counter */
uint8_t cntTORetrys; /*!< Timeouts counter */
uint8_t cntRTOXRetrys; /*!< RTOX counter */
uint8_t cntNACKRetrys; /*!< NACK counter */
uint8_t cntATNRetrys; /*!< Attention (ATN) counter */
uint16_t fsc; /*!< Current Frame Size (FSC) to be used */
bool isTxChaining; /*!< Flag for chaining on Transmission */
bool isRxChaining; /*!< Flag for chaining on Reception */
uint8_t* txBuf; /*!< Pointer to the Tx buffer to be sent */
uint8_t* rxBuf; /*!< Pointer to the Rx buffer for incoming data */
uint16_t txBufLen; /*!< Length of the data in the txBuf */
uint16_t rxBufLen; /*!< Length of rxBuf buffer */
uint16_t* rxRcvdLen; /*!< Length of the data in the rxBuf */
uint8_t txBufPaylPos; /*!< Position in txBuf where data starts */
uint8_t rxBufPaylPos; /*!< Position in rxBuf where data is to be placed */
bool* isChaining; /*!< Flag for chaining on Reception */
rfalNfcDepDevice* nfcDepDev; /*!< Pointer to NFC-DEP device info */
uint32_t RTOXTimer; /*!< Timer used for RTOX */
rfalNfcDepDeactCallback isDeactivating; /*!< Deactivating flag check callback */
bool isReqPending; /*!< Flag pending REQ from Target activation */
bool isTxPending; /*!< Flag pending DEP Block while waiting RTOX Ack */
bool isWait4RTOX; /*!< Flag for waiting RTOX Ack */
rfalNfcDepPduTxRxParam PDUParam; /*!< PDU TxRx params */
uint16_t PDUTxPos; /*!< PDU Tx position */
uint16_t PDURxPos; /*!< PDU Rx position */
bool isPDURxChaining; /*!< PDU Transceive chaining flag */
} rfalNfcDep;
/*
******************************************************************************
* LOCAL VARIABLES
******************************************************************************
*/
static rfalNfcDep gNfcip; /*!< NFCIP module instance */
/*
******************************************************************************
* LOCAL FUNCTION PROTOTYPES
******************************************************************************
*/
static ReturnCode nfcipTxRx(
rfalNfcDepCmd cmd,
uint8_t* txBuf,
uint32_t fwt,
uint8_t* paylBuf,
uint8_t paylBufLen,
uint8_t* rxBuf,
uint16_t rxBufLen,
uint16_t* rxActLen);
static ReturnCode nfcipTx(
rfalNfcDepCmd cmd,
uint8_t* txBuf,
uint8_t* paylBuf,
uint16_t paylLen,
uint8_t pfbData,
uint32_t fwt);
static ReturnCode nfcipDEPControlMsg(uint8_t pfb, uint8_t RTOX);
static ReturnCode nfcipInitiatorHandleDEP(
ReturnCode rxRes,
uint16_t rxLen,
uint16_t* outActRxLen,
bool* outIsChaining);
static ReturnCode
nfcipTargetHandleRX(ReturnCode rxRes, uint16_t* outActRxLen, bool* outIsChaining);
static ReturnCode nfcipTargetHandleActivation(rfalNfcDepDevice* nfcDepDev, uint8_t* outBRS);
/*!
******************************************************************************
* \brief NFCIP Configure
*
* Configures the nfcip layer with the given configurations
*
* \param[in] cfg : nfcip configuration for following communication
******************************************************************************
*/
static void nfcipConfig(const rfalNfcDepConfigs* cfg);
/*!
******************************************************************************
* \brief Set DEP parameters
*
* This method sets the parameters/configs for following Data Exchange
* Sets the nfcip module state according to the role it is configured
*
*
* \warning To be used only after proper Initiator/Target activation:
* nfcipTargetHandleActivation() or nfcipInitiatorActivate() has
* returned success
*
* This must be called before nfcipRun() in case of Target to pass
* rxBuffer
*
* Everytime some data needs to be transmitted call this to set it and
* call nfcipRun() until done or error
*
* \param[in] DEPParams : the parameters to be used during Data Exchange
******************************************************************************
*/
static void nfcipSetDEPParams(const rfalNfcDepDEPParams* DEPParams);
/*!
******************************************************************************
* \brief NFCIP run protocol
*
* This method handles all the nfcip protocol during Data Exchange (DEP
* requests and responses).
*
* A data exchange cycle is considered a DEP REQ and a DEP RES.
*
* In case of Tx chaining(MI) must signal it with nfcipSetDEPParams()
* In case of Rx chaining(MI) outIsChaining will be set to true and the
* current data returned
*
* \param[out] outActRxLen : data received length
* \param[out] outIsChaining : true if other peer is performing chaining(MI)
*
* \return ERR_NONE : Data exchange cycle completed successfully
* \return ERR_TIMEOUT : Timeout occurred
* \return ERR_PROTO : Protocol error occurred
* \return ERR_AGAIN : Other peer is doing chaining(MI), current block
* was received successfully call again until complete
*
******************************************************************************
*/
static ReturnCode nfcipRun(uint16_t* outActRxLen, bool* outIsChaining);
/*!
******************************************************************************
* \brief Transmission method
*
* This method checks if the current communication is Active or Passive
* and performs the necessary procedures for each communication type
*
* Transmits the data hold in txBuf
*
* \param[in] txBuf : buffer to transmit
* \param[in] txBufLen : txBuffer capacity
* \param[in] fwt : fwt for current Tx
*
* \return ERR_NONE : No error
******************************************************************************
*/
static ReturnCode nfcipDataTx(uint8_t* txBuf, uint16_t txBufLen, uint32_t fwt);
/*!
******************************************************************************
* \brief Reception method
*
* This method checks if the current communication is Active or Passive
* and calls the appropriate reception method
*
* Copies incoming data to rxBuf
*
* \param[in] blocking : reception is to be done blocking or non-blocking
*
* \return ERR_BUSY : Busy
* \return ERR_NONE : No error
******************************************************************************
*/
static ReturnCode nfcipDataRx(bool blocking);
/*
******************************************************************************
* LOCAL FUNCTIONS
******************************************************************************
*/
/*******************************************************************************/
/*******************************************************************************/
static bool nfcipDxIsSupported(uint8_t Dx, uint8_t BRx, uint8_t BSx) {
uint8_t Bx;
/* Take the min of the possible bit rates, we'll use one for both directions */
Bx = MIN(BRx, BSx);
/* Lower bit rates must be supported for P2P */
if((Dx <= (uint8_t)RFAL_NFCDEP_Dx_04_424)) {
return true;
}
if((Dx == (uint8_t)RFAL_NFCDEP_Dx_08_848) && (Bx >= (uint8_t)RFAL_NFCDEP_Bx_08_848)) {
return true;
}
return false;
}
/*******************************************************************************/
static ReturnCode nfcipTxRx(
rfalNfcDepCmd cmd,
uint8_t* txBuf,
uint32_t fwt,
uint8_t* paylBuf,
uint8_t paylBufLen,
uint8_t* rxBuf,
uint16_t rxBufLen,
uint16_t* rxActLen) {
ReturnCode ret;
if((cmd == NFCIP_CMD_DEP_REQ) ||
(cmd == NFCIP_CMD_DEP_RES)) /* this method cannot be used for DEPs */
{
return ERR_PARAM;
}
/* Assign the global params for this TxRx */
gNfcip.rxBuf = rxBuf;
gNfcip.rxBufLen = rxBufLen;
gNfcip.rxRcvdLen = rxActLen;
/*******************************************************************************/
/* Transmission */
/*******************************************************************************/
if(txBuf != NULL) /* if nothing to Tx, just do Rx */
{
EXIT_ON_ERR(ret, nfcipTx(cmd, txBuf, paylBuf, paylBufLen, 0, fwt));
}
/*******************************************************************************/
/* Reception */
/*******************************************************************************/
ret = nfcipDataRx(true);
if(ret != ERR_NONE) {
return ret;
}
/*******************************************************************************/
*rxActLen = *rxBuf; /* Use LEN byte instead due to with/without CRC modes */
return ERR_NONE; /* Tx and Rx completed successfully */
}
/*******************************************************************************/
static ReturnCode nfcipDEPControlMsg(uint8_t pfb, uint8_t RTOX) {
uint8_t ctrlMsg[20];
rfalNfcDepCmd depCmd;
uint32_t fwt;
/*******************************************************************************/
/* Calculate Cmd and fwt to be used */
/*******************************************************************************/
depCmd =
((gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) ? NFCIP_CMD_DEP_RES : NFCIP_CMD_DEP_REQ);
fwt =
((gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) ?
NFCIP_NO_FWT :
(nfcip_PFBisSTO(pfb) ? ((RTOX * gNfcip.cfg.fwt) + gNfcip.cfg.dFwt) :
(gNfcip.cfg.fwt + gNfcip.cfg.dFwt)));
if(nfcip_PFBisSTO(pfb)) {
ctrlMsg[RFAL_NFCDEP_DEPREQ_HEADER_LEN] = RTOX;
return nfcipTx(
depCmd, ctrlMsg, &ctrlMsg[RFAL_NFCDEP_DEPREQ_HEADER_LEN], sizeof(uint8_t), pfb, fwt);
} else {
return nfcipTx(depCmd, ctrlMsg, NULL, 0, pfb, fwt);
}
}
/*******************************************************************************/
static void nfcipClearCounters(void) {
gNfcip.cntATNRetrys = 0;
gNfcip.cntNACKRetrys = 0;
gNfcip.cntTORetrys = 0;
gNfcip.cntTxRetrys = 0;
gNfcip.cntRTOXRetrys = 0;
}
/*******************************************************************************/
static ReturnCode nfcipInitiatorHandleDEP(
ReturnCode rxRes,
uint16_t rxLen,
uint16_t* outActRxLen,
bool* outIsChaining) {
ReturnCode ret;
uint8_t nfcDepLen;
uint8_t rxMsgIt;
uint8_t rxPFB;
uint8_t rxRTOX;
uint8_t optHdrLen;
ret = ERR_INTERNAL;
rxMsgIt = 0;
optHdrLen = 0;
*outActRxLen = 0;
*outIsChaining = false;
/*******************************************************************************/
/* Handle reception errors */
/*******************************************************************************/
switch(rxRes) {
/*******************************************************************************/
/* Timeout -> Digital 1.0 14.15.5.6 */
case ERR_TIMEOUT:
nfcipLogI(" NFCIP(I) TIMEOUT TORetrys:%d \r\n", gNfcip.cntTORetrys);
/* Digital 1.0 14.15.5.6 - If nTO >= Max raise protocol error */
if(gNfcip.cntTORetrys++ >= RFAL_NFCDEP_TO_RETRYS) {
return ERR_PROTO;
}
/*******************************************************************************/
/* Upon Timeout error, if Deactivation is pending, no more error recovery
* will be done #54.
* This is used to address the issue some devices that havea big TO.
* Normally LLCP layer has timeout already, and NFCIP layer is still
* running error handling, retrying ATN/NACKs */
/*******************************************************************************/
if(nfcipIsDeactivationPending()) {
nfcipLogI(" skipping error recovery due deactivation pending \r\n");
return ERR_TIMEOUT;
}
/* Digital 1.0 14.15.5.6 1) If last PDU was NACK */
if(nfcip_PFBisRNACK(gNfcip.lastPFB)) {
/* Digital 1.0 14.15.5.6 2) if NACKs failed raise protocol error */
if(gNfcip.cntNACKRetrys++ >= RFAL_NFCDEP_MAX_NACK_RETRYS) {
return ERR_PROTO;
}
/* Send NACK */
nfcipLogI(" NFCIP(I) Sending NACK retry: %d \r\n", gNfcip.cntNACKRetrys);
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBRPDU_NACK(gNfcip.pni), 0));
return ERR_BUSY;
}
nfcipLogI(" NFCIP(I) Checking if to send ATN ATNRetrys: %d \r\n", gNfcip.cntATNRetrys);
/* Digital 1.0 14.15.5.6 3) Otherwise send ATN */
if(gNfcip.cntATNRetrys++ >= RFAL_NFCDEP_MAX_NACK_RETRYS) {
return ERR_PROTO;
}
/* Send ATN */
nfcipLogI(" NFCIP(I) Sending ATN \r\n");
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBSPDU_ATN(), 0));
return ERR_BUSY;
/*******************************************************************************/
/* Data rcvd with error -> Digital 1.0 14.12.5.4 */
case ERR_CRC:
case ERR_PAR:
case ERR_FRAMING:
case ERR_RF_COLLISION:
nfcipLogI(" NFCIP(I) rx Error: %d \r\n", rxRes);
/* Digital 1.0 14.12.5.4 Tx Error with data, ignore */
if(rxLen < NFCIP_MIN_TXERROR_LEN) {
nfcipLogI(" NFCIP(I) Transmission error w data \r\n");
#if 0
if(gNfcip.cfg.commMode == RFAL_NFCDEP_COMM_PASSIVE)
{
nfcipLogI( " NFCIP(I) Transmission error w data -> reEnabling Rx \r\n" );
nfcipReEnableRxTout( NFCIP_TRECOV );
return ERR_BUSY;
}
#endif /* 0 */
}
/* Digital 1.1 16.12.5.4 if NACKs failed raise Transmission error */
if(gNfcip.cntNACKRetrys++ >= RFAL_NFCDEP_MAX_NACK_RETRYS) {
return ERR_FRAMING;
}
/* Send NACK */
nfcipLogI(" NFCIP(I) Sending NACK \r\n");
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBRPDU_NACK(gNfcip.pni), 0));
return ERR_BUSY;
case ERR_NONE:
break;
case ERR_BUSY:
return ERR_BUSY; /* Debug purposes */
default:
nfcipLogW(" NFCIP(I) Error: %d \r\n", rxRes);
return rxRes;
}
/*******************************************************************************/
/* Rx OK check if valid DEP PDU */
/*******************************************************************************/
/* Due to different modes on ST25R391x (with/without CRC) use NFC-DEP LEN instead of bytes retrieved */
nfcDepLen = gNfcip.rxBuf[rxMsgIt++];
nfcipLogD(" NFCIP(I) rx OK: %d bytes \r\n", nfcDepLen);
/* Digital 1.0 14.15.5.5 Protocol Error */
if(gNfcip.rxBuf[rxMsgIt++] != NFCIP_RES) {
nfcipLogW(" NFCIP(I) error %02X instead of %02X \r\n", gNfcip.rxBuf[--rxMsgIt], NFCIP_RES);
return ERR_PROTO;
}
/* Digital 1.0 14.15.5.5 Protocol Error */
if(gNfcip.rxBuf[rxMsgIt++] != (uint8_t)NFCIP_CMD_DEP_RES) {
nfcipLogW(
" NFCIP(I) error %02X instead of %02X \r\n",
gNfcip.rxBuf[--rxMsgIt],
NFCIP_CMD_DEP_RES);
return ERR_PROTO;
}
rxPFB = gNfcip.rxBuf[rxMsgIt++];
/*******************************************************************************/
/* Check for valid PFB type */
if(!(nfcip_PFBisSPDU(rxPFB) || nfcip_PFBisRPDU(rxPFB) || nfcip_PFBisIPDU(rxPFB))) {
return ERR_PROTO;
}
/*******************************************************************************/
/* Digital 1.0 14.8.2.1 check if DID is expected and match -> Protocol Error */
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
if((gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.did) || !nfcip_PFBhasDID(rxPFB)) {
return ERR_PROTO;
}
optHdrLen++; /* Inc header optional field cnt*/
} else if(nfcip_PFBhasDID(rxPFB)) /* DID not expected but rcv */
{
return ERR_PROTO;
} else {
/* MISRA 15.7 - Empty else */
}
/*******************************************************************************/
/* Digital 1.0 14.6.2.8 & 14.6.3.11 NAD must not be used */
if(gNfcip.cfg.nad != RFAL_NFCDEP_NAD_NO) {
if((gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.nad) || !nfcip_PFBhasNAD(rxPFB)) {
return ERR_PROTO;
}
optHdrLen++; /* Inc header optional field cnt*/
} else if(nfcip_PFBhasNAD(rxPFB)) /* NAD not expected but rcv */
{
return ERR_PROTO;
} else {
/* MISRA 15.7 - Empty else */
}
/*******************************************************************************/
/* Process R-PDU */
/*******************************************************************************/
if(nfcip_PFBisRPDU(rxPFB)) {
/*******************************************************************************/
/* R ACK */
/*******************************************************************************/
if(nfcip_PFBisRACK(rxPFB)) {
nfcipLogI(" NFCIP(I) Rcvd ACK \r\n");
if(gNfcip.pni == nfcip_PBF_PNI(rxPFB)) {
/* 14.12.3.3 R-ACK with correct PNI -> Increment */
gNfcip.pni = nfcip_PNIInc(gNfcip.pni);
/* R-ACK while not performing chaining -> Protocol error*/
if(!gNfcip.isTxChaining) {
return ERR_PROTO;
}
nfcipClearCounters();
gNfcip.state = NFCIP_ST_INIT_DEP_IDLE;
return ERR_NONE; /* This block has been transmitted */
} else /* Digital 1.0 14.12.4.5 ACK with wrong PNI Initiator may retransmit */
{
if(gNfcip.cntTxRetrys++ >= RFAL_NFCDEP_MAX_TX_RETRYS) {
return ERR_PROTO;
}
/* Extended the MAY in Digital 1.0 14.12.4.5 to only reTransmit if the ACK
* is for the previous DEP, otherwise raise Protocol immediately
* If the PNI difference is more than 1 it is worthless to reTransmit 3x
* and after raise the error */
if(nfcip_PNIDec(gNfcip.pni) == nfcip_PBF_PNI(rxPFB)) {
/* ReTransmit */
nfcipLogI(" NFCIP(I) Rcvd ACK prev PNI -> reTx \r\n");
gNfcip.state = NFCIP_ST_INIT_DEP_TX;
return ERR_BUSY;
}
nfcipLogI(" NFCIP(I) Rcvd ACK unexpected far PNI -> Error \r\n");
return ERR_PROTO;
}
} else /* Digital 1.0 - 14.12.5.2 Target must never send NACK */
{
return ERR_PROTO;
}
}
/*******************************************************************************/
/* Process S-PDU */
/*******************************************************************************/
if(nfcip_PFBisSPDU(rxPFB)) {
nfcipLogI(" NFCIP(I) Rcvd S-PDU \r\n");
/*******************************************************************************/
/* S ATN */
/*******************************************************************************/
if(nfcip_PFBisSATN(rxPFB)) /* If is a S-ATN */
{
nfcipLogI(" NFCIP(I) Rcvd ATN \r\n");
if(nfcip_PFBisSATN(gNfcip.lastPFB)) /* Check if is expected */
{
gNfcip.cntATNRetrys = 0; /* Clear ATN counter */
/* Although spec is not clear NFC Forum Digital test is expecting to
* retransmit upon receiving ATN_RES */
if(nfcip_PFBisSTO(gNfcip.lastPFBnATN)) {
nfcipLogI(" NFCIP(I) Rcvd ATN -> reTx RTOX_RES \r\n");
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBSPDU_TO(), gNfcip.lastRTOX));
} else {
/* ReTransmit ? */
if(gNfcip.cntTxRetrys++ >= RFAL_NFCDEP_MAX_TX_RETRYS) {
return ERR_PROTO;
}
nfcipLogI(" NFCIP(I) Rcvd ATN -> reTx PNI: %d \r\n", gNfcip.pni);
gNfcip.state = NFCIP_ST_INIT_DEP_TX;
}
return ERR_BUSY;
} else /* Digital 1.0 14.12.4.4 & 14.12.4.8 */
{
return ERR_PROTO;
}
}
/*******************************************************************************/
/* S TO */
/*******************************************************************************/
else if(nfcip_PFBisSTO(rxPFB)) /* If is a S-TO (RTOX) */
{
nfcipLogI(" NFCIP(I) Rcvd TO \r\n");
rxRTOX = gNfcip.rxBuf[rxMsgIt++];
/* Digital 1.1 16.12.4.3 - Initiator MAY stop accepting subsequent RTOX Req *
* - RTOX request to an ATN -> Protocol error */
if((gNfcip.cntRTOXRetrys++ > RFAL_NFCDEP_MAX_RTOX_RETRYS) ||
nfcip_PFBisSATN(gNfcip.lastPFB)) {
return ERR_PROTO;
}
/* Digital 1.1 16.8.4.1 RTOX must be between [1,59] */
if((rxRTOX < NFCIP_INIT_MIN_RTOX) || (rxRTOX > NFCIP_INIT_MAX_RTOX)) {
return ERR_PROTO;
}
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBSPDU_TO(), rxRTOX));
gNfcip.lastRTOX = rxRTOX;
return ERR_BUSY;
} else {
/* Unexpected S-PDU */
return ERR_PROTO; /* PRQA S 2880 # MISRA 2.1 - Guard code to prevent unexpected behavior */
}
}
/*******************************************************************************/
/* Process I-PDU */
/*******************************************************************************/
if(nfcip_PFBisIPDU(rxPFB)) {
if(gNfcip.pni != nfcip_PBF_PNI(rxPFB)) {
nfcipLogI(
" NFCIP(I) Rcvd IPDU wrong PNI curPNI: %d rxPNI: %d \r\n",
gNfcip.pni,
nfcip_PBF_PNI(rxPFB));
return ERR_PROTO;
}
nfcipLogD(" NFCIP(I) Rcvd IPDU OK PNI: %d \r\n", gNfcip.pni);
/* 14.12.3.3 I-PDU with correct PNI -> Increment */
gNfcip.pni = nfcip_PNIInc(gNfcip.pni);
/* Successful data Exchange */
nfcipClearCounters();
*outActRxLen = ((uint16_t)nfcDepLen - RFAL_NFCDEP_DEP_HEADER - (uint16_t)optHdrLen);
if((&gNfcip.rxBuf[gNfcip.rxBufPaylPos] !=
&gNfcip.rxBuf[RFAL_NFCDEP_DEP_HEADER + optHdrLen]) &&
(*outActRxLen > 0U)) {
ST_MEMMOVE(
&gNfcip.rxBuf[gNfcip.rxBufPaylPos],
&gNfcip.rxBuf[RFAL_NFCDEP_DEP_HEADER + optHdrLen],
*outActRxLen);
}
/*******************************************************************************/
/* Check if target is indicating chaining MI */
/*******************************************************************************/
if(nfcip_PFBisIMI(rxPFB)) {
gNfcip.isRxChaining = true;
*outIsChaining = true;
nfcipLogD(" NFCIP(I) Rcvd IPDU OK w MI -> ACK \r\n");
EXIT_ON_ERR(
ret, nfcipDEPControlMsg(nfcip_PFBRPDU_ACK(gNfcip.pni), gNfcip.rxBuf[rxMsgIt++]));
return ERR_AGAIN; /* Send Again signalling to run again, but some chaining data has arrived*/
} else {
gNfcip.isRxChaining = false;
gNfcip.state = NFCIP_ST_INIT_DEP_IDLE;
ret = ERR_NONE; /* Data exchange done */
}
}
return ret;
}
/*******************************************************************************/
static ReturnCode
nfcipTargetHandleRX(ReturnCode rxRes, uint16_t* outActRxLen, bool* outIsChaining) {
ReturnCode ret;
uint8_t nfcDepLen;
uint8_t rxMsgIt;
uint8_t rxPFB;
uint8_t optHdrLen;
uint8_t resBuf[RFAL_NFCDEP_HEADER_PAD + NFCIP_TARGET_RES_MAX];
ret = ERR_INTERNAL;
rxMsgIt = 0;
optHdrLen = 0;
*outActRxLen = 0;
*outIsChaining = false;
/*******************************************************************************/
/* Handle reception errors */
/*******************************************************************************/
switch(rxRes) {
/*******************************************************************************/
case ERR_NONE:
break;
case ERR_LINK_LOSS:
nfcipLogW(" NFCIP(T) Error: %d \r\n", rxRes);
return rxRes;
case ERR_BUSY:
return ERR_BUSY; /* Debug purposes */
case ERR_TIMEOUT:
case ERR_CRC:
case ERR_PAR:
case ERR_FRAMING:
case ERR_PROTO:
default:
/* Digital 1.1 16.12.5.2 The Target MUST NOT attempt any error recovery. *
* The Target MUST always stay in receive mode when a *
* Transmission Error or a Protocol Error occurs. *
* *
* Do not push Transmission/Protocol Errors to upper layer in Listen Mode #766 */
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY;
}
/*******************************************************************************/
/* Rx OK check if valid DEP PDU */
/*******************************************************************************/
/* Due to different modes on ST25R391x (with/without CRC) use NFC-DEP LEN instead of bytes retrieved */
nfcDepLen = gNfcip.rxBuf[rxMsgIt++];
nfcipLogD(" NFCIP(T) rx OK: %d bytes \r\n", nfcDepLen);
if(gNfcip.rxBuf[rxMsgIt++] != NFCIP_REQ) {
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad request */
}
/*******************************************************************************/
/* Check whether target rcvd a normal DEP or deactivation request */
/*******************************************************************************/
switch(gNfcip.rxBuf[rxMsgIt++]) {
/*******************************************************************************/
case(uint8_t)NFCIP_CMD_DEP_REQ:
break; /* Continue to normal DEP processing */
/*******************************************************************************/
case(uint8_t)NFCIP_CMD_DSL_REQ:
nfcipLogI(" NFCIP(T) rx DSL \r\n");
/* Digital 1.0 14.9.1.2 If DID is used and incorrect ignore it */
/* [Digital 1.0, 16.9.1.2]: If DID == 0, Target SHALL ignore DSL_REQ with DID */
if((((gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.did) ||
(nfcDepLen != RFAL_NFCDEP_DSL_RLS_LEN_DID)) &&
(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO)) ||
((gNfcip.cfg.did == RFAL_NFCDEP_DID_NO) &&
(nfcDepLen != RFAL_NFCDEP_DSL_RLS_LEN_NO_DID))) {
nfcipLogI(" NFCIP(T) DSL wrong DID, ignoring \r\n");
return ERR_BUSY;
}
nfcipTx(NFCIP_CMD_DSL_RES, resBuf, NULL, 0, 0, NFCIP_NO_FWT);
gNfcip.state = NFCIP_ST_TARG_DEP_SLEEP;
return ERR_SLEEP_REQ;
/*******************************************************************************/
case(uint8_t)NFCIP_CMD_RLS_REQ:
nfcipLogI(" NFCIP(T) rx RLS \r\n");
/* Digital 1.0 14.10.1.2 If DID is used and incorrect ignore it */
/* [Digital 1.0, 16.10.2.2]: If DID == 0, Target SHALL ignore DSL_REQ with DID */
if((((gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.did) ||
(nfcDepLen != RFAL_NFCDEP_DSL_RLS_LEN_DID)) &&
(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO)) ||
((gNfcip.cfg.did == RFAL_NFCDEP_DID_NO) &&
(nfcDepLen > RFAL_NFCDEP_DSL_RLS_LEN_NO_DID))) {
nfcipLogI(" NFCIP(T) RLS wrong DID, ignoring \r\n");
return ERR_BUSY;
}
nfcipTx(NFCIP_CMD_RLS_RES, resBuf, NULL, 0, 0, NFCIP_NO_FWT);
gNfcip.state = NFCIP_ST_TARG_DEP_IDLE;
return ERR_RELEASE_REQ;
/*******************************************************************************/
/*case NFCIP_CMD_PSL_REQ: PSL must be handled in Activation only */
/*case NFCIP_CMD_WUP_REQ: WUP not in NFC Forum Digital 1.0 */
default:
/* Don't go to NFCIP_ST_TARG_DEP_IDLE state as it needs to ignore this *
* invalid frame, and keep waiting for more frames */
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad frame */
}
/*******************************************************************************/
rxPFB = gNfcip.rxBuf[rxMsgIt++]; /* Store rcvd PFB */
/*******************************************************************************/
/* Check for valid PFB type */
if(!(nfcip_PFBisSPDU(rxPFB) || nfcip_PFBisRPDU(rxPFB) || nfcip_PFBisIPDU(rxPFB))) {
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore invalid PFB */
}
/*******************************************************************************/
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
if(!nfcip_PFBhasDID(rxPFB)) {
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad/missing DID */
}
if(gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.did) /* MISRA 13.5 */
{
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad/missing DID */
}
optHdrLen++; /* Inc header optional field cnt*/
} else if(nfcip_PFBhasDID(rxPFB)) /* DID not expected but rcv */
{
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected DID */
} else {
/* MISRA 15.7 - Empty else */
}
/*******************************************************************************/
if(gNfcip.cfg.nad != RFAL_NFCDEP_NAD_NO) {
if((gNfcip.rxBuf[rxMsgIt++] != gNfcip.cfg.did) || !nfcip_PFBhasDID(rxPFB)) {
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad/missing DID */
}
optHdrLen++; /* Inc header optional field cnt*/
} else if(nfcip_PFBhasNAD(rxPFB)) /* NAD not expected but rcv */
{
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected NAD */
} else {
/* MISRA 15.7 - Empty else */
}
/*******************************************************************************/
/* Process R-PDU */
/*******************************************************************************/
if(nfcip_PFBisRPDU(rxPFB)) {
nfcipLogD(" NFCIP(T) Rcvd R-PDU \r\n");
/*******************************************************************************/
/* R ACK */
/*******************************************************************************/
if(nfcip_PFBisRACK(rxPFB)) {
nfcipLogI(" NFCIP(T) Rcvd ACK \r\n");
if(gNfcip.pni == nfcip_PBF_PNI(rxPFB)) {
/* R-ACK while not performing chaining -> Protocol error */
if(!gNfcip.isTxChaining) {
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected ACK */
}
/* This block has been transmitted and acknowledged, perform RTOX until next data is provided */
/* Digital 1.1 16.12.4.7 - If ACK rcvd continue with chaining or an RTOX */
nfcipTimerStart(
gNfcip.RTOXTimer,
nfcipRTOXAdjust(nfcipConv1FcToMs(rfalNfcDepWT2RWT(gNfcip.cfg.to))));
gNfcip.state = NFCIP_ST_TARG_DEP_RTOX;
return ERR_NONE; /* This block has been transmitted */
}
/* Digital 1.0 14.12.3.4 - If last send was ATN and rx PNI is minus 1 */
else if(
nfcip_PFBisSATN(gNfcip.lastPFB) &&
(nfcip_PNIDec(gNfcip.pni) == nfcip_PBF_PNI(rxPFB))) {
nfcipLogI(" NFCIP(T) wrong PNI, last was ATN reTx \r\n");
/* Spec says to leave current PNI as is, but will be Inc after Tx, remaining the same */
gNfcip.pni = nfcip_PNIDec(gNfcip.pni);
gNfcip.state = NFCIP_ST_TARG_DEP_TX;
return ERR_BUSY;
} else {
/* MISRA 15.7 - Empty else */
}
}
/*******************************************************************************/
/* R NACK */
/*******************************************************************************/
/* ISO 18092 12.6.1.3.3 When rcv NACK if PNI = prev PNI sent -> reTx */
else if(nfcip_PFBisRNACK(rxPFB) && (nfcip_PNIDec(gNfcip.pni) == nfcip_PBF_PNI(rxPFB))) {
nfcipLogI(" NFCIP(T) Rcvd NACK \r\n");
gNfcip.pni = nfcip_PNIDec(gNfcip.pni); /* Dec so that has the prev PNI */
gNfcip.state = NFCIP_ST_TARG_DEP_TX;
return ERR_BUSY;
} else {
nfcipLogI(" NFCIP(T) Unexpected R-PDU \r\n");
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected R-PDU */
}
}
/*******************************************************************************/
/* Process S-PDU */
/*******************************************************************************/
if(nfcip_PFBisSPDU(rxPFB)) {
nfcipLogD(" NFCIP(T) Rcvd S-PDU \r\n");
/*******************************************************************************/
/* S ATN */
/*******************************************************************************/
/* ISO 18092 12.6.3 Attention */
if(nfcip_PFBisSATN(rxPFB)) /* If is a S-ATN */
{
nfcipLogI(" NFCIP(T) Rcvd ATN curPNI: %d \r\n", gNfcip.pni);
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBSPDU_ATN(), 0));
return ERR_BUSY;
}
/*******************************************************************************/
/* S TO */
/*******************************************************************************/
else if(nfcip_PFBisSTO(rxPFB)) /* If is a S-TO (RTOX) */
{
if(nfcip_PFBisSTO(gNfcip.lastPFBnATN)) {
nfcipLogI(" NFCIP(T) Rcvd TO \r\n");
/* Digital 1.1 16.8.4.6 RTOX value in RES different that in REQ -> Protocol Error */
if(gNfcip.lastRTOX != gNfcip.rxBuf[rxMsgIt++]) {
nfcipLogI(" NFCIP(T) Mismatched RTOX value \r\n");
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected RTOX value */
}
/* Clear waiting for RTOX Ack Flag */
gNfcip.isWait4RTOX = false;
/* Check if a Tx is already pending */
if(gNfcip.isTxPending) {
nfcipLogW(" NFCIP(T) Tx pending, go immediately to TX \r\n");
gNfcip.state = NFCIP_ST_TARG_DEP_TX;
return ERR_BUSY;
}
/* Start RTOX timer and change to check state */
nfcipTimerStart(
gNfcip.RTOXTimer,
nfcipRTOXAdjust(
nfcipConv1FcToMs(gNfcip.lastRTOX * rfalNfcDepWT2RWT(gNfcip.cfg.to))));
gNfcip.state = NFCIP_ST_TARG_DEP_RTOX;
return ERR_BUSY;
}
} else {
/* Unexpected S-PDU */
nfcipLogI(
" NFCIP(T) Unexpected S-PDU \r\n"); /* PRQA S 2880 # MISRA 2.1 - Guard code to prevent unexpected behavior */
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore unexpected S-PDU */
}
}
/*******************************************************************************/
/* Process I-PDU */
/*******************************************************************************/
if(nfcip_PFBisIPDU(rxPFB)) {
if(gNfcip.pni != nfcip_PBF_PNI(rxPFB)) {
nfcipLogI(
" NFCIP(T) Rcvd IPDU wrong PNI curPNI: %d rxPNI: %d \r\n",
gNfcip.pni,
nfcip_PBF_PNI(rxPFB));
/* Digital 1.1 16.12.3.4 - If last send was ATN and rx PNI is minus 1 */
if(nfcip_PFBisSATN(gNfcip.lastPFB) &&
(nfcip_PNIDec(gNfcip.pni) == nfcip_PBF_PNI(rxPFB))) {
/* Spec says to leave current PNI as is, but will be Inc after Data Tx, remaining the same */
gNfcip.pni = nfcip_PNIDec(gNfcip.pni);
if(nfcip_PFBisIMI(rxPFB)) {
nfcipLogI(
" NFCIP(T) PNI = prevPNI && ATN before && chaining -> send ACK \r\n");
EXIT_ON_ERR(
ret,
nfcipDEPControlMsg(nfcip_PFBRPDU_ACK(gNfcip.pni), gNfcip.rxBuf[rxMsgIt++]));
/* Digital 1.1 16.12.3.4 (...) leave the current PNI unchanged afterwards */
gNfcip.pni = nfcip_PNIInc(gNfcip.pni);
} else {
nfcipLogI(" NFCIP(T) PNI = prevPNI && ATN before -> reTx last I-PDU \r\n");
gNfcip.state = NFCIP_ST_TARG_DEP_TX;
}
return ERR_BUSY;
}
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
return ERR_BUSY; /* ERR_PROTO - Ignore bad PNI value */
}
nfcipLogD(" NFCIP(T) Rcvd IPDU OK PNI: %d \r\n", gNfcip.pni);
/*******************************************************************************/
/* Successful data exchange */
/*******************************************************************************/
*outActRxLen = ((uint16_t)nfcDepLen - RFAL_NFCDEP_DEP_HEADER - (uint16_t)optHdrLen);
nfcipClearCounters();
if((&gNfcip.rxBuf[gNfcip.rxBufPaylPos] !=
&gNfcip.rxBuf[RFAL_NFCDEP_DEP_HEADER + optHdrLen]) &&
(*outActRxLen > 0U)) {
ST_MEMMOVE(
&gNfcip.rxBuf[gNfcip.rxBufPaylPos],
&gNfcip.rxBuf[RFAL_NFCDEP_DEP_HEADER + optHdrLen],
*outActRxLen);
}
/*******************************************************************************/
/* Check if Initiator is indicating chaining MI */
/*******************************************************************************/
if(nfcip_PFBisIMI(rxPFB)) {
gNfcip.isRxChaining = true;
*outIsChaining = true;
nfcipLogD(" NFCIP(T) Rcvd IPDU OK w MI -> ACK \r\n");
EXIT_ON_ERR(
ret, nfcipDEPControlMsg(nfcip_PFBRPDU_ACK(gNfcip.pni), gNfcip.rxBuf[rxMsgIt++]));
gNfcip.pni = nfcip_PNIInc(gNfcip.pni);
return ERR_AGAIN; /* Send Again signalling to run again, but some chaining data has arrived*/
} else {
if(gNfcip.isRxChaining) {
nfcipLogI(" NFCIP(T) Rcvd last IPDU chaining finished \r\n");
}
/*******************************************************************************/
/* Reception done, send to DH and start RTOX timer */
/*******************************************************************************/
nfcipTimerStart(
gNfcip.RTOXTimer,
nfcipRTOXAdjust(nfcipConv1FcToMs(rfalNfcDepWT2RWT(gNfcip.cfg.to))));
gNfcip.state = NFCIP_ST_TARG_DEP_RTOX;
gNfcip.isRxChaining = false;
ret = ERR_NONE; /* Data exchange done */
}
}
return ret;
}
/*******************************************************************************/
static ReturnCode nfcipTx(
rfalNfcDepCmd cmd,
uint8_t* txBuf,
uint8_t* paylBuf,
uint16_t paylLen,
uint8_t pfbData,
uint32_t fwt) {
uint16_t txBufIt;
uint8_t* txBlock;
uint8_t* payloadBuf;
uint8_t pfb;
if(txBuf == NULL) {
return ERR_PARAM;
}
payloadBuf = paylBuf; /* MISRA 17.8: Use intermediate variable */
if((paylLen == 0U) || (payloadBuf == NULL)) {
payloadBuf = (uint8_t*)&txBuf
[RFAL_NFCDEP_DEPREQ_HEADER_LEN]; /* If not a DEP (no Data) ensure enough space for header */
}
txBufIt = 0;
pfb = pfbData; /* MISRA 17.8: Use intermediate variable */
txBlock = payloadBuf; /* Point to beginning of the Data, and go backwards */
gNfcip.lastCmd = (uint8_t)cmd; /* Store last cmd sent */
gNfcip.lastPFB = NFCIP_PFB_INVALID; /* Reset last pfb sent */
/*******************************************************************************/
/* Compute outgoing NFCIP message */
/*******************************************************************************/
switch(cmd) {
/*******************************************************************************/
case NFCIP_CMD_ATR_RES:
case NFCIP_CMD_ATR_REQ:
rfalNfcDepSetNFCID(payloadBuf, gNfcip.cfg.nfcid, gNfcip.cfg.nfcidLen); /* NFCID */
txBufIt += RFAL_NFCDEP_NFCID3_LEN;
payloadBuf[txBufIt++] = gNfcip.cfg.did; /* DID */
payloadBuf[txBufIt++] = gNfcip.cfg.bs; /* BS */
payloadBuf[txBufIt++] = gNfcip.cfg.br; /* BR */
if(cmd == NFCIP_CMD_ATR_RES) {
payloadBuf[txBufIt++] = gNfcip.cfg.to; /* ATR_RES[ TO ] */
}
if(gNfcip.cfg.gbLen > 0U) {
payloadBuf[txBufIt++] = nfcip_PPwGB(gNfcip.cfg.lr); /* PP signalling GB */
ST_MEMCPY(
&payloadBuf[txBufIt], gNfcip.cfg.gb, gNfcip.cfg.gbLen); /* set General Bytes */
txBufIt += gNfcip.cfg.gbLen;
} else {
payloadBuf[txBufIt++] = rfalNfcDepLR2PP(gNfcip.cfg.lr); /* PP without GB */
}
if((txBufIt + RFAL_NFCDEP_CMDTYPE_LEN + RFAL_NFCDEP_CMD_LEN) >
RFAL_NFCDEP_ATRREQ_MAX_LEN) /* Check max ATR length (ATR_REQ = ATR_RES)*/
{
return ERR_PARAM;
}
break;
/*******************************************************************************/
case NFCIP_CMD_WUP_REQ: /* ISO 18092 - 12.5.2.1 */
rfalNfcDepSetNFCID((payloadBuf), gNfcip.cfg.nfcid, gNfcip.cfg.nfcidLen); /* NFCID */
txBufIt += RFAL_NFCDEP_NFCID3_LEN;
*(--txBlock) = gNfcip.cfg.did; /* DID */
break;
/*******************************************************************************/
case NFCIP_CMD_WUP_RES: /* ISO 18092 - 12.5.2.2 */
case NFCIP_CMD_PSL_REQ:
case NFCIP_CMD_PSL_RES:
*(--txBlock) = gNfcip.cfg.did; /* DID */
break;
/*******************************************************************************/
case NFCIP_CMD_RLS_REQ:
case NFCIP_CMD_RLS_RES:
case NFCIP_CMD_DSL_REQ:
case NFCIP_CMD_DSL_RES:
/* Digital 1.0 - 14.8.1.1 & 14.9.1.1 & 14.10.1.1 Only add DID if not 0 */
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
*(--txBlock) = gNfcip.cfg.did; /* DID */
}
break;
/*******************************************************************************/
case NFCIP_CMD_DEP_REQ:
case NFCIP_CMD_DEP_RES:
/* Compute optional PFB bits */
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
pfb |= NFCIP_PFB_DID_BIT;
}
if(gNfcip.cfg.nad != RFAL_NFCDEP_NAD_NO) {
pfb |= NFCIP_PFB_NAD_BIT;
}
if((gNfcip.isTxChaining) && (nfcip_PFBisIPDU(pfb))) {
pfb |= NFCIP_PFB_MI_BIT;
}
/* Store PFB for future handling */
gNfcip.lastPFB = pfb; /* store PFB sent */
if(!nfcip_PFBisSATN(pfb)) {
gNfcip.lastPFBnATN = pfb; /* store last PFB different then ATN */
}
/* Add NAD if it is to be supported */
if(gNfcip.cfg.nad != RFAL_NFCDEP_NAD_NO) {
*(--txBlock) = gNfcip.cfg.nad; /* NAD */
}
/* Digital 1.0 - 14.8.1.1 & 14.8.1.1 Only add DID if not 0 */
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
*(--txBlock) = gNfcip.cfg.did; /* DID */
}
*(--txBlock) = pfb; /* PFB */
/* NCI 1.0 - Check if Empty frames are allowed */
if((paylLen == 0U) && nfcipIsEmptyDEPDisabled(gNfcip.cfg.oper) && nfcip_PFBisIPDU(pfb)) {
return ERR_PARAM;
}
break;
/*******************************************************************************/
default:
return ERR_PARAM;
}
/*******************************************************************************/
/* Prepend Header */
/*******************************************************************************/
*(--txBlock) = (uint8_t)cmd; /* CMD */
*(--txBlock) = (uint8_t)(nfcipCmdIsReq(cmd) ? NFCIP_REQ : NFCIP_RES); /* CMDType */
txBufIt +=
paylLen +
(uint16_t)((uint32_t)payloadBuf - (uint32_t)txBlock); /* Calculate overall buffer size */
if(txBufIt > gNfcip.fsc) /* Check if msg length violates the maximum payload size FSC */
{
return ERR_NOTSUPP;
}
/*******************************************************************************/
return nfcipDataTx(txBlock, txBufIt, fwt);
}
/*
******************************************************************************
* GLOBAL FUNCTIONS
******************************************************************************
*/
/*******************************************************************************/
static void nfcipConfig(const rfalNfcDepConfigs* cfg) {
if(cfg == NULL) {
return;
}
ST_MEMCPY(&gNfcip.cfg, cfg, sizeof(rfalNfcDepConfigs)); /* Copy given config to local */
gNfcip.cfg.to =
MIN(RFAL_NFCDEP_WT_TRG_MAX, gNfcip.cfg.to); /* Ensure proper WT value */
gNfcip.cfg.did = nfcip_DIDMax(gNfcip.cfg.did); /* Ensure proper DID value */
gNfcip.fsc = rfalNfcDepLR2FS(gNfcip.cfg.lr); /* Calculate FSC based on given LR */
gNfcip.state =
((gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) ? NFCIP_ST_TARG_WAIT_ATR :
NFCIP_ST_INIT_IDLE);
}
/*******************************************************************************/
static ReturnCode nfcipRun(uint16_t* outActRxLen, bool* outIsChaining) {
ReturnCode ret;
ret = ERR_SYNTAX;
nfcipLogD(" NFCIP Run() state: %d \r\n", gNfcip.state);
switch(gNfcip.state) {
/*******************************************************************************/
case NFCIP_ST_IDLE:
case NFCIP_ST_INIT_DEP_IDLE:
case NFCIP_ST_TARG_DEP_IDLE:
case NFCIP_ST_TARG_DEP_SLEEP:
return ERR_NONE;
/*******************************************************************************/
case NFCIP_ST_INIT_DEP_TX:
nfcipLogD(" NFCIP(I) Tx PNI: %d txLen: %d \r\n", gNfcip.pni, gNfcip.txBufLen);
ret = nfcipTx(
NFCIP_CMD_DEP_REQ,
gNfcip.txBuf,
&gNfcip.txBuf[gNfcip.txBufPaylPos],
gNfcip.txBufLen,
nfcip_PFBIPDU(gNfcip.pni),
(gNfcip.cfg.fwt + gNfcip.cfg.dFwt));
switch(ret) {
case ERR_NONE:
gNfcip.state = NFCIP_ST_INIT_DEP_RX;
break;
case ERR_PARAM:
default:
gNfcip.state = NFCIP_ST_INIT_DEP_IDLE;
return ret;
}
/* fall through */
/*******************************************************************************/
case NFCIP_ST_INIT_DEP_RX: /* PRQA S 2003 # MISRA 16.3 - Intentional fall through */
ret = nfcipDataRx(false);
if(ret != ERR_BUSY) {
ret = nfcipInitiatorHandleDEP(ret, *gNfcip.rxRcvdLen, outActRxLen, outIsChaining);
}
break;
/*******************************************************************************/
case NFCIP_ST_TARG_DEP_RTOX:
if(!nfcipTimerisExpired(gNfcip.RTOXTimer)) /* Do nothing until RTOX timer has expired */
{
return ERR_BUSY;
}
/* If we cannot send a RTOX raise a Timeout error so that we do not
* hold the field On forever in AP2P */
if(nfcipIsRTOXReqDisabled(gNfcip.cfg.oper)) {
/* We should reEnable Rx, and measure time between our field Off to
* either report link loss or recover #287 */
nfcipLogI(" NFCIP(T) RTOX not sent due to config, NOT reenabling Rx \r\n");
return ERR_TIMEOUT;
}
if(gNfcip.cntRTOXRetrys++ >
RFAL_NFCDEP_MAX_RTOX_RETRYS) /* Check maximum consecutive RTOX requests */
{
return ERR_PROTO;
}
nfcipLogI(" NFCIP(T) RTOX sent \r\n");
gNfcip.lastRTOX =
nfcip_RTOXTargMax(gNfcip.cfg.to); /* Calculate requested RTOX value, and send it */
EXIT_ON_ERR(ret, nfcipDEPControlMsg(nfcip_PFBSPDU_TO(), gNfcip.lastRTOX));
/* Set waiting for RTOX Ack Flag */
gNfcip.isWait4RTOX = true;
gNfcip.state = NFCIP_ST_TARG_DEP_RX; /* Go back to Rx to process RTOX ack */
return ERR_BUSY;
/*******************************************************************************/
case NFCIP_ST_TARG_DEP_TX:
nfcipLogD(" NFCIP(T) Tx PNI: %d txLen: %d \r\n", gNfcip.pni, gNfcip.txBufLen);
ret = nfcipTx(
NFCIP_CMD_DEP_RES,
gNfcip.txBuf,
&gNfcip.txBuf[gNfcip.txBufPaylPos],
gNfcip.txBufLen,
nfcip_PFBIPDU(gNfcip.pni),
NFCIP_NO_FWT);
/* Clear flags */
gNfcip.isTxPending = false;
gNfcip.isWait4RTOX = false;
/* Digital 1.0 14.12.3.4 Increment the current PNI after Tx */
gNfcip.pni = nfcip_PNIInc(gNfcip.pni);
switch(ret) {
case ERR_NONE:
gNfcip.state = NFCIP_ST_TARG_DEP_RX; /* All OK, goto Rx state */
break;
case ERR_PARAM:
default:
gNfcip.state = NFCIP_ST_TARG_DEP_IDLE; /* Upon Tx error, goto IDLE state */
return ret;
}
/* fall through */
/*******************************************************************************/
case NFCIP_ST_TARG_DEP_RX: /* PRQA S 2003 # MISRA 16.3 - Intentional fall through */
if(gNfcip.isReqPending) /* if already has Data should be from a DEP from nfcipTargetHandleActivation() */
{
nfcipLogD(" NFCIP(T) Skipping Rx Using DEP from Activation \r\n");
gNfcip.isReqPending = false;
ret = ERR_NONE;
} else {
ret = nfcipDataRx(false);
}
if(ret != ERR_BUSY) {
ret = nfcipTargetHandleRX(ret, outActRxLen, outIsChaining);
}
break;
/*******************************************************************************/
default:
/* MISRA 16.4: no empty default statement (a comment being enough) */
break;
}
return ret;
}
/*******************************************************************************/
void rfalNfcDepSetDeactivatingCallback(rfalNfcDepDeactCallback pFunc) {
gNfcip.isDeactivating = pFunc;
}
/*******************************************************************************/
void rfalNfcDepInitialize(void) {
nfcipLogD(" NFCIP Ini() \r\n");
gNfcip.state = NFCIP_ST_IDLE;
gNfcip.isDeactivating = NULL;
gNfcip.isTxPending = false;
gNfcip.isWait4RTOX = false;
gNfcip.isReqPending = false;
gNfcip.cfg.oper =
(RFAL_NFCDEP_OPER_FULL_MI_DIS | RFAL_NFCDEP_OPER_EMPTY_DEP_EN | RFAL_NFCDEP_OPER_ATN_EN |
RFAL_NFCDEP_OPER_RTOX_REQ_EN);
gNfcip.cfg.did = RFAL_NFCDEP_DID_NO;
gNfcip.cfg.nad = RFAL_NFCDEP_NAD_NO;
gNfcip.cfg.br = RFAL_NFCDEP_Bx_NO_HIGH_BR;
gNfcip.cfg.bs = RFAL_NFCDEP_Bx_NO_HIGH_BR;
gNfcip.cfg.lr = RFAL_NFCDEP_LR_254;
gNfcip.fsc = rfalNfcDepLR2FS(gNfcip.cfg.lr);
gNfcip.cfg.gbLen = 0;
gNfcip.cfg.fwt = RFAL_NFCDEP_MAX_FWT;
gNfcip.cfg.dFwt = RFAL_NFCDEP_MAX_FWT;
gNfcip.pni = 0;
/* Destroy any ongoing RTOX timer*/
nfcipTimerDestroy(gNfcip.RTOXTimer);
gNfcip.RTOXTimer = 0U;
gNfcip.PDUTxPos = 0;
gNfcip.PDURxPos = 0;
gNfcip.PDUParam.rxLen = NULL;
gNfcip.PDUParam.rxBuf = NULL;
gNfcip.PDUParam.txBuf = NULL;
nfcipClearCounters();
}
/*******************************************************************************/
static void nfcipSetDEPParams(const rfalNfcDepDEPParams* DEPParams) {
nfcipLogD(" NFCIP SetDEP() txLen: %d \r\n", DEPParams->txBufLen);
gNfcip.isTxChaining = DEPParams->txChaining;
gNfcip.txBuf = DEPParams->txBuf;
gNfcip.rxBuf = DEPParams->rxBuf;
gNfcip.txBufLen = DEPParams->txBufLen;
gNfcip.rxBufLen = DEPParams->rxBufLen;
gNfcip.txBufPaylPos = DEPParams->txBufPaylPos;
gNfcip.rxBufPaylPos = DEPParams->rxBufPaylPos;
if(DEPParams->did != RFAL_NFCDEP_DID_KEEP) {
gNfcip.cfg.did = nfcip_DIDMax(DEPParams->did);
}
gNfcip.cfg.fwt = DEPParams->fwt;
gNfcip.cfg.dFwt = DEPParams->dFwt;
gNfcip.fsc = DEPParams->fsc;
if(gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) {
/* If there's any data to be sent go for Tx */
if(DEPParams->txBufLen > 0U) {
/* Ensure that an RTOX Ack is not being expected at moment */
if(!gNfcip.isWait4RTOX) {
gNfcip.state = NFCIP_ST_TARG_DEP_TX;
return;
} else {
/* If RTOX Ack is expected, signal a pending Tx to be transmitted right after */
gNfcip.isTxPending = true;
nfcipLogW(" NFCIP(T) Waiting RTOX, queueing outgoing DEP Block \r\n");
}
}
/*Digital 1.0 14.12.4.1 In target mode the first PDU MUST be sent by the Initiator */
gNfcip.state = NFCIP_ST_TARG_DEP_RX;
return;
}
/* New data TxRx request clear previous error counters for consecutive TxRx without reseting communication/protocol layer*/
nfcipClearCounters();
gNfcip.state = NFCIP_ST_INIT_DEP_TX;
}
/*******************************************************************************/
bool rfalNfcDepTargetRcvdATR(void) {
return (
(gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) && nfcipIsTarget(gNfcip.state) &&
(gNfcip.state > NFCIP_ST_TARG_WAIT_ATR));
}
/*******************************************************************************/
bool rfalNfcDepIsAtrReq(const uint8_t* buf, uint16_t bufLen, uint8_t* nfcid3) {
uint8_t msgIt;
msgIt = 0;
if((bufLen < RFAL_NFCDEP_ATRREQ_MIN_LEN) || (bufLen > RFAL_NFCDEP_ATRREQ_MAX_LEN)) {
return false;
}
if(buf[msgIt++] != NFCIP_REQ) {
return false;
}
if(buf[msgIt++] != (uint8_t)NFCIP_CMD_ATR_REQ) {
return false;
}
/* Output NFID3 if requested */
if(nfcid3 != NULL) {
ST_MEMCPY(nfcid3, &buf[RFAL_NFCDEP_ATR_REQ_NFCID3_POS], RFAL_NFCDEP_NFCID3_LEN);
}
return true;
}
/*******************************************************************************/
static ReturnCode nfcipTargetHandleActivation(rfalNfcDepDevice* nfcDepDev, uint8_t* outBRS) {
ReturnCode ret;
uint8_t msgIt;
uint8_t txBuf[RFAL_NFCDEP_HEADER_PAD + NFCIP_PSLRES_LEN];
/*******************************************************************************/
/* Check if we are in correct state */
/*******************************************************************************/
if(gNfcip.state != NFCIP_ST_TARG_WAIT_ACTV) {
return ERR_WRONG_STATE;
}
/*******************************************************************************/
/* Check required parameters */
/*******************************************************************************/
if(outBRS == NULL) {
return ERR_PARAM;
}
/*******************************************************************************/
/* Wait and process incoming cmd (PSL / DEP) */
/*******************************************************************************/
ret = nfcipDataRx(false);
if(ret != ERR_NONE) {
return ret;
}
msgIt = 0;
*outBRS = RFAL_NFCDEP_BRS_MAINTAIN; /* set out BRS to be maintained */
msgIt++; /* Skip LEN byte */
if(gNfcip.rxBuf[msgIt++] != NFCIP_REQ) {
return ERR_PROTO;
}
if(gNfcip.rxBuf[msgIt] == (uint8_t)NFCIP_CMD_PSL_REQ) {
msgIt++;
if(gNfcip.rxBuf[msgIt++] != gNfcip.cfg.did) /* Checking DID */
{
return ERR_PROTO;
}
nfcipLogI(" NFCIP(T) PSL REQ rcvd \r\n");
*outBRS = gNfcip.rxBuf[msgIt++]; /* assign output BRS value */
/* Store FSL(LR) and update current config */
gNfcip.cfg.lr = (gNfcip.rxBuf[msgIt++] & RFAL_NFCDEP_LR_VAL_MASK);
gNfcip.fsc = rfalNfcDepLR2FS(gNfcip.cfg.lr);
/*******************************************************************************/
/* Update NFC-DDE Device info */
if(nfcDepDev != NULL) {
/* Update Bitrate info */
/* PRQA S 4342 2 # MISRA 10.5 - Layout of enum rfalBitRate and definition of rfalNfcDepBRS2DSI guarantee no invalid enum values to be created */
nfcDepDev->info.DSI = (rfalBitRate)rfalNfcDepBRS2DSI(
*outBRS); /* DSI codes the bit rate from Initiator to Target */
nfcDepDev->info.DRI = (rfalBitRate)rfalNfcDepBRS2DRI(
*outBRS); /* DRI codes the bit rate from Target to Initiator */
/* Update Length Reduction and Frame Size */
nfcDepDev->info.LR = gNfcip.cfg.lr;
nfcDepDev->info.FS = gNfcip.fsc;
/* Update PPi byte */
nfcDepDev->activation.Initiator.ATR_REQ.PPi &= ~RFAL_NFCDEP_PP_LR_MASK;
nfcDepDev->activation.Initiator.ATR_REQ.PPi |= rfalNfcDepLR2PP(gNfcip.cfg.lr);
}
rfalSetBitRate(RFAL_BR_KEEP, gNfcip.nfcDepDev->info.DSI);
EXIT_ON_ERR(ret, nfcipTx(NFCIP_CMD_PSL_RES, txBuf, NULL, 0, 0, NFCIP_NO_FWT));
} else {
if(gNfcip.rxBuf[msgIt] == (uint8_t)NFCIP_CMD_DEP_REQ) {
msgIt++;
/*******************************************************************************/
/* Digital 1.0 14.12.3.1 PNI must be initialized to 0 */
if(nfcip_PBF_PNI(gNfcip.rxBuf[msgIt]) != 0U) {
return ERR_PROTO;
}
/*******************************************************************************/
/* Digital 1.0 14.8.2.1 check if DID is expected and match -> Protocol Error */
if(nfcip_PFBhasDID(gNfcip.rxBuf[msgIt])) {
if(gNfcip.rxBuf[++msgIt] != gNfcip.cfg.did) {
return ERR_PROTO;
}
} else if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) /* DID expected but not rcv */
{
return ERR_PROTO;
} else {
/* MISRA 15.7 - Empty else */
}
}
/* Signal Request pending to be digested on normal Handling (DEP_REQ, DSL_REQ, RLS_REQ) */
gNfcip.isReqPending = true;
}
gNfcip.state = NFCIP_ST_TARG_DEP_RX;
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode
rfalNfcDepATR(const rfalNfcDepAtrParam* param, rfalNfcDepAtrRes* atrRes, uint8_t* atrResLen) {
ReturnCode ret;
rfalNfcDepConfigs cfg;
uint16_t rxLen;
uint8_t msgIt;
uint8_t txBuf[RFAL_NFCDEP_ATRREQ_MAX_LEN];
uint8_t rxBuf[NFCIP_ATRRES_BUF_LEN];
if((param == NULL) || (atrRes == NULL) || (atrResLen == NULL)) {
return ERR_PARAM;
}
/*******************************************************************************/
/* Configure NFC-DEP layer */
/*******************************************************************************/
cfg.did = param->DID;
cfg.nad = param->NAD;
cfg.fwt = RFAL_NFCDEP_MAX_FWT;
cfg.dFwt = RFAL_NFCDEP_MAX_FWT;
cfg.br = param->BR;
cfg.bs = param->BS;
cfg.lr = param->LR;
cfg.to = RFAL_NFCDEP_WT_TRG_MAX; /* Not used in Initiator mode */
cfg.gbLen = param->GBLen;
if(cfg.gbLen > 0U) /* MISRA 21.18 */
{
ST_MEMCPY(cfg.gb, param->GB, cfg.gbLen);
}
cfg.nfcidLen = param->nfcidLen;
if(cfg.nfcidLen > 0U) /* MISRA 21.18 */
{
ST_MEMCPY(cfg.nfcid, param->nfcid, cfg.nfcidLen);
}
cfg.role = RFAL_NFCDEP_ROLE_INITIATOR;
cfg.oper = param->operParam;
cfg.commMode = param->commMode;
rfalNfcDepInitialize();
nfcipConfig(&cfg);
/*******************************************************************************/
/* Send ATR_REQ */
/*******************************************************************************/
EXIT_ON_ERR(
ret,
nfcipTxRx(
NFCIP_CMD_ATR_REQ,
txBuf,
nfcipRWTActivation(),
NULL,
0,
rxBuf,
NFCIP_ATRRES_BUF_LEN,
&rxLen));
/*******************************************************************************/
/* ATR sent, check response */
/*******************************************************************************/
msgIt = 0;
rxLen = ((uint16_t)rxBuf[msgIt++] - RFAL_NFCDEP_LEN_LEN); /* use LEN byte */
if((rxLen < RFAL_NFCDEP_ATRRES_MIN_LEN) ||
(rxLen > RFAL_NFCDEP_ATRRES_MAX_LEN)) /* Checking length: ATR_RES */
{
return ERR_PROTO;
}
if(rxBuf[msgIt++] != NFCIP_RES) /* Checking if is a response*/
{
return ERR_PROTO;
}
if(rxBuf[msgIt++] != (uint8_t)NFCIP_CMD_ATR_RES) /* Checking if is a ATR RES */
{
return ERR_PROTO;
}
ST_MEMCPY((uint8_t*)atrRes, (rxBuf + RFAL_NFCDEP_LEN_LEN), rxLen);
*atrResLen = (uint8_t)rxLen;
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepPSL(uint8_t BRS, uint8_t FSL) {
ReturnCode ret;
uint16_t rxLen;
uint8_t msgIt;
uint8_t txBuf[NFCIP_PSLREQ_LEN + NFCIP_PSLPAY_LEN];
uint8_t rxBuf[NFCIP_PSLRES_LEN];
msgIt = NFCIP_PSLREQ_LEN;
txBuf[msgIt++] = BRS;
txBuf[msgIt++] = FSL;
/*******************************************************************************/
/* Send PSL REQ and wait for response */
/*******************************************************************************/
EXIT_ON_ERR(
ret,
nfcipTxRx(
NFCIP_CMD_PSL_REQ,
txBuf,
nfcipRWTActivation(),
&txBuf[NFCIP_PSLREQ_LEN],
(msgIt - NFCIP_PSLREQ_LEN),
rxBuf,
NFCIP_PSLRES_LEN,
&rxLen));
/*******************************************************************************/
/* PSL sent, check response */
/*******************************************************************************/
msgIt = 0;
rxLen = (uint16_t)(rxBuf[msgIt++]); /* use LEN byte */
if(rxLen < NFCIP_PSLRES_LEN) /* Checking length: LEN + RLS_RES */
{
return ERR_PROTO;
}
if(rxBuf[msgIt++] != NFCIP_RES) /* Checking if is a response */
{
return ERR_PROTO;
}
if(rxBuf[msgIt++] != (uint8_t)NFCIP_CMD_PSL_RES) /* Checking if is a PSL RES */
{
return ERR_PROTO;
}
if(rxBuf[msgIt++] != gNfcip.cfg.did) /* Checking DID */
{
return ERR_PROTO;
}
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepDSL(void) {
ReturnCode ret;
uint8_t txBuf[RFAL_NFCDEP_HEADER_PAD + NFCIP_DSLREQ_LEN];
uint8_t rxBuf[NFCIP_DSLRES_LEN];
uint8_t rxMsgIt;
uint16_t rxLen = 0;
if(gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) {
return ERR_NONE; /* Target has no deselect procedure */
}
/* Repeating a DSL REQ is optional, not doing it */
EXIT_ON_ERR(
ret,
nfcipTxRx(
NFCIP_CMD_DSL_REQ,
txBuf,
nfcipRWTActivation(),
NULL,
0,
rxBuf,
(uint16_t)sizeof(rxBuf),
&rxLen));
/*******************************************************************************/
rxMsgIt = 0;
if(rxBuf[rxMsgIt++] < NFCIP_DSLRES_MIN) /* Checking length: LEN + DSL_RES */
{
return ERR_PROTO;
}
if(rxBuf[rxMsgIt++] != NFCIP_RES) /* Checking if is a response */
{
return ERR_PROTO;
}
if(rxBuf[rxMsgIt++] != (uint8_t)NFCIP_CMD_DSL_RES) /* Checking if is DSL RES */
{
return ERR_PROTO;
}
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
if(rxBuf[rxMsgIt++] != gNfcip.cfg.did) {
return ERR_PROTO;
}
}
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepRLS(void) {
ReturnCode ret;
uint8_t txBuf[RFAL_NFCDEP_HEADER_PAD + NFCIP_RLSREQ_LEN];
uint8_t rxBuf[NFCIP_RLSRES_LEN];
uint8_t rxMsgIt;
uint16_t rxLen = 0;
if(gNfcip.cfg.role == RFAL_NFCDEP_ROLE_TARGET) /* Target has no release procedure */
{
return ERR_NONE;
}
/* Repeating a RLS REQ is optional, not doing it */
EXIT_ON_ERR(
ret,
nfcipTxRx(
NFCIP_CMD_RLS_REQ,
txBuf,
nfcipRWTActivation(),
NULL,
0,
rxBuf,
(uint16_t)sizeof(rxBuf),
&rxLen));
/*******************************************************************************/
rxMsgIt = 0;
if(rxBuf[rxMsgIt++] < NFCIP_RLSRES_MIN) /* Checking length: LEN + RLS_RES */
{
return ERR_PROTO;
}
if(rxBuf[rxMsgIt++] != NFCIP_RES) /* Checking if is a response */
{
return ERR_PROTO;
}
if(rxBuf[rxMsgIt++] != (uint8_t)NFCIP_CMD_RLS_RES) /* Checking if is RLS RES */
{
return ERR_PROTO;
}
if(gNfcip.cfg.did != RFAL_NFCDEP_DID_NO) {
if(rxBuf[rxMsgIt++] != gNfcip.cfg.did) {
return ERR_PROTO;
}
}
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepInitiatorHandleActivation(
rfalNfcDepAtrParam* param,
rfalBitRate desiredBR,
rfalNfcDepDevice* nfcDepDev) {
ReturnCode ret;
uint8_t maxRetyrs;
uint8_t PSL_BRS;
uint8_t PSL_FSL;
bool sendPSL;
if((param == NULL) || (nfcDepDev == NULL)) {
return ERR_PARAM;
}
param->NAD = RFAL_NFCDEP_NAD_NO; /* Digital 1.1 16.6.2.9 Initiator SHALL NOT use NAD */
maxRetyrs = NFCIP_ATR_RETRY_MAX;
/*******************************************************************************/
/* Send ATR REQ and wait for response */
/*******************************************************************************/
do { /* Upon transmission error ATR REQ should be retried */
ret = rfalNfcDepATR(
param,
&nfcDepDev->activation.Target.ATR_RES,
&nfcDepDev->activation.Target.ATR_RESLen);
if(nfcipIsTransmissionError(ret)) {
continue;
}
break;
} while((maxRetyrs--) != 0U);
if(ret != ERR_NONE) {
return ret;
}
/*******************************************************************************/
/* Compute NFC-DEP device with ATR_RES */
/*******************************************************************************/
nfcDepDev->info.GBLen = (nfcDepDev->activation.Target.ATR_RESLen - RFAL_NFCDEP_ATRRES_MIN_LEN);
nfcDepDev->info.DID = nfcDepDev->activation.Target.ATR_RES.DID;
nfcDepDev->info.NAD =
RFAL_NFCDEP_NAD_NO; /* Digital 1.1 16.6.3.11 Initiator SHALL ignore b1 of PPt */
nfcDepDev->info.LR = rfalNfcDepPP2LR(nfcDepDev->activation.Target.ATR_RES.PPt);
nfcDepDev->info.FS = rfalNfcDepLR2FS(nfcDepDev->info.LR);
nfcDepDev->info.WT = (nfcDepDev->activation.Target.ATR_RES.TO & RFAL_NFCDEP_WT_MASK);
nfcDepDev->info.FWT = rfalNfcDepCalculateRWT(nfcDepDev->info.WT);
nfcDepDev->info.dFWT = RFAL_NFCDEP_WT_DELTA;
rfalGetBitRate(&nfcDepDev->info.DSI, &nfcDepDev->info.DRI);
/*******************************************************************************/
/* Check if a PSL needs to be sent */
/*******************************************************************************/
sendPSL = false;
PSL_BRS = rfalNfcDepDx2BRS(
nfcDepDev->info.DSI); /* Set current bit rate divisor on both directions */
PSL_FSL = nfcDepDev->info.LR; /* Set current Frame Size */
/* Activity 1.0 9.4.4.15 & 9.4.6.3 NFC-DEP Activation PSL
* Activity 2.0 9.4.4.17 & 9.4.6.6 NFC-DEP Activation PSL
*
* PSL_REQ shall only be sent if desired bit rate is different from current (Activity 1.0)
* PSL_REQ shall be sent to update LR or bit rate (Activity 2.0)
* */
#if 0 /* PSL due to LR is disabled, can be enabled if desired*/
/*******************************************************************************/
/* Check Frame Size */
/*******************************************************************************/
if( gNfcip.cfg.lr < nfcDepDev->info.LR ) /* If our Length reduction is smaller */
{
sendPSL = true;
nfcDepDev->info.LR = MIN( nfcDepDev->info.LR, gNfcip.cfg.lr );
gNfcip.cfg.lr = nfcDepDev->info.LR; /* Update nfcip LR to be used */
gNfcip.fsc = rfalNfcDepLR2FS( gNfcip.cfg.lr ); /* Update nfcip FSC to be used */
PSL_FSL = gNfcip.cfg.lr; /* Set LR to be sent */
nfcipLogI( " NFCIP(I) Frame Size differ, PSL new fsc: %d \r\n", gNfcip.fsc );
}
#endif
/*******************************************************************************/
/* Check Baud rates */
/*******************************************************************************/
if((nfcDepDev->info.DSI != desiredBR) &&
(desiredBR != RFAL_BR_KEEP)) /* if desired BR is different */
{
if(nfcipDxIsSupported(
(uint8_t)desiredBR,
nfcDepDev->activation.Target.ATR_RES.BRt,
nfcDepDev->activation.Target.ATR_RES
.BSt)) /* if desired BR is supported */ /* MISRA 13.5 */
{
sendPSL = true;
PSL_BRS = rfalNfcDepDx2BRS(desiredBR);
nfcipLogI(" NFCIP(I) BR differ, PSL BR: 0x%02X \r\n", PSL_BRS);
}
}
/*******************************************************************************/
if(sendPSL) {
/*******************************************************************************/
/* Send PSL REQ and wait for response */
/*******************************************************************************/
EXIT_ON_ERR(ret, rfalNfcDepPSL(PSL_BRS, PSL_FSL));
/* Check if bit rate has been changed */
if(nfcDepDev->info.DSI != desiredBR) {
/* Check if device was in Passive NFC-A and went to higher bit rates, use NFC-F */
if((nfcDepDev->info.DSI == RFAL_BR_106) &&
(gNfcip.cfg.commMode == RFAL_NFCDEP_COMM_PASSIVE)) {
#if RFAL_FEATURE_NFCF
/* If Passive initialize NFC-F module */
rfalNfcfPollerInitialize(desiredBR);
#else /* RFAL_FEATURE_NFCF */
return ERR_NOTSUPP;
#endif /* RFAL_FEATURE_NFCF */
}
nfcDepDev->info.DRI = desiredBR; /* DSI Bit Rate coding from Initiator to Target */
nfcDepDev->info.DSI = desiredBR; /* DRI Bit Rate coding from Target to Initiator */
rfalSetBitRate(nfcDepDev->info.DSI, nfcDepDev->info.DRI);
}
return ERR_NONE; /* PSL has been sent */
}
return ERR_NONE; /* No PSL has been sent */
}
/*******************************************************************************/
uint32_t rfalNfcDepCalculateRWT(uint8_t wt) {
/* Digital 1.0 14.6.3.8 & Digital 1.1 16.6.3.9 */
/* Digital 1.1 16.6.3.9 treat all RFU values as WT=14 */
uint8_t responseWaitTime = MIN(RFAL_NFCDEP_WT_INI_MAX, wt);
return (uint32_t)rfalNfcDepWT2RWT(responseWaitTime);
}
/*******************************************************************************/
static ReturnCode nfcipDataTx(uint8_t* txBuf, uint16_t txBufLen, uint32_t fwt) {
return rfalTransceiveBlockingTx(
txBuf,
txBufLen,
gNfcip.rxBuf,
gNfcip.rxBufLen,
gNfcip.rxRcvdLen,
(RFAL_TXRX_FLAGS_DEFAULT | (uint32_t)RFAL_TXRX_FLAGS_NFCIP1_ON),
((fwt == NFCIP_NO_FWT) ? RFAL_FWT_NONE : fwt));
}
/*******************************************************************************/
static ReturnCode nfcipDataRx(bool blocking) {
ReturnCode ret;
/* Perform Rx either blocking or non-blocking */
if(blocking) {
ret = rfalTransceiveBlockingRx();
} else {
ret = rfalGetTransceiveStatus();
}
if(ret != ERR_BUSY) {
if(gNfcip.rxRcvdLen != NULL) {
(*gNfcip.rxRcvdLen) = rfalConvBitsToBytes(*gNfcip.rxRcvdLen);
if((ret == ERR_NONE) && (gNfcip.rxBuf != NULL)) {
/* Digital 1.1 16.4.1.3 - Length byte LEN SHALL have a value between 3 and 255 -> otherwise treat as Transmission Error *
* - Ensure that actual received and frame length do match, otherwise treat as Transmission error */
if((*gNfcip.rxRcvdLen != (uint16_t)*gNfcip.rxBuf) ||
(*gNfcip.rxRcvdLen < RFAL_NFCDEP_LEN_MIN) ||
(*gNfcip.rxRcvdLen > RFAL_NFCDEP_LEN_MAX)) {
return ERR_FRAMING;
}
}
}
}
return ret;
}
/*******************************************************************************/
ReturnCode rfalNfcDepListenStartActivation(
const rfalNfcDepTargetParam* param,
const uint8_t* atrReq,
uint16_t atrReqLength,
rfalNfcDepListenActvParam rxParam) {
ReturnCode ret;
rfalNfcDepConfigs cfg;
if((param == NULL) || (atrReq == NULL) || (rxParam.rxLen == NULL)) {
return ERR_PARAM;
}
/*******************************************************************************/
/* Check whether is a valid ATR_REQ Compute NFC-DEP device */
if(!rfalNfcDepIsAtrReq(atrReq, atrReqLength, NULL)) {
return ERR_PARAM;
}
rxParam.nfcDepDev->activation.Initiator.ATR_REQLen =
(uint8_t)atrReqLength; /* nfcipIsAtrReq() is already checking Min and Max buffer lengths */
if(atrReqLength > 0U) /* MISRA 21.18 */
{
ST_MEMCPY(
(uint8_t*)&rxParam.nfcDepDev->activation.Initiator.ATR_REQ, atrReq, atrReqLength);
}
rxParam.nfcDepDev->info.GBLen = (uint8_t)(atrReqLength - RFAL_NFCDEP_ATRREQ_MIN_LEN);
rxParam.nfcDepDev->info.DID = rxParam.nfcDepDev->activation.Initiator.ATR_REQ.DID;
rxParam.nfcDepDev->info.NAD =
RFAL_NFCDEP_NAD_NO; /* Digital 1.1 16.6.2.9 Initiator SHALL NOT use NAD */
rxParam.nfcDepDev->info.LR =
rfalNfcDepPP2LR(rxParam.nfcDepDev->activation.Initiator.ATR_REQ.PPi);
rxParam.nfcDepDev->info.FS = rfalNfcDepLR2FS(rxParam.nfcDepDev->info.LR);
rxParam.nfcDepDev->info.WT = 0;
rxParam.nfcDepDev->info.FWT = NFCIP_NO_FWT;
rxParam.nfcDepDev->info.dFWT = NFCIP_NO_FWT;
rfalGetBitRate(&rxParam.nfcDepDev->info.DSI, &rxParam.nfcDepDev->info.DRI);
/* Store Device Info location, updated upon a PSL */
gNfcip.nfcDepDev = rxParam.nfcDepDev;
/*******************************************************************************/
cfg.did = rxParam.nfcDepDev->activation.Initiator.ATR_REQ.DID;
cfg.nad = RFAL_NFCDEP_NAD_NO;
cfg.fwt = RFAL_NFCDEP_MAX_FWT;
cfg.dFwt = RFAL_NFCDEP_MAX_FWT;
cfg.br = param->brt;
cfg.bs = param->bst;
cfg.lr = rfalNfcDepPP2LR(param->ppt);
cfg.gbLen = param->GBtLen;
if(cfg.gbLen > 0U) /* MISRA 21.18 */
{
ST_MEMCPY(cfg.gb, param->GBt, cfg.gbLen);
}
cfg.nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
ST_MEMCPY(cfg.nfcid, param->nfcid3, RFAL_NFCDEP_NFCID3_LEN);
cfg.to = param->to;
cfg.role = RFAL_NFCDEP_ROLE_TARGET;
cfg.oper = param->operParam;
cfg.commMode = param->commMode;
rfalNfcDepInitialize();
nfcipConfig(&cfg);
/*******************************************************************************/
/* Reply with ATR RES to Initiator */
/*******************************************************************************/
gNfcip.rxBuf = (uint8_t*)rxParam.rxBuf;
gNfcip.rxBufLen = sizeof(rfalNfcDepBufFormat);
gNfcip.rxRcvdLen = rxParam.rxLen;
gNfcip.rxBufPaylPos = RFAL_NFCDEP_DEPREQ_HEADER_LEN;
gNfcip.isChaining = rxParam.isRxChaining;
gNfcip.txBufPaylPos = RFAL_NFCDEP_DEPREQ_HEADER_LEN;
EXIT_ON_ERR(ret, nfcipTx(NFCIP_CMD_ATR_RES, (uint8_t*)gNfcip.rxBuf, NULL, 0, 0, NFCIP_NO_FWT));
gNfcip.state = NFCIP_ST_TARG_WAIT_ACTV;
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepListenGetActivationStatus(void) {
ReturnCode err;
uint8_t BRS;
BRS = RFAL_NFCDEP_BRS_MAINTAIN;
err = nfcipTargetHandleActivation(gNfcip.nfcDepDev, &BRS);
switch(err) {
case ERR_NONE:
if(BRS != RFAL_NFCDEP_BRS_MAINTAIN) {
/* DSI codes the bit rate from Initiator to Target */
/* DRI codes the bit rate from Target to Initiator */
if(gNfcip.cfg.commMode == RFAL_NFCDEP_COMM_ACTIVE) {
EXIT_ON_ERR(
err,
rfalSetMode(
RFAL_MODE_LISTEN_ACTIVE_P2P,
gNfcip.nfcDepDev->info.DRI,
gNfcip.nfcDepDev->info.DSI));
} else {
EXIT_ON_ERR(
err,
rfalSetMode(
((RFAL_BR_106 == gNfcip.nfcDepDev->info.DRI) ? RFAL_MODE_LISTEN_NFCA :
RFAL_MODE_LISTEN_NFCF),
gNfcip.nfcDepDev->info.DRI,
gNfcip.nfcDepDev->info.DSI));
}
}
break;
case ERR_BUSY:
// do nothing
break;
case ERR_PROTO:
default:
// re-enable receiving of data
nfcDepReEnableRx(gNfcip.rxBuf, gNfcip.rxBufLen, gNfcip.rxRcvdLen);
break;
}
return err;
}
/*******************************************************************************/
ReturnCode rfalNfcDepStartTransceive(const rfalNfcDepTxRxParam* param) {
rfalNfcDepDEPParams nfcDepParams;
nfcDepParams.txBuf = (uint8_t*)param->txBuf;
nfcDepParams.txBufLen = param->txBufLen;
nfcDepParams.txChaining = param->isTxChaining;
nfcDepParams.txBufPaylPos =
RFAL_NFCDEP_DEPREQ_HEADER_LEN; /* position in txBuf where actual outgoing data is located */
nfcDepParams.did = RFAL_NFCDEP_DID_KEEP;
nfcDepParams.rxBufPaylPos = RFAL_NFCDEP_DEPREQ_HEADER_LEN;
nfcDepParams.rxBuf = (uint8_t*)param->rxBuf;
nfcDepParams.rxBufLen = sizeof(rfalNfcDepBufFormat);
nfcDepParams.fsc = param->FSx;
nfcDepParams.fwt = param->FWT;
nfcDepParams.dFwt = param->dFWT;
gNfcip.rxRcvdLen = param->rxLen;
gNfcip.isChaining = param->isRxChaining;
nfcipSetDEPParams(&nfcDepParams);
return ERR_NONE;
}
/*******************************************************************************/
ReturnCode rfalNfcDepGetTransceiveStatus(void) {
return nfcipRun(gNfcip.rxRcvdLen, gNfcip.isChaining);
}
/*******************************************************************************/
static void rfalNfcDepPdu2BLockParam(
rfalNfcDepPduTxRxParam pduParam,
rfalNfcDepTxRxParam* blockParam,
uint16_t txPos,
uint16_t rxPos) {
uint16_t maxInfLen;
NO_WARNING(rxPos); /* Keep this param for future use */
blockParam->DID = pduParam.DID;
blockParam->FSx = pduParam.FSx;
blockParam->FWT = pduParam.FWT;
blockParam->dFWT = pduParam.dFWT;
/* Calculate max INF/Payload to be sent to other device */
maxInfLen = (blockParam->FSx - (RFAL_NFCDEP_HEADER + RFAL_NFCDEP_DEP_PFB_LEN));
maxInfLen += ((blockParam->DID != RFAL_NFCDEP_DID_NO) ? RFAL_NFCDEP_DID_LEN : 0U);
if((pduParam.txBufLen - txPos) > maxInfLen) {
blockParam->isTxChaining = true;
blockParam->txBufLen = maxInfLen;
} else {
blockParam->isTxChaining = false;
blockParam->txBufLen = (pduParam.txBufLen - txPos);
}
/* TxBuf is moved to the beginning for every Block */
blockParam->txBuf =
(rfalNfcDepBufFormat*)pduParam
.txBuf; /* PRQA S 0310 # MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication */
blockParam->rxBuf =
pduParam
.tmpBuf; /* Simply using the pdu buffer is not possible because of current ACK handling */
blockParam->isRxChaining = &gNfcip.isPDURxChaining;
blockParam->rxLen = pduParam.rxLen;
}
/*******************************************************************************/
ReturnCode rfalNfcDepStartPduTransceive(rfalNfcDepPduTxRxParam param) {
rfalNfcDepTxRxParam txRxParam;
/* Initialize and store APDU context */
gNfcip.PDUParam = param;
gNfcip.PDUTxPos = 0;
gNfcip.PDURxPos = 0;
/* Convert PDU TxRxParams to Block TxRxParams */
rfalNfcDepPdu2BLockParam(gNfcip.PDUParam, &txRxParam, gNfcip.PDUTxPos, gNfcip.PDURxPos);
return rfalNfcDepStartTransceive(&txRxParam);
}
/*******************************************************************************/
ReturnCode rfalNfcDepGetPduTransceiveStatus(void) {
ReturnCode ret;
rfalNfcDepTxRxParam txRxParam;
ret = rfalNfcDepGetTransceiveStatus();
switch(ret) {
/*******************************************************************************/
case ERR_NONE:
/* Check if we are still doing chaining on Tx */
if(gNfcip.isTxChaining) {
/* Add already Tx bytes */
gNfcip.PDUTxPos += gNfcip.txBufLen;
/* Convert APDU TxRxParams to I-Block TxRxParams */
rfalNfcDepPdu2BLockParam(
gNfcip.PDUParam, &txRxParam, gNfcip.PDUTxPos, gNfcip.PDURxPos);
if(txRxParam.txBufLen > 0U) /* MISRA 21.18 */
{
/* Move next Block to beginning of APDU Tx buffer */
ST_MEMCPY(
gNfcip.PDUParam.txBuf->pdu,
&gNfcip.PDUParam.txBuf->pdu[gNfcip.PDUTxPos],
txRxParam.txBufLen);
}
EXIT_ON_ERR(ret, rfalNfcDepStartTransceive(&txRxParam));
return ERR_BUSY;
}
/* PDU TxRx is done */
/* fall through */
/*******************************************************************************/
case ERR_AGAIN: /* PRQA S 2003 # MISRA 16.3 - Intentional fall through */
/* Check if no PDU transceive has been started before (data from rfalNfcDepListenStartActivation) */
if(gNfcip.PDUParam.rxLen == NULL) {
/* In Listen mode first chained packet cannot be retrieved via APDU interface */
if(ret == ERR_AGAIN) {
return ERR_NOTSUPP;
}
/* TxRx is complete and full data is already available */
return ERR_NONE;
}
if((*gNfcip.PDUParam.rxLen) > 0U) /* MISRA 21.18 */
{
/* Ensure that data in tmpBuf still fits into PDU buffer */
if((uint16_t)((uint16_t)gNfcip.PDURxPos + (*gNfcip.PDUParam.rxLen)) >
RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN) {
return ERR_NOMEM;
}
/* Copy chained packet from tmp buffer to PDU buffer */
ST_MEMCPY(
&gNfcip.PDUParam.rxBuf->pdu[gNfcip.PDURxPos],
gNfcip.PDUParam.tmpBuf->inf,
*gNfcip.PDUParam.rxLen);
gNfcip.PDURxPos += *gNfcip.PDUParam.rxLen;
}
/* Update output param rxLen */
*gNfcip.PDUParam.rxLen = gNfcip.PDURxPos;
/* Wait for following Block or PDU TxRx is done */
return ((ret == ERR_AGAIN) ? ERR_BUSY : ERR_NONE);
/*******************************************************************************/
default:
/* MISRA 16.4: no empty default statement (a comment being enough) */
break;
}
return ret;
}
#endif /* RFAL_FEATURE_NFC_DEP */
Reference in a new issue View git blame Copy permalink