DarkFlippers/unleashed-firmware
1
1
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware.git synced 2024-12-18 02:41:36 +03:00
Code Issues Projects Releases Wiki Activity
b405a22cd1
unleashed-firmware/lib/ST25RFAL002/source/rfal_nfcDep.c
Aleksandr Kutuzov 4c9eb4928d NFC: application + rfal + driver.
2020-10-20 14:12:28 +03:00

2715 lines
116 KiB
C
Executable File
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 New Issue View Git Blame Copy Permalink