unleashed-firmware/lib/ST25RFAL002/source/rfal_isoDep.c

/******************************************************************************
  * \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_isoDep.c
 *
 *  \author Gustavo Patricio
 *
 *  \brief Implementation of ISO-DEP protocol
 *  
 *  This implementation was based on the following specs:
 *    - ISO/IEC 14443-4  2nd Edition 2008-07-15
 *    - NFC Forum Digital Protocol  1.1 2014-01-14
 *
 */

/*
 ******************************************************************************
 * INCLUDES
 ******************************************************************************
 */

#include "rfal_isoDep.h"
#include "rfal_rf.h"
#include "utils.h"

/*
 ******************************************************************************
 * ENABLE SWITCH
 ******************************************************************************
 */

#if RFAL_FEATURE_ISO_DEP

#if(!RFAL_FEATURE_ISO_DEP_POLL && !RFAL_FEATURE_ISO_DEP_LISTEN)
#error \
    " RFAL: Invalid ISO-DEP Configuration. Please select at least one mode: Poller and/or Listener. "
#endif

/* Check for valid I-Block length [RFAL_ISODEP_FSX_16 ; RFAL_ISODEP_FSX_4096]*/
#if((RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN > 4096) || (RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN < 16))
#error \
    " RFAL: Invalid ISO-DEP IBlock Max length. Please change RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN. "
#endif

/* Check for valid APDU length. */
#if((RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN < RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN))
#error " RFAL: Invalid ISO-DEP APDU Max length. Please change RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN. "
#endif

/*
 ******************************************************************************
 * DEFINES
 ******************************************************************************
 */
#define ISODEP_CRC_LEN RFAL_CRC_LEN /*!< ISO1443 CRC Length */

#define ISODEP_PCB_POS (0U) /*!< PCB position on message header*/
#define ISODEP_SWTX_INF_POS (1U) /*!< INF position in a S-WTX       */

#define ISODEP_DID_POS (1U) /*!< DID position on message header*/
#define ISODEP_SWTX_PARAM_LEN (1U) /*!< SWTX parameter length         */

#define ISODEP_DSL_MAX_LEN \
    (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN) /*!< Deselect Req/Res length */

#define ISODEP_PCB_xBLOCK_MASK (0xC0U) /*!< Bit mask for Block type       */
#define ISODEP_PCB_IBLOCK (0x00U) /*!< Bit mask indicating a I-Block */
#define ISODEP_PCB_RBLOCK (0x80U) /*!< Bit mask indicating a R-Block */
#define ISODEP_PCB_SBLOCK (0xC0U) /*!< Bit mask indicating a S-Block */
#define ISODEP_PCB_INVALID (0x40U) /*!< Bit mask of an Invalid PCB    */

#define ISODEP_HDR_MAX_LEN                       \
    (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN + \
     RFAL_ISODEP_NAD_LEN) /*!< Max header length (PCB + DID + NAD)      */

#define ISODEP_PCB_IB_VALID_MASK \
    (ISODEP_PCB_B6_BIT | ISODEP_PCB_B2_BIT) /*!< Bit mask for the MUST bits on I-Block    */
#define ISODEP_PCB_IB_VALID_VAL \
    (ISODEP_PCB_B2_BIT) /*!< Value for the MUST bits on I-Block       */
#define ISODEP_PCB_RB_VALID_MASK             \
    (ISODEP_PCB_B6_BIT | ISODEP_PCB_B3_BIT | \
     ISODEP_PCB_B2_BIT) /*!< Bit mask for the MUST bits on R-Block    */
#define ISODEP_PCB_RB_VALID_VAL \
    (ISODEP_PCB_B6_BIT | ISODEP_PCB_B2_BIT) /*!< Value for the MUST bits on R-Block       */
#define ISODEP_PCB_SB_VALID_MASK             \
    (ISODEP_PCB_B3_BIT | ISODEP_PCB_B2_BIT | \
     ISODEP_PCB_B1_BIT) /*!< Bit mask for the MUST bits on I-Block    */
#define ISODEP_PCB_SB_VALID_VAL \
    (ISODEP_PCB_B2_BIT) /*!< Value for the MUST bits on I-Block       */

#define ISODEP_PCB_B1_BIT \
    (0x01U) /*!< Bit mask for the RFU S Blocks                                        */
#define ISODEP_PCB_B2_BIT \
    (0x02U) /*!< Bit mask for the RFU bit2 in I,S,R Blocks                            */
#define ISODEP_PCB_B3_BIT \
    (0x04U) /*!< Bit mask for the RFU bit3 in R Blocks                                */
#define ISODEP_PCB_B6_BIT \
    (0x20U) /*!< Bit mask for the RFU bit2 in R Blocks                                */
#define ISODEP_PCB_CHAINING_BIT \
    (0x10U) /*!< Bit mask for the chaining bit of an ISO DEP I-Block in PCB.          */
#define ISODEP_PCB_DID_BIT \
    (0x08U) /*!< Bit mask for the DID presence bit of an ISO DEP I,S,R Blocks PCB.    */
#define ISODEP_PCB_NAD_BIT \
    (0x04U) /*!< Bit mask for the NAD presence bit of an ISO DEP I,S,R Blocks in PCB  */
#define ISODEP_PCB_BN_MASK \
    (0x01U) /*!< Bit mask for the block number of an ISO DEP I,R Block in PCB         */

#define ISODEP_SWTX_PL_MASK \
    (0xC0U) /*!< Bit mask for the Power Level bits of the inf byte of an WTX request or response */
#define ISODEP_SWTX_WTXM_MASK \
    (0x3FU) /*!< Bit mask for the WTXM bits of the inf byte of an WTX request or response        */

#define ISODEP_RBLOCK_INF_LEN (0U) /*!< INF length of R-Block               Digital 1.1 15.1.3 */
#define ISODEP_SDSL_INF_LEN (0U) /*!< INF length of S(DSL)                Digital 1.1 15.1.3 */
#define ISODEP_SWTX_INF_LEN (1U) /*!< INF length of S(WTX)                Digital 1.1 15.2.2 */

#define ISODEP_WTXM_MIN (1U) /*!< Minimum allowed value for the WTXM, Digital 1.0 13.2.2 */
#define ISODEP_WTXM_MAX (59U) /*!< Maximum allowed value for the WTXM, Digital 1.0 13.2.2 */

#define ISODEP_PCB_Sxx_MASK (0x30U) /*!< Bit mask for the S-Block type                          */
#define ISODEP_PCB_DESELECT (0x00U) /*!< Bit mask for S-Block indicating Deselect               */
#define ISODEP_PCB_WTX (0x30U) /*!< Bit mask for S-Block indicating Waiting Time eXtension */

#define ISODEP_PCB_Rx_MASK (0x10U) /*!< Bit mask for the R-Block type       */
#define ISODEP_PCB_ACK (0x00U) /*!< Bit mask for R-Block indicating ACK */
#define ISODEP_PCB_NAK (0x10U) /*!< Bit mask for R-Block indicating NAK */

/*! Maximum length of control message (no INF) */
#define ISODEP_CONTROLMSG_BUF_LEN \
    (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN + RFAL_ISODEP_NAD_LEN + ISODEP_SWTX_PARAM_LEN)

#define ISODEP_FWT_DEACTIVATION \
    (71680U) /*!< FWT used for DESELECT  Digital 2.2 B10  ISO1444-4 7.2 & 8.1 */
#define ISODEP_MAX_RERUNS (0x0FFFFFFFU) /*!< Maximum rerun retrys for a blocking protocol run*/

#define ISODEP_PCBSBLOCK \
    (0x00U | ISODEP_PCB_SBLOCK | ISODEP_PCB_B2_BIT) /*!< PCB Value of a S-Block                 */
#define ISODEP_PCB_SDSL \
    (ISODEP_PCBSBLOCK | ISODEP_PCB_DESELECT) /*!< PCB Value of a S-Block with DESELECT   */
#define ISODEP_PCB_SWTX \
    (ISODEP_PCBSBLOCK | ISODEP_PCB_WTX) /*!< PCB Value of a S-Block with WTX        */
#define ISODEP_PCB_SPARAMETERS \
    (ISODEP_PCB_SBLOCK | ISODEP_PCB_WTX) /*!< PCB Value of a S-Block with PARAMETERS */

#define ISODEP_FWI_LIS_MAX_NFC \
    8U /*!< FWT Listener Max FWIT4ATmax FWIBmax  Digital 1.1  A6 & A3  */
#define ISODEP_FWI_LIS_MAX_EMVCO \
    7U /*!< FWT Listener Max FWIMAX       EMVCo 2.6 A.5                */
#define ISODEP_FWI_LIS_MAX                               \
    (uint8_t)(                                           \
        (gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) ? \
            ISODEP_FWI_LIS_MAX_EMVCO :                   \
            ISODEP_FWI_LIS_MAX_NFC) /*!< FWI Listener Max as NFC / EMVCo */
#define ISODEP_FWT_LIS_MAX \
    rfalIsoDepFWI2FWT(ISODEP_FWI_LIS_MAX) /*!< FWT Listener Max                       */

#define ISODEP_FWI_MIN_10 (1U) /*!< Minimum value for FWI Digital 1.0 11.6.2.17 */
#define ISODEP_FWI_MIN_11 (0U) /*!< Default value for FWI Digital 1.1 13.6.2    */
#define ISODEP_FWI_MAX (14U) /*!< Maximum value for FWI Digital 1.0 11.6.2.17 */
#define ISODEP_SFGI_MIN (0U) /*!< Default value for FWI Digital 1.1 13.6.2.22 */
#define ISODEP_SFGI_MAX (14U) /*!< Maximum value for FWI Digital 1.1 13.6.2.22 */

#define RFAL_ISODEP_SPARAM_TVL_HDR_LEN (2U) /*!< S(PARAMETERS) TVL header length: Tag + Len */
#define RFAL_ISODEP_SPARAM_HDR_LEN \
    (RFAL_ISODEP_PCB_LEN +         \
     RFAL_ISODEP_SPARAM_TVL_HDR_LEN) /*!< S(PARAMETERS) header length: PCB + Tag + Len */

/**********************************************************************************************************************/
/**********************************************************************************************************************/
#define RFAL_ISODEP_NO_PARAM (0U) /*!< No parameter flag for isoDepHandleControlMsg()     */

#define RFAL_ISODEP_CMD_RATS (0xE0U) /*!< RATS command   Digital 1.1  13.6.1                 */

#define RFAL_ISODEP_ATS_MIN_LEN (1U) /*!< Minimum ATS length   Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_HDR_LEN (5U) /*!< ATS headerlength     Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_MAX_LEN \
    (RFAL_ISODEP_ATS_HDR_LEN +  \
     RFAL_ISODEP_ATS_HB_MAX_LEN) /*!< Maximum ATS length   Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_T0_FSCI_MASK (0x0FU) /*!< ATS T0's FSCI mask   Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_TB_FWI_SHIFT (4U) /*!< ATS TB's FWI shift   Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_FWI_MASK (0x0FU) /*!< ATS TB's FWI shift   Digital 1.1  13.6.2 */
#define RFAL_ISODEP_ATS_TL_POS (0x00U) /*!< ATS TL's position    Digital 1.1  13.6.2 */

#define RFAL_ISODEP_PPS_SB (0xD0U) /*!< PPS REQ PPSS's SB value (no CID)   ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_MASK (0xF0U) /*!< PPS REQ PPSS's SB mask             ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_SB_DID_MASK \
    (0x0FU) /*!< PPS REQ PPSS's DID|CID mask        ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_PPS0_PPS1_PRESENT \
    (0x11U) /*!< PPS REQ PPS0 indicating that PPS1 is present       */
#define RFAL_ISODEP_PPS_PPS1 (0x00U) /*!< PPS REQ PPS1 fixed value           ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_PPS1_DSI_SHIFT \
    (2U) /*!< PPS REQ PPS1 fixed value           ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_PPS1_DXI_MASK \
    (0x0FU) /*!< PPS REQ PPS1 fixed value           ISO14443-4  5.3 */
#define RFAL_ISODEP_PPS_RES_LEN (1U) /*!< PPS Response length                ISO14443-4  5.4 */
#define RFAL_ISODEP_PPS_STARTBYTE_POS \
    (0U) /*!< PPS REQ PPSS's byte position       ISO14443-4  5.4 */
#define RFAL_ISODEP_PPS_PPS0_POS (1U) /*!< PPS REQ PPS0's byte position       ISO14443-4  5.4 */
#define RFAL_ISODEP_PPS_PPS1_POS (2U) /*!< PPS REQ PPS1's byte position       ISO14443-4  5.4 */
#define RFAL_ISODEP_PPS0_VALID_MASK \
    (0xEFU) /*!< PPS REQ PPS0 valid coding mask     ISO14443-4  5.4 */

#define RFAL_ISODEP_CMD_ATTRIB (0x1DU) /*!< ATTRIB command                 Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_PARAM2_DSI_SHIFT \
    (6U) /*!< ATTRIB PARAM2 DSI shift        Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_PARAM2_DRI_SHIFT \
    (4U) /*!< ATTRIB PARAM2 DRI shift        Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_PARAM2_DXI_MASK \
    (0xF0U) /*!< ATTRIB PARAM2 DxI mask         Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_PARAM2_FSDI_MASK \
    (0x0FU) /*!< ATTRIB PARAM2 FSDI mask        Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_PARAM4_DID_MASK \
    (0x0FU) /*!< ATTRIB PARAM4 DID mask         Digital 1.1  14.6.1 */
#define RFAL_ISODEP_ATTRIB_HDR_LEN (9U) /*!< ATTRIB REQ header length       Digital 1.1  14.6.1 */

#define RFAL_ISODEP_ATTRIB_RES_HDR_LEN \
    (1U) /*!< ATTRIB RES header length       Digital 1.1  14.6.2 */
#define RFAL_ISODEP_ATTRIB_RES_MBLIDID_POS \
    (0U) /*!< ATTRIB RES MBLI|DID position   Digital 1.1  14.6.2 */
#define RFAL_ISODEP_ATTRIB_RES_DID_MASK \
    (0x0FU) /*!< ATTRIB RES DID mask            Digital 1.1  14.6.2 */
#define RFAL_ISODEP_ATTRIB_RES_MBLI_MASK \
    (0x0FU) /*!< ATTRIB RES MBLI mask           Digital 1.1  14.6.2 */
#define RFAL_ISODEP_ATTRIB_RES_MBLI_SHIFT \
    (4U) /*!< ATTRIB RES MBLI shift          Digital 1.1  14.6.2 */

#define RFAL_ISODEP_DID_MASK (0x0FU) /*!< ISODEP's DID mask                                  */
#define RFAL_ISODEP_DID_00 (0U) /*!< ISODEP's DID value 0                               */

#define RFAL_ISODEP_FSDI_MAX_NFC (8U) /*!< Max FSDI value   Digital 2.0  14.6.1.9 & B7 & B8   */
#define RFAL_ISODEP_FSDI_MAX_NFC_21 \
    (0x0CU) /*!< Max FSDI value   Digital 2.1  14.6.1.9 & Table 72  */
#define RFAL_ISODEP_FSDI_MAX_EMV (0x0CU) /*!< Max FSDI value   EMVCo 3.0  5.7.2.5                */

#define RFAL_ISODEP_RATS_PARAM_FSDI_MASK \
    (0xF0U) /*!< Mask bits for FSDI in RATS                         */
#define RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT \
    (4U) /*!< Shift for FSDI in RATS                             */
#define RFAL_ISODEP_RATS_PARAM_DID_MASK \
    (0x0FU) /*!< Mask bits for DID in RATS                          */

#define RFAL_ISODEP_ATS_TL_OFFSET \
    (0x00U) /*!< Offset of TL on ATS                                */
#define RFAL_ISODEP_ATS_TA_OFFSET \
    (0x02U) /*!< Offset of TA if it is present on ATS               */
#define RFAL_ISODEP_ATS_TB_OFFSET \
    (0x03U) /*!< Offset of TB if both TA and TB is present on ATS   */
#define RFAL_ISODEP_ATS_TC_OFFSET \
    (0x04U) /*!< Offset of TC if both TA,TB & TC are present on ATS */
#define RFAL_ISODEP_ATS_HIST_OFFSET \
    (0x05U) /*!< Offset of Historical Bytes if TA, TB & TC are present on ATS          */
#define RFAL_ISODEP_ATS_TC_ADV_FEAT \
    (0x10U) /*!< Bit mask indicating support for Advanced protocol features: DID & NAD */
#define RFAL_ISODEP_ATS_TC_DID (0x02U) /*!< Bit mask indicating support for DID                 */
#define RFAL_ISODEP_ATS_TC_NAD (0x01U) /*!< Bit mask indicating support for NAD                 */

#define RFAL_ISODEP_PPS0_PPS1_PRESENT \
    (0x11U) /*!< PPS0 byte indicating that PPS1 is present            */
#define RFAL_ISODEP_PPS0_PPS1_NOT_PRESENT \
    (0x01U) /*!< PPS0 byte indicating that PPS1 is NOT present        */
#define RFAL_ISODEP_PPS1_DRI_MASK \
    (0x03U) /*!< PPS1 byte DRI mask bits                              */
#define RFAL_ISODEP_PPS1_DSI_MASK \
    (0x0CU) /*!< PPS1 byte DSI mask bits                              */
#define RFAL_ISODEP_PPS1_DSI_SHIFT \
    (2U) /*!< PPS1 byte DSI shift                                  */
#define RFAL_ISODEP_PPS1_DxI_MASK \
    (0x03U) /*!< PPS1 byte DSI/DRS mask bits                          */

/*! Delta Time for polling during Activation (ATS) : 20ms    Digital 1.0 11.7.1.1 & A.7    */
#define RFAL_ISODEP_T4T_DTIME_POLL_10 rfalConvMsTo1fc(20)

/*! Delta Time for polling during Activation (ATS) : 16.4ms  Digital 1.1 13.8.1.1 & A.6
 *  Use 16 ms as testcase T4AT_BI_10_03 sends a frame exactly at the border */
#define RFAL_ISODEP_T4T_DTIME_POLL_11 216960U

/*! Activation frame waiting time FWT(act) = 71680/fc (~5286us) Digital 1.1 13.8.1.1 & A.6 */
#define RFAL_ISODEP_T4T_FWT_ACTIVATION (71680U + RFAL_ISODEP_T4T_DTIME_POLL_11)

/*! Delta frame waiting time = 16/fc  Digital 1.0  11.7.1.3 & A.7*/
#define RFAL_ISODEP_DFWT_10 16U

/*! Delta frame waiting time = 16/fc  Digital 2.0  14.8.1.3 & B.7*/
#define RFAL_ISODEP_DFWT_20 49152U

/*
 ******************************************************************************
 * MACROS
 ******************************************************************************
 */

#define isoDep_PCBisIBlock(pcb)                                       \
    (((pcb) & (ISODEP_PCB_xBLOCK_MASK | ISODEP_PCB_IB_VALID_MASK)) == \
     (ISODEP_PCB_IBLOCK | ISODEP_PCB_IB_VALID_VAL)) /*!< Checks if pcb is a I-Block */
#define isoDep_PCBisRBlock(pcb)                                       \
    (((pcb) & (ISODEP_PCB_xBLOCK_MASK | ISODEP_PCB_RB_VALID_MASK)) == \
     (ISODEP_PCB_RBLOCK | ISODEP_PCB_RB_VALID_VAL)) /*!< Checks if pcb is a R-Block */
#define isoDep_PCBisSBlock(pcb)                                       \
    (((pcb) & (ISODEP_PCB_xBLOCK_MASK | ISODEP_PCB_SB_VALID_MASK)) == \
     (ISODEP_PCB_SBLOCK | ISODEP_PCB_SB_VALID_VAL)) /*!< Checks if pcb is a S-Block */

#define isoDep_PCBisChaining(pcb)       \
    (((pcb)&ISODEP_PCB_CHAINING_BIT) == \
     ISODEP_PCB_CHAINING_BIT) /*!< Checks if pcb is indicating chaining */

#define isoDep_PCBisDeselect(pcb)   \
    (((pcb)&ISODEP_PCB_Sxx_MASK) == \
     ISODEP_PCB_DESELECT) /*!< Checks if pcb is indicating DESELECT */
#define isoDep_PCBisWTX(pcb) \
    (((pcb)&ISODEP_PCB_Sxx_MASK) == ISODEP_PCB_WTX) /*!< Checks if pcb is indicating WTX      */

#define isoDep_PCBisACK(pcb) \
    (((pcb)&ISODEP_PCB_Rx_MASK) == ISODEP_PCB_ACK) /*!< Checks if pcb is indicating ACK      */
#define isoDep_PCBisNAK(pcb) \
    (((pcb)&ISODEP_PCB_Rx_MASK) == ISODEP_PCB_NAK) /*!< Checks if pcb is indicating ACK      */

#define isoDep_PCBhasDID(pcb) \
    (((pcb)&ISODEP_PCB_DID_BIT) == ISODEP_PCB_DID_BIT) /*!< Checks if pcb is indicating DID      */
#define isoDep_PCBhasNAD(pcb) \
    (((pcb)&ISODEP_PCB_NAD_BIT) == ISODEP_PCB_NAD_BIT) /*!< Checks if pcb is indicating NAD      */

#define isoDep_PCBisIChaining(pcb) \
    (isoDep_PCBisIBlock(pcb) &&    \
     isoDep_PCBisChaining(pcb)) /*!< Checks if pcb is I-Block indicating chaining*/

#define isoDep_PCBisSDeselect(pcb) \
    (isoDep_PCBisSBlock(pcb) &&    \
     isoDep_PCBisDeselect(pcb)) /*!< Checks if pcb is S-Block indicating DESELECT*/
#define isoDep_PCBisSWTX(pcb)   \
    (isoDep_PCBisSBlock(pcb) && \
     isoDep_PCBisWTX(pcb)) /*!< Checks if pcb is S-Block indicating WTX     */

#define isoDep_PCBisRACK(pcb)   \
    (isoDep_PCBisRBlock(pcb) && \
     isoDep_PCBisACK(pcb)) /*!< Checks if pcb is R-Block indicating ACK     */
#define isoDep_PCBisRNAK(pcb)   \
    (isoDep_PCBisRBlock(pcb) && \
     isoDep_PCBisNAK(pcb)) /*!< Checks if pcb is R-Block indicating NAK     */

#define isoDep_PCBIBlock(bn) \
    ((uint8_t)(0x00U | ISODEP_PCB_IBLOCK | ISODEP_PCB_B2_BIT | ((bn)&ISODEP_PCB_BN_MASK))) /*!< Returns an I-Block with the given block number (bn)                     */
#define isoDep_PCBIBlockChaining(bn) \
    ((uint8_t)(isoDep_PCBIBlock(bn) | ISODEP_PCB_CHAINING_BIT)) /*!< Returns an I-Block with the given block number (bn) indicating chaining */

#define isoDep_PCBRBlock(bn) \
    ((uint8_t)(0x00U | ISODEP_PCB_RBLOCK | ISODEP_PCB_B6_BIT | ISODEP_PCB_B2_BIT | ((bn)&ISODEP_PCB_BN_MASK))) /*!< Returns an R-Block with the given block number (bn)                */
#define isoDep_PCBRACK(bn) \
    ((uint8_t)(isoDep_PCBRBlock(bn) | ISODEP_PCB_ACK)) /*!< Returns an R-Block with the given block number (bn) indicating ACK */
#define isoDep_PCBRNAK(bn) \
    ((uint8_t)(isoDep_PCBRBlock(bn) | ISODEP_PCB_NAK)) /*!< Returns an R-Block with the given block number (bn) indicating NAK */

#define isoDep_GetBN(pcb) \
    ((uint8_t)((pcb)&ISODEP_PCB_BN_MASK)) /*!< Returns the block number (bn) from the given pcb */
#define isoDep_GetWTXM(inf) \
    ((uint8_t)((            \
        inf)&ISODEP_SWTX_WTXM_MASK)) /*!< Returns the WTX value from the given inf byte    */
#define isoDep_isWTXMValid(wtxm)    \
    (((wtxm) >= ISODEP_WTXM_MIN) && \
     ((wtxm) <= ISODEP_WTXM_MAX)) /*!< Checks if the given wtxm is valid                */

#define isoDep_WTXMListenerMax(fwt)            \
    (MIN(                                      \
        (uint8_t)(ISODEP_FWT_LIS_MAX / (fwt)), \
        ISODEP_WTXM_MAX)) /*!< Calculates the Max WTXM value for the given fwt as a Listener    */

#define isoDepCalcdSGFT(s) \
    (384U * ((uint32_t)1U  \
             << (s))) /*!< Calculates the dSFGT with given SFGI  Digital 1.1  13.8.2.1 & A.6*/
#define isoDepCalcSGFT(s)  \
    (4096U * ((uint32_t)1U \
              << (s))) /*!< Calculates the SFGT with given SFGI  Digital 1.1  13.8.2         */

#define isoDep_PCBNextBN(bn)   \
    (((uint8_t)(bn) ^ 0x01U) & \
     ISODEP_PCB_BN_MASK) /*!< Returns the value of the next block number based on bn     */
#define isoDep_PCBPrevBN(bn) \
    isoDep_PCBNextBN(bn) /*!< Returns the value of the previous block number based on bn */
#define isoDep_ToggleBN(bn) \
    ((bn) =                 \
         (((bn) ^ 0x01U) &  \
          ISODEP_PCB_BN_MASK)) /*!< Toggles the block number value of the given bn             */

#define isoDep_WTXAdjust(v) \
    ((v) - ((v) >> 3)) /*!< Adjust WTX timer value to a percentage of the total, current 88% */

/*! ISO 14443-4 7.5.6.2 & Digital 1.1 - 15.2.6.2  The CE SHALL NOT attempt error recovery and remains in Rx mode upon Transmission or a Protocol Error */
#define isoDepReEnableRx(rxB, rxBL, rxL) \
    rfalTransceiveBlockingTx(NULL, 0, rxB, rxBL, rxL, RFAL_TXRX_FLAGS_DEFAULT, RFAL_FWT_NONE)

/*! Macro used for the blocking methods */
#define rfalIsoDepRunBlocking(e, fn) \
    do {                             \
        (e) = (fn);                  \
        rfalWorker();                \
    } while((e) == ERR_BUSY)

#define isoDepTimerStart(timer, time_ms)                    \
    do {                                                    \
        platformTimerDestroy(timer);                        \
        (timer) = platformTimerCreate((uint16_t)(time_ms)); \
    } while(0) /*!< Configures and starts the WTX timer  */
#define isoDepTimerisExpired(timer) \
    platformTimerIsExpired(timer) /*!< Checks WTX timer has expired                     */
#define isoDepTimerDestroy(timer) \
    platformTimerDestroy(timer) /*!< Destroys WTX timer                               */

/*
 ******************************************************************************
 * LOCAL DATA TYPES
 ******************************************************************************
 */

/*! Internal structure to be used in handling of S(PARAMETRS) only */
typedef struct {
    uint8_t pcb; /*!< PCB byte                      */
    rfalIsoDepSParameter sParam; /*!< S(PARAMETERS)                 */
} rfalIsoDepControlMsgSParam;

/*! Enumeration of the possible control message types */
typedef enum {
    ISODEP_R_ACK, /*!< R-ACK  Acknowledge            */
    ISODEP_R_NAK, /*!< R-NACK Negative acknowledge   */
    ISODEP_S_WTX, /*!< S-WTX  Waiting Time Extension */
    ISODEP_S_DSL /*!< S-DSL  Deselect               */
} rfalIsoDepControlMsg;

/*! Enumeration of the IsoDep roles */
typedef enum {
    ISODEP_ROLE_PCD, /*!< Perform as Reader/PCD          */
    ISODEP_ROLE_PICC /*!< Perform as Card/PICC           */
} rfalIsoDepRole;

/*! ISO-DEP layer states */
typedef enum {
    ISODEP_ST_IDLE, /*!< Idle State                     */
    ISODEP_ST_PCD_TX, /*!< PCD Transmission State         */
    ISODEP_ST_PCD_RX, /*!< PCD Reception State            */
    ISODEP_ST_PCD_WAIT_DSL, /*!< PCD Wait for DSL response      */

    ISODEP_ST_PICC_ACT_ATS, /*!< PICC has replied to RATS (ATS) */
    ISODEP_ST_PICC_ACT_ATTRIB, /*!< PICC has replied to ATTRIB     */
    ISODEP_ST_PICC_RX, /*!< PICC Reception State           */
    ISODEP_ST_PICC_SWTX, /*!< PICC Waiting Time eXtension    */
    ISODEP_ST_PICC_SDSL, /*!< PICC S(DSL) response ongoing   */
    ISODEP_ST_PICC_TX, /*!< PICC Transmission State        */

    ISODEP_ST_PCD_ACT_RATS, /*!< PCD activation (RATS)          */
    ISODEP_ST_PCD_ACT_PPS, /*!< PCD activation (PPS)           */

} rfalIsoDepState;

/*! Holds all ISO-DEP data(counters, buffers, ID, timeouts, frame size)         */
typedef struct {
    rfalIsoDepState state; /*!< ISO-DEP module state                      */
    rfalIsoDepRole role; /*!< Current ISO-DEP role                      */

    uint8_t blockNumber; /*!< Current block number                      */
    uint8_t did; /*!< Current DID                               */
    uint8_t nad; /*!< Current DID                               */
    uint8_t cntIRetrys; /*!< I-Block retry counter                     */
    uint8_t cntRRetrys; /*!< R-Block retry counter                     */
    uint8_t cntSDslRetrys; /*!< S(DESELECT) retry counter                 */
    uint8_t cntSWtxRetrys; /*!< Overall S(WTX) retry counter              */
    uint8_t cntSWtxNack; /*!< R(NACK) answered with S(WTX) counter      */
    uint32_t fwt; /*!< Current FWT (Frame Waiting Time)          */
    uint32_t dFwt; /*!< Current delta FWT                         */
    uint16_t fsx; /*!< Current FSx FSC or FSD (max Frame size)   */
    bool isTxChaining; /*!< Flag for chaining on Tx                   */
    bool isRxChaining; /*!< Flag for chaining on Rx                   */
    uint8_t* txBuf; /*!< Tx buffer pointer                         */
    uint8_t* rxBuf; /*!< Rx buffer pointer                         */
    uint16_t txBufLen; /*!< Tx buffer length                          */
    uint16_t rxBufLen; /*!< Rx buffer length                          */
    uint8_t txBufInfPos; /*!< Start of payload in txBuf                 */
    uint8_t rxBufInfPos; /*!< Start of payload in rxBuf                 */

    uint16_t ourFsx; /*!< Our current FSx FSC or FSD (Frame size)   */
    uint8_t lastPCB; /*!< Last PCB sent                             */
    uint8_t lastWTXM; /*!< Last WTXM sent                            */
    uint8_t atsTA; /*!< TA on ATS                                 */
    uint8_t hdrLen; /*!< Current ISO-DEP length                    */
    rfalBitRate txBR; /*!< Current Tx Bit Rate                       */
    rfalBitRate rxBR; /*!< Current Rx Bit Rate                       */
    uint16_t* rxLen; /*!< Output parameter ptr to Rx length         */
    bool* rxChaining; /*!< Output parameter ptr to Rx chaining flag  */
    uint32_t WTXTimer; /*!< Timer used for WTX                        */
    bool lastDID00; /*!< Last PCD block had DID flag (for DID = 0) */

    bool isTxPending; /*!< Flag pending Block while waiting WTX Ack  */
    bool isWait4WTX; /*!< Flag for waiting WTX Ack                  */

    uint8_t maxRetriesI; /*!< Number of retries for a I-Block           */
    uint8_t maxRetriesR; /*!< Number of retries for a R-Block           */
    uint8_t maxRetriesSDSL; /*!< Number of retries for S(DESELECT) errors  */
    uint8_t maxRetriesSWTX; /*!< Number of retries for S(WTX) errors       */
    uint8_t maxRetriesSnWTX; /*!< Number of retries S(WTX) replied w NACK  */
    uint8_t maxRetriesRATS; /*!< Number of retries for RATS                */

    rfalComplianceMode compMode; /*!< Compliance mode                           */

    uint8_t ctrlBuf[ISODEP_CONTROLMSG_BUF_LEN]; /*!< Control msg buf   */
    uint16_t ctrlRxLen; /*!< Control msg rcvd len                         */

    union { /*  PRQA S 0750 # MISRA 19.2 - Members of the union will not be used concurrently, only one frame at a time */
#if RFAL_FEATURE_NFCA
        rfalIsoDepRats ratsReq;
        rfalIsoDepPpsReq ppsReq;
#endif /* RFAL_FEATURE_NFCA */

#if RFAL_FEATURE_NFCB
        rfalIsoDepAttribCmd attribReq;
#endif /* RFAL_FEATURE_NFCB */
    } actv; /*!< Activation buffer              */

    uint8_t* rxLen8; /*!< Receive length (8-bit)         */
    rfalIsoDepDevice* actvDev; /*!< Activation Device Info         */
    rfalIsoDepListenActvParam actvParam; /*!< Listen Activation context      */

    rfalIsoDepApduTxRxParam APDUParam; /*!< APDU TxRx params               */
    uint16_t APDUTxPos; /*!< APDU Tx position               */
    uint16_t APDURxPos; /*!< APDU Rx position               */
    bool isAPDURxChaining; /*!< APDU Transceive chaining flag  */

} rfalIsoDep;

/*
 ******************************************************************************
 * LOCAL VARIABLES
 ******************************************************************************
 */

static rfalIsoDep gIsoDep; /*!< ISO-DEP Module instance               */

/*
 ******************************************************************************
 * LOCAL FUNCTION PROTOTYPES
 ******************************************************************************
 */
static void isoDepClearCounters(void);
static ReturnCode
    isoDepTx(uint8_t pcb, const uint8_t* txBuf, uint8_t* infBuf, uint16_t infLen, uint32_t fwt);
static ReturnCode isoDepHandleControlMsg(rfalIsoDepControlMsg controlMsg, uint8_t param);
static void rfalIsoDepApdu2IBLockParam(
    rfalIsoDepApduTxRxParam apduParam,
    rfalIsoDepTxRxParam* iBlockParam,
    uint16_t txPos,
    uint16_t rxPos);

#if RFAL_FEATURE_ISO_DEP_POLL
static ReturnCode isoDepDataExchangePCD(uint16_t* outActRxLen, bool* outIsChaining);
static void rfalIsoDepCalcBitRate(
    rfalBitRate maxAllowedBR,
    uint8_t piccBRCapability,
    rfalBitRate* dsi,
    rfalBitRate* dri);
static uint32_t rfalIsoDepSFGI2SFGT(uint8_t sfgi);

#if RFAL_FEATURE_NFCA
static ReturnCode
    rfalIsoDepStartRATS(rfalIsoDepFSxI FSDI, uint8_t DID, rfalIsoDepAts* ats, uint8_t* atsLen);
static ReturnCode rfalIsoDepGetRATSStatus(void);
static ReturnCode
    rfalIsoDepStartPPS(uint8_t DID, rfalBitRate DSI, rfalBitRate DRI, rfalIsoDepPpsRes* ppsRes);
static ReturnCode rfalIsoDepGetPPSSTatus(void);
#endif /* RFAL_FEATURE_NFCA */

#if RFAL_FEATURE_NFCB
static ReturnCode rfalIsoDepStartATTRIB(
    const uint8_t* nfcid0,
    uint8_t PARAM1,
    rfalBitRate DSI,
    rfalBitRate DRI,
    rfalIsoDepFSxI FSDI,
    uint8_t PARAM3,
    uint8_t DID,
    const uint8_t* HLInfo,
    uint8_t HLInfoLen,
    uint32_t fwt,
    rfalIsoDepAttribRes* attribRes,
    uint8_t* attribResLen);
static ReturnCode rfalIsoDepGetATTRIBStatus(void);
#endif /* RFAL_FEATURE_NFCB */

#endif /* RFAL_FEATURE_ISO_DEP_POLL */

#if RFAL_FEATURE_ISO_DEP_LISTEN
static ReturnCode isoDepDataExchangePICC(void);
static ReturnCode isoDepReSendControlMsg(void);
#endif

/*
 ******************************************************************************
 * LOCAL FUNCTIONS
 ******************************************************************************
 */

/*******************************************************************************/
static void isoDepClearCounters(void) {
    gIsoDep.cntIRetrys = 0;
    gIsoDep.cntRRetrys = 0;
    gIsoDep.cntSDslRetrys = 0;
    gIsoDep.cntSWtxRetrys = 0;
    gIsoDep.cntSWtxNack = 0;
}

/*******************************************************************************/
static ReturnCode
    isoDepTx(uint8_t pcb, const uint8_t* txBuf, uint8_t* infBuf, uint16_t infLen, uint32_t fwt) {
    uint8_t* txBlock;
    uint16_t txBufLen;
    uint8_t computedPcb;
    rfalTransceiveContext ctx;

    txBlock = infBuf; /* Point to beginning of the INF, and go backwards     */
    gIsoDep.lastPCB = pcb; /* Store the last PCB sent                             */

    if(infLen > 0U) {
        if(((uint32_t)infBuf - (uint32_t)txBuf) <
           gIsoDep.hdrLen) /* Check that we can fit the header in the given space */
        {
            return ERR_NOMEM;
        }
    }

    /*******************************************************************************/
    /* Compute optional PCB bits */
    computedPcb = pcb;
    if((gIsoDep.did != RFAL_ISODEP_NO_DID) ||
       ((gIsoDep.did == RFAL_ISODEP_DID_00) && gIsoDep.lastDID00)) {
        computedPcb |= ISODEP_PCB_DID_BIT;
    }
    if(gIsoDep.nad != RFAL_ISODEP_NO_NAD) {
        computedPcb |= ISODEP_PCB_NAD_BIT;
    }
    if((gIsoDep.isTxChaining) && (isoDep_PCBisIBlock(computedPcb))) {
        computedPcb |= ISODEP_PCB_CHAINING_BIT;
    }

    /*******************************************************************************/
    /* Compute Payload on the given txBuf, start by the PCB | DID | NAD | before INF */

    if(gIsoDep.nad != RFAL_ISODEP_NO_NAD) {
        *(--txBlock) = gIsoDep.nad; /* NAD is optional */
    }

    if((gIsoDep.did != RFAL_ISODEP_NO_DID) ||
       ((gIsoDep.did == RFAL_ISODEP_DID_00) && gIsoDep.lastDID00)) {
        *(--txBlock) = gIsoDep.did; /* DID is optional */
    }

    *(--txBlock) = computedPcb; /* PCB always present */

    txBufLen =
        (infLen +
         (uint16_t)((uint32_t)infBuf - (uint32_t)txBlock)); /* Calculate overall buffer size */

    if(txBufLen > (gIsoDep.fsx -
                   ISODEP_CRC_LEN)) /* Check if msg length violates the maximum frame size FSC */
    {
        return ERR_NOTSUPP;
    }

    rfalCreateByteFlagsTxRxContext(
        ctx,
        txBlock,
        txBufLen,
        gIsoDep.rxBuf,
        gIsoDep.rxBufLen,
        gIsoDep.rxLen,
        RFAL_TXRX_FLAGS_DEFAULT,
        ((gIsoDep.role == ISODEP_ROLE_PICC) ? RFAL_FWT_NONE : fwt));
    return rfalStartTransceive(&ctx);
}

/*******************************************************************************/
static ReturnCode isoDepHandleControlMsg(rfalIsoDepControlMsg controlMsg, uint8_t param) {
    uint8_t pcb;
    uint8_t infLen;
    uint32_t fwtTemp;

    infLen = 0;
    fwtTemp = (gIsoDep.fwt + gIsoDep.dFwt);
    ST_MEMSET(gIsoDep.ctrlBuf, 0x00, ISODEP_CONTROLMSG_BUF_LEN);

    switch(controlMsg) {
    /*******************************************************************************/
    case ISODEP_R_ACK:

        if(gIsoDep.cntRRetrys++ > gIsoDep.maxRetriesR) {
            return ERR_TIMEOUT; /* NFC Forum mandates timeout or transmission error depending on previous errors */
        }

        pcb = isoDep_PCBRACK(gIsoDep.blockNumber);
        break;

    /*******************************************************************************/
    case ISODEP_R_NAK:

        if((gIsoDep.cntRRetrys++ > gIsoDep.maxRetriesR) || /* Max R Block retries reached */
           (gIsoDep.cntSWtxNack >=
            gIsoDep
                .maxRetriesSnWTX)) /* Max number PICC is allowed to respond with S(WTX) to R(NAK) */
        {
            return ERR_TIMEOUT;
        }

        pcb = isoDep_PCBRNAK(gIsoDep.blockNumber);
        break;

    /*******************************************************************************/
    case ISODEP_S_WTX:

        if((gIsoDep.cntSWtxRetrys++ > gIsoDep.maxRetriesSWTX) &&
           (gIsoDep.maxRetriesSWTX != RFAL_ISODEP_MAX_WTX_RETRYS_ULTD)) {
            return ERR_PROTO;
        }

        /* Check if WTXM is valid */
        if(!isoDep_isWTXMValid(param)) {
            return ERR_PROTO;
        }

        if(gIsoDep.role == ISODEP_ROLE_PCD) {
            /* Calculate temp Wait Time eXtension */
            fwtTemp = (gIsoDep.fwt * param);
            fwtTemp = MIN(RFAL_ISODEP_MAX_FWT, fwtTemp);
            fwtTemp += gIsoDep.dFwt;
        }

        pcb = ISODEP_PCB_SWTX;
        gIsoDep.ctrlBuf[RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN + infLen++] = param;
        break;

    /*******************************************************************************/
    case ISODEP_S_DSL:

        if(gIsoDep.cntSDslRetrys++ > gIsoDep.maxRetriesSDSL) {
            return ERR_TIMEOUT; /* NFC Forum mandates timeout or transmission error depending on previous errors */
        }

        if(gIsoDep.role == ISODEP_ROLE_PCD) {
            /* Digital 1.0 - 13.2.7.3 Poller must wait fwtDEACTIVATION */
            fwtTemp = ISODEP_FWT_DEACTIVATION;
            gIsoDep.state = ISODEP_ST_PCD_WAIT_DSL;
        }
        pcb = ISODEP_PCB_SDSL;
        break;

    /*******************************************************************************/
    default:
        return ERR_INTERNAL;
    }

    return isoDepTx(
        pcb,
        gIsoDep.ctrlBuf,
        &gIsoDep.ctrlBuf[RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN],
        infLen,
        fwtTemp);
}

#if RFAL_FEATURE_ISO_DEP_LISTEN
/*******************************************************************************/
static ReturnCode isoDepReSendControlMsg(void) {
    if(isoDep_PCBisRACK(gIsoDep.lastPCB)) {
        return isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM);
    }

    if(isoDep_PCBisRNAK(gIsoDep.lastPCB)) {
        return isoDepHandleControlMsg(ISODEP_R_NAK, RFAL_ISODEP_NO_PARAM);
    }

    if(isoDep_PCBisSDeselect(gIsoDep.lastPCB)) {
        return isoDepHandleControlMsg(ISODEP_S_DSL, RFAL_ISODEP_NO_PARAM);
    }

    if(isoDep_PCBisSWTX(gIsoDep.lastPCB)) {
        return isoDepHandleControlMsg(ISODEP_S_WTX, gIsoDep.lastWTXM);
    }
    return ERR_WRONG_STATE;
}
#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */

/*
 ******************************************************************************
 * GLOBAL FUNCTIONS
 ******************************************************************************
 */

/*******************************************************************************/
void rfalIsoDepInitialize(void) {
    gIsoDep.state = ISODEP_ST_IDLE;
    gIsoDep.role = ISODEP_ROLE_PCD;
    gIsoDep.did = RFAL_ISODEP_NO_DID;
    gIsoDep.nad = RFAL_ISODEP_NO_NAD;
    gIsoDep.blockNumber = 0;
    gIsoDep.isTxChaining = false;
    gIsoDep.isRxChaining = false;
    gIsoDep.lastDID00 = false;
    gIsoDep.lastPCB = ISODEP_PCB_INVALID;
    gIsoDep.fsx = (uint16_t)RFAL_ISODEP_FSX_16;
    gIsoDep.ourFsx = (uint16_t)RFAL_ISODEP_FSX_16;
    gIsoDep.hdrLen = RFAL_ISODEP_PCB_LEN;

    gIsoDep.rxLen = NULL;
    gIsoDep.rxBuf = NULL;
    gIsoDep.rxBufInfPos = 0U;
    gIsoDep.txBufInfPos = 0U;

    gIsoDep.isTxPending = false;
    gIsoDep.isWait4WTX = false;

    gIsoDep.compMode = RFAL_COMPLIANCE_MODE_NFC;
    gIsoDep.maxRetriesR = RFAL_ISODEP_MAX_R_RETRYS;
    gIsoDep.maxRetriesI = RFAL_ISODEP_MAX_I_RETRYS;
    gIsoDep.maxRetriesSDSL = RFAL_ISODEP_MAX_DSL_RETRYS;
    gIsoDep.maxRetriesSWTX = RFAL_ISODEP_MAX_WTX_RETRYS;
    gIsoDep.maxRetriesSnWTX = RFAL_ISODEP_MAX_WTX_NACK_RETRYS;
    gIsoDep.maxRetriesRATS = RFAL_ISODEP_RATS_RETRIES;

    gIsoDep.APDURxPos = 0;
    gIsoDep.APDUTxPos = 0;
    gIsoDep.APDUParam.rxLen = NULL;
    gIsoDep.APDUParam.rxBuf = NULL;
    gIsoDep.APDUParam.txBuf = NULL;

    isoDepClearCounters();

    /* Destroy any ongoing WTX timer */
    isoDepTimerDestroy(gIsoDep.WTXTimer);
    gIsoDep.WTXTimer = 0U;
}

/*******************************************************************************/
void rfalIsoDepInitializeWithParams(
    rfalComplianceMode compMode,
    uint8_t maxRetriesR,
    uint8_t maxRetriesSnWTX,
    uint8_t maxRetriesSWTX,
    uint8_t maxRetriesSDSL,
    uint8_t maxRetriesI,
    uint8_t maxRetriesRATS) {
    rfalIsoDepInitialize();

    gIsoDep.compMode = compMode;
    gIsoDep.maxRetriesR = maxRetriesR;
    gIsoDep.maxRetriesSnWTX = maxRetriesSnWTX;
    gIsoDep.maxRetriesSWTX = maxRetriesSWTX;
    gIsoDep.maxRetriesSDSL = maxRetriesSDSL;
    gIsoDep.maxRetriesI = maxRetriesI;
    gIsoDep.maxRetriesRATS = maxRetriesRATS;
}

#if RFAL_FEATURE_ISO_DEP_POLL
/*******************************************************************************/
static ReturnCode isoDepDataExchangePCD(uint16_t* outActRxLen, bool* outIsChaining) {
    ReturnCode ret;
    uint8_t rxPCB;

    /* Check out parameters */
    if((outActRxLen == NULL) || (outIsChaining == NULL)) {
        return ERR_PARAM;
    }

    *outIsChaining = false;

    /* Calculate header required and check if the buffers InfPositions are suitable */
    gIsoDep.hdrLen = RFAL_ISODEP_PCB_LEN;
    if(gIsoDep.did != RFAL_ISODEP_NO_DID) {
        gIsoDep.hdrLen += RFAL_ISODEP_DID_LEN;
    }
    if(gIsoDep.nad != RFAL_ISODEP_NO_NAD) {
        gIsoDep.hdrLen += RFAL_ISODEP_NAD_LEN;
    }

    /* Check if there is enough space before the infPos to append ISO-DEP headers on rx and tx */
    if((gIsoDep.rxBufInfPos < gIsoDep.hdrLen) || (gIsoDep.txBufInfPos < gIsoDep.hdrLen)) {
        return ERR_PARAM;
    }

    /*******************************************************************************/
    switch(gIsoDep.state) {
    /*******************************************************************************/
    case ISODEP_ST_IDLE:
        return ERR_NONE;

    /*******************************************************************************/
    case ISODEP_ST_PCD_TX:
        ret = isoDepTx(
            isoDep_PCBIBlock(gIsoDep.blockNumber),
            gIsoDep.txBuf,
            &gIsoDep.txBuf[gIsoDep.txBufInfPos],
            gIsoDep.txBufLen,
            (gIsoDep.fwt + gIsoDep.dFwt));
        switch(ret) {
        case ERR_NONE:
            gIsoDep.state = ISODEP_ST_PCD_RX;
            break;

        default:
            return ret;
        }
        /* fall through */

    /*******************************************************************************/
    case ISODEP_ST_PCD_WAIT_DSL: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
    case ISODEP_ST_PCD_RX:

        ret = rfalGetTransceiveStatus();
        switch(ret) {
        /* Data rcvd with error or timeout -> Send R-NAK */
        case ERR_TIMEOUT:
        case ERR_CRC:
        case ERR_PAR:
        case ERR_FRAMING: /* added to handle test cases scenario TC_POL_NFCB_T4AT_BI_82_x_y & TC_POL_NFCB_T4BT_BI_82_x_y */
        case ERR_INCOMPLETE_BYTE: /* added to handle test cases scenario TC_POL_NFCB_T4AT_BI_82_x_y & TC_POL_NFCB_T4BT_BI_82_x_y */

            if(gIsoDep
                   .isRxChaining) { /* Rule 5 - In PICC chaining when a invalid/timeout occurs -> R-ACK */
                EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM));
            } else if(
                gIsoDep.state ==
                ISODEP_ST_PCD_WAIT_DSL) { /* Rule 8 - If s-Deselect response fails MAY retransmit */
                EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_S_DSL, RFAL_ISODEP_NO_PARAM));
            } else { /* Rule 4 - When a invalid block or timeout occurs -> R-NACK */
                EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_NAK, RFAL_ISODEP_NO_PARAM));
            }
            return ERR_BUSY;

        case ERR_NONE:
            break;

        case ERR_BUSY:
            return ERR_BUSY; /* Debug purposes */

        default:
            return ret;
        }

        /*******************************************************************************/
        /* No error, process incoming msg                                              */
        /*******************************************************************************/

        (*outActRxLen) = rfalConvBitsToBytes(*outActRxLen);

        /* Check rcvd msg length, cannot be less then the expected header */
        if(((*outActRxLen) < gIsoDep.hdrLen) || ((*outActRxLen) >= gIsoDep.ourFsx)) {
            return ERR_PROTO;
        }

        /* Grab rcvd PCB */
        rxPCB = gIsoDep.rxBuf[ISODEP_PCB_POS];

        /* EMVCo doesn't allow usage of for CID or NAD   EMVCo 2.6 TAble 10.2 */
        if((gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) &&
           (isoDep_PCBhasDID(rxPCB) || isoDep_PCBhasNAD(rxPCB))) {
            return ERR_PROTO;
        }

        /* If we are expecting DID, check if PCB signals its presence and if device ID match*/
        if((gIsoDep.did != RFAL_ISODEP_NO_DID) &&
           (!isoDep_PCBhasDID(rxPCB) || (gIsoDep.did != gIsoDep.rxBuf[ISODEP_DID_POS]))) {
            return ERR_PROTO;
        }

        /*******************************************************************************/
        /* Process S-Block                                                             */
        /*******************************************************************************/
        if(isoDep_PCBisSBlock(rxPCB)) {
            /* Check if is a Wait Time eXtension */
            if(isoDep_PCBisSWTX(rxPCB)) {
                /* Check if PICC has requested S(WTX) as response to R(NAK)  EMVCo 3.0 10.3.5.5 / Digital 2.0  16.2.6.5 */
                if(isoDep_PCBisRNAK(gIsoDep.lastPCB)) {
                    gIsoDep.cntSWtxNack++; /* Count S(WTX) upon R(NAK) */
                    gIsoDep.cntRRetrys = 0; /* Reset R-Block counter has PICC has responded */
                } else {
                    gIsoDep.cntSWtxNack = 0; /* Reset R(NACK)->S(WTX) counter */
                }

                /* Rule 3 - respond to S-block: get 1st INF byte S(STW): Power + WTXM */
                EXIT_ON_ERR(
                    ret,
                    isoDepHandleControlMsg(
                        ISODEP_S_WTX, isoDep_GetWTXM(gIsoDep.rxBuf[gIsoDep.hdrLen])));
                return ERR_BUSY;
            }

            /* Check if is a deselect response */
            if(isoDep_PCBisSDeselect(rxPCB)) {
                if(gIsoDep.state == ISODEP_ST_PCD_WAIT_DSL) {
                    rfalIsoDepInitialize(); /* Session finished reInit vars */
                    return ERR_NONE;
                }

                /* Deselect response not expected  */
                /* fall through to PROTO error */
            }
            /* Unexpected S-Block */
            return ERR_PROTO;
        }

        /*******************************************************************************/
        /* Process R-Block                                                             */
        /*******************************************************************************/
        else if(isoDep_PCBisRBlock(rxPCB)) {
            if(isoDep_PCBisRACK(rxPCB)) /* Check if is a R-ACK */
            {
                if(isoDep_GetBN(rxPCB) == gIsoDep.blockNumber) /* Expected block number  */
                {
                    /* Rule B - ACK with expected bn -> Increment block number */
                    gIsoDep.blockNumber = isoDep_PCBNextBN(gIsoDep.blockNumber);

                    /* R-ACK only allowed when PCD chaining */
                    if(!gIsoDep.isTxChaining) {
                        return ERR_PROTO;
                    }

                    /* Rule 7 - Chaining transaction done, continue chaining */
                    isoDepClearCounters();
                    return ERR_NONE; /* This block has been transmitted */
                } else {
                    /* Rule 6 - R-ACK with wrong block number retransmit                          */
                    /* Digital 2.0  16.2.5.4 - Retransmit maximum two times                       */
                    /* EMVCo 3.0 10.3.4.3 -  PCD may re-transmit the last I-Block or report error */
                    if(gIsoDep.cntIRetrys++ < gIsoDep.maxRetriesI) {
                        gIsoDep.cntRRetrys = 0; /* Clear R counter only */
                        gIsoDep.state = ISODEP_ST_PCD_TX;
                        return ERR_BUSY;
                    }
                    return ERR_TIMEOUT; /* NFC Forum mandates timeout or transmission error depending on previous errors */
                }
            } else /* Unexcpected R-Block */
            {
                return ERR_PROTO;
            }
        }

        /*******************************************************************************/
        /* Process I-Block                                                             */
        /*******************************************************************************/
        else if(isoDep_PCBisIBlock(rxPCB)) {
            /*******************************************************************************/
            /* is PICC performing chaining                                                 */
            if(isoDep_PCBisChaining(rxPCB)) {
                gIsoDep.isRxChaining = true;
                *outIsChaining = true;

                if(isoDep_GetBN(rxPCB) == gIsoDep.blockNumber) {
                    /* Rule B - ACK with correct block number -> Increase Block number */
                    isoDep_ToggleBN(gIsoDep.blockNumber);

                    isoDepClearCounters(); /* Clear counters in case R counter is already at max */

                    /* Rule 2 - Send ACK */
                    EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM));

                    /* Received I-Block with chaining, send current data to DH */

                    /* remove ISO DEP header, check is necessary to move the INF data on the buffer */
                    *outActRxLen -= gIsoDep.hdrLen;
                    if((gIsoDep.hdrLen != gIsoDep.rxBufInfPos) && (*outActRxLen > 0U)) {
                        ST_MEMMOVE(
                            &gIsoDep.rxBuf[gIsoDep.rxBufInfPos],
                            &gIsoDep.rxBuf[gIsoDep.hdrLen],
                            *outActRxLen);
                    }

                    isoDepClearCounters();
                    return ERR_AGAIN; /* Send Again signalling to run again, but some chaining data has arrived */
                } else {
                    /* Rule 5 - PICC chaining invalid I-Block -> R-ACK */
                    EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM));
                }
                return ERR_BUSY;
            }

            gIsoDep.isRxChaining = false; /* clear PICC chaining flag */

            if(isoDep_GetBN(rxPCB) == gIsoDep.blockNumber) {
                /* Rule B - I-Block with correct block number -> Increase Block number */
                isoDep_ToggleBN(gIsoDep.blockNumber);

                /* I-Block transaction done successfully */

                /* remove ISO DEP header, check is necessary to move the INF data on the buffer */
                *outActRxLen -= gIsoDep.hdrLen;
                if((gIsoDep.hdrLen != gIsoDep.rxBufInfPos) && (*outActRxLen > 0U)) {
                    ST_MEMMOVE(
                        &gIsoDep.rxBuf[gIsoDep.rxBufInfPos],
                        &gIsoDep.rxBuf[gIsoDep.hdrLen],
                        *outActRxLen);
                }

                gIsoDep.state = ISODEP_ST_IDLE;
                isoDepClearCounters();
                return ERR_NONE;
            } else {
                if((gIsoDep.compMode != RFAL_COMPLIANCE_MODE_ISO)) {
                    /* Invalid Block (not chaining) -> Raise error   Digital 1.1  15.2.6.4   EMVCo 2.6  10.3.5.4 */
                    return ERR_PROTO;
                }

                /* Rule 4 - Invalid Block -> R-NAK */
                EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_NAK, RFAL_ISODEP_NO_PARAM));
                return ERR_BUSY;
            }
        } else /* not S/R/I - Block */
        {
            return ERR_PROTO;
        }
        /* fall through */

    /*******************************************************************************/
    default: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
        /* MISRA 16.4: no empty default (comment will suffice) */
        break;
    }

    return ERR_INTERNAL;
}

/*******************************************************************************/
ReturnCode rfalIsoDepDeselect(void) {
    ReturnCode ret;
    uint32_t cntRerun;
    bool dummyB;

    /*******************************************************************************/
    /* Using local static vars and static config to cope with a Deselect after     *
     * RATS\ATTRIB without any I-Block exchanged                                   */
    gIsoDep.rxLen = &gIsoDep.ctrlRxLen;
    gIsoDep.rxBuf = gIsoDep.ctrlBuf;
    gIsoDep.rxBufLen = ISODEP_CONTROLMSG_BUF_LEN - (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN);
    gIsoDep.rxBufInfPos = (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN);
    gIsoDep.txBufInfPos = (RFAL_ISODEP_PCB_LEN + RFAL_ISODEP_DID_LEN);

    /*******************************************************************************/
    /* The Deselect process is being done blocking, Digital 1.0 - 13.2.7.1 MUST wait response and retry*/
    /* Set the maximum reruns while we will wait for a response */
    cntRerun = ISODEP_MAX_RERUNS;

    /* Send DSL request and run protocol until get a response, error or "timeout" */
    EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_S_DSL, RFAL_ISODEP_NO_PARAM));
    do {
        ret = isoDepDataExchangePCD(gIsoDep.rxLen, &dummyB);
        rfalWorker();
    } while(((cntRerun--) != 0U) && (ret == ERR_BUSY));

    rfalIsoDepInitialize();
    return ((cntRerun == 0U) ? ERR_TIMEOUT : ret);
}

#endif /* RFAL_FEATURE_ISO_DEP_POLL */

/*******************************************************************************/
uint32_t rfalIsoDepFWI2FWT(uint8_t fwi) {
    uint32_t result;
    uint8_t tmpFWI;

    tmpFWI = fwi;

    /* RFU values -> take the default value  
     * Digital 1.0  11.6.2.17  FWI[1,14]
     * Digital 1.1  7.6.2.22   FWI[0,14]
     * EMVCo 2.6    Table A.5  FWI[0,14] */
    if(tmpFWI > ISODEP_FWI_MAX) {
        tmpFWI = RFAL_ISODEP_FWI_DEFAULT;
    }

    /* FWT = (256 x 16/fC) x 2^FWI => 2^(FWI+12)  Digital 1.1  13.8.1 & 7.9.1 */

    result = ((uint32_t)1U << (tmpFWI + 12U));
    result = MIN(RFAL_ISODEP_MAX_FWT, result); /* Maximum Frame Waiting Time must be fulfilled */

    return result;
}

/*******************************************************************************/
uint16_t rfalIsoDepFSxI2FSx(uint8_t FSxI) {
    uint16_t fsx;
    uint8_t fsi;

    /* Enforce maximum FSxI/FSx allowed - NFC Forum and EMVCo differ */
    fsi =
        ((gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) ? MIN(FSxI, RFAL_ISODEP_FSDI_MAX_EMV) :
                                                          MIN(FSxI, RFAL_ISODEP_FSDI_MAX_NFC));

    switch(fsi) {
    case(uint8_t)RFAL_ISODEP_FSXI_16:
        fsx = (uint16_t)RFAL_ISODEP_FSX_16;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_24:
        fsx = (uint16_t)RFAL_ISODEP_FSX_24;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_32:
        fsx = (uint16_t)RFAL_ISODEP_FSX_32;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_40:
        fsx = (uint16_t)RFAL_ISODEP_FSX_40;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_48:
        fsx = (uint16_t)RFAL_ISODEP_FSX_48;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_64:
        fsx = (uint16_t)RFAL_ISODEP_FSX_64;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_96:
        fsx = (uint16_t)RFAL_ISODEP_FSX_96;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_128:
        fsx = (uint16_t)RFAL_ISODEP_FSX_128;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_256:
        fsx = (uint16_t)RFAL_ISODEP_FSX_256;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_512:
        fsx = (uint16_t)RFAL_ISODEP_FSX_512;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_1024:
        fsx = (uint16_t)RFAL_ISODEP_FSX_1024;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_2048:
        fsx = (uint16_t)RFAL_ISODEP_FSX_2048;
        break;
    case(uint8_t)RFAL_ISODEP_FSXI_4096:
        fsx = (uint16_t)RFAL_ISODEP_FSX_4096;
        break;
    default:
        fsx = (uint16_t)RFAL_ISODEP_FSX_256;
        break;
    }
    return fsx;
}

#if RFAL_FEATURE_ISO_DEP_LISTEN

/*******************************************************************************/
bool rfalIsoDepIsRats(const uint8_t* buf, uint8_t bufLen) {
    if(buf != NULL) {
        if((RFAL_ISODEP_CMD_RATS == (uint8_t)*buf) && (sizeof(rfalIsoDepRats) == bufLen)) {
            return true;
        }
    }
    return false;
}

/*******************************************************************************/
bool rfalIsoDepIsAttrib(const uint8_t* buf, uint8_t bufLen) {
    if(buf != NULL) {
        if((RFAL_ISODEP_CMD_ATTRIB == (uint8_t)*buf) &&
           (RFAL_ISODEP_ATTRIB_REQ_MIN_LEN <= bufLen) &&
           ((RFAL_ISODEP_ATTRIB_REQ_MIN_LEN + RFAL_ISODEP_ATTRIB_HLINFO_LEN) >= bufLen)) {
            return true;
        }
    }
    return false;
}

/*******************************************************************************/
ReturnCode rfalIsoDepListenStartActivation(
    rfalIsoDepAtsParam* atsParam,
    const rfalIsoDepAttribResParam* attribResParam,
    const uint8_t* buf,
    uint16_t bufLen,
    rfalIsoDepListenActvParam actParam) {
    uint8_t* txBuf;
    uint8_t bufIt;
    const uint8_t* buffer = buf;

    /*******************************************************************************/
    bufIt = 0;
    txBuf =
        (uint8_t*)actParam
            .rxBuf; /* Use the rxBuf as TxBuf as well, the struct enforces a size enough MAX( NFCA_ATS_MAX_LEN, NFCB_ATTRIB_RES_MAX_LEN ) */
    gIsoDep.txBR = RFAL_BR_106;
    gIsoDep.rxBR = RFAL_BR_106;

    /* Check for a valid buffer pointer */
    if(buffer == NULL) {
        return ERR_PARAM;
    }

    /*******************************************************************************/
    if(*buffer == RFAL_ISODEP_CMD_RATS) {
        /* Check ATS parameters */
        if(atsParam == NULL) {
            return ERR_PARAM;
        }

        /* If requested copy RATS to device info */
        if(actParam.isoDepDev != NULL) {
            ST_MEMCPY(
                (uint8_t*)&actParam.isoDepDev->activation.A.Poller.RATS,
                buffer,
                sizeof(rfalIsoDepRats)); /* Copy RATS' CMD + PARAM */
        }

        /*******************************************************************************/
        /* Process RATS                                                                */
        buffer++;
        gIsoDep.fsx = rfalIsoDepFSxI2FSx(
            (((*buffer) & RFAL_ISODEP_RATS_PARAM_FSDI_MASK) >> RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT));
        gIsoDep.did = (*buffer & RFAL_ISODEP_DID_MASK);

        /*******************************************************************************/
        /* Digital 1.1  13.6.1.8 - DID as to between 0 and 14 */
        if(gIsoDep.did > RFAL_ISODEP_DID_MAX) {
            return ERR_PROTO;
        }

        /* Check if we are configured to support DID */
        if((gIsoDep.did != RFAL_ISODEP_DID_00) && (!atsParam->didSupport)) {
            return ERR_NOTSUPP;
        }

        /*******************************************************************************/
        /* Check RFAL supported bit rates  */
        if((!(RFAL_SUPPORT_BR_CE_A_212) &&
            (((atsParam->ta & RFAL_ISODEP_ATS_TA_DPL_212) != 0U) ||
             ((atsParam->ta & RFAL_ISODEP_ATS_TA_DLP_212) != 0U))) ||
           (!(RFAL_SUPPORT_BR_CE_A_424) &&
            (((atsParam->ta & RFAL_ISODEP_ATS_TA_DPL_424) != 0U) ||
             ((atsParam->ta & RFAL_ISODEP_ATS_TA_DLP_424) != 0U))) ||
           (!(RFAL_SUPPORT_BR_CE_A_848) &&
            (((atsParam->ta & RFAL_ISODEP_ATS_TA_DPL_848) != 0U) ||
             ((atsParam->ta & RFAL_ISODEP_ATS_TA_DLP_848) != 0U)))) {
            return ERR_NOTSUPP;
        }

        /* Enforce proper FWI configuration */
        if(atsParam->fwi > ISODEP_FWI_LIS_MAX) {
            atsParam->fwi = ISODEP_FWI_LIS_MAX;
        }

        gIsoDep.atsTA = atsParam->ta;
        gIsoDep.fwt = rfalIsoDepFWI2FWT(atsParam->fwi);
        gIsoDep.ourFsx = rfalIsoDepFSxI2FSx(atsParam->fsci);

        /* Ensure proper/maximum Historical Bytes length  */
        atsParam->hbLen = MIN(RFAL_ISODEP_ATS_HB_MAX_LEN, atsParam->hbLen);

        /*******************************************************************************/
        /* Compute ATS                                                                 */

        txBuf[bufIt++] = (RFAL_ISODEP_ATS_HIST_OFFSET + atsParam->hbLen); /* TL */
        txBuf[bufIt++] =
            ((RFAL_ISODEP_ATS_T0_TA_PRESENCE_MASK | RFAL_ISODEP_ATS_T0_TB_PRESENCE_MASK |
              RFAL_ISODEP_ATS_T0_TC_PRESENCE_MASK) |
             atsParam->fsci); /* T0 */
        txBuf[bufIt++] = atsParam->ta; /* TA */
        txBuf[bufIt++] =
            ((atsParam->fwi << RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT) |
             (atsParam->sfgi & RFAL_ISODEP_RATS_PARAM_FSDI_MASK)); /* TB */
        txBuf[bufIt++] = (uint8_t)((atsParam->didSupport) ? RFAL_ISODEP_ATS_TC_DID : 0U); /* TC */

        if(atsParam->hbLen > 0U) /* MISRA 21.18 */
        {
            ST_MEMCPY(&txBuf[bufIt], atsParam->hb, atsParam->hbLen); /* T1-Tk */
            bufIt += atsParam->hbLen;
        }

        gIsoDep.state = ISODEP_ST_PICC_ACT_ATS;

    }
    /*******************************************************************************/
    else if(*buffer == RFAL_ISODEP_CMD_ATTRIB) {
        /* Check ATTRIB parameters */
        if(attribResParam == NULL) {
            return ERR_PARAM;
        }

        /*  REMARK: ATTRIB handling */
        NO_WARNING(attribResParam);
        NO_WARNING(bufLen);
        return ERR_NOT_IMPLEMENTED;
    } else {
        return ERR_PARAM;
    }

    gIsoDep.actvParam = actParam;

    /*******************************************************************************/
    /* If requested copy to ISO-DEP device info */
    if(actParam.isoDepDev != NULL) {
        actParam.isoDepDev->info.DID = gIsoDep.did;
        actParam.isoDepDev->info.FSx = gIsoDep.fsx;
        actParam.isoDepDev->info.FWT = gIsoDep.fwt;
        actParam.isoDepDev->info.dFWT = 0;
        actParam.isoDepDev->info.DSI = gIsoDep.txBR;
        actParam.isoDepDev->info.DRI = gIsoDep.rxBR;
    }

    return rfalTransceiveBlockingTx(
        txBuf,
        bufIt,
        (uint8_t*)actParam.rxBuf,
        sizeof(rfalIsoDepBufFormat),
        actParam.rxLen,
        RFAL_TXRX_FLAGS_DEFAULT,
        RFAL_FWT_NONE);
}

/*******************************************************************************/
ReturnCode rfalIsoDepListenGetActivationStatus(void) {
    ReturnCode err;
    uint8_t* txBuf;
    uint8_t bufIt;

    rfalBitRate dsi;
    rfalBitRate dri;

    /* Check if Activation is running */
    if(gIsoDep.state < ISODEP_ST_PICC_ACT_ATS) {
        return ERR_WRONG_STATE;
    }

    /* Check if Activation has finished already */
    if(gIsoDep.state >= ISODEP_ST_PICC_RX) {
        return ERR_NONE;
    }

    /*******************************************************************************/
    /* Check for incoming msg */
    err = rfalGetTransceiveStatus();
    switch(err) {
    /*******************************************************************************/
    case ERR_NONE:
        break;

    /*******************************************************************************/
    case ERR_LINK_LOSS:
    case ERR_BUSY:
        return err;

    /*******************************************************************************/
    case ERR_CRC:
    case ERR_PAR:
    case ERR_FRAMING:

        /* ISO14443 4  5.6.2.2 2  If ATS has been replied upon a invalid block, PICC disables the PPS responses */
        if(gIsoDep.state == ISODEP_ST_PICC_ACT_ATS) {
            gIsoDep.state = ISODEP_ST_PICC_RX;
            break;
        }
        /* fall through */

    /*******************************************************************************/
    default: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
        /* ReEnable the receiver and wait for another frame */
        isoDepReEnableRx(
            (uint8_t*)gIsoDep.actvParam.rxBuf,
            sizeof(rfalIsoDepBufFormat),
            gIsoDep.actvParam.rxLen);

        return ERR_BUSY;
    }

    txBuf =
        (uint8_t*)gIsoDep.actvParam
            .rxBuf; /* Use the rxBuf as TxBuf as well, the struct enforces a size enough  MAX(NFCA_PPS_RES_LEN, ISODEP_DSL_MAX_LEN) */
    dri = RFAL_BR_KEEP; /* The RFAL_BR_KEEP is used to check if PPS with BR change was requested */
    dsi = RFAL_BR_KEEP; /* MISRA 9.1 */
    bufIt = 0;

    /*******************************************************************************/
    gIsoDep.role = ISODEP_ROLE_PICC;

    /*******************************************************************************/
    if(gIsoDep.state == ISODEP_ST_PICC_ACT_ATS) {
        /* Check for a PPS    ISO 14443-4  5.3 */
        if((((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_STARTBYTE_POS] &
            RFAL_ISODEP_PPS_MASK) == RFAL_ISODEP_PPS_SB) {
            /* ISO 14443-4  5.3.1  Check if the we are the addressed DID/CID */
            /* ISO 14443-4  5.3.2  Check for a valid PPS0 */
            if(((((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_STARTBYTE_POS] &
                 RFAL_ISODEP_DID_MASK) != gIsoDep.did) ||
               ((((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_PPS0_POS] &
                 RFAL_ISODEP_PPS0_VALID_MASK) != RFAL_ISODEP_PPS0_PPS1_NOT_PRESENT)) {
                /* Invalid DID on PPS request or Invalid PPS0, reEnable the receiver and wait another frame */
                isoDepReEnableRx(
                    (uint8_t*)gIsoDep.actvParam.rxBuf,
                    sizeof(rfalIsoDepBufFormat),
                    gIsoDep.actvParam.rxLen);

                return ERR_BUSY;
            }

            /*******************************************************************************/
            /* Check PPS1 presence */
            if(((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_PPS0_POS] ==
               RFAL_ISODEP_PPS0_PPS1_PRESENT) {
                uint8_t newdri = ((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_PPS1_POS] &
                                 RFAL_ISODEP_PPS1_DxI_MASK; /* MISRA 10.8 */
                uint8_t newdsi = (((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_PPS1_POS] >>
                                  RFAL_ISODEP_PPS1_DSI_SHIFT) &
                                 RFAL_ISODEP_PPS1_DxI_MASK; /* MISRA 10.8 */
                /* PRQA S 4342 2 # MISRA 10.5 - Layout of enum rfalBitRate and above masks guarantee no invalid enum values to be created */
                dri = (rfalBitRate)(newdri);
                dsi = (rfalBitRate)(newdsi);

                if((!(RFAL_SUPPORT_BR_CE_A_106) &&
                    ((dsi == RFAL_BR_106) || (dri == RFAL_BR_106))) ||
                   (!(RFAL_SUPPORT_BR_CE_A_212) &&
                    ((dsi == RFAL_BR_212) || (dri == RFAL_BR_212))) ||
                   (!(RFAL_SUPPORT_BR_CE_A_424) &&
                    ((dsi == RFAL_BR_424) || (dri == RFAL_BR_424))) ||
                   (!(RFAL_SUPPORT_BR_CE_A_848) &&
                    ((dsi == RFAL_BR_848) || (dri == RFAL_BR_848)))) {
                    return ERR_PROTO;
                }
            }

            /*******************************************************************************/
            /* Compute and send PPS RES / Ack                                              */
            txBuf[bufIt++] = ((uint8_t*)gIsoDep.actvParam.rxBuf)[RFAL_ISODEP_PPS_STARTBYTE_POS];

            rfalTransceiveBlockingTx(
                txBuf,
                bufIt,
                (uint8_t*)gIsoDep.actvParam.rxBuf,
                sizeof(rfalIsoDepBufFormat),
                gIsoDep.actvParam.rxLen,
                RFAL_TXRX_FLAGS_DEFAULT,
                RFAL_FWT_NONE);

            /*******************************************************************************/
            /* Exchange the bit rates if requested */
            if(dri != RFAL_BR_KEEP) {
                rfalSetBitRate(
                    dsi,
                    dri); /*  PRQA S  2880 # MISRA 2.1 - Unreachable code due to configuration option being set/unset above (RFAL_SUPPORT_BR_CE_A_xxx) */

                gIsoDep.txBR = dsi; /* DSI codes the divisor from PICC to PCD */
                gIsoDep.rxBR = dri; /* DRI codes the divisor from PCD to PICC */

                if(gIsoDep.actvParam.isoDepDev != NULL) {
                    gIsoDep.actvParam.isoDepDev->info.DSI = dsi;
                    gIsoDep.actvParam.isoDepDev->info.DRI = dri;
                }
            }
        }
        /* Check for a S-Deselect is done on Data Exchange Activity                    */
    }

    /*******************************************************************************/
    gIsoDep.hdrLen = RFAL_ISODEP_PCB_LEN;
    gIsoDep.hdrLen +=
        RFAL_ISODEP_DID_LEN; /* Always assume DID to be aligned with Digital 1.1  15.1.2 and ISO14443  4 5.6.3    #454 */
    gIsoDep.hdrLen += (uint8_t)((gIsoDep.nad != RFAL_ISODEP_NO_NAD) ? RFAL_ISODEP_NAD_LEN : 0U);

    /*******************************************************************************/
    /* Rule C - The PICC block number shall be initialized to 1 at activation */
    gIsoDep.blockNumber = 1;

    /* Activation done, keep the rcvd data in, reMap the activation buffer to the global to be retrieved by the DEP method */
    gIsoDep.rxBuf = (uint8_t*)gIsoDep.actvParam.rxBuf;
    gIsoDep.rxBufLen = sizeof(rfalIsoDepBufFormat);
    gIsoDep.rxBufInfPos =
        (uint8_t)((uint32_t)gIsoDep.actvParam.rxBuf->inf - (uint32_t)gIsoDep.actvParam.rxBuf->prologue);
    gIsoDep.rxLen = gIsoDep.actvParam.rxLen;
    gIsoDep.rxChaining = gIsoDep.actvParam.isRxChaining;

    gIsoDep.state = ISODEP_ST_PICC_RX;
    return ERR_NONE;
}

#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */

/*******************************************************************************/
uint16_t rfalIsoDepGetMaxInfLen(void) {
    /* Check whether all parameters are valid, otherwise return minimum default value */
    if((gIsoDep.fsx < (uint16_t)RFAL_ISODEP_FSX_16) ||
       (gIsoDep.fsx > (uint16_t)RFAL_ISODEP_FSX_4096) || (gIsoDep.hdrLen > ISODEP_HDR_MAX_LEN)) {
        uint16_t isodepFsx16 = (uint16_t)RFAL_ISODEP_FSX_16; /* MISRA 10.1 */
        return (isodepFsx16 - RFAL_ISODEP_PCB_LEN - ISODEP_CRC_LEN);
    }

    return (gIsoDep.fsx - gIsoDep.hdrLen - ISODEP_CRC_LEN);
}

/*******************************************************************************/
ReturnCode rfalIsoDepStartTransceive(rfalIsoDepTxRxParam param) {
    gIsoDep.txBuf = param.txBuf->prologue;
    gIsoDep.txBufInfPos = (uint8_t)((uint32_t)param.txBuf->inf - (uint32_t)param.txBuf->prologue);
    gIsoDep.txBufLen = param.txBufLen;
    gIsoDep.isTxChaining = param.isTxChaining;

    gIsoDep.rxBuf = param.rxBuf->prologue;
    gIsoDep.rxBufInfPos = (uint8_t)((uint32_t)param.rxBuf->inf - (uint32_t)param.rxBuf->prologue);
    gIsoDep.rxBufLen = sizeof(rfalIsoDepBufFormat);

    gIsoDep.rxLen = param.rxLen;
    gIsoDep.rxChaining = param.isRxChaining;

    gIsoDep.fwt = param.FWT;
    gIsoDep.dFwt = param.dFWT;
    gIsoDep.fsx = param.FSx;
    gIsoDep.did = param.DID;

    /* Only change the FSx from activation if no to Keep */
    gIsoDep.ourFsx = ((param.ourFSx != RFAL_ISODEP_FSX_KEEP) ? param.ourFSx : gIsoDep.ourFsx);

    /* Clear inner control params for next dataExchange */
    gIsoDep.isRxChaining = false;
    isoDepClearCounters();

    if(gIsoDep.role == ISODEP_ROLE_PICC) {
        if(gIsoDep.txBufLen > 0U) {
            /* Ensure that an RTOX Ack is not being expected at moment */
            if(!gIsoDep.isWait4WTX) {
                gIsoDep.state = ISODEP_ST_PICC_TX;
                return ERR_NONE;
            } else {
                /* If RTOX Ack is expected, signal a pending Tx to be transmitted right after */
                gIsoDep.isTxPending = true;
            }
        }

        /* Digital 1.1  15.2.5.1 The first block SHALL be sent by the Reader/Writer */
        gIsoDep.state = ISODEP_ST_PICC_RX;
        return ERR_NONE;
    }

    gIsoDep.state = ISODEP_ST_PCD_TX;
    return ERR_NONE;
}

/*******************************************************************************/
ReturnCode rfalIsoDepGetTransceiveStatus(void) {
    if(gIsoDep.role == ISODEP_ROLE_PICC) {
#if RFAL_FEATURE_ISO_DEP_LISTEN
        return isoDepDataExchangePICC();
#else
        return ERR_NOTSUPP;
#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */
    } else {
#if RFAL_FEATURE_ISO_DEP_POLL
        return isoDepDataExchangePCD(gIsoDep.rxLen, gIsoDep.rxChaining);
#else
        return ERR_NOTSUPP;
#endif /* RFAL_FEATURE_ISO_DEP_POLL */
    }
}

#if RFAL_FEATURE_ISO_DEP_LISTEN

/*******************************************************************************/
static ReturnCode isoDepDataExchangePICC(void) {
    uint8_t rxPCB;
    ReturnCode ret;

    switch(gIsoDep.state) {
    /*******************************************************************************/
    case ISODEP_ST_IDLE:
        return ERR_NONE;

    /*******************************************************************************/
    case ISODEP_ST_PICC_TX:

        ret = isoDepTx(
            isoDep_PCBIBlock(gIsoDep.blockNumber),
            gIsoDep.txBuf,
            &gIsoDep.txBuf[gIsoDep.txBufInfPos],
            gIsoDep.txBufLen,
            RFAL_FWT_NONE);

        /* Clear pending Tx flag */
        gIsoDep.isTxPending = false;

        switch(ret) {
        case ERR_NONE:
            gIsoDep.state = ISODEP_ST_PICC_RX;
            return ERR_BUSY;

        default:
            /* MISRA 16.4: no empty default statement (a comment being enough) */
            break;
        }
        return ret;

    /*******************************************************************************/
    case ISODEP_ST_PICC_RX:

        ret = rfalGetTransceiveStatus();
        switch(ret) {
        /*******************************************************************************/
        /* Data rcvd with error or timeout -> mute */
        case ERR_TIMEOUT:
        case ERR_CRC:
        case ERR_PAR:
        case ERR_FRAMING:

            /* Digital 1.1 - 15.2.6.2  The CE SHALL NOT attempt error recovery and remains in Rx mode upon Transmission or a Protocol Error */
            isoDepReEnableRx((uint8_t*)gIsoDep.rxBuf, sizeof(rfalIsoDepBufFormat), gIsoDep.rxLen);

            return ERR_BUSY;

        /*******************************************************************************/
        case ERR_LINK_LOSS:
            return ret; /* Debug purposes */

        case ERR_BUSY:
            return ret; /* Debug purposes */

        /*******************************************************************************/
        case ERR_NONE:
            *gIsoDep.rxLen = rfalConvBitsToBytes(*gIsoDep.rxLen);
            break;

        /*******************************************************************************/
        default:
            return ret;
        }
        break;

    /*******************************************************************************/
    case ISODEP_ST_PICC_SWTX:

        if(!isoDepTimerisExpired(gIsoDep.WTXTimer)) /* Do nothing until WTX timer has expired */
        {
            return ERR_BUSY;
        }

        /* Set waiting for WTX Ack Flag */
        gIsoDep.isWait4WTX = true;

        /* Digital 1.1  15.2.2.9 - Calculate the WTXM such that FWTtemp <= FWTmax */
        gIsoDep.lastWTXM = (uint8_t)isoDep_WTXMListenerMax(gIsoDep.fwt);
        EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_S_WTX, gIsoDep.lastWTXM));

        gIsoDep.state = ISODEP_ST_PICC_RX; /* Go back to Rx to process WTX ack        */
        return ERR_BUSY;

    /*******************************************************************************/
    case ISODEP_ST_PICC_SDSL:

        if(rfalIsTransceiveInRx()) /* Wait until DSL response has been sent */
        {
            rfalIsoDepInitialize(); /* Session finished reInit vars */
            return ERR_SLEEP_REQ; /* Notify Deselect request      */
        }
        return ERR_BUSY;

    /*******************************************************************************/
    default:
        return ERR_INTERNAL;
    }

    /* ISO 14443-4 7.5.6.2 CE SHALL NOT attempt error recovery -> clear counters */
    isoDepClearCounters();

    /*******************************************************************************/
    /* No error, process incoming msg                                              */
    /*******************************************************************************/

    /* Grab rcvd PCB */
    rxPCB = gIsoDep.rxBuf[ISODEP_PCB_POS];

    /*******************************************************************************/
    /* When DID=0 PCD may or may not use DID, therefore check whether current PCD request 
     * has DID present to be reflected on max INF length                         #454  */

    /* ReCalculate Header Length */
    gIsoDep.hdrLen = RFAL_ISODEP_PCB_LEN;
    gIsoDep.hdrLen += (uint8_t)((isoDep_PCBhasDID(rxPCB)) ? RFAL_ISODEP_DID_LEN : 0U);
    gIsoDep.hdrLen += (uint8_t)((isoDep_PCBhasNAD(rxPCB)) ? RFAL_ISODEP_NAD_LEN : 0U);

    /* Store whether last PCD block had DID. for PICC special handling of DID = 0 */
    if(gIsoDep.did == RFAL_ISODEP_DID_00) {
        gIsoDep.lastDID00 = ((isoDep_PCBhasDID(rxPCB)) ? true : false);
    }

    /*******************************************************************************/
    /* Check rcvd msg length, cannot be less then the expected header    OR        * 
     * if the rcvd msg exceeds our announced frame size (FSD)                      */
    if(((*gIsoDep.rxLen) < gIsoDep.hdrLen) ||
       ((*gIsoDep.rxLen) > (gIsoDep.ourFsx - ISODEP_CRC_LEN))) {
        isoDepReEnableRx(
            (uint8_t*)gIsoDep.actvParam.rxBuf,
            sizeof(rfalIsoDepBufFormat),
            gIsoDep.actvParam.rxLen);
        return ERR_BUSY; /* ERR_PROTO Ignore this protocol request */
    }

    /* If we are expecting DID, check if PCB signals its presence and if device ID match OR
     * If our DID=0 and DID is sent but with an incorrect value                              */
    if(((gIsoDep.did != RFAL_ISODEP_DID_00) &&
        (!isoDep_PCBhasDID(rxPCB) || (gIsoDep.did != gIsoDep.rxBuf[ISODEP_DID_POS]))) ||
       ((gIsoDep.did == RFAL_ISODEP_DID_00) && isoDep_PCBhasDID(rxPCB) &&
        (RFAL_ISODEP_DID_00 != gIsoDep.rxBuf[ISODEP_DID_POS]))) {
        isoDepReEnableRx(
            (uint8_t*)gIsoDep.actvParam.rxBuf,
            sizeof(rfalIsoDepBufFormat),
            gIsoDep.actvParam.rxLen);
        return ERR_BUSY; /* Ignore a wrong DID request */
    }

    /* If we aren't expecting NAD and it's received */
    if((gIsoDep.nad == RFAL_ISODEP_NO_NAD) && isoDep_PCBhasNAD(rxPCB)) {
        isoDepReEnableRx(
            (uint8_t*)gIsoDep.actvParam.rxBuf,
            sizeof(rfalIsoDepBufFormat),
            gIsoDep.actvParam.rxLen);
        return ERR_BUSY; /* Ignore a unexpected NAD request */
    }

    /*******************************************************************************/
    /* Process S-Block                                                             */
    /*******************************************************************************/
    if(isoDep_PCBisSBlock(rxPCB)) {
        /* Check if is a Wait Time eXtension */
        if(isoDep_PCBisSWTX(rxPCB)) {
            /* Check if we're expecting a S-WTX */
            if(isoDep_PCBisWTX(gIsoDep.lastPCB)) {
                /* Digital 1.1  15.2.2.11 S(WTX) Ack with different WTXM -> Protocol Error  *
                 *              Power level indication also should be set to 0              */
                if((gIsoDep.rxBuf[gIsoDep.hdrLen] == gIsoDep.lastWTXM) &&
                   ((*gIsoDep.rxLen - gIsoDep.hdrLen) == ISODEP_SWTX_INF_LEN)) {
                    /* Clear waiting for RTOX Ack Flag */
                    gIsoDep.isWait4WTX = false;

                    /* Check if a Tx is already pending */
                    if(gIsoDep.isTxPending) {
                        /* Has a pending Tx, go immediately to TX */
                        gIsoDep.state = ISODEP_ST_PICC_TX;
                        return ERR_BUSY;
                    }

                    /* Set WTX timer */
                    isoDepTimerStart(
                        gIsoDep.WTXTimer,
                        isoDep_WTXAdjust((gIsoDep.lastWTXM * rfalConv1fcToMs(gIsoDep.fwt))));

                    gIsoDep.state = ISODEP_ST_PICC_SWTX;
                    return ERR_BUSY;
                }
            }
            /* Unexpected/Incorrect S-WTX, fall into reRenable */
        }

        /* Check if is a Deselect request */
        if(isoDep_PCBisSDeselect(rxPCB) &&
           ((*gIsoDep.rxLen - gIsoDep.hdrLen) == ISODEP_SDSL_INF_LEN)) {
            EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_S_DSL, RFAL_ISODEP_NO_PARAM));

            /* S-DSL transmission ongoing, wait until complete */
            gIsoDep.state = ISODEP_ST_PICC_SDSL;
            return ERR_BUSY;
        }

        /* Unexpected S-Block, fall into reRenable */
    }

    /*******************************************************************************/
    /* Process R-Block                                                             */
    /*******************************************************************************/
    else if(isoDep_PCBisRBlock(rxPCB) && ((*gIsoDep.rxLen - gIsoDep.hdrLen) == ISODEP_RBLOCK_INF_LEN)) {
        if(isoDep_PCBisRACK(rxPCB)) /* Check if is a R-ACK */
        {
            if(isoDep_GetBN(rxPCB) == gIsoDep.blockNumber) /* Check block number  */
            {
                /* Rule 11 - R(ACK) with current bn -> re-transmit */
                if(!isoDep_PCBisIBlock(gIsoDep.lastPCB)) {
                    isoDepReSendControlMsg();
                } else {
                    gIsoDep.state = ISODEP_ST_PICC_TX;
                }

                return ERR_BUSY;
            } else {
                if(!gIsoDep.isTxChaining) {
                    /* Rule 13 violation R(ACK) without performing chaining */
                    isoDepReEnableRx(
                        (uint8_t*)gIsoDep.rxBuf, sizeof(rfalIsoDepBufFormat), gIsoDep.rxLen);
                    return ERR_BUSY;
                }

                /* Rule E -  R(ACK) with not current bn -> toogle bn */
                isoDep_ToggleBN(gIsoDep.blockNumber);

                /* This block has been transmitted and acknowledged, perform WTX until next data is provided  */

                /* Rule 9 - PICC is allowed to send an S(WTX) instead of an I-block or an R(ACK) */
                isoDepTimerStart(gIsoDep.WTXTimer, isoDep_WTXAdjust(rfalConv1fcToMs(gIsoDep.fwt)));
                gIsoDep.state = ISODEP_ST_PICC_SWTX;

                /* Rule 13 - R(ACK) with not current bn -> continue chaining */
                return ERR_NONE; /* This block has been transmitted */
            }
        } else if(isoDep_PCBisRNAK(rxPCB)) /* Check if is a R-NACK */
        {
            if(isoDep_GetBN(rxPCB) == gIsoDep.blockNumber) /* Check block number  */
            {
                /* Rule 11 - R(NAK) with current bn -> re-transmit last x-Block */
                if(!isoDep_PCBisIBlock(gIsoDep.lastPCB)) {
                    isoDepReSendControlMsg();
                } else {
                    gIsoDep.state = ISODEP_ST_PICC_TX;
                }

                return ERR_BUSY;
            } else {
                /* Rule 12 - R(NAK) with not current bn -> R(ACK) */
                EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM));

                return ERR_BUSY;
            }
        } else {
            /* MISRA 15.7 - Empty else */
        }

        /* Unexpected R-Block, fall into reRenable */
    }

    /*******************************************************************************/
    /* Process I-Block                                                             */
    /*******************************************************************************/
    else if(isoDep_PCBisIBlock(rxPCB)) {
        /* Rule D - When an I-block is received, the PICC shall toggle its block number before sending a block */
        isoDep_ToggleBN(gIsoDep.blockNumber);

        /*******************************************************************************/
        /* Check if the block number is the one expected                               */
        /* Check if PCD sent an I-Block instead ACK/NACK when we are chaining          */
        if((isoDep_GetBN(rxPCB) != gIsoDep.blockNumber) || (gIsoDep.isTxChaining)) {
            /* Remain in the same Block Number */
            isoDep_ToggleBN(gIsoDep.blockNumber);

            /* ISO 14443-4 7.5.6.2 & Digital 1.1 - 15.2.6.2  The CE SHALL NOT attempt error recovery and remains in Rx mode upon Transmission or a Protocol Error */
            isoDepReEnableRx((uint8_t*)gIsoDep.rxBuf, sizeof(rfalIsoDepBufFormat), gIsoDep.rxLen);
            return ERR_BUSY;
        }

        /*******************************************************************************/
        /* is PCD performing chaining  ?                                               */
        if(isoDep_PCBisChaining(rxPCB)) {
            gIsoDep.isRxChaining = true;
            *gIsoDep.rxChaining = true; /* Output Parameter*/

            EXIT_ON_ERR(ret, isoDepHandleControlMsg(ISODEP_R_ACK, RFAL_ISODEP_NO_PARAM));

            /* Received I-Block with chaining, send current data to DH */

            /* remove ISO DEP header, check is necessary to move the INF data on the buffer */
            *gIsoDep.rxLen -= gIsoDep.hdrLen;
            if((gIsoDep.hdrLen != gIsoDep.rxBufInfPos) && (*gIsoDep.rxLen > 0U)) {
                ST_MEMMOVE(
                    &gIsoDep.rxBuf[gIsoDep.rxBufInfPos],
                    &gIsoDep.rxBuf[gIsoDep.hdrLen],
                    *gIsoDep.rxLen);
            }
            return ERR_AGAIN; /* Send Again signalling to run again, but some chaining data has arrived*/
        }

        /*******************************************************************************/
        /* PCD is not performing chaining                                              */
        gIsoDep.isRxChaining = false; /* clear PCD chaining flag */
        *gIsoDep.rxChaining = false; /* Output Parameter        */

        /* remove ISO DEP header, check is necessary to move the INF data on the buffer */
        *gIsoDep.rxLen -= gIsoDep.hdrLen;
        if((gIsoDep.hdrLen != gIsoDep.rxBufInfPos) && (*gIsoDep.rxLen > 0U)) {
            ST_MEMMOVE(
                &gIsoDep.rxBuf[gIsoDep.rxBufInfPos],
                &gIsoDep.rxBuf[gIsoDep.hdrLen],
                *gIsoDep.rxLen);
        }

        /*******************************************************************************/
        /* Reception done, send data back and start WTX timer                          */
        isoDepTimerStart(gIsoDep.WTXTimer, isoDep_WTXAdjust(rfalConv1fcToMs(gIsoDep.fwt)));

        gIsoDep.state = ISODEP_ST_PICC_SWTX;
        return ERR_NONE;
    } else {
        /* MISRA 15.7 - Empty else */
    }

    /* Unexpected/Unknown Block */
    /* ISO 14443-4 7.5.6.2 & Digital 1.1 - 15.2.6.2  The CE SHALL NOT attempt error recovery and remains in Rx mode upon Transmission or a Protocol Error */
    isoDepReEnableRx((uint8_t*)gIsoDep.rxBuf, sizeof(rfalIsoDepBufFormat), gIsoDep.rxLen);

    return ERR_BUSY;
}
#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */

#if RFAL_FEATURE_ISO_DEP_POLL

#if RFAL_FEATURE_NFCA

/*******************************************************************************/
static ReturnCode
    rfalIsoDepStartRATS(rfalIsoDepFSxI FSDI, uint8_t DID, rfalIsoDepAts* ats, uint8_t* atsLen) {
    rfalTransceiveContext ctx;

    if(ats == NULL) {
        return ERR_PARAM;
    }

    gIsoDep.rxBuf = (uint8_t*)ats;
    gIsoDep.rxLen8 = atsLen;
    gIsoDep.did = DID;

    /*******************************************************************************/
    /* Compose RATS */
    gIsoDep.actv.ratsReq.CMD = RFAL_ISODEP_CMD_RATS;
    gIsoDep.actv.ratsReq.PARAM =
        (((uint8_t)FSDI << RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT) & RFAL_ISODEP_RATS_PARAM_FSDI_MASK) |
        (DID & RFAL_ISODEP_RATS_PARAM_DID_MASK);

    rfalCreateByteFlagsTxRxContext(
        ctx,
        (uint8_t*)&gIsoDep.actv.ratsReq,
        sizeof(rfalIsoDepRats),
        (uint8_t*)ats,
        sizeof(rfalIsoDepAts),
        &gIsoDep.rxBufLen,
        RFAL_TXRX_FLAGS_DEFAULT,
        RFAL_ISODEP_T4T_FWT_ACTIVATION);
    return rfalStartTransceive(&ctx);
}

/*******************************************************************************/
static ReturnCode rfalIsoDepGetRATSStatus(void) {
    ReturnCode ret;

    ret = rfalGetTransceiveStatus();
    if(ret == ERR_NONE) {
        gIsoDep.rxBufLen = rfalConvBitsToBytes(gIsoDep.rxBufLen);

        /* Check for valid ATS length  Digital 1.1  13.6.2.1 & 13.6.2.3 */
        if((gIsoDep.rxBufLen < RFAL_ISODEP_ATS_MIN_LEN) ||
           (gIsoDep.rxBufLen > RFAL_ISODEP_ATS_MAX_LEN) ||
           (gIsoDep.rxBuf[RFAL_ISODEP_ATS_TL_POS] != gIsoDep.rxBufLen)) {
            return ERR_PROTO;
        }

        /* Assign our FSx, in case the a Deselect is send without Transceive */
        gIsoDep.ourFsx = rfalIsoDepFSxI2FSx(
            (uint8_t)(gIsoDep.actv.ratsReq.PARAM >> RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT));

        /* Check and assign if ATS length was requested (length also available on TL) */
        if(gIsoDep.rxLen8 != NULL) {
            *gIsoDep.rxLen8 = (uint8_t)gIsoDep.rxBufLen;
        }
    }

    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepRATS(rfalIsoDepFSxI FSDI, uint8_t DID, rfalIsoDepAts* ats, uint8_t* atsLen) {
    ReturnCode ret;

    EXIT_ON_ERR(ret, rfalIsoDepStartRATS(FSDI, DID, ats, atsLen));
    rfalIsoDepRunBlocking(ret, rfalIsoDepGetRATSStatus());

    return ret;
}

/*******************************************************************************/
static ReturnCode
    rfalIsoDepStartPPS(uint8_t DID, rfalBitRate DSI, rfalBitRate DRI, rfalIsoDepPpsRes* ppsRes) {
    rfalTransceiveContext ctx;

    if((ppsRes == NULL) || (DSI > RFAL_BR_848) || (DRI > RFAL_BR_848) ||
       (DID > RFAL_ISODEP_DID_MAX)) {
        return ERR_PARAM;
    }

    gIsoDep.rxBuf = (uint8_t*)ppsRes;

    /*******************************************************************************/
    /* Compose PPS Request */
    gIsoDep.actv.ppsReq.PPSS = (RFAL_ISODEP_PPS_SB | (DID & RFAL_ISODEP_PPS_SB_DID_MASK));
    gIsoDep.actv.ppsReq.PPS0 = RFAL_ISODEP_PPS_PPS0_PPS1_PRESENT;
    gIsoDep.actv.ppsReq.PPS1 =
        (RFAL_ISODEP_PPS_PPS1 |
         ((((uint8_t)DSI << RFAL_ISODEP_PPS_PPS1_DSI_SHIFT) | (uint8_t)DRI) &
          RFAL_ISODEP_PPS_PPS1_DXI_MASK));

    rfalCreateByteFlagsTxRxContext(
        ctx,
        (uint8_t*)&gIsoDep.actv.ppsReq,
        sizeof(rfalIsoDepPpsReq),
        (uint8_t*)ppsRes,
        sizeof(rfalIsoDepPpsRes),
        &gIsoDep.rxBufLen,
        RFAL_TXRX_FLAGS_DEFAULT,
        RFAL_ISODEP_T4T_FWT_ACTIVATION);
    return rfalStartTransceive(&ctx);
}

/*******************************************************************************/
static ReturnCode rfalIsoDepGetPPSSTatus(void) {
    ReturnCode ret;

    ret = rfalGetTransceiveStatus();
    if(ret == ERR_NONE) {
        gIsoDep.rxBufLen = rfalConvBitsToBytes(gIsoDep.rxBufLen);

        /* Check for valid PPS Response   */
        if((gIsoDep.rxBufLen != RFAL_ISODEP_PPS_RES_LEN) ||
           (*gIsoDep.rxBuf != gIsoDep.actv.ppsReq.PPSS)) {
            return ERR_PROTO;
        }
    }
    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepPPS(uint8_t DID, rfalBitRate DSI, rfalBitRate DRI, rfalIsoDepPpsRes* ppsRes) {
    ReturnCode ret;

    EXIT_ON_ERR(ret, rfalIsoDepStartPPS(DID, DSI, DRI, ppsRes));
    rfalIsoDepRunBlocking(ret, rfalIsoDepGetPPSSTatus());

    return ret;
}

#endif /* RFAL_FEATURE_NFCA */

#if RFAL_FEATURE_NFCB

static ReturnCode rfalIsoDepStartATTRIB(
    const uint8_t* nfcid0,
    uint8_t PARAM1,
    rfalBitRate DSI,
    rfalBitRate DRI,
    rfalIsoDepFSxI FSDI,
    uint8_t PARAM3,
    uint8_t DID,
    const uint8_t* HLInfo,
    uint8_t HLInfoLen,
    uint32_t fwt,
    rfalIsoDepAttribRes* attribRes,
    uint8_t* attribResLen) {
    rfalTransceiveContext ctx;

    if((attribRes == NULL) || (attribResLen == NULL) || (DSI > RFAL_BR_848) ||
       (DRI > RFAL_BR_848) || (DID > RFAL_ISODEP_DID_MAX)) {
        return ERR_NONE;
    }

    gIsoDep.rxBuf = (uint8_t*)attribRes;
    gIsoDep.rxLen8 = attribResLen;
    gIsoDep.did = DID;

    /*******************************************************************************/
    /* Compose ATTRIB command */
    gIsoDep.actv.attribReq.cmd = RFAL_ISODEP_CMD_ATTRIB;
    gIsoDep.actv.attribReq.Param.PARAM1 = PARAM1;
    gIsoDep.actv.attribReq.Param.PARAM2 =
        (((((uint8_t)DSI << RFAL_ISODEP_ATTRIB_PARAM2_DSI_SHIFT) |
           ((uint8_t)DRI << RFAL_ISODEP_ATTRIB_PARAM2_DRI_SHIFT)) &
          RFAL_ISODEP_ATTRIB_PARAM2_DXI_MASK) |
         ((uint8_t)FSDI & RFAL_ISODEP_ATTRIB_PARAM2_FSDI_MASK));
    gIsoDep.actv.attribReq.Param.PARAM3 = PARAM3;
    gIsoDep.actv.attribReq.Param.PARAM4 = (DID & RFAL_ISODEP_ATTRIB_PARAM4_DID_MASK);
    ST_MEMCPY(gIsoDep.actv.attribReq.nfcid0, nfcid0, RFAL_NFCB_NFCID0_LEN);

    /* Append the Higher layer Info if provided */
    if((HLInfo != NULL) && (HLInfoLen > 0U)) {
        ST_MEMCPY(
            gIsoDep.actv.attribReq.HLInfo, HLInfo, MIN(HLInfoLen, RFAL_ISODEP_ATTRIB_HLINFO_LEN));
    }

    rfalCreateByteFlagsTxRxContext(
        ctx,
        (uint8_t*)&gIsoDep.actv.attribReq,
        (uint16_t)(RFAL_ISODEP_ATTRIB_HDR_LEN + MIN((uint16_t)HLInfoLen, RFAL_ISODEP_ATTRIB_HLINFO_LEN)),
        (uint8_t*)gIsoDep.rxBuf,
        sizeof(rfalIsoDepAttribRes),
        &gIsoDep.rxBufLen,
        RFAL_TXRX_FLAGS_DEFAULT,
        fwt);
    return rfalStartTransceive(&ctx);
}

/*******************************************************************************/
static ReturnCode rfalIsoDepGetATTRIBStatus(void) {
    ReturnCode ret;

    ret = rfalGetTransceiveStatus();
    if(ret == ERR_NONE) {
        gIsoDep.rxBufLen = rfalConvBitsToBytes(gIsoDep.rxBufLen);

        /* Check a for valid ATTRIB Response   Digital 1.1  15.6.2.1 */
        if((gIsoDep.rxBufLen < RFAL_ISODEP_ATTRIB_RES_HDR_LEN) ||
           ((gIsoDep.rxBuf[RFAL_ISODEP_ATTRIB_RES_MBLIDID_POS] &
             RFAL_ISODEP_ATTRIB_RES_DID_MASK) != gIsoDep.did)) {
            return ERR_PROTO;
        }

        if(gIsoDep.rxLen8 != NULL) {
            *gIsoDep.rxLen8 = (uint8_t)gIsoDep.rxBufLen;
        }

        gIsoDep.ourFsx = rfalIsoDepFSxI2FSx(
            (uint8_t)(gIsoDep.actv.attribReq.Param.PARAM2 & RFAL_ISODEP_ATTRIB_PARAM2_FSDI_MASK));
    }

    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepATTRIB(
    const uint8_t* nfcid0,
    uint8_t PARAM1,
    rfalBitRate DSI,
    rfalBitRate DRI,
    rfalIsoDepFSxI FSDI,
    uint8_t PARAM3,
    uint8_t DID,
    const uint8_t* HLInfo,
    uint8_t HLInfoLen,
    uint32_t fwt,
    rfalIsoDepAttribRes* attribRes,
    uint8_t* attribResLen) {
    ReturnCode ret;

    EXIT_ON_ERR(
        ret,
        rfalIsoDepStartATTRIB(
            nfcid0,
            PARAM1,
            DSI,
            DRI,
            FSDI,
            PARAM3,
            DID,
            HLInfo,
            HLInfoLen,
            fwt,
            attribRes,
            attribResLen));
    rfalIsoDepRunBlocking(ret, rfalIsoDepGetATTRIBStatus());

    return ret;
}

#endif /* RFAL_FEATURE_NFCB */

#if RFAL_FEATURE_NFCA

/*******************************************************************************/
ReturnCode rfalIsoDepPollAHandleActivation(
    rfalIsoDepFSxI FSDI,
    uint8_t DID,
    rfalBitRate maxBR,
    rfalIsoDepDevice* isoDepDev) {
    ReturnCode ret;

    EXIT_ON_ERR(ret, rfalIsoDepPollAStartActivation(FSDI, DID, maxBR, isoDepDev));
    rfalIsoDepRunBlocking(ret, rfalIsoDepPollAGetActivationStatus());

    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepPollAStartActivation(
    rfalIsoDepFSxI FSDI,
    uint8_t DID,
    rfalBitRate maxBR,
    rfalIsoDepDevice* isoDepDev) {
    ReturnCode ret;

    if(isoDepDev == NULL) {
        return ERR_PARAM;
    }

    /* Enable EMD handling according   Digital 1.1  4.1.1.1 ; EMVCo 2.6  4.9.2 */
    rfalSetErrorHandling(RFAL_ERRORHANDLING_EMVCO);

    /* Start RATS Transceive */
    EXIT_ON_ERR(
        ret,
        rfalIsoDepStartRATS(
            FSDI,
            DID,
            &isoDepDev->activation.A.Listener.ATS,
            &isoDepDev->activation.A.Listener.ATSLen));

    isoDepDev->info.DSI = maxBR;
    gIsoDep.actvDev = isoDepDev;
    gIsoDep.cntRRetrys = gIsoDep.maxRetriesRATS;
    gIsoDep.state = ISODEP_ST_PCD_ACT_RATS;

    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepPollAGetActivationStatus(void) {
    ReturnCode ret;
    uint8_t msgIt;
    rfalBitRate maxBR;

    switch(gIsoDep.state) {
    /*******************************************************************************/
    case ISODEP_ST_PCD_ACT_RATS:

        ret = rfalIsoDepGetRATSStatus();
        if(ret != ERR_BUSY) {
            if(ret != ERR_NONE) {
                /* EMVCo 2.6  9.6.1.1 & 9.6.1.2  If a timeout error is detected retransmit, on transmission error abort */
                if((gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) && (ret != ERR_TIMEOUT)) {
                    break;
                }

                if(gIsoDep.cntRRetrys != 0U) {
                    /* Ensure FDT before retransmission (reuse RFAL GT timer) */
                    rfalSetGT(rfalGetFDTPoll());
                    rfalFieldOnAndStartGT();

                    /* Send RATS retransmission */ /* PRQA S 4342 1 # MISRA 10.5 - Layout of enum rfalIsoDepFSxI is guaranteed whithin 4bit range */
                    EXIT_ON_ERR(
                        ret,
                        rfalIsoDepStartRATS(
                            (rfalIsoDepFSxI)(uint8_t)(gIsoDep.actv.ratsReq.PARAM >> RFAL_ISODEP_RATS_PARAM_FSDI_SHIFT),
                            gIsoDep.did,
                            &gIsoDep.actvDev->activation.A.Listener.ATS,
                            &gIsoDep.actvDev->activation.A.Listener.ATSLen));
                    gIsoDep.cntRRetrys--;
                    ret = ERR_BUSY;
                }
                /* Switch between NFC Forum and ISO14443-4 behaviour #595
                     *   ISO14443-4  5.6.1  If RATS fails, a Deactivation sequence should be performed as defined on clause 8  
                     *   Activity 1.1  9.6  Device Deactivation Activity is to be only performed when there's an active device */
                else if(gIsoDep.compMode == RFAL_COMPLIANCE_MODE_ISO) {
                    rfalIsoDepDeselect();
                } else {
                    /* MISRA 15.7 - Empty else */
                }
            } else /* ATS received */
            {
                maxBR = gIsoDep.actvDev->info.DSI; /* Retrieve requested max bitrate */

                /*******************************************************************************/
                /* Process ATS Response                                                        */
                gIsoDep.actvDev->info.FWI =
                    RFAL_ISODEP_FWI_DEFAULT; /* Default value   EMVCo 2.6  5.7.2.6  */
                gIsoDep.actvDev->info.SFGI = 0U;
                gIsoDep.actvDev->info.MBL = 0U;
                gIsoDep.actvDev->info.DSI = RFAL_BR_106;
                gIsoDep.actvDev->info.DRI = RFAL_BR_106;
                gIsoDep.actvDev->info.FSxI = (uint8_t)
                    RFAL_ISODEP_FSXI_32; /* FSC default value is 32 bytes  ISO14443-A  5.2.3 */

                /*******************************************************************************/
                /* Check for ATS optional fields                                               */
                if(gIsoDep.actvDev->activation.A.Listener.ATS.TL > RFAL_ISODEP_ATS_MIN_LEN) {
                    msgIt = RFAL_ISODEP_ATS_MIN_LEN;

                    /* Format byte T0 is optional, if present assign FSDI */
                    gIsoDep.actvDev->info.FSxI =
                        (gIsoDep.actvDev->activation.A.Listener.ATS.T0 &
                         RFAL_ISODEP_ATS_T0_FSCI_MASK);

                    /* T0 has already been processed, always the same position */
                    msgIt++;

                    /* Check if TA is present */
                    if((gIsoDep.actvDev->activation.A.Listener.ATS.T0 &
                        RFAL_ISODEP_ATS_T0_TA_PRESENCE_MASK) != 0U) {
                        rfalIsoDepCalcBitRate(
                            maxBR,
                            ((uint8_t*)&gIsoDep.actvDev->activation.A.Listener.ATS)[msgIt++],
                            &gIsoDep.actvDev->info.DSI,
                            &gIsoDep.actvDev->info.DRI);
                    }

                    /* Check if TB is present */
                    if((gIsoDep.actvDev->activation.A.Listener.ATS.T0 &
                        RFAL_ISODEP_ATS_T0_TB_PRESENCE_MASK) != 0U) {
                        gIsoDep.actvDev->info.SFGI =
                            ((uint8_t*)&gIsoDep.actvDev->activation.A.Listener.ATS)[msgIt++];
                        gIsoDep.actvDev->info.FWI =
                            (uint8_t)((gIsoDep.actvDev->info.SFGI >> RFAL_ISODEP_ATS_TB_FWI_SHIFT) & RFAL_ISODEP_ATS_FWI_MASK);
                        gIsoDep.actvDev->info.SFGI &= RFAL_ISODEP_ATS_TB_SFGI_MASK;
                    }

                    /* Check if TC is present */
                    if((gIsoDep.actvDev->activation.A.Listener.ATS.T0 &
                        RFAL_ISODEP_ATS_T0_TC_PRESENCE_MASK) != 0U) {
                        /* Check for Protocol features support */
                        /* Advanced protocol features defined on Digital 1.0 Table 69, removed after */
                        gIsoDep.actvDev->info.supAdFt =
                            (((((uint8_t*)&gIsoDep.actvDev->activation.A.Listener.ATS)[msgIt] &
                               RFAL_ISODEP_ATS_TC_ADV_FEAT) != 0U) ?
                                 true :
                                 false);
                        gIsoDep.actvDev->info.supDID =
                            (((((uint8_t*)&gIsoDep.actvDev->activation.A.Listener.ATS)[msgIt] &
                               RFAL_ISODEP_ATS_TC_DID) != 0U) ?
                                 true :
                                 false);
                        gIsoDep.actvDev->info.supNAD =
                            (((((uint8_t*)&gIsoDep.actvDev->activation.A.Listener.ATS)[msgIt++] &
                               RFAL_ISODEP_ATS_TC_NAD) != 0U) ?
                                 true :
                                 false);
                    }
                }

                gIsoDep.actvDev->info.FSx = rfalIsoDepFSxI2FSx(gIsoDep.actvDev->info.FSxI);
                gIsoDep.fsx = gIsoDep.actvDev->info.FSx;

                gIsoDep.actvDev->info.SFGT =
                    rfalIsoDepSFGI2SFGT((uint8_t)gIsoDep.actvDev->info.SFGI);

                /* Ensure SFGT before following frame (reuse RFAL GT timer) */
                rfalSetGT(rfalConvMsTo1fc(gIsoDep.actvDev->info.SFGT));
                rfalFieldOnAndStartGT();

                gIsoDep.actvDev->info.FWT = rfalIsoDepFWI2FWT(gIsoDep.actvDev->info.FWI);
                gIsoDep.actvDev->info.dFWT = RFAL_ISODEP_DFWT_20;

                gIsoDep.actvDev->info.DID =
                    ((gIsoDep.actvDev->info.supDID) ? gIsoDep.did : RFAL_ISODEP_NO_DID);
                gIsoDep.actvDev->info.NAD = RFAL_ISODEP_NO_NAD;

                /*******************************************************************************/
                /* If higher bit rates are supported by both devices, send PPS                 */
                if((gIsoDep.actvDev->info.DSI != RFAL_BR_106) ||
                   (gIsoDep.actvDev->info.DRI != RFAL_BR_106)) {
                    /* Send PPS */ /*  PRQA S 0310 1 # MISRA 11.3 - Intentional safe cast to avoiding buffer duplication */
                    EXIT_ON_ERR(
                        ret,
                        rfalIsoDepStartPPS(
                            gIsoDep.actvDev->info.DID,
                            gIsoDep.actvDev->info.DSI,
                            gIsoDep.actvDev->info.DRI,
                            (rfalIsoDepPpsRes*)&gIsoDep.ctrlBuf));

                    gIsoDep.state = ISODEP_ST_PCD_ACT_PPS;
                    return ERR_BUSY;
                }

                return ERR_NONE;
            }
        }
        break;

    /*******************************************************************************/
    case ISODEP_ST_PCD_ACT_PPS:
        ret = rfalIsoDepGetPPSSTatus();
        if(ret != ERR_BUSY) {
            /* Check whether PPS has been acknowledge */
            if(ret == ERR_NONE) {
                /* DSI code the divisor from PICC to PCD */
                /* DRI code the divisor from PCD to PICC */
                rfalSetBitRate(gIsoDep.actvDev->info.DRI, gIsoDep.actvDev->info.DSI);
            } else {
                /* If PPS has faled keep activation bit rate */
                gIsoDep.actvDev->info.DSI = RFAL_BR_106;
                gIsoDep.actvDev->info.DRI = RFAL_BR_106;
            }
        }
        break;

    /*******************************************************************************/
    default:
        ret = ERR_WRONG_STATE;
        break;
    }

    return ret;
}
#endif /* RFAL_FEATURE_NFCA */

#if RFAL_FEATURE_NFCB

/*******************************************************************************/
ReturnCode rfalIsoDepPollBHandleActivation(
    rfalIsoDepFSxI FSDI,
    uint8_t DID,
    rfalBitRate maxBR,
    uint8_t PARAM1,
    const rfalNfcbListenDevice* nfcbDev,
    const uint8_t* HLInfo,
    uint8_t HLInfoLen,
    rfalIsoDepDevice* isoDepDev) {
    ReturnCode ret;

    EXIT_ON_ERR(
        ret,
        rfalIsoDepPollBStartActivation(
            FSDI, DID, maxBR, PARAM1, nfcbDev, HLInfo, HLInfoLen, isoDepDev));
    rfalIsoDepRunBlocking(ret, rfalIsoDepPollBGetActivationStatus());

    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepPollBStartActivation(
    rfalIsoDepFSxI FSDI,
    uint8_t DID,
    rfalBitRate maxBR,
    uint8_t PARAM1,
    const rfalNfcbListenDevice* nfcbDev,
    const uint8_t* HLInfo,
    uint8_t HLInfoLen,
    rfalIsoDepDevice* isoDepDev) {
    ReturnCode ret;

    /***************************************************************************/
    /* Initialize ISO-DEP Device with info from SENSB_RES                      */
    isoDepDev->info.FWI =
        ((nfcbDev->sensbRes.protInfo.FwiAdcFo >> RFAL_NFCB_SENSB_RES_FWI_SHIFT) &
         RFAL_NFCB_SENSB_RES_FWI_MASK);
    isoDepDev->info.FWT = rfalIsoDepFWI2FWT(isoDepDev->info.FWI);
    isoDepDev->info.dFWT = RFAL_NFCB_DFWT;
    isoDepDev->info.SFGI =
        (((uint32_t)nfcbDev->sensbRes.protInfo.SFGI >> RFAL_NFCB_SENSB_RES_SFGI_SHIFT) &
         RFAL_NFCB_SENSB_RES_SFGI_MASK);
    isoDepDev->info.SFGT = rfalIsoDepSFGI2SFGT((uint8_t)isoDepDev->info.SFGI);
    isoDepDev->info.FSxI =
        ((nfcbDev->sensbRes.protInfo.FsciProType >> RFAL_NFCB_SENSB_RES_FSCI_SHIFT) &
         RFAL_NFCB_SENSB_RES_FSCI_MASK);
    isoDepDev->info.FSx = rfalIsoDepFSxI2FSx(isoDepDev->info.FSxI);
    isoDepDev->info.DID = DID;
    isoDepDev->info.supDID =
        (((nfcbDev->sensbRes.protInfo.FwiAdcFo & RFAL_NFCB_SENSB_RES_FO_DID_MASK) != 0U) ? true :
                                                                                           false);
    isoDepDev->info.supNAD =
        (((nfcbDev->sensbRes.protInfo.FwiAdcFo & RFAL_NFCB_SENSB_RES_FO_NAD_MASK) != 0U) ? true :
                                                                                           false);

    /* Check if DID requested is supported by PICC */
    if((DID != RFAL_ISODEP_NO_DID) && (!isoDepDev->info.supDID)) {
        return ERR_PARAM;
    }

    /* Enable EMD handling according   Digital 2.1  4.1.1.1 ; EMVCo 3.0  4.9.2 */
    rfalSetErrorHandling(RFAL_ERRORHANDLING_EMVCO);

    /***************************************************************************/
    /* Set FDT Poll to be used on upcoming communications                      */
    if(gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) {
        /* Disregard Minimum TR2 returned by PICC, always use FDTb MIN   EMVCo 3.0  6.3.2.10  */
        rfalSetFDTPoll(RFAL_FDT_POLL_NFCB_POLLER);
    } else {
        /* Apply minimum TR2 from SENSB_RES   Digital 2.1  7.6.2.23 */
        rfalSetFDTPoll(rfalNfcbTR2ToFDT(
            ((nfcbDev->sensbRes.protInfo.FsciProType >> RFAL_NFCB_SENSB_RES_PROTO_TR2_SHIFT) &
             RFAL_NFCB_SENSB_RES_PROTO_TR2_MASK)));
    }

    /* Calculate max Bit Rate */
    rfalIsoDepCalcBitRate(
        maxBR, nfcbDev->sensbRes.protInfo.BRC, &isoDepDev->info.DSI, &isoDepDev->info.DRI);

    /***************************************************************************/
    /* Send ATTRIB Command                                                     */
    EXIT_ON_ERR(
        ret,
        rfalIsoDepStartATTRIB(
            (const uint8_t*)&nfcbDev->sensbRes.nfcid0,
            (((nfcbDev->sensbRes.protInfo.FwiAdcFo & RFAL_NFCB_SENSB_RES_ADC_ADV_FEATURE_MASK) !=
              0U) ?
                 PARAM1 :
                 RFAL_ISODEP_ATTRIB_REQ_PARAM1_DEFAULT),
            isoDepDev->info.DSI,
            isoDepDev->info.DRI,
            FSDI,
            (gIsoDep.compMode == RFAL_COMPLIANCE_MODE_EMV) ?
                RFAL_NFCB_SENSB_RES_PROTO_ISO_MASK :
                (nfcbDev->sensbRes.protInfo.FsciProType &
                 ((RFAL_NFCB_SENSB_RES_PROTO_TR2_MASK << RFAL_NFCB_SENSB_RES_PROTO_TR2_SHIFT) |
                  RFAL_NFCB_SENSB_RES_PROTO_ISO_MASK)), /* EMVCo 2.6 6.4.1.9 */
            DID,
            HLInfo,
            HLInfoLen,
            (isoDepDev->info.FWT + isoDepDev->info.dFWT),
            &isoDepDev->activation.B.Listener.ATTRIB_RES,
            &isoDepDev->activation.B.Listener.ATTRIB_RESLen));

    gIsoDep.actvDev = isoDepDev;
    return ret;
}

/*******************************************************************************/
ReturnCode rfalIsoDepPollBGetActivationStatus(void) {
    ReturnCode ret;
    uint8_t mbli;

    /***************************************************************************/
    /* Process ATTRIB Response                                                 */
    ret = rfalIsoDepGetATTRIBStatus();
    if(ret != ERR_BUSY) {
        if(ret == ERR_NONE) {
            /* Digital 1.1 14.6.2.3 - Check if received DID match */
            if((gIsoDep.actvDev->activation.B.Listener.ATTRIB_RES.mbliDid &
                RFAL_ISODEP_ATTRIB_RES_DID_MASK) != gIsoDep.did) {
                return ERR_PROTO;
            }

            /* Retrieve MBLI and calculate new FDS/MBL (Maximum Buffer Length) */
            mbli =
                ((gIsoDep.actvDev->activation.B.Listener.ATTRIB_RES.mbliDid >>
                  RFAL_ISODEP_ATTRIB_RES_MBLI_SHIFT) &
                 RFAL_ISODEP_ATTRIB_RES_MBLI_MASK);
            if(mbli > 0U) {
                /* Digital 1.1  14.6.2  Calculate Maximum Buffer Length MBL = FSC x 2^(MBLI-1) */
                gIsoDep.actvDev->info.MBL =
                    (gIsoDep.actvDev->info.FSx * ((uint32_t)1U << (mbli - 1U)));
            }

            /* DSI code the divisor from PICC to PCD */
            /* DRI code the divisor from PCD to PICC */
            rfalSetBitRate(gIsoDep.actvDev->info.DRI, gIsoDep.actvDev->info.DSI);

            /* REMARK: SoF EoF TR0 and TR1 are not passed on to RF layer */

            /* Start the SFGT timer (reuse RFAL GT timer) */
            rfalSetGT(rfalConvMsTo1fc(gIsoDep.actvDev->info.SFGT));
            rfalFieldOnAndStartGT();
        } else {
            gIsoDep.actvDev->info.DSI = RFAL_BR_106;
            gIsoDep.actvDev->info.DRI = RFAL_BR_106;
        }

        /*******************************************************************************/
        /* Store already FS info,  rfalIsoDepGetMaxInfLen() may be called before setting TxRx params */
        gIsoDep.fsx = gIsoDep.actvDev->info.FSx;
    }

    return ret;
}

#endif /* RFAL_FEATURE_NFCB */

/*******************************************************************************/
ReturnCode rfalIsoDepPollHandleSParameters(
    rfalIsoDepDevice* isoDepDev,
    rfalBitRate maxTxBR,
    rfalBitRate maxRxBR) {
    uint8_t it;
    uint8_t supPCD2PICC;
    uint8_t supPICC2PCD;
    uint8_t currenttxBR;
    uint8_t currentrxBR;
    rfalBitRate txBR;
    rfalBitRate rxBR;
    uint16_t rcvLen;
    ReturnCode ret;
    rfalIsoDepControlMsgSParam sParam;

    if((isoDepDev == NULL) || (maxTxBR > RFAL_BR_13560) || (maxRxBR > RFAL_BR_13560)) {
        return ERR_PARAM;
    }

    it = 0;
    supPICC2PCD = 0x00;
    supPCD2PICC = 0x00;
    txBR = RFAL_BR_106;
    rxBR = RFAL_BR_106;
    sParam.pcb = ISODEP_PCB_SPARAMETERS;

    /*******************************************************************************/
    /* Send S(PARAMETERS) - Block Info */
    sParam.sParam.tag = RFAL_ISODEP_SPARAM_TAG_BLOCKINFO;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_BRREQ;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_BRREQ_LEN;
    sParam.sParam.length = it;

    /* Send S(PARAMETERS). Use a fixed FWI of 4   ISO14443-4 2016  7.2 */
    EXIT_ON_ERR(
        ret,
        rfalTransceiveBlockingTxRx(
            (uint8_t*)&sParam,
            (RFAL_ISODEP_SPARAM_HDR_LEN + (uint16_t)it),
            (uint8_t*)&sParam,
            sizeof(rfalIsoDepControlMsgSParam),
            &rcvLen,
            RFAL_TXRX_FLAGS_DEFAULT,
            ISODEP_FWT_DEACTIVATION));

    it = 0;

    /*******************************************************************************/
    /* Check S(PARAMETERS) response */
    if((sParam.pcb != ISODEP_PCB_SPARAMETERS) ||
       (sParam.sParam.tag != RFAL_ISODEP_SPARAM_TAG_BLOCKINFO) ||
       (sParam.sParam.value[it] != RFAL_ISODEP_SPARAM_TAG_BRIND) ||
       (rcvLen < RFAL_ISODEP_SPARAM_HDR_LEN) ||
       (rcvLen != ((uint16_t)sParam.sParam.length + RFAL_ISODEP_SPARAM_HDR_LEN))) {
        return ERR_PROTO;
    }

    /* Retrieve PICC's bit rate PICC capabilities */
    for(it = 0; it < (rcvLen - (uint16_t)RFAL_ISODEP_SPARAM_TAG_LEN); it++) {
        if((sParam.sParam.value[it] == RFAL_ISODEP_SPARAM_TAG_SUP_PCD2PICC) &&
           (sParam.sParam.value[it + (uint16_t)RFAL_ISODEP_SPARAM_TAG_LEN] ==
            RFAL_ISODEP_SPARAM_TAG_PCD2PICC_LEN)) {
            supPCD2PICC = sParam.sParam.value[it + RFAL_ISODEP_SPARAM_TAG_PCD2PICC_LEN];
        }

        if((sParam.sParam.value[it] == RFAL_ISODEP_SPARAM_TAG_SUP_PICC2PCD) &&
           (sParam.sParam.value[it + (uint16_t)RFAL_ISODEP_SPARAM_TAG_LEN] ==
            RFAL_ISODEP_SPARAM_TAG_PICC2PCD_LEN)) {
            supPICC2PCD = sParam.sParam.value[it + RFAL_ISODEP_SPARAM_TAG_PICC2PCD_LEN];
        }
    }

    /*******************************************************************************/
    /* Check if requested bit rates are supported by PICC */
    if((supPICC2PCD == 0x00U) || (supPCD2PICC == 0x00U)) {
        return ERR_PROTO;
    }

    for(it = 0; it <= (uint8_t)maxTxBR; it++) {
        if((supPCD2PICC & (0x01U << it)) != 0U) {
            txBR = (rfalBitRate)
                it; /* PRQA S 4342 # MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created */
        }
    }
    for(it = 0; it <= (uint8_t)maxRxBR; it++) {
        if((supPICC2PCD & (0x01U << it)) != 0U) {
            rxBR = (rfalBitRate)
                it; /* PRQA S 4342 # MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created */
        }
    }

    it = 0;
    currenttxBR = (uint8_t)txBR;
    currentrxBR = (uint8_t)rxBR;

    /*******************************************************************************/
    /* Send S(PARAMETERS) - Bit rates Activation */
    sParam.sParam.tag = RFAL_ISODEP_SPARAM_TAG_BLOCKINFO;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_BRACT;
    sParam.sParam.value[it++] =
        (RFAL_ISODEP_SPARAM_TVL_HDR_LEN + RFAL_ISODEP_SPARAM_TAG_PCD2PICC_LEN +
         RFAL_ISODEP_SPARAM_TVL_HDR_LEN + RFAL_ISODEP_SPARAM_TAG_PICC2PCD_LEN);
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_SEL_PCD2PICC;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_PCD2PICC_LEN;
    sParam.sParam.value[it++] = ((uint8_t)0x01U << currenttxBR);
    sParam.sParam.value[it++] = 0x00U;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_SEL_PICC2PCD;
    sParam.sParam.value[it++] = RFAL_ISODEP_SPARAM_TAG_PICC2PCD_LEN;
    sParam.sParam.value[it++] = ((uint8_t)0x01U << currentrxBR);
    sParam.sParam.value[it++] = 0x00U;
    sParam.sParam.length = it;

    EXIT_ON_ERR(
        ret,
        rfalTransceiveBlockingTxRx(
            (uint8_t*)&sParam,
            (RFAL_ISODEP_SPARAM_HDR_LEN + (uint16_t)it),
            (uint8_t*)&sParam,
            sizeof(rfalIsoDepControlMsgSParam),
            &rcvLen,
            RFAL_TXRX_FLAGS_DEFAULT,
            (isoDepDev->info.FWT + isoDepDev->info.dFWT)));

    it = 0;

    /*******************************************************************************/
    /* Check S(PARAMETERS) Acknowledge  */
    if((sParam.pcb != ISODEP_PCB_SPARAMETERS) ||
       (sParam.sParam.tag != RFAL_ISODEP_SPARAM_TAG_BLOCKINFO) ||
       (sParam.sParam.value[it] != RFAL_ISODEP_SPARAM_TAG_BRACK) ||
       (rcvLen < RFAL_ISODEP_SPARAM_HDR_LEN)) {
        return ERR_PROTO;
    }

    EXIT_ON_ERR(ret, rfalSetBitRate(txBR, rxBR));

    isoDepDev->info.DRI = txBR;
    isoDepDev->info.DSI = rxBR;

    return ERR_NONE;
}

/*******************************************************************************/
static void rfalIsoDepCalcBitRate(
    rfalBitRate maxAllowedBR,
    uint8_t piccBRCapability,
    rfalBitRate* dsi,
    rfalBitRate* dri) {
    uint8_t driMask;
    uint8_t dsiMask;
    int8_t i;
    bool bitrateFound;
    rfalBitRate curMaxBR;

    curMaxBR = maxAllowedBR;

    do {
        bitrateFound = true;

        (*dsi) = RFAL_BR_106;
        (*dri) = RFAL_BR_106;

        /* Digital 1.0  5.6.2.5 & 11.6.2.14: A received RFU value of b4 = 1b MUST be interpreted as if b7 to b1 ? 0000000b (only 106 kbits/s in both direction) */
        if(((RFAL_ISODEP_BITRATE_RFU_MASK & piccBRCapability) != 0U) || (curMaxBR > RFAL_BR_848) ||
           (curMaxBR == RFAL_BR_KEEP)) {
            return;
        }

        /***************************************************************************/
        /* Determine Listen->Poll bit rate */
        dsiMask = (piccBRCapability & RFAL_ISODEP_BSI_MASK);
        for(i = 2; i >= 0; i--) // Check supported bit rate from the highest
        {
            if(((dsiMask & (0x10U << (uint8_t)i)) != 0U) &&
               (((uint8_t)i + 1U) <= (uint8_t)curMaxBR)) {
                uint8_t newdsi = ((uint8_t)i) + 1U;
                (*dsi) = (rfalBitRate)
                    newdsi; /* PRQA S 4342 # MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created */
                break;
            }
        }

        /***************************************************************************/
        /* Determine Poll->Listen bit rate */
        driMask = (piccBRCapability & RFAL_ISODEP_BRI_MASK);
        for(i = 2; i >= 0; i--) /* Check supported bit rate from the highest */
        {
            if(((driMask & (0x01U << (uint8_t)i)) != 0U) &&
               (((uint8_t)i + 1U) <= (uint8_t)curMaxBR)) {
                uint8_t newdri = ((uint8_t)i) + 1U;
                (*dri) = (rfalBitRate)
                    newdri; /* PRQA S 4342 # MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created */
                break;
            }
        }

        /***************************************************************************/
        /* Check if different bit rate is supported */

        /* Digital 1.0 Table 67: if b8=1b, then only the same bit rate divisor for both directions is supported */
        if((piccBRCapability & RFAL_ISODEP_SAME_BITRATE_MASK) != 0U) {
            (*dsi) = MIN((*dsi), (*dri));
            (*dri) = (*dsi);
            /* Check that the baudrate is supported */
            if((RFAL_BR_106 != (*dsi)) &&
               (!(((dsiMask & (0x10U << ((uint8_t)(*dsi) - 1U))) != 0U) &&
                  ((driMask & (0x01U << ((uint8_t)(*dri) - 1U))) != 0U)))) {
                bitrateFound = false;
                curMaxBR =
                    (*dsi); /* set allowed bitrate to be lowest and determine bit rate again */
            }
        }
    } while(!(bitrateFound));
}

/*******************************************************************************/
static uint32_t rfalIsoDepSFGI2SFGT(uint8_t sfgi) {
    uint32_t sfgt;
    uint8_t tmpSFGI;

    tmpSFGI = sfgi;

    if(tmpSFGI > ISODEP_SFGI_MAX) {
        tmpSFGI = ISODEP_SFGI_MIN;
    }

    if(tmpSFGI != ISODEP_SFGI_MIN) {
        /* If sfgi != 0 wait SFGT + dSFGT   Digital 1.1  13.8.2.1 */
        sfgt = isoDepCalcSGFT(sfgi) + isoDepCalcdSGFT(sfgi);
    }
    /* Otherwise use FDTPoll min Digital  1.1  13.8.2.3*/
    else {
        sfgt = RFAL_FDT_POLL_NFCA_POLLER;
    }

    /* Convert carrier cycles to milli seconds */
    return (rfalConv1fcToMs(sfgt) + 1U);
}

#endif /* RFAL_FEATURE_ISO_DEP_POLL */

/*******************************************************************************/
static void rfalIsoDepApdu2IBLockParam(
    rfalIsoDepApduTxRxParam apduParam,
    rfalIsoDepTxRxParam* iBlockParam,
    uint16_t txPos,
    uint16_t rxPos) {
    NO_WARNING(rxPos); /* Keep this param for future use */

    iBlockParam->DID = apduParam.DID;
    iBlockParam->FSx = apduParam.FSx;
    iBlockParam->ourFSx = apduParam.ourFSx;
    iBlockParam->FWT = apduParam.FWT;
    iBlockParam->dFWT = apduParam.dFWT;

    if((apduParam.txBufLen - txPos) > rfalIsoDepGetMaxInfLen()) {
        iBlockParam->isTxChaining = true;
        iBlockParam->txBufLen = rfalIsoDepGetMaxInfLen();
    } else {
        iBlockParam->isTxChaining = false;
        iBlockParam->txBufLen = (apduParam.txBufLen - txPos);
    }

    /* TxBuf is moved to the beginning for every I-Block */
    iBlockParam->txBuf =
        (rfalIsoDepBufFormat*)apduParam
            .txBuf; /*  PRQA S 0310 # MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication */
    iBlockParam->rxBuf =
        apduParam
            .tmpBuf; /* Simply using the apdu buffer is not possible because of current ACK handling */
    iBlockParam->isRxChaining = &gIsoDep.isAPDURxChaining;
    iBlockParam->rxLen = apduParam.rxLen;
}

/*******************************************************************************/
ReturnCode rfalIsoDepStartApduTransceive(rfalIsoDepApduTxRxParam param) {
    rfalIsoDepTxRxParam txRxParam;

    /* Initialize and store APDU context */
    gIsoDep.APDUParam = param;
    gIsoDep.APDUTxPos = 0;
    gIsoDep.APDURxPos = 0;

    /* Assign current FSx to calculate INF length (only change the FSx from activation if no to Keep) */
    gIsoDep.ourFsx = ((param.ourFSx != RFAL_ISODEP_FSX_KEEP) ? param.ourFSx : gIsoDep.ourFsx);
    gIsoDep.fsx = param.FSx;

    /* Convert APDU TxRxParams to I-Block TxRxParams */
    rfalIsoDepApdu2IBLockParam(
        gIsoDep.APDUParam, &txRxParam, gIsoDep.APDUTxPos, gIsoDep.APDURxPos);

    return rfalIsoDepStartTransceive(txRxParam);
}

/*******************************************************************************/
ReturnCode rfalIsoDepGetApduTransceiveStatus(void) {
    ReturnCode ret;
    rfalIsoDepTxRxParam txRxParam;

    ret = rfalIsoDepGetTransceiveStatus();
    switch(ret) {
    /*******************************************************************************/
    case ERR_NONE:

        /* Check if we are still doing chaining on Tx */
        if(gIsoDep.isTxChaining) {
            /* Add already Tx bytes */
            gIsoDep.APDUTxPos += gIsoDep.txBufLen;

            /* Convert APDU TxRxParams to I-Block TxRxParams */
            rfalIsoDepApdu2IBLockParam(
                gIsoDep.APDUParam, &txRxParam, gIsoDep.APDUTxPos, gIsoDep.APDURxPos);

            if(txRxParam.txBufLen > 0U) /* MISRA 21.18 */
            {
                /* Move next I-Block to beginning of APDU Tx buffer */
                ST_MEMCPY(
                    gIsoDep.APDUParam.txBuf->apdu,
                    &gIsoDep.APDUParam.txBuf->apdu[gIsoDep.APDUTxPos],
                    txRxParam.txBufLen);
            }

            EXIT_ON_ERR(ret, rfalIsoDepStartTransceive(txRxParam));
            return ERR_BUSY;
        }

        /* APDU TxRx is done */
        /* fall through */

    /*******************************************************************************/
    case ERR_AGAIN: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */

        /* Check if no APDU transceive has been started before (data from rfalIsoDepListenStartActivation) */
        if(gIsoDep.APDUParam.rxLen == NULL) {
            if(ret == ERR_AGAIN) {
                /* In Listen mode first chained packet cannot be retrieved via APDU interface */
                return ERR_NOTSUPP;
            }

            /* TxRx is complete and full data is already available */
            return ERR_NONE;
        }

        if(*gIsoDep.APDUParam.rxLen > 0U) /* MISRA 21.18 */
        {
            /* Ensure that data in tmpBuf still fits into APDU buffer */
            if((gIsoDep.APDURxPos + (*gIsoDep.APDUParam.rxLen)) >
               (uint16_t)RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN) {
                return ERR_NOMEM;
            }

            /* Copy chained packet from tmp buffer to APDU buffer */
            ST_MEMCPY(
                &gIsoDep.APDUParam.rxBuf->apdu[gIsoDep.APDURxPos],
                gIsoDep.APDUParam.tmpBuf->inf,
                *gIsoDep.APDUParam.rxLen);
            gIsoDep.APDURxPos += *gIsoDep.APDUParam.rxLen;
        }

        /* Update output param rxLen */
        *gIsoDep.APDUParam.rxLen = gIsoDep.APDURxPos;

        /* Wait for following I-Block or APDU TxRx has finished */
        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_ISO_DEP */