/******************************************************************************
  * \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:   ST25R391x firmware
 *      Revision:
 *      LANGUAGE:  ISO C99
 */

/*! \file rfal_nfca.c
 *
 *  \author Gustavo Patricio
 *
 *  \brief Provides several NFC-A convenience methods and definitions
 *  
 *  It provides a Poller (ISO14443A PCD) interface and as well as 
 *  some NFC-A Listener (ISO14443A PICC) helpers.
 *
 *  The definitions and helpers methods provided by this module are only
 *  up to ISO14443-3 layer
 *  
 */

/*
 ******************************************************************************
 * INCLUDES
 ******************************************************************************
 */
#include "rfal_nfca.h"
#include "utils.h"

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

#ifndef RFAL_FEATURE_NFCA
    #define RFAL_FEATURE_NFCA   false    /* NFC-A module configuration missing. Disabled by default */
#endif

#if RFAL_FEATURE_NFCA

/*
 ******************************************************************************
 * GLOBAL DEFINES
 ******************************************************************************
 */

#define RFAL_NFCA_SLP_FWT           rfalConvMsTo1fc(1)    /*!< Check 1ms for any modulation  ISO14443-3 6.4.3   */
#define RFAL_NFCA_SLP_CMD           0x50U                 /*!< SLP cmd (byte1)    Digital 1.1  6.9.1 & Table 20 */
#define RFAL_NFCA_SLP_BYTE2         0x00U                 /*!< SLP byte2          Digital 1.1  6.9.1 & Table 20 */
#define RFAL_NFCA_SLP_CMD_POS       0U                    /*!< SLP cmd position   Digital 1.1  6.9.1 & Table 20 */
#define RFAL_NFCA_SLP_BYTE2_POS     1U                    /*!< SLP byte2 position Digital 1.1  6.9.1 & Table 20 */

#define RFAL_NFCA_SDD_CT            0x88U                 /*!< Cascade Tag value Digital 1.1 6.7.2              */
#define RFAL_NFCA_SDD_CT_LEN        1U                    /*!< Cascade Tag length                               */

#define RFAL_NFCA_SLP_REQ_LEN       2U                    /*!< SLP_REQ length                                   */

#define RFAL_NFCA_SEL_CMD_LEN       1U                    /*!< SEL_CMD length                                   */
#define RFAL_NFCA_SEL_PAR_LEN       1U                    /*!< SEL_PAR length                                   */
#define RFAL_NFCA_SEL_SELPAR        rfalNfcaSelPar(7U, 0U)/*!< SEL_PAR on Select is always with 4 data/nfcid    */
#define RFAL_NFCA_BCC_LEN           1U                    /*!< BCC length                                       */

#define RFAL_NFCA_SDD_REQ_LEN       (RFAL_NFCA_SEL_CMD_LEN + RFAL_NFCA_SEL_PAR_LEN)   /*!< SDD_REQ length       */
#define RFAL_NFCA_SDD_RES_LEN       (RFAL_NFCA_CASCADE_1_UID_LEN + RFAL_NFCA_BCC_LEN) /*!< SDD_RES length       */

#define RFAL_NFCA_T_RETRANS         5U                    /*!< t RETRANSMISSION [3, 33]ms   EMVCo 2.6  A.5      */
#define RFAL_NFCA_N_RETRANS         2U                    /*!< Number of retries            EMVCo 2.6  9.6.1.3  */
 

/*! SDD_REQ (Select) Cascade Levels  */
enum
{
    RFAL_NFCA_SEL_CASCADE_L1 = 0,  /*!< SDD_REQ Cascade Level 1 */
    RFAL_NFCA_SEL_CASCADE_L2 = 1,  /*!< SDD_REQ Cascade Level 2 */
    RFAL_NFCA_SEL_CASCADE_L3 = 2   /*!< SDD_REQ Cascade Level 3 */
};

/*! SDD_REQ (Select) request Cascade Level command   Digital 1.1 Table 15 */
enum
{
    RFAL_NFCA_CMD_SEL_CL1 = 0x93, /*!< SDD_REQ command Cascade Level 1 */
    RFAL_NFCA_CMD_SEL_CL2 = 0x95, /*!< SDD_REQ command Cascade Level 2 */
    RFAL_NFCA_CMD_SEL_CL3 = 0x97, /*!< SDD_REQ command Cascade Level 3 */
};

/*
******************************************************************************
* GLOBAL MACROS
******************************************************************************
*/
#define rfalNfcaSelPar( nBy, nbi )         (uint8_t)((((nBy)<<4U) & 0xF0U) | ((nbi)&0x0FU) )         /*!< Calculates SEL_PAR with the bytes/bits to be sent */
#define rfalNfcaCLn2SELCMD( cl )           (uint8_t)((uint8_t)(RFAL_NFCA_CMD_SEL_CL1) + (2U*(cl)))   /*!< Calculates SEL_CMD with the given cascade level   */
#define rfalNfcaNfcidLen2CL( len )         ((len) / 5U)                                              /*!< Calculates cascade level by the NFCID length      */
#define rfalNfcaRunBlocking( e, fn )       do{ (e)=(fn); rfalWorker(); }while( (e) == ERR_BUSY )     /*!< Macro used for the blocking methods               */

/*
******************************************************************************
* GLOBAL TYPES
******************************************************************************
*/

/*! Colission Resolution states */
typedef enum{
    RFAL_NFCA_CR_IDLE,                     /*!< IDLE state                      */
    RFAL_NFCA_CR_CL,                       /*!< New Cascading Level state       */
    RFAL_NFCA_CR_SDD,                      /*!< Perform anticollsion state      */
    RFAL_NFCA_CR_SEL,                      /*!< Perform CL Selection state      */
    RFAL_NFCA_CR_DONE                      /*!< Collision Resolution done state */
}colResState;


/*! Colission Resolution context */
typedef struct{
    uint8_t               devLimit;        /*!< Device limit to be used                                 */
    rfalComplianceMode    compMode;        /*!< Compliancy mode to be used                              */
    rfalNfcaListenDevice* nfcaDevList;     /*!< Location of the device list                             */
    uint8_t*              devCnt;          /*!< Location of the device counter                          */
    bool                  collPending;     /*!< Collision pending flag                                  */
    
    bool*                 collPend;         /*!< Location of collision pending flag (Single CR)          */
    rfalNfcaSelReq        selReq;           /*!< SelReqused during anticollision (Single CR)             */
    rfalNfcaSelRes*       selRes;           /*!< Location to place of the SEL_RES(SAK) (Single CR)       */
    uint8_t*              nfcId1;           /*!< Location to place the NFCID1 (Single CR)                */
    uint8_t*              nfcId1Len;        /*!< Location to place the NFCID1 length (Single CR)         */
    uint8_t               cascadeLv;        /*!< Current Cascading Level (Single CR)                     */
    colResState           state;            /*!< Single Collision Resolution state (Single CR)           */
    uint8_t               bytesTxRx;        /*!< TxRx bytes used during anticollision loop (Single CR)   */
    uint8_t               bitsTxRx;         /*!< TxRx bits used during anticollision loop (Single CR)    */
    uint16_t              rxLen;    
    uint32_t              tmrFDT;           /*!< FDT timer used between SED_REQs  (Single CR)            */
    uint8_t               retries;          /*!< Retries to be performed upon a timeout error (Single CR)*/
    uint8_t               backtrackCnt;     /*!< Backtrack retries (Single CR)                           */
    bool                  doBacktrack;      /*!< Backtrack flag (Single CR)                              */
}colResParams;


/*! RFAL NFC-A instance */
typedef struct{
    colResParams          CR;               /*!< Collision Resolution context                            */
} rfalNfca;


/*! SLP_REQ (HLTA) format   Digital 1.1  6.9.1 & Table 20 */
typedef struct
{
    uint8_t      frame[RFAL_NFCA_SLP_REQ_LEN];  /*!< SLP:  0x50 0x00  */
} rfalNfcaSlpReq;


/*
******************************************************************************
* LOCAL VARIABLES
******************************************************************************
*/
static rfalNfca gNfca;  /*!< RFAL NFC-A instance  */

/*
******************************************************************************
* LOCAL FUNCTION PROTOTYPES
******************************************************************************
*/
static uint8_t    rfalNfcaCalculateBcc( const uint8_t* buf, uint8_t bufLen );
static ReturnCode rfalNfcaPollerStartSingleCollisionResolution( uint8_t devLimit, bool *collPending, rfalNfcaSelRes *selRes, uint8_t *nfcId1, uint8_t *nfcId1Len );
static ReturnCode rfalNfcaPollerGetSingleCollisionResolutionStatus( void );

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

static uint8_t rfalNfcaCalculateBcc( const uint8_t* buf, uint8_t bufLen )
{
    uint8_t i;
    uint8_t BCC;
    
    BCC = 0;
    
    /* BCC is XOR over first 4 bytes of the SDD_RES  Digital 1.1 6.7.2 */
    for(i = 0; i < bufLen; i++)
    {
        BCC ^= buf[i];
    }
    
    return BCC;
}

/*******************************************************************************/
static ReturnCode rfalNfcaPollerStartSingleCollisionResolution( uint8_t devLimit, bool *collPending, rfalNfcaSelRes *selRes, uint8_t *nfcId1, uint8_t *nfcId1Len )
{
    /* Check parameters */
    if( (collPending == NULL) || (selRes == NULL) || (nfcId1 == NULL) || (nfcId1Len == NULL) )
    {
        return ERR_PARAM;
    }
    
    /* Initialize output parameters */
    *collPending = false;  /* Activity 1.1  9.3.4.6 */
    *nfcId1Len   = 0;
    ST_MEMSET( nfcId1, 0x00, RFAL_NFCA_CASCADE_3_UID_LEN );
    
    
    /* Save parameters */
    gNfca.CR.devLimit    = devLimit;
    gNfca.CR.collPend    = collPending;
    gNfca.CR.selRes      = selRes;
    gNfca.CR.nfcId1      = nfcId1;
    gNfca.CR.nfcId1Len   = nfcId1Len;

    platformTimerDestroy( gNfca.CR.tmrFDT );
    gNfca.CR.tmrFDT      = 0U;
    gNfca.CR.retries     = RFAL_NFCA_N_RETRANS;
    gNfca.CR.cascadeLv   = (uint8_t)RFAL_NFCA_SEL_CASCADE_L1;
    gNfca.CR.state       = RFAL_NFCA_CR_CL;
   
    gNfca.CR.doBacktrack  = false;
    gNfca.CR.backtrackCnt = 3U;
    
    return ERR_NONE;
}


/*******************************************************************************/
static ReturnCode rfalNfcaPollerGetSingleCollisionResolutionStatus( void )
{
    ReturnCode ret;
    uint8_t    collBit = 1U;  /* standards mandate or recommend collision bit to be set to One. */
    
    
    /* Check if FDT timer is still running */
    if( !platformTimerIsExpired( gNfca.CR.tmrFDT ) && (gNfca.CR.tmrFDT != 0U) )
    {
        return ERR_BUSY;
    }
    
    /*******************************************************************************/
    /* Go through all Cascade Levels     Activity 1.1  9.3.4 */    
    if( gNfca.CR.cascadeLv > (uint8_t)RFAL_NFCA_SEL_CASCADE_L3 )
    {
        return ERR_INTERNAL;
    }
    
    switch( gNfca.CR.state )
    {
        /*******************************************************************************/
        case RFAL_NFCA_CR_CL:
            
            /* Initialize the SDD_REQ to send for the new cascade level */
            ST_MEMSET( (uint8_t*)&gNfca.CR.selReq, 0x00, sizeof(rfalNfcaSelReq) );
        
            gNfca.CR.bytesTxRx = RFAL_NFCA_SDD_REQ_LEN;
            gNfca.CR.bitsTxRx  = 0U;
            gNfca.CR.state     = RFAL_NFCA_CR_SDD;
        
            /* fall through */
        
        /*******************************************************************************/
        case RFAL_NFCA_CR_SDD:   /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
            
            /* Calculate SEL_CMD and SEL_PAR with the bytes/bits to be sent */
            gNfca.CR.selReq.selCmd = rfalNfcaCLn2SELCMD( gNfca.CR.cascadeLv );
            gNfca.CR.selReq.selPar = rfalNfcaSelPar(gNfca.CR.bytesTxRx, gNfca.CR.bitsTxRx);
        
            /* Send SDD_REQ (Anticollision frame) */
            ret = rfalISO14443ATransceiveAnticollisionFrame( (uint8_t*)&gNfca.CR.selReq, &gNfca.CR.bytesTxRx, &gNfca.CR.bitsTxRx, &gNfca.CR.rxLen, RFAL_NFCA_FDTMIN );

            /* Retry upon timeout  EMVCo 2.6  9.6.1.3 */
            if( (ret == ERR_TIMEOUT) && (gNfca.CR.devLimit==0U) && (gNfca.CR.retries != 0U) )
            {
                gNfca.CR.retries--;
                platformTimerDestroy( gNfca.CR.tmrFDT );
                gNfca.CR.tmrFDT = platformTimerCreate( RFAL_NFCA_T_RETRANS );
                break;
            }
            
            /* Covert rxLen into bytes */
            gNfca.CR.rxLen = rfalConvBitsToBytes( gNfca.CR.rxLen );
            
            
            if( (ret == ERR_TIMEOUT) && (gNfca.CR.backtrackCnt != 0U) && (!gNfca.CR.doBacktrack)
                && !((RFAL_NFCA_SDD_REQ_LEN == gNfca.CR.bytesTxRx) && (0U == gNfca.CR.bitsTxRx))     )
            {
                /* In multiple card scenarios it may always happen that some 
                 * collisions of a weaker tag go unnoticed. If then a later 
                 * collision is recognized and the strong tag has a 0 at the 
                 * collision position then no tag will respond. Catch this 
                 * corner case and then try with the bit being sent as zero. */
                rfalNfcaSensRes sensRes;
                ret = ERR_RF_COLLISION;
                rfalNfcaPollerCheckPresence( RFAL_14443A_SHORTFRAME_CMD_REQA, &sensRes );
                /* Algorithm below does a post-increment, decrement to go back to current position */
                if (0U == gNfca.CR.bitsTxRx)
                {
                    gNfca.CR.bitsTxRx = 7;
                    gNfca.CR.bytesTxRx--;
                }
                else
                {
                    gNfca.CR.bitsTxRx--;
                }
                collBit = (uint8_t)( ((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] & (1U << gNfca.CR.bitsTxRx) );
                collBit = (uint8_t)((0U==collBit)?1U:0U); // invert the collision bit
                gNfca.CR.doBacktrack = true;
                gNfca.CR.backtrackCnt--;
            }
            else
            {
                gNfca.CR.doBacktrack = false;
            }

            if( ret == ERR_RF_COLLISION )
            {
                /* Check received length */
                if( (gNfca.CR.bytesTxRx + ((gNfca.CR.bitsTxRx != 0U) ? 1U : 0U)) > (RFAL_NFCA_SDD_RES_LEN + RFAL_NFCA_SDD_REQ_LEN) )
                {
                    return ERR_PROTO;
                }

                if( ((gNfca.CR.bytesTxRx + ((gNfca.CR.bitsTxRx != 0U) ? 1U : 0U)) > (RFAL_NFCA_CASCADE_1_UID_LEN + RFAL_NFCA_SDD_REQ_LEN)) && (gNfca.CR.backtrackCnt != 0U) )
                { /* Collision in BCC: Anticollide only UID part */
                    gNfca.CR.backtrackCnt--;
                    gNfca.CR.bytesTxRx = RFAL_NFCA_CASCADE_1_UID_LEN + RFAL_NFCA_SDD_REQ_LEN - 1U;
                    gNfca.CR.bitsTxRx = 7;
                    collBit = (uint8_t)( ((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] & (1U << gNfca.CR.bitsTxRx) ); /* Not a real collision, extract the actual bit for the subsequent code */
                }
                
                if( (gNfca.CR.devLimit == 0U) && !(*gNfca.CR.collPend) )
                {   
                    /* Activity 1.0 & 1.1  9.3.4.12: If CON_DEVICES_LIMIT has a value of 0, then 
                     * NFC Forum Device is configured to perform collision detection only       */
                    *gNfca.CR.collPend = true;
                    return ERR_IGNORE;
                }
                
                *gNfca.CR.collPend = true;
                
                /* Set and select the collision bit, with the number of bytes/bits successfully TxRx */
                if (collBit != 0U)
                {
                    ((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] = (uint8_t)(((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] | (1U << gNfca.CR.bitsTxRx));   /* MISRA 10.3 */
                }
                else
                {
                    ((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] = (uint8_t)(((uint8_t*)&gNfca.CR.selReq)[gNfca.CR.bytesTxRx] & ~(1U << gNfca.CR.bitsTxRx));  /* MISRA 10.3 */
                }

                gNfca.CR.bitsTxRx++;
                
                /* Check if number of bits form a byte */
                if( gNfca.CR.bitsTxRx == RFAL_BITS_IN_BYTE )
                {
                    gNfca.CR.bitsTxRx = 0;
                    gNfca.CR.bytesTxRx++;
                }
                break;
            }
            
            /*******************************************************************************/
            /* Check if Collision loop has failed */
            if( ret != ERR_NONE )
            {
                return ret;
            }
            
            
            /* If collisions are to be reported check whether the response is complete */
            if( (gNfca.CR.devLimit == 0U) && (gNfca.CR.rxLen != sizeof(rfalNfcaSddRes)) )
            {
                return ERR_PROTO;
            }
            
            /* Check if the received BCC match */
            if( gNfca.CR.selReq.bcc != rfalNfcaCalculateBcc( gNfca.CR.selReq.nfcid1, RFAL_NFCA_CASCADE_1_UID_LEN ) )
            {
                return ERR_PROTO;
            }
            
            /*******************************************************************************/
            /* Anticollision OK, Select this Cascade Level */
            gNfca.CR.selReq.selPar = RFAL_NFCA_SEL_SELPAR;
            
            gNfca.CR.retries = RFAL_NFCA_N_RETRANS;
            gNfca.CR.state   = RFAL_NFCA_CR_SEL;
            break;
            
        /*******************************************************************************/
        case RFAL_NFCA_CR_SEL:
            
            /* Send SEL_REQ (Select command) - Retry upon timeout  EMVCo 2.6  9.6.1.3 */
            ret = rfalTransceiveBlockingTxRx( (uint8_t*)&gNfca.CR.selReq, sizeof(rfalNfcaSelReq), (uint8_t*)gNfca.CR.selRes, sizeof(rfalNfcaSelRes), &gNfca.CR.rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_NFCA_FDTMIN );
                
            /* Retry upon timeout  EMVCo 2.6  9.6.1.3 */
            if( (ret == ERR_TIMEOUT) && (gNfca.CR.devLimit==0U) && (gNfca.CR.retries != 0U) )
            {
                gNfca.CR.retries--;
                platformTimerDestroy( gNfca.CR.tmrFDT );
                gNfca.CR.tmrFDT = platformTimerCreate( RFAL_NFCA_T_RETRANS );
                break;
            }
            
            if( ret != ERR_NONE )
            {
                return ret;
            }
            
            /* Ensure proper response length */
            if( gNfca.CR.rxLen != sizeof(rfalNfcaSelRes) )
            {
                return ERR_PROTO;
            }
            
            /*******************************************************************************/
            /* Check cascade byte, if cascade tag then go next cascade level */
            if( *gNfca.CR.selReq.nfcid1 == RFAL_NFCA_SDD_CT )
            {
                /* Cascade Tag present, store nfcid1 bytes (excluding cascade tag) and continue for next CL */
                ST_MEMCPY( &gNfca.CR.nfcId1[*gNfca.CR.nfcId1Len], &((uint8_t*)&gNfca.CR.selReq.nfcid1)[RFAL_NFCA_SDD_CT_LEN], (RFAL_NFCA_CASCADE_1_UID_LEN - RFAL_NFCA_SDD_CT_LEN) );
                *gNfca.CR.nfcId1Len += (RFAL_NFCA_CASCADE_1_UID_LEN - RFAL_NFCA_SDD_CT_LEN);
                
                /* Go to next cascade level */
                gNfca.CR.state = RFAL_NFCA_CR_CL;
                gNfca.CR.cascadeLv++;
            }
            else
            {
                /* UID Selection complete, Stop Cascade Level loop */
                ST_MEMCPY( &gNfca.CR.nfcId1[*gNfca.CR.nfcId1Len], (uint8_t*)&gNfca.CR.selReq.nfcid1, RFAL_NFCA_CASCADE_1_UID_LEN );
                *gNfca.CR.nfcId1Len += RFAL_NFCA_CASCADE_1_UID_LEN;
                
                gNfca.CR.state = RFAL_NFCA_CR_DONE;
                break;                             /* Only flag operation complete on the next execution */
            }
            break;
        
        /*******************************************************************************/
        case RFAL_NFCA_CR_DONE:
            return ERR_NONE;
        
        /*******************************************************************************/
        default:
            return ERR_WRONG_STATE;
    }
    return ERR_BUSY;
}

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

/*******************************************************************************/
ReturnCode rfalNfcaPollerInitialize( void )
{
    ReturnCode ret;
    
    EXIT_ON_ERR( ret, rfalSetMode( RFAL_MODE_POLL_NFCA, RFAL_BR_106, RFAL_BR_106 ) );
    rfalSetErrorHandling( RFAL_ERRORHANDLING_NFC );
    
    rfalSetGT( RFAL_GT_NFCA );
    rfalSetFDTListen( RFAL_FDT_LISTEN_NFCA_POLLER );
    rfalSetFDTPoll( RFAL_FDT_POLL_NFCA_POLLER );
    
    return ERR_NONE;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerCheckPresence( rfal14443AShortFrameCmd cmd, rfalNfcaSensRes *sensRes )
{
    ReturnCode ret;
    uint16_t   rcvLen;
    
    /* Digital 1.1 6.10.1.3  For Commands ALL_REQ, SENS_REQ, SDD_REQ, and SEL_REQ, the NFC Forum Device      *
     *              MUST treat receipt of a Listen Frame at a time after FDT(Listen, min) as a Timeour Error */
    
    ret = rfalISO14443ATransceiveShortFrame(  cmd, (uint8_t*)sensRes, (uint8_t)rfalConvBytesToBits(sizeof(rfalNfcaSensRes)), &rcvLen, RFAL_NFCA_FDTMIN  );
    if( (ret == ERR_RF_COLLISION) || (ret == ERR_CRC)  || (ret == ERR_NOMEM) || (ret == ERR_FRAMING) || (ret == ERR_PAR) )
    {
       ret = ERR_NONE;
    }

    return ret;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerTechnologyDetection( rfalComplianceMode compMode, rfalNfcaSensRes *sensRes )
{
    ReturnCode ret;
    
    EXIT_ON_ERR( ret, rfalNfcaPollerCheckPresence( ((compMode == RFAL_COMPLIANCE_MODE_EMV) ? RFAL_14443A_SHORTFRAME_CMD_WUPA : RFAL_14443A_SHORTFRAME_CMD_REQA), sensRes ) );
    
    /* Send SLP_REQ as  Activity 1.1  9.2.3.6 and EMVCo 2.6  9.2.1.3 */
    if( compMode != RFAL_COMPLIANCE_MODE_ISO)
    {
        rfalNfcaPollerSleep();
    }
    return ERR_NONE;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerSingleCollisionResolution( uint8_t devLimit, bool *collPending, rfalNfcaSelRes *selRes, uint8_t *nfcId1, uint8_t *nfcId1Len )
{
    
    ReturnCode ret;
    
    EXIT_ON_ERR( ret, rfalNfcaPollerStartSingleCollisionResolution( devLimit, collPending, selRes, nfcId1, nfcId1Len ) );
    rfalNfcaRunBlocking( ret, rfalNfcaPollerGetSingleCollisionResolutionStatus() );
    
    return ret;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerStartFullCollisionResolution( rfalComplianceMode compMode, uint8_t devLimit, rfalNfcaListenDevice *nfcaDevList, uint8_t *devCnt )
{
    ReturnCode      ret;
    rfalNfcaSensRes sensRes;
    uint16_t        rcvLen;
    
    if( (nfcaDevList == NULL) || (devCnt == NULL) )
    {
        return ERR_PARAM;
    }
    
    *devCnt = 0;
    ret     = ERR_NONE;
    
    /*******************************************************************************/
    /* Send ALL_REQ before Anticollision if a Sleep was sent before  Activity 1.1  9.3.4.1 and EMVco 2.6  9.3.2.1 */
    if( compMode != RFAL_COMPLIANCE_MODE_ISO )
    {
        ret = rfalISO14443ATransceiveShortFrame( RFAL_14443A_SHORTFRAME_CMD_WUPA, (uint8_t*)&nfcaDevList->sensRes, (uint8_t)rfalConvBytesToBits(sizeof(rfalNfcaSensRes)), &rcvLen, RFAL_NFCA_FDTMIN  );
        if(ret != ERR_NONE)
        {
            if( (compMode == RFAL_COMPLIANCE_MODE_EMV) || ((ret != ERR_RF_COLLISION) && (ret != ERR_CRC) && (ret != ERR_FRAMING) && (ret != ERR_PAR)) )
            {
                return ret;
            }
        }
        
        /* Check proper SENS_RES/ATQA size */
        if( (ret == ERR_NONE) && (rfalConvBytesToBits(sizeof(rfalNfcaSensRes)) != rcvLen) )
        {
            return ERR_PROTO;
        }
    }
    
    /*******************************************************************************/
    /* Store the SENS_RES from Technology Detection or from WUPA */ 
    sensRes = nfcaDevList->sensRes;
    
    if( devLimit > 0U )  /* MISRA 21.18 */
    {
        ST_MEMSET( nfcaDevList, 0x00, (sizeof(rfalNfcaListenDevice) * devLimit) );
    }
    
    /* Restore the prev SENS_RES, assuming that the SENS_RES received is from first device
     * When only one device is detected it's not woken up then we'll have no SENS_RES (ATQA) */
    nfcaDevList->sensRes = sensRes;
    
    /* Save parameters */
    gNfca.CR.devCnt      = devCnt;
    gNfca.CR.devLimit    = devLimit;
    gNfca.CR.nfcaDevList = nfcaDevList;
    gNfca.CR.compMode    = compMode;
    
    
    #if RFAL_FEATURE_T1T
    /*******************************************************************************/
    /* Only check for T1T if previous SENS_RES was received without a transmission  *
     * error. When collisions occur bits in the SENS_RES may look like a T1T        */
    /* If T1T Anticollision is not supported  Activity 1.1  9.3.4.3 */
    if( rfalNfcaIsSensResT1T( &nfcaDevList->sensRes ) && (devLimit != 0U) && (ret == ERR_NONE) && (compMode != RFAL_COMPLIANCE_MODE_EMV) )
    {
        /* RID_REQ shall be performed              Activity 1.1  9.3.4.24 */
        rfalT1TPollerInitialize();
        EXIT_ON_ERR( ret, rfalT1TPollerRid( &nfcaDevList->ridRes ) );
        
        *devCnt = 1U;
        nfcaDevList->isSleep   = false;
        nfcaDevList->type      = RFAL_NFCA_T1T;
        nfcaDevList->nfcId1Len = RFAL_NFCA_CASCADE_1_UID_LEN;
        ST_MEMCPY( &nfcaDevList->nfcId1, &nfcaDevList->ridRes.uid, RFAL_NFCA_CASCADE_1_UID_LEN );
        
        return ERR_NONE;
    }
    #endif /* RFAL_FEATURE_T1T */
    
    return rfalNfcaPollerStartSingleCollisionResolution( devLimit, &gNfca.CR.collPending, &nfcaDevList->selRes, (uint8_t*)&nfcaDevList->nfcId1, &nfcaDevList->nfcId1Len );
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerGetFullCollisionResolutionStatus( void )
{
    ReturnCode ret;
    uint8_t    newDevType;
    
    if( (gNfca.CR.nfcaDevList == NULL) || (gNfca.CR.devCnt == NULL) )
    {
        return ERR_WRONG_STATE;
    }
    
    /*******************************************************************************/
    /* Check whether a T1T has already been detected */
    if( rfalNfcaIsSensResT1T( &gNfca.CR.nfcaDevList->sensRes ) && (gNfca.CR.nfcaDevList->type == RFAL_NFCA_T1T) )
    {
        /* T1T doesn't support Anticollision */
        return ERR_NONE;
    }
    
    
    /*******************************************************************************/
    EXIT_ON_ERR( ret, rfalNfcaPollerGetSingleCollisionResolutionStatus() );

    /* Assign Listen Device */
    newDevType = ((uint8_t)gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].selRes.sak) & RFAL_NFCA_SEL_RES_CONF_MASK;  /* MISRA 10.8 */
    /* PRQA S 4342 1 # MISRA 10.5 - Guaranteed that no invalid enum values are created: see guard_eq_RFAL_NFCA_T2T, .... */
    gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].type    = (rfalNfcaListenDeviceType) newDevType;
    gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].isSleep = false;
    (*gNfca.CR.devCnt)++;

    
    /* If a collision was detected and device counter is lower than limit  Activity 1.1  9.3.4.21 */
    if( (*gNfca.CR.devCnt < gNfca.CR.devLimit) && (gNfca.CR.collPending) )
    {
        /* Put this device to Sleep  Activity 1.1  9.3.4.22 */
        rfalNfcaPollerSleep();
        gNfca.CR.nfcaDevList[(*gNfca.CR.devCnt - 1U)].isSleep = true;
        
        
        /* Send a new SENS_REQ to check for other cards  Activity 1.1  9.3.4.23 */
        ret = rfalNfcaPollerCheckPresence( RFAL_14443A_SHORTFRAME_CMD_REQA, &gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].sensRes );
        if( ret == ERR_TIMEOUT )
        {
            /* No more devices found, exit */
            gNfca.CR.collPending = false;
        }
        else
        {
            /* Another device found, continue loop */
            gNfca.CR.collPending = true;
        }
    }
    else
    {
        /* Exit loop */
        gNfca.CR.collPending = false;
    }
        
    
    /*******************************************************************************/
    /* Check if collision resolution shall continue */
    if( (*gNfca.CR.devCnt < gNfca.CR.devLimit) && (gNfca.CR.collPending) )
    {
        EXIT_ON_ERR( ret, rfalNfcaPollerStartSingleCollisionResolution(  gNfca.CR.devLimit, 
                                                                         &gNfca.CR.collPending, 
                                                                         &gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].selRes, 
                                                                         (uint8_t*)&gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].nfcId1, 
                                                                         &gNfca.CR.nfcaDevList[*gNfca.CR.devCnt].nfcId1Len ) );
    
        return ERR_BUSY;
    }
    
    return ERR_NONE;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerFullCollisionResolution( rfalComplianceMode compMode, uint8_t devLimit, rfalNfcaListenDevice *nfcaDevList, uint8_t *devCnt )
{
    ReturnCode ret;
    
    EXIT_ON_ERR( ret, rfalNfcaPollerStartFullCollisionResolution( compMode, devLimit, nfcaDevList, devCnt ) );
    rfalNfcaRunBlocking( ret, rfalNfcaPollerGetFullCollisionResolutionStatus() );
    
    return ret;
}

ReturnCode rfalNfcaPollerSleepFullCollisionResolution( uint8_t devLimit, rfalNfcaListenDevice *nfcaDevList, uint8_t *devCnt )
{
    bool       firstRound;
    uint8_t    tmpDevCnt;
    ReturnCode ret;


    if( (nfcaDevList == NULL) || (devCnt == NULL) )
    {
        return ERR_PARAM;
    }

    /* Only use ALL_REQ (WUPA) on the first round */
    firstRound = true;  
    *devCnt    = 0;
    
    
    /* Perform collision resolution until no new device is found */
    do
    {
        tmpDevCnt = 0;
        ret = rfalNfcaPollerFullCollisionResolution( (firstRound ? RFAL_COMPLIANCE_MODE_NFC : RFAL_COMPLIANCE_MODE_ISO), (devLimit - *devCnt), &nfcaDevList[*devCnt], &tmpDevCnt );

        if( (ret == ERR_NONE) && (tmpDevCnt > 0U) )
        {
            *devCnt += tmpDevCnt;

            /* Check whether to seacrh for more devices */
            if( *devCnt < devLimit )
            {
                /* Set last found device to sleep (all others are slept already) */
                rfalNfcaPollerSleep();
                nfcaDevList[((*devCnt)-1U)].isSleep = true;
                
                /* Check if any other device is present */
                ret = rfalNfcaPollerCheckPresence( RFAL_14443A_SHORTFRAME_CMD_REQA, &nfcaDevList[*devCnt].sensRes );
                if( ret == ERR_NONE )
                {
                    firstRound = false;
                    continue;
                }
            }
        }
        break;
    }
    while( true );

    return ((*devCnt > 0U) ? ERR_NONE : ret);
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerSelect( const uint8_t *nfcid1, uint8_t nfcidLen, rfalNfcaSelRes *selRes )
{
    uint8_t        i;
    uint8_t        cl;
    uint8_t        nfcidOffset;
    uint16_t       rxLen;
    ReturnCode     ret;
    rfalNfcaSelReq selReq;
    
    if( (nfcid1 == NULL) || (nfcidLen > RFAL_NFCA_CASCADE_3_UID_LEN) || (selRes == NULL) )
    {
        return ERR_PARAM;
    }
    
    
    /* Calculate Cascate Level */
    cl          = rfalNfcaNfcidLen2CL( nfcidLen );
    nfcidOffset = 0;
    
    /*******************************************************************************/
    /* Go through all Cascade Levels     Activity 1.1  9.4.4 */
    for( i = RFAL_NFCA_SEL_CASCADE_L1; i <= cl; i++ )
    {
        /* Assign SEL_CMD according to the CLn and SEL_PAR*/
        selReq.selCmd = rfalNfcaCLn2SELCMD(i);
        selReq.selPar = RFAL_NFCA_SEL_SELPAR;
        
        /* Compute NFCID/Data on the SEL_REQ command   Digital 1.1  Table 18 */
        if( cl != i )
        {
            *selReq.nfcid1 = RFAL_NFCA_SDD_CT;
            ST_MEMCPY( &selReq.nfcid1[RFAL_NFCA_SDD_CT_LEN], &nfcid1[nfcidOffset], (RFAL_NFCA_CASCADE_1_UID_LEN - RFAL_NFCA_SDD_CT_LEN) );
            nfcidOffset += (RFAL_NFCA_CASCADE_1_UID_LEN - RFAL_NFCA_SDD_CT_LEN);
        }
        else
        {
            ST_MEMCPY( selReq.nfcid1, &nfcid1[nfcidOffset], RFAL_NFCA_CASCADE_1_UID_LEN );
        }
        
        /* Calculate nfcid's BCC */
        selReq.bcc = rfalNfcaCalculateBcc( (uint8_t*)&selReq.nfcid1, sizeof(selReq.nfcid1) );
        
        /*******************************************************************************/
        /* Send SEL_REQ  */
        EXIT_ON_ERR( ret, rfalTransceiveBlockingTxRx( (uint8_t*)&selReq, sizeof(rfalNfcaSelReq), (uint8_t*)selRes, sizeof(rfalNfcaSelRes), &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_NFCA_FDTMIN ) );
        
        /* Ensure proper response length */
        if( rxLen != sizeof(rfalNfcaSelRes) )
        {
            return ERR_PROTO;
        }
    }
    
    /* REMARK: Could check if NFCID1 is complete */
    
    return ERR_NONE;
}


/*******************************************************************************/
ReturnCode rfalNfcaPollerSleep( void )
{
    rfalNfcaSlpReq slpReq;
    uint8_t        rxBuf;    /* dummy buffer, just to perform Rx */
    
    slpReq.frame[RFAL_NFCA_SLP_CMD_POS]   = RFAL_NFCA_SLP_CMD;
    slpReq.frame[RFAL_NFCA_SLP_BYTE2_POS] = RFAL_NFCA_SLP_BYTE2;
    
    rfalTransceiveBlockingTxRx( (uint8_t*)&slpReq, sizeof(rfalNfcaSlpReq), &rxBuf, sizeof(rxBuf), NULL, RFAL_TXRX_FLAGS_DEFAULT, RFAL_NFCA_SLP_FWT );
        
    /* ISO14443-3 6.4.3  HLTA - If PICC responds with any modulation during 1 ms this response shall be interpreted as not acknowledge 
       Digital 2.0  6.9.2.1 & EMVCo 3.0  5.6.2.1 - consider the HLTA command always acknowledged
       No check to be compliant with NFC and EMVCo, and to improve interoprability (Kovio RFID Tag)
    */
    
    return ERR_NONE;
}


/*******************************************************************************/
bool rfalNfcaListenerIsSleepReq( const uint8_t *buf, uint16_t bufLen )
{
    /* Check if length and payload match */
    if( (bufLen != sizeof(rfalNfcaSlpReq)) || (buf[RFAL_NFCA_SLP_CMD_POS] != RFAL_NFCA_SLP_CMD) || (buf[RFAL_NFCA_SLP_BYTE2_POS] != RFAL_NFCA_SLP_BYTE2) )
    {
        return false;
    }
    
    return true;
}

/* If the guards here don't compile then the code above cannot work anymore. */
extern uint8_t guard_eq_RFAL_NFCA_T2T[((RFAL_NFCA_SEL_RES_CONF_MASK&(uint8_t)RFAL_NFCA_T2T) == (uint8_t)RFAL_NFCA_T2T)?1:(-1)];
extern uint8_t guard_eq_RFAL_NFCA_T4T[((RFAL_NFCA_SEL_RES_CONF_MASK&(uint8_t)RFAL_NFCA_T4T) == (uint8_t)RFAL_NFCA_T4T)?1:(-1)];
extern uint8_t guard_eq_RFAL_NFCA_NFCDEP[((RFAL_NFCA_SEL_RES_CONF_MASK&(uint8_t)RFAL_NFCA_NFCDEP) == (uint8_t)RFAL_NFCA_NFCDEP)?1:(-1)];
extern uint8_t guard_eq_RFAL_NFCA_T4T_NFCDEP[((RFAL_NFCA_SEL_RES_CONF_MASK&(uint8_t)RFAL_NFCA_T4T_NFCDEP) == (uint8_t)RFAL_NFCA_T4T_NFCDEP)?1:(-1)];
#endif /* RFAL_FEATURE_NFCA */