Momentum-Apps/mifare_nested/lib/nfclegacy/ST25RFAL002/source/rfal_nfca.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:   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 "../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 */