Revert "Merge esubghz_chat from https://github.com/xMasterX/all-the-plugins"

This reverts commit 9774a2f1d5fe19830a70755a27fe16f7386d637e, reversing
changes made to a1b5a7e967759d22264c005b5b9aaa76291c9f83.

esubghz_chat/application.fam

@@ -7,10 +7,9 @@ App(
         "gui",
         "subghz",
     ],
-    stack_size=7 * 1024,
+    stack_size=8 * 1024,
     fap_category="Sub-GHz",
     fap_libs=["mbedtls"],
-    fap_private_libs=[Lib(name="nfclegacy"), Lib(name="parity")],
     fap_icon="assets/chat_10px.png",
     fap_icon_assets="assets",
     fap_icon_assets_symbol="esubghz_chat",

esubghz_chat/esubghz_chat.c

@@ -547,15 +547,6 @@ static void chat_box_free(ESubGhzChatState* state) {
 }
 
 int32_t esubghz_chat(const char* args) {
-    if(furi_hal_nfc_is_hal_ready() != FuriHalNfcErrorNone) {
-        printf("NFC chip failed to start\r\n");
-        return -1;
-    }
-
-    furi_hal_nfc_acquire();
-    furi_hal_nfc_low_power_mode_start();
-    furi_hal_nfc_release();
-    furry_hal_nfc_init();
     /* init the crypto system */
     crypto_init();
 
@@ -619,20 +610,16 @@ int32_t esubghz_chat(const char* args) {
         goto err_alloc_worker;
     }
 
-    NfcDevice* nfcdevic = nfc_device_alloc();
-    state->nfc_dev_data = &nfcdevic->dev_data;
-
-    state->nfc_worker = nfc_worker_alloc();
-    if(state->nfc_worker == NULL) {
-        goto err_alloc_nworker;
-    }
-
-    /*state->nfc_dev_data = malloc(sizeof(NfcDeviceData));
-    if(state->nfc_dev_data == NULL) {
-        goto err_alloc_ndevdata;
-    }*/
+    // state->nfc_worker = nfc_worker_alloc();
+    // if(state->nfc_worker == NULL) {
+    //     goto err_alloc_nworker;
+    // }
 
-    //memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData));
+    // state->nfc_dev_data = malloc(sizeof(NfcDeviceData));
+    // if(state->nfc_dev_data == NULL) {
+    //     goto err_alloc_ndevdata;
+    // }
+    // memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData));
 
     state->crypto_ctx = crypto_ctx_alloc();
     if(state->crypto_ctx == NULL) {
@@ -728,7 +715,7 @@ int32_t esubghz_chat(const char* args) {
     }
 
     /* if it is running, stop the NFC worker */
-    nfc_worker_stop(state->nfc_worker);
+    // nfc_worker_stop(state->nfc_worker);
 
     err = 0;
 
@@ -753,12 +740,10 @@ int32_t esubghz_chat(const char* args) {
     crypto_ctx_clear(state->crypto_ctx);
 
     /* clear nfc data */
-    if(state->nfc_dev_data->parsed_data != NULL) {
-        furi_string_free(state->nfc_dev_data->parsed_data);
-    }
-
-    //nfc_device_data_clear(state->nfc_dev_data);
-    crypto_explicit_bzero(state->nfc_dev_data, sizeof(NfcDeviceData));
+    // if(state->nfc_dev_data->parsed_data != NULL) {
+    //     furi_string_free(state->nfc_dev_data->parsed_data);
+    // }
+    // crypto_explicit_bzero(state->nfc_dev_data, sizeof(NfcDeviceData));
 
     /* deinit devices */
     radio_device_loader_end(state->subghz_device);
@@ -773,14 +758,12 @@ int32_t esubghz_chat(const char* args) {
     crypto_ctx_free(state->crypto_ctx);
 
 err_alloc_crypto:
-    //free(state->nfc_dev_data);
-
-    //err_alloc_ndevdata:
-    nfc_worker_free(state->nfc_worker);
+    //     free(state->nfc_dev_data);
 
-    nfc_device_free(nfcdevic);
+    // err_alloc_ndevdata:
+    //     nfc_worker_free(state->nfc_worker);
 
-err_alloc_nworker:
+    // err_alloc_nworker:
     subghz_tx_rx_worker_free(state->subghz_worker);
 
 err_alloc_worker:
@@ -820,12 +803,5 @@ err_alloc:
         FURI_LOG_I(APPLICATION_NAME, "Clean exit.");
     }
 
-    furry_hal_nfc_deinit();
-
-    //
-    furi_hal_nfc_acquire();
-    furi_hal_nfc_low_power_mode_start();
-    furi_hal_nfc_release();
-
     return err;
 }

esubghz_chat/esubghz_chat_i.h

@@ -19,7 +19,7 @@
 
 #include "esubghz_chat_icons.h"
 
-#include <lib/nfclegacy/nfc_worker.h>
+#include <assets_icons.h>
 
 #define APPLICATION_NAME "ESubGhzChat"
 
@@ -58,8 +58,8 @@ typedef struct {
     const SubGhzDevice* subghz_device;
 
     // for NFC
-    NfcWorker* nfc_worker;
-    NfcDeviceData* nfc_dev_data;
+    // NfcWorker* nfc_worker;
+    // NfcDeviceData* nfc_dev_data;
 
     // message assembly before TX
     FuriString* name_prefix;
@@ -100,7 +100,7 @@ typedef enum {
     ESubGhzChatEvent_KeyMenuPassword,
     ESubGhzChatEvent_KeyMenuHexKey,
     ESubGhzChatEvent_KeyMenuGenKey,
-    ESubGhzChatEvent_KeyMenuReadKeyFromNfc,
+    // ESubGhzChatEvent_KeyMenuReadKeyFromNfc,
     ESubGhzChatEvent_KeyReadPopupFailed,
     ESubGhzChatEvent_KeyReadPopupSucceeded,
     ESubGhzChatEvent_PassEntered,

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_analogConfig.h

@@ -1,435 +0,0 @@
-
-/******************************************************************************
-  * \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_AnalogConfig.h
- *
- *  \author bkam
- *
- *  \brief RF Chip Analog Configuration Settings
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup AnalogConfig
- * \brief RFAL Analog Config Module
- * @{
- * 
- */
-
-#ifndef RFAL_ANALOG_CONFIG_H
-#define RFAL_ANALOG_CONFIG_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-
-#define RFAL_ANALOG_CONFIG_LUT_SIZE \
-    (87U) /*!< Maximum number of Configuration IDs in the Loop Up Table     */
-#define RFAL_ANALOG_CONFIG_LUT_NOT_FOUND \
-    (0xFFU) /*!< Index value indicating no Configuration IDs found            */
-
-#define RFAL_ANALOG_CONFIG_TBL_SIZE \
-    (1024U) /*!< Maximum number of Register-Mask-Value in the Setting List    */
-
-#define RFAL_ANALOG_CONFIG_POLL_LISTEN_MODE_MASK \
-    (0x8000U) /*!< Mask bit of Poll Mode in Analog Configuration ID             */
-#define RFAL_ANALOG_CONFIG_TECH_MASK \
-    (0x7F00U) /*!< Mask bits for Technology in Analog Configuration ID          */
-#define RFAL_ANALOG_CONFIG_BITRATE_MASK \
-    (0x00F0U) /*!< Mask bits for Bit rate in Analog Configuration ID            */
-#define RFAL_ANALOG_CONFIG_DIRECTION_MASK \
-    (0x000FU) /*!< Mask bits for Direction in Analog Configuration ID           */
-#define RFAL_ANALOG_CONFIG_CHIP_SPECIFIC_MASK \
-    (0x00FFU) /*!< Mask bits for Chip Specific Technology                       */
-
-#define RFAL_ANALOG_CONFIG_POLL_LISTEN_MODE_SHIFT \
-    (15U) /*!< Shift value of Poll Mode in Analog Configuration ID          */
-#define RFAL_ANALOG_CONFIG_TECH_SHIFT \
-    (8U) /*!< Shift value for Technology in Analog Configuration ID        */
-#define RFAL_ANALOG_CONFIG_BITRATE_SHIFT \
-    (4U) /*!< Shift value for Technology in Analog Configuration ID        */
-#define RFAL_ANALOG_CONFIG_DIRECTION_SHIFT \
-    (0U) /*!< Shift value for Direction in Analog Configuration ID         */
-
-#define RFAL_ANALOG_CONFIG_POLL \
-    (0x0000U) /*!< Poll Mode bit setting in Analog Configuration ID             */
-#define RFAL_ANALOG_CONFIG_LISTEN \
-    (0x8000U) /*!< Listen Mode bit setting in Analog Configuration ID           */
-
-#define RFAL_ANALOG_CONFIG_TECH_CHIP \
-    (0x0000U) /*!< Chip-Specific bit setting in Analog Configuration ID         */
-#define RFAL_ANALOG_CONFIG_TECH_NFCA \
-    (0x0100U) /*!< NFC-A Technology bits setting in Analog Configuration ID     */
-#define RFAL_ANALOG_CONFIG_TECH_NFCB \
-    (0x0200U) /*!< NFC-B Technology bits setting in Analog Configuration ID     */
-#define RFAL_ANALOG_CONFIG_TECH_NFCF \
-    (0x0400U) /*!< NFC-F Technology bits setting in Analog Configuration ID     */
-#define RFAL_ANALOG_CONFIG_TECH_AP2P \
-    (0x0800U) /*!< AP2P Technology bits setting in Analog Configuration ID      */
-#define RFAL_ANALOG_CONFIG_TECH_NFCV \
-    (0x1000U) /*!< NFC-V Technology bits setting in Analog Configuration ID     */
-#define RFAL_ANALOG_CONFIG_TECH_RFU (0x2000U) /*!< RFU for Technology bits */
-
-#define RFAL_ANALOG_CONFIG_BITRATE_COMMON \
-    (0x0000U) /*!< Common settings for all bit rates in Analog Configuration ID */
-#define RFAL_ANALOG_CONFIG_BITRATE_106 \
-    (0x0010U) /*!< 106kbits/s settings in Analog Configuration ID               */
-#define RFAL_ANALOG_CONFIG_BITRATE_212 \
-    (0x0020U) /*!< 212kbits/s settings in Analog Configuration ID               */
-#define RFAL_ANALOG_CONFIG_BITRATE_424 \
-    (0x0030U) /*!< 424kbits/s settings in Analog Configuration ID               */
-#define RFAL_ANALOG_CONFIG_BITRATE_848 \
-    (0x0040U) /*!< 848kbits/s settings in Analog Configuration ID               */
-#define RFAL_ANALOG_CONFIG_BITRATE_1695 \
-    (0x0050U) /*!< 1695kbits/s settings in Analog Configuration ID              */
-#define RFAL_ANALOG_CONFIG_BITRATE_3390 \
-    (0x0060U) /*!< 3390kbits/s settings in Analog Configuration ID              */
-#define RFAL_ANALOG_CONFIG_BITRATE_6780 \
-    (0x0070U) /*!< 6780kbits/s settings in Analog Configuration ID              */
-#define RFAL_ANALOG_CONFIG_BITRATE_1OF4 \
-    (0x00C0U) /*!< 1 out of 4 for NFC-V setting in Analog Configuration ID      */
-#define RFAL_ANALOG_CONFIG_BITRATE_1OF256 \
-    (0x00D0U) /*!< 1 out of 256 for NFC-V setting in Analog Configuration ID    */
-
-#define RFAL_ANALOG_CONFIG_NO_DIRECTION \
-    (0x0000U) /*!< No direction setting in Analog Conf ID (Chip Specific only)  */
-#define RFAL_ANALOG_CONFIG_TX \
-    (0x0001U) /*!< Transmission bit setting in Analog Configuration ID          */
-#define RFAL_ANALOG_CONFIG_RX \
-    (0x0002U) /*!< Reception bit setting in Analog Configuration ID             */
-#define RFAL_ANALOG_CONFIG_ANTICOL \
-    (0x0003U) /*!< Anticollision setting in Analog Configuration ID             */
-#define RFAL_ANALOG_CONFIG_DPO \
-    (0x0004U) /*!< DPO setting in Analog Configuration ID                       */
-
-#define RFAL_ANALOG_CONFIG_CHIP_INIT \
-    (0x0000U) /*!< Chip-Specific event: Startup;Reset;Initialize                */
-#define RFAL_ANALOG_CONFIG_CHIP_DEINIT \
-    (0x0001U) /*!< Chip-Specific event: Deinitialize                            */
-#define RFAL_ANALOG_CONFIG_CHIP_FIELD_ON \
-    (0x0002U) /*!< Chip-Specific event: Field On                                */
-#define RFAL_ANALOG_CONFIG_CHIP_FIELD_OFF \
-    (0x0003U) /*!< Chip-Specific event: Field Off                               */
-#define RFAL_ANALOG_CONFIG_CHIP_WAKEUP_ON \
-    (0x0004U) /*!< Chip-Specific event: Wake-up On                              */
-#define RFAL_ANALOG_CONFIG_CHIP_WAKEUP_OFF \
-    (0x0005U) /*!< Chip-Specific event: Wake-up Off                             */
-#define RFAL_ANALOG_CONFIG_CHIP_LISTEN_ON \
-    (0x0006U) /*!< Chip-Specific event: Listen On                               */
-#define RFAL_ANALOG_CONFIG_CHIP_LISTEN_OFF \
-    (0x0007U) /*!< Chip-Specific event: Listen Off                              */
-#define RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON \
-    (0x0008U) /*!< Chip-Specific event: Poll common                             */
-#define RFAL_ANALOG_CONFIG_CHIP_LISTEN_COMMON \
-    (0x0009U) /*!< Chip-Specific event: Listen common                           */
-#define RFAL_ANALOG_CONFIG_CHIP_LOWPOWER_ON \
-    (0x000AU) /*!< Chip-Specific event: Low Power On                            */
-#define RFAL_ANALOG_CONFIG_CHIP_LOWPOWER_OFF \
-    (0x000BU) /*!< Chip-Specific event: Low Power Off                           */
-
-#define RFAL_ANALOG_CONFIG_UPDATE_LAST \
-    (0x00U) /*!< Value indicating Last configuration set during update        */
-#define RFAL_ANALOG_CONFIG_UPDATE_MORE \
-    (0x01U) /*!< Value indicating More configuration set coming during update */
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-#define RFAL_ANALOG_CONFIG_ID_GET_POLL_LISTEN(id) \
-    (RFAL_ANALOG_CONFIG_POLL_LISTEN_MODE_MASK & (id)) /*!< Check if id indicates Listen mode   */
-
-#define RFAL_ANALOG_CONFIG_ID_GET_TECH(id) \
-    (RFAL_ANALOG_CONFIG_TECH_MASK & (id)) /*!< Get the technology of Configuration ID     */
-#define RFAL_ANALOG_CONFIG_ID_IS_CHIP(id) \
-    (RFAL_ANALOG_CONFIG_TECH_MASK & (id)) /*!< Check if ID indicates Chip-specific        */
-#define RFAL_ANALOG_CONFIG_ID_IS_NFCA(id) \
-    (RFAL_ANALOG_CONFIG_TECH_NFCA & (id)) /*!< Check if ID indicates NFC-A                */
-#define RFAL_ANALOG_CONFIG_ID_IS_NFCB(id) \
-    (RFAL_ANALOG_CONFIG_TECH_NFCB & (id)) /*!< Check if ID indicates NFC-B                */
-#define RFAL_ANALOG_CONFIG_ID_IS_NFCF(id) \
-    (RFAL_ANALOG_CONFIG_TECH_NFCF & (id)) /*!< Check if ID indicates NFC-F                */
-#define RFAL_ANALOG_CONFIG_ID_IS_AP2P(id) \
-    (RFAL_ANALOG_CONFIG_TECH_AP2P & (id)) /*!< Check if ID indicates AP2P                 */
-#define RFAL_ANALOG_CONFIG_ID_IS_NFCV(id) \
-    (RFAL_ANALOG_CONFIG_TECH_NFCV & (id)) /*!< Check if ID indicates NFC-V                */
-
-#define RFAL_ANALOG_CONFIG_ID_GET_BITRATE(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_MASK & (id)) /*!< Get Bitrate of Configuration ID            */
-#define RFAL_ANALOG_CONFIG_ID_IS_COMMON(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_MASK & (id)) /*!< Check if ID indicates common bitrate       */
-#define RFAL_ANALOG_CONFIG_ID_IS_106(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_106 & (id)) /*!< Check if ID indicates 106kbits/s           */
-#define RFAL_ANALOG_CONFIG_ID_IS_212(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_212 & (id)) /*!< Check if ID indicates 212kbits/s           */
-#define RFAL_ANALOG_CONFIG_ID_IS_424(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_424 & (id)) /*!< Check if ID indicates 424kbits/s           */
-#define RFAL_ANALOG_CONFIG_ID_IS_848(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_848 & (id)) /*!< Check if ID indicates 848kbits/s           */
-#define RFAL_ANALOG_CONFIG_ID_IS_1695(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_1695 & (id)) /*!< Check if ID indicates 1695kbits/s          */
-#define RFAL_ANALOG_CONFIG_ID_IS_3390(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_3390 & (id)) /*!< Check if ID indicates 3390kbits/s          */
-#define RFAL_ANALOG_CONFIG_ID_IS_6780(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_6780 & (id)) /*!< Check if ID indicates 6780kbits/s          */
-#define RFAL_ANALOG_CONFIG_ID_IS_1OF4(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_1OF4 & (id)) /*!< Check if ID indicates 1 out of 4 bitrate   */
-#define RFAL_ANALOG_CONFIG_ID_IS_1OF256(id) \
-    (RFAL_ANALOG_CONFIG_BITRATE_1OF256 & (id)) /*!< Check if ID indicates 1 out of 256 bitrate */
-
-#define RFAL_ANALOG_CONFIG_ID_GET_DIRECTION(id) \
-    (RFAL_ANALOG_CONFIG_DIRECTION_MASK & (id)) /*!< Get Direction of Configuration ID          */
-#define RFAL_ANALOG_CONFIG_ID_IS_TX(id) \
-    (RFAL_ANALOG_CONFIG_TX & (id)) /*!< Check if id indicates TX                   */
-#define RFAL_ANALOG_CONFIG_ID_IS_RX(id) \
-    (RFAL_ANALOG_CONFIG_RX & (id)) /*!< Check if id indicates RX                   */
-
-#define RFAL_ANALOG_CONFIG_CONFIG_NUM(x) \
-    (sizeof(x) / sizeof((x)[0])) /*!< Get Analog Config number                   */
-
-/*! Set Analog Config ID value by: Mode, Technology, Bitrate and Direction      */
-#define RFAL_ANALOG_CONFIG_ID_SET(mode, tech, br, direction)                              \
-    (RFAL_ANALOG_CONFIG_ID_GET_POLL_LISTEN(mode) | RFAL_ANALOG_CONFIG_ID_GET_TECH(tech) | \
-     RFAL_ANALOG_CONFIG_ID_GET_BITRATE(br) | RFAL_ANALOG_CONFIG_ID_GET_DIRECTION(direction))
-
-/*
- ******************************************************************************
- * GLOBAL DATA TYPES
- ******************************************************************************
- */
-
-typedef uint8_t
-    rfalAnalogConfigMode; /*!< Polling or Listening Mode of Configuration                    */
-typedef uint8_t
-    rfalAnalogConfigTech; /*!< Technology of Configuration                                   */
-typedef uint8_t
-    rfalAnalogConfigBitrate; /*!< Bitrate of Configuration                                      */
-typedef uint8_t
-    rfalAnalogConfigDirection; /*!< Transmit/Receive direction of Configuration                   */
-
-typedef uint8_t
-    rfalAnalogConfigRegAddr[2]; /*!< Register Address to ST Chip                                   */
-typedef uint8_t
-    rfalAnalogConfigRegMask; /*!< Register Mask Value                                           */
-typedef uint8_t
-    rfalAnalogConfigRegVal; /*!< Register Value                                                */
-
-typedef uint16_t
-    rfalAnalogConfigId; /*!< Analog Configuration ID                                       */
-typedef uint16_t
-    rfalAnalogConfigOffset; /*!< Analog Configuration offset address in the table              */
-typedef uint8_t
-    rfalAnalogConfigNum; /*!< Number of Analog settings for the respective Configuration ID */
-
-/*! Struct that contain the Register-Mask-Value set. Make sure that the whole structure size is even and unaligned! */
-typedef struct {
-    rfalAnalogConfigRegAddr addr; /*!< Register Address    */
-    rfalAnalogConfigRegMask mask; /*!< Register Mask Value */
-    rfalAnalogConfigRegVal val; /*!< Register Value      */
-} rfalAnalogConfigRegAddrMaskVal;
-
-/*! Struct that represents the Analog Configs */
-typedef struct {
-    uint8_t id[sizeof(rfalAnalogConfigId)]; /*!< Configuration ID                   */
-    rfalAnalogConfigNum num; /*!< Number of Config Sets to follow    */
-    rfalAnalogConfigRegAddrMaskVal regSet[];
-    /*!< Register-Mask-Value sets           */ /*  PRQA S 1060 # MISRA 18.7 - Flexible Array Members are the only meaningful way of denoting a variable length input buffer which follows a fixed header structure. */
-} rfalAnalogConfig;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*!
- *****************************************************************************
- * \brief Initialize the Analog Configuration
- * 
- * Reset the Analog Configuration LUT pointer to reference to default settings.
- * 
- *****************************************************************************
- */
-void rfalAnalogConfigInitialize(void);
-
-/*!
- *****************************************************************************
- * \brief Indicate if the current Analog Configuration Table is complete and ready to be used.
- * 
- * \return true if current Analog Configuration Table is complete and ready to be used.
- * \return false if current Analog Configuration Table is incomplete
- * 
- *****************************************************************************
- */
-bool rfalAnalogConfigIsReady(void);
-
-/*!
- *****************************************************************************
- * \brief  Write the whole Analog Configuration table in raw format 
- *  
- * Writes the Analog Configuration and Look Up Table with the given raw table
- * 
- * NOTE: Function does not check the validity of the given Table contents
- * 
- * \param[in]  configTbl:     location of config Table to be loaded
- * \param[in]  configTblSize: size of the config Table to be loaded
- * 
- * \return ERR_NONE    : if setting is updated
- * \return ERR_PARAM   : if configTbl is invalid
- * \return ERR_NOMEM   : if the given Table is bigger exceeds the max size
- * \return ERR_REQUEST : if the update Configuration Id is disabled
- *
- *****************************************************************************
- */
-ReturnCode rfalAnalogConfigListWriteRaw(const uint8_t* configTbl, uint16_t configTblSize);
-
-/*!
- *****************************************************************************
- * \brief  Write the Analog Configuration table with new analog settings.
- *  
- * Writes the Analog Configuration and Look Up Table with the new list of register-mask-value 
- * and Configuration ID respectively.
- * 
- * NOTE: Function does not check for the validity of the Register Address.
- * 
- * \param[in]  more: 0x00 indicates it is last Configuration ID settings; 
- *                   0x01 indicates more Configuration ID setting(s) are coming.
- * \param[in]  *config: reference to the configuration list of current Configuration ID.
- *                          
- * \return ERR_PARAM   : if Configuration ID or parameter is invalid
- * \return ERR_NOMEM   : if LUT is full      
- * \return ERR_REQUEST : if the update Configuration Id is disabled               
- * \return ERR_NONE    : if setting is updated
- *
- *****************************************************************************
- */
-ReturnCode rfalAnalogConfigListWrite(uint8_t more, const rfalAnalogConfig* config);
-
-/*!
- *****************************************************************************
- * \brief  Read the whole Analog Configuration table in raw format
- *  
- * Reads the whole Analog Configuration Table in raw format
- * 
- * \param[out]   tblBuf: location to the buffer to place the Config Table 
- * \param[in]    tblBufLen: length of the buffer to place the Config Table
- * \param[out]   configTblSize: Config Table size 
- *                          
- * \return ERR_PARAM : if configTbl or configTblSize is invalid
- * \return ERR_NOMEM : if configTblSize is not enough for the whole table           
- * \return ERR_NONE  : if read is successful
- * 
- *****************************************************************************
- */
-ReturnCode
-    rfalAnalogConfigListReadRaw(uint8_t* tblBuf, uint16_t tblBufLen, uint16_t* configTblSize);
-
-/*!
- *****************************************************************************
- * \brief  Read the Analog Configuration table.
- *  
- * Read the Analog Configuration Table
- * 
- * \param[in]     configOffset: offset to the next Configuration ID in the List Table to be read.   
- * \param[out]    more: 0x00 indicates it is last Configuration ID settings; 
- *                      0x01 indicates more Configuration ID setting(s) are coming.
- * \param[out]    config: configuration id, number of configuration sets and register-mask-value sets
- * \param[in]     numConfig: the remaining configuration settings space available;
- *                          
- * \return ERR_NOMEM : if number of Configuration for respective Configuration ID is greater the the remaining configuration setting space available                
- * \return ERR_NONE  : if read is successful
- * 
- *****************************************************************************
- */
-ReturnCode rfalAnalogConfigListRead(
-    rfalAnalogConfigOffset* configOffset,
-    uint8_t* more,
-    rfalAnalogConfig* config,
-    rfalAnalogConfigNum numConfig);
-
-/*!
- *****************************************************************************
- * \brief  Set the Analog settings of indicated Configuration ID.
- *  
- * Update the chip with indicated analog settings of indicated Configuration ID.
- *
- * \param[in]  configId: configuration ID
- *                            
- * \return ERR_PARAM if Configuration ID is invalid
- * \return ERR_INTERNAL if error updating setting to chip                   
- * \return ERR_NONE if new settings is applied to chip
- *
- *****************************************************************************
- */
-ReturnCode rfalSetAnalogConfig(rfalAnalogConfigId configId);
-
-/*!
- *****************************************************************************
- * \brief  Generates Analog Config mode ID 
- *
- * Converts RFAL mode and bitrate into Analog Config Mode ID.
- *  
- * Update the chip with indicated analog settings of indicated Configuration ID.
- *
- * \param[in]  md:  RFAL mode format
- * \param[in]  br:  RFAL bit rate format
- * \param[in]  dir: Analog Config communication direction
- *                            
- * \return  Analog Config Mode ID
- *
- *****************************************************************************
- */
-uint16_t rfalAnalogConfigGenModeID(rfalMode md, rfalBitRate br, uint16_t dir);
-
-#endif /* RFAL_ANALOG_CONFIG_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_chip.h

@@ -1,287 +0,0 @@
-
-/******************************************************************************
-  * \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_chip.h
- *
- *  \author Gustavo Patricio 
- *
- *  \brief RF Chip specific Layer
- *  
- *  \warning This layer, which provides direct access to RF chip, should 
- *           only be used for debug purposes and/or advanced features
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup Chip
- * \brief RFAL RF Chip Module
- * @{
- * 
- */
-
-#ifndef RFAL_CHIP_H
-#define RFAL_CHIP_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*****************************************************************************
- *  RF Chip                                                                  *  
- *****************************************************************************/
-
-/*!
- *****************************************************************************
- * \brief Writes a register on the RF Chip
- *
- * Checks if the given register is valid and if so, writes the value(s)
- * on the RF Chip register
- * 
- * \param[in] reg: register address to be written, or the first if len > 1
- * \param[in] values: pointer with content to be written on the register(s)
- * \param[in] len: number of consecutive registers to be written
- *  
- * 
- * \return ERR_PARAM    : Invalid register or bad request
- * \return ERR_NOTSUPP  : Feature not supported
- * \return ERR_NONE     : Write done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipWriteReg(uint16_t reg, const uint8_t* values, uint8_t len);
-
-/*!
- *****************************************************************************
- * \brief Reads a register on the RF Chip
- *
- * Checks if the given register is valid and if so, reads the value(s)
- * of the RF Chip register(s)
- * 
- * \param[in]  reg: register address to be read, or the first if len > 1
- * \param[out] values: pointer where the register(s) read content will be placed 
- * \param[in]  len: number of consecutive registers to be read  
- * 
- * \return ERR_PARAM    : Invalid register or bad request
- * \return ERR_NOTSUPP  : Feature not supported
- * \return ERR_NONE     : Read done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipReadReg(uint16_t reg, uint8_t* values, uint8_t len);
-
-/*!
- *****************************************************************************
- * \brief Change a register on the RF Chip
- *
- * Change the value of the register bits on the RF Chip Test set in the valueMask. 
- * 
- * \param[in] reg: register address to be modified
- * \param[in] valueMask: mask value of the register bits to be changed
- * \param[in] value: register value to be set
- * 
- * \return ERR_PARAM    : Invalid register or bad request
- * \return ERR_NOTSUPP  : Feature not supported
- * \return ERR_OK       : Change done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipChangeRegBits(uint16_t reg, uint8_t valueMask, uint8_t value);
-
-/*!
- *****************************************************************************
- * \brief Writes a Test register on the RF Chip
- *
- * Writes the value on the RF Chip Test register
- * 
- * \param[in] reg: register address to be written
- * \param[in] value: value to be written on the register
- *  
- * 
- * \return ERR_PARAM    : Invalid register or bad request
- * \return ERR_NOTSUPP  : Feature not supported
- * \return ERR_NONE     : Write done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipWriteTestReg(uint16_t reg, uint8_t value);
-
-/*!
- *****************************************************************************
- * \brief Reads a Test register on the RF Chip
- *
- * Reads the value of the RF Chip Test register
- * 
- * \param[in]  reg: register address to be read
- * \param[out] value: pointer where the register content will be placed  
- * 
- * \return ERR_PARAM    :Invalid register or bad request
- * \return ERR_NOTSUPP  : Feature not supported
- * \return ERR_NONE     : Read done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipReadTestReg(uint16_t reg, uint8_t* value);
-
-/*!
- *****************************************************************************
- * \brief Change a Test register on the RF Chip
- *
- * Change the value of the register bits on the RF Chip Test set in the valueMask. 
- * 
- * \param[in] reg: test register address to be modified
- * \param[in] valueMask: mask value of the register bits to be changed
- * \param[in] value: register value to be set
- * 
- * \return ERR_PARAM     : Invalid register or bad request
- * \return ERR_NOTSUPP   : Feature not supported
- * \return ERR_OK        : Change done with no error
- *****************************************************************************
- */
-ReturnCode rfalChipChangeTestRegBits(uint16_t reg, uint8_t valueMask, uint8_t value);
-
-/*!
- *****************************************************************************
- * \brief Execute command on the RF Chip
- *
- * Checks if the given command is valid and if so, executes it on 
- * the RF Chip
- * 
- * \param[in] cmd: direct command to be executed
- * 
- * \return ERR_PARAM     : Invalid command or bad request
- * \return  ERR_NOTSUPP  : Feature not supported
- * \return ERR_NONE      : Direct command executed with no error
- *****************************************************************************
- */
-ReturnCode rfalChipExecCmd(uint16_t cmd);
-
-/*! 
- *****************************************************************************
- * \brief  Set RFO
- *
- * Sets the RFO value to be used when the field is on (unmodulated/active)
- * 
- * \param[in] rfo : the RFO value to be used
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipSetRFO(uint8_t rfo);
-
-/*! 
- *****************************************************************************
- * \brief  Get RFO
- *
- * Gets the RFO value used used when the field is on (unmodulated/active)
- *
- * \param[out] result : the current RFO value 
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipGetRFO(uint8_t* result);
-
-/*! 
- *****************************************************************************
- * \brief  Measure Amplitude
- *
- * Measures the RF Amplitude
- *
- * \param[out] result : result of RF measurement
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipMeasureAmplitude(uint8_t* result);
-
-/*! 
- *****************************************************************************
- * \brief  Measure Phase
- *
- * Measures the Phase
- *
- * \param[out] result : result of Phase measurement
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipMeasurePhase(uint8_t* result);
-
-/*! 
- *****************************************************************************
- * \brief  Measure Capacitance
- *
- * Measures the Capacitance
- *
- * \param[out] result : result of Capacitance measurement
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipMeasureCapacitance(uint8_t* result);
-
-/*! 
- *****************************************************************************
- * \brief  Measure Power Supply
- *
- * Measures the Power Supply
- *
- * \param[in]   param : measurement parameter (chip specific)
- * \param[out] result : result of the measurement
- *
- * \return  ERR_IO           : Internal error
- * \return  ERR_NOTSUPP      : Feature not supported
- * \return  ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalChipMeasurePowerSupply(uint8_t param, uint8_t* result);
-
-#endif /* RFAL_CHIP_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_crc.h

@@ -1,74 +0,0 @@
-
-/******************************************************************************
-  * \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_crc.h
- *
- *  \author Ulrich Herrmann
- *
- *  \brief CRC calculation module
- *
- */
-/*!
- * 
- */
-
-#ifndef RFAL_CRC_H_
-#define RFAL_CRC_H_
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../platform.h"
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-/*! 
- *****************************************************************************
- *  \brief  Calculate CRC according to CCITT standard.
- *
- *  This function takes \a length bytes from \a buf and calculates the CRC
- *  for this data. The result is returned.
- *  \note This implementation calculates the CRC with LSB first, i.e. all
- *  bytes are "read" from right to left.
- *
- *  \param[in] preloadValue : Initial value of CRC calculation.
- *  \param[in] buf : buffer to calculate the CRC for.
- *  \param[in] length : size of the buffer.
- *
- *  \return 16 bit long crc value.
- *
- *****************************************************************************
- */
-extern uint16_t rfalCrcCalculateCcitt(uint16_t preloadValue, const uint8_t* buf, uint16_t length);
-
-#endif /* RFAL_CRC_H_ */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_dpo.h

@@ -1,207 +0,0 @@
-
-/******************************************************************************
-  * @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:
-  *
-  *        http://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_dpo.h
- *
- *  \author Martin Zechleitner
- *
- *  \brief Dynamic Power adjustment
- *  
- *  This module provides an interface to perform the power adjustment dynamically 
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup DPO
- * \brief RFAL Dynamic Power Module
- * @{
- * 
- */
-
-#ifndef RFAL_DPO_H
-#define RFAL_DPO_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_DPO_TABLE_SIZE_MAX 15U /*!< Max DPO table size */
-#define RFAL_DPO_TABLE_PARAMETER 3U /*!< DPO table Parameter length */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! DPO table entry struct */
-typedef struct {
-    uint8_t rfoRes; /*!< Setting for the resistance level of the RFO */
-    uint8_t inc; /*!< Threshold for incrementing the output power */
-    uint8_t dec; /*!< Threshold for decrementing the output power */
-} rfalDpoEntry;
-
-/*! Function pointer to method doing the reference measurement */
-typedef ReturnCode (*rfalDpoMeasureFunc)(uint8_t*);
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize dynamic power table
- *  
- *  This function sets the internal dynamic power table to the default 
- *  values stored in rfal_DpoTbl.h
- *  
- *****************************************************************************
- */
-void rfalDpoInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  Set the measurement method
- *  
- * This function sets the measurement method used for reference measurement.
- * Based on the measurement the power will then be adjusted
- *  
- * \param[in]  dpoMeasureFunc: callback of measurement function
- *
- *****************************************************************************
- */
-void rfalDpoSetMeasureCallback(rfalDpoMeasureFunc dpoMeasureFunc);
-
-/*! 
- *****************************************************************************
- * \brief  Write dynamic power table
- *  
- * Load the dynamic power table  
- *
- * \param[in]  powerTbl:     location of power Table to be loaded
- * \param[in]  powerTblEntries: number of entries of the power Table to be loaded
- * 
- * \return ERR_NONE    : No error
- * \return ERR_PARAM   : if configTbl is invalid
- * \return ERR_NOMEM   : if the given Table is bigger exceeds the max size
- *****************************************************************************
- */
-ReturnCode rfalDpoTableWrite(rfalDpoEntry* powerTbl, uint8_t powerTblEntries);
-
-/*! 
- *****************************************************************************
- * \brief  Dynamic power table Read
- *  
- * Read the dynamic power table  
- *
- * \param[out]   tblBuf: location to the rfalDpoEntry[] to place the Table 
- * \param[in]    tblBufEntries: number of entries available in tblBuf to place the power Table
- * \param[out]   tableEntries: returned number of entries actually written into tblBuf
- * 
- * \return ERR_NONE    : No error
- * \return ERR_PARAM   : if configTbl is invalid or parameters are invalid
- *****************************************************************************
- */
-ReturnCode rfalDpoTableRead(rfalDpoEntry* tblBuf, uint8_t tblBufEntries, uint8_t* tableEntries);
-
-/*! 
- *****************************************************************************
- * \brief  Dynamic power adjust
- *  
- * It measures the current output and adjusts the power accordingly to 
- * the dynamic power table  
- * 
- * \return ERR_NONE        : No error
- * \return ERR_PARAM       : if configTbl is invalid or parameters are invalid
- * \return ERR_WRONG_STATE : if the current state is valid for DPO Adjustment
- *****************************************************************************
- */
-ReturnCode rfalDpoAdjust(void);
-
-/*! 
- *****************************************************************************
- * \brief  Get Current Dynamic power table entry
- *  
- * Return current used DPO power table entry settings
- *
- * \return ERR_NONE    : Current DpoEntry. This includes d_res, inc and dec
- * 
- *****************************************************************************
- */
-rfalDpoEntry* rfalDpoGetCurrentTableEntry(void);
-
-/*! 
- *****************************************************************************
- * \brief  Dynamic power set enabled state
- *  
- * \param[in]     enable: new active state
- *
- * Set state to enable or disable the Dynamic power adjustment 
- * 
- *****************************************************************************
- */
-void rfalDpoSetEnabled(bool enable);
-
-/*! 
- *****************************************************************************
- * \brief  Get the Dynamic power enabled state
- *  
- * Get state of the Dynamic power adjustment 
- * 
- * \return true   : enabled
- * \return false  : disabled
- *****************************************************************************
- */
-bool rfalDpoIsEnabled(void);
-
-#endif /* RFAL_DPO_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_iso15693_2.h

@@ -1,206 +0,0 @@
-
-/******************************************************************************
-  * \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_iso15693_2.h
- *
- *  \author Ulrich Herrmann
- *
- *  \brief Implementation of ISO-15693-2
- *
- */
-/*!
- * 
- */
-
-#ifndef RFAL_ISO_15693_2_H
-#define RFAL_ISO_15693_2_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../platform.h"
-#include "../st_errno.h"
-
-/*
-******************************************************************************
-* GLOBAL DATATYPES
-******************************************************************************
-*/
-/*! Enum holding possible VCD codings  */
-typedef enum { ISO15693_VCD_CODING_1_4, ISO15693_VCD_CODING_1_256 } iso15693VcdCoding_t;
-
-/*! Enum holding possible VICC datarates */
-
-/*! Configuration parameter used by #iso15693PhyConfigure  */
-typedef struct {
-    iso15693VcdCoding_t coding; /*!< desired VCD coding                                       */
-    uint32_t
-        speedMode; /*!< 0: normal mode, 1: 2^1 = x2 Fast mode, 2 : 2^2 = x4 mode, 3 : 2^3 = x8 mode - all rx pulse numbers and times are divided by 1,2,4,8 */
-} iso15693PhyConfig_t;
-
-/*! Parameters how the stream mode should work */
-struct iso15693StreamConfig {
-    uint8_t useBPSK; /*!< 0: subcarrier, 1:BPSK */
-    uint8_t din; /*!< the divider for the in subcarrier frequency: fc/2^din  */
-    uint8_t dout; /*!< the divider for the in subcarrier frequency fc/2^dout */
-    uint8_t report_period_length; /*!< the length of the reporting period 2^report_period_length*/
-};
-/*
-******************************************************************************
-* GLOBAL CONSTANTS
-******************************************************************************
-*/
-
-#define ISO15693_REQ_FLAG_TWO_SUBCARRIERS \
-    0x01U /*!< Flag indication that communication uses two subcarriers */
-#define ISO15693_REQ_FLAG_HIGH_DATARATE \
-    0x02U /*!< Flag indication that communication uses high bitrate    */
-#define ISO15693_MASK_FDT_LISTEN \
-    (65) /*!< t1min = 308,2us = 4192/fc = 65.5 * 64/fc                */
-
-/*! t1max = 323,3us = 4384/fc = 68.5 * 64/fc
- *         12 = 768/fc unmodulated time of single subcarrior SoF */
-#define ISO15693_FWT (69 + 12)
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-/*! 
- *****************************************************************************
- *  \brief  Initialize the ISO15693 phy
- *
- *  \param[in] config : ISO15693 phy related configuration (See #iso15693PhyConfig_t)
- *  \param[out] needed_stream_config : return a pointer to the stream config 
- *              needed for this iso15693 config. To be used for configure RF chip.
- *
- *  \return ERR_IO : Error during communication.
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-extern ReturnCode iso15693PhyConfigure(
-    const iso15693PhyConfig_t* config,
-    const struct iso15693StreamConfig** needed_stream_config);
-
-/*! 
- *****************************************************************************
- *  \brief  Return current phy configuration
- *
- *  This function returns current Phy configuration previously
- *  set by #iso15693PhyConfigure
- *
- *  \param[out] config : ISO15693 phy configuration.
- *
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-extern ReturnCode iso15693PhyGetConfiguration(iso15693PhyConfig_t* config);
-
-/*! 
- *****************************************************************************
- *  \brief  Code an ISO15693 compatible frame
- *
- *  This function takes \a length bytes from \a buffer, perform proper
- *  encoding and sends out the frame to the ST25R391x.
- *
- *  \param[in] buffer : data to send, modified to adapt flags.
- *  \param[in] length : number of bytes to send.
- *  \param[in] sendCrc : If set to true, CRC is appended to the frame
- *  \param[in] sendFlags: If set to true, flag field is sent according to
- *                        ISO15693.
- *  \param[in] picopassMode :  If set to true, the coding will be according to Picopass
- *  \param[out] subbit_total_length : Return the complete bytes which need to 
- *                                   be send for the current coding
- *  \param[in,out] offset : Set to 0 for first transfer, function will update it to
-                            point to next byte to be coded
- *  \param[out] outbuf : buffer where the function will store the coded subbit stream
- *  \param[out] outBufSize : the size of the output buffer
- *  \param[out] actOutBufSize : the amount of data stored into the buffer at this call
- *
- *  \return ERR_IO : Error during communication.
- *  \return ERR_AGAIN : Data was not coded all the way. Call function again with a new/emptied buffer
- *  \return ERR_NO_MEM : In case outBuf is not big enough. Needs to have at 
-                         least 5 bytes for 1of4 coding and 65 bytes for 1of256 coding
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-extern ReturnCode iso15693VCDCode(
-    uint8_t* buffer,
-    uint16_t length,
-    bool sendCrc,
-    bool sendFlags,
-    bool picopassMode,
-    uint16_t* subbit_total_length,
-    uint16_t* offset,
-    uint8_t* outbuf,
-    uint16_t outBufSize,
-    uint16_t* actOutBufSize);
-
-/*! 
- *****************************************************************************
- *  \brief  Receive an ISO15693 compatible frame
- *
- *  This function receives an ISO15693 frame from the ST25R391x, decodes the frame
- *  and writes the raw data to \a buffer.
- *  \note Buffer needs to be big enough to hold CRC also (+2 bytes)
- *
- *  \param[in] inBuf : buffer with the hamming coded stream to be decoded
- *  \param[in] inBufLen : number of bytes to decode (=length of buffer).
- *  \param[out] outBuf : buffer where received data shall be written to.
- *  \param[in] outBufLen : Length of output buffer, should be approx twice the size of inBuf
- *  \param[out] outBufPos : The number of decoded bytes. Could be used in 
- *                          extended implementation to allow multiple calls
- *  \param[out] bitsBeforeCol : in case of ERR_COLLISION this value holds the
- *   number of bits in the current byte where the collision happened.
- *  \param[in] ignoreBits : number of bits in the beginning where collisions will be ignored
- *  \param[in] picopassMode :  if set to true, the decoding will be according to Picopass
- *
- *  \return ERR_COLLISION : collision occurred, data incorrect
- *  \return ERR_CRC : CRC error, data incorrect
- *  \return ERR_TIMEOUT : timeout waiting for data.
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-extern ReturnCode iso15693VICCDecode(
-    const uint8_t* inBuf,
-    uint16_t inBufLen,
-    uint8_t* outBuf,
-    uint16_t outBufLen,
-    uint16_t* outBufPos,
-    uint16_t* bitsBeforeCol,
-    uint16_t ignoreBits,
-    bool picopassMode);
-
-#endif /* RFAL_ISO_15693_2_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_isoDep.h

@@ -1,1092 +0,0 @@
-
-/******************************************************************************
-  * \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_isoDep.h
- *
- *  \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
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup ISO-DEP
- * \brief RFAL ISO-DEP Module
- * @{
- * 
- */
-
-#ifndef RFAL_ISODEP_H_
-#define RFAL_ISODEP_H_
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "rfal_nfcb.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_ISO_DEP
-#define RFAL_FEATURE_ISO_DEP \
-    false /*!< ISO-DEP module configuration missing. Disabled by default */
-#endif
-
-/* If module is disabled remove the need for the user to set lengths */
-#if !RFAL_FEATURE_ISO_DEP
-#undef RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN
-#undef RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN
-
-#define RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN (1U) /*!< ISO-DEP I-Block max length, set to "none" */
-#define RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN (1U) /*!< ISO-DEP APDU max length, set to "none"    */
-#endif /* !RFAL_FEATURE_NFC_DEP  */
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-
-#define RFAL_ISODEP_PROLOGUE_SIZE \
-    (3U) /*!< Length of Prologue Field for I-Block Format                       */
-
-#define RFAL_ISODEP_PCB_LEN \
-    (1U) /*!< PCB length                                                        */
-#define RFAL_ISODEP_DID_LEN \
-    (1U) /*!< DID length                                                        */
-#define RFAL_ISODEP_NAD_LEN \
-    (1U) /*!< NAD length                                                        */
-#define RFAL_ISODEP_NO_DID \
-    (0x00U) /*!< DID value indicating the ISO-DEP layer not to use DID             */
-#define RFAL_ISODEP_NO_NAD \
-    (0xFFU) /*!< NAD value indicating the ISO-DEP layer not to use NAD             */
-
-#define RFAL_ISODEP_FWI_MASK \
-    (0xF0U) /*!< Mask bits of FWI                                                  */
-#define RFAL_ISODEP_FWI_SHIFT \
-    (4U) /*!< Shift val of FWI                                                  */
-#define RFAL_ISODEP_FWI_DEFAULT \
-    (4U) /*!< Default value for FWI Digital 1.0 11.6.2.17                       */
-#define RFAL_ISODEP_ADV_FEATURE \
-    (0x0FU) /*!< Indicate 256 Bytes FSD and Advanc Proto Feature support:NAD & DID */
-
-#define RFAL_ISODEP_DID_MAX \
-    (14U) /*!< Maximum DID value                                                 */
-
-#define RFAL_ISODEP_BRI_MASK \
-    (0x07U) /*!< Mask bits for Poll to Listen Send bitrate                         */
-#define RFAL_ISODEP_BSI_MASK \
-    (0x70U) /*!< Mask bits for Listen to Poll Send bitrate                         */
-#define RFAL_ISODEP_SAME_BITRATE_MASK \
-    (0x80U) /*!< Mask bit indicate only same bit rate D for both direction support */
-#define RFAL_ISODEP_BITRATE_RFU_MASK \
-    (0x08U) /*!< Mask bit for RFU                                                  */
-
-/*! Maximum Frame Waiting Time = ((256 * 16/fc) * 2^FWImax) = ((256*16/fc)*2^14) = (67108864)/fc = 2^26 (1/fc)                  */
-#define RFAL_ISODEP_MAX_FWT ((uint32_t)1U << 26)
-
-#define RFAL_ISODEP_FSDI_DEFAULT \
-    RFAL_ISODEP_FSXI_256 /*!< Default Frame Size Integer in Poll mode              */
-#define RFAL_ISODEP_FSX_KEEP (0xFFU) /*!< Flag to keep FSX from activation                     */
-#define RFAL_ISODEP_DEFAULT_FSCI \
-    RFAL_ISODEP_FSXI_256 /*!< FSCI default value to be used  in Listen Mode        */
-#define RFAL_ISODEP_DEFAULT_FSC \
-    RFAL_ISODEP_FSX_256 /*!< FSC default value (aligned RFAL_ISODEP_DEFAULT_FSCI) */
-#define RFAL_ISODEP_DEFAULT_SFGI (0U) /*!< SFGI Default value to be used  in Listen Mode        */
-#define RFAL_ISODEP_DEFAULT_FWI (8U) /*!< Default Listener FWI (Max)      Digital 2.0  B7 & B3 */
-
-#define RFAL_ISODEP_APDU_MAX_LEN \
-    RFAL_ISODEP_FSX_1024 /*!< Max APDU length                                      */
-
-#define RFAL_ISODEP_ATTRIB_RES_MBLI_NO_INFO \
-    (0x00U) /*!< MBLI indicating no information on its internal input buffer size  */
-#define RFAL_ISODEP_ATTRIB_REQ_PARAM1_DEFAULT \
-    (0x00U) /*!< Default values of Param 1 of ATTRIB_REQ Digital 1.0  12.6.1.3-5   */
-#define RFAL_ISODEP_ATTRIB_HLINFO_LEN \
-    (32U) /*!< Maximum Size of Higher Layer Information                          */
-#define RFAL_ISODEP_ATS_HB_MAX_LEN \
-    (15U) /*!< Maximum length of Historical Bytes  Digital 1.1  13.6.2.23        */
-#define RFAL_ISODEP_ATTRIB_REQ_MIN_LEN \
-    (9U) /*!< Minimum Length of ATTRIB_REQ command                              */
-#define RFAL_ISODEP_ATTRIB_RES_MIN_LEN \
-    (1U) /*!< Minimum Length of ATTRIB_RES response                             */
-
-#define RFAL_ISODEP_SPARAM_VALUES_MAX_LEN \
-    (16U) /*!< Maximum Length of the value field on S(PARAMETERS)                */
-#define RFAL_ISODEP_SPARAM_TAG_BLOCKINFO \
-    (0xA0U) /*!< S(PARAMETERS) tag Block information                               */
-#define RFAL_ISODEP_SPARAM_TAG_BRREQ \
-    (0xA1U) /*!< S(PARAMETERS) tag Bit rates Request                               */
-#define RFAL_ISODEP_SPARAM_TAG_BRIND \
-    (0xA2U) /*!< S(PARAMETERS) tag Bit rates Indication                            */
-#define RFAL_ISODEP_SPARAM_TAG_BRACT \
-    (0xA3U) /*!< S(PARAMETERS) tag Bit rates Activation                            */
-#define RFAL_ISODEP_SPARAM_TAG_BRACK \
-    (0xA4U) /*!< S(PARAMETERS) tag Bit rates Acknowledgement                       */
-
-#define RFAL_ISODEP_SPARAM_TAG_SUP_PCD2PICC \
-    (0x80U) /*!< S(PARAMETERS) tag Supported bit rates from PCD to PICC            */
-#define RFAL_ISODEP_SPARAM_TAG_SUP_PICC2PCD \
-    (0x81U) /*!< S(PARAMETERS) tag Supported bit rates from PICC to PCD            */
-#define RFAL_ISODEP_SPARAM_TAG_SUP_FRAME \
-    (0x82U) /*!< S(PARAMETERS) tag Supported framing options PICC to PCD           */
-#define RFAL_ISODEP_SPARAM_TAG_SEL_PCD2PICC \
-    (0x83U) /*!< S(PARAMETERS) tag Selected bit rate from PCD to PICC              */
-#define RFAL_ISODEP_SPARAM_TAG_SEL_PICC2PCD \
-    (0x84U) /*!< S(PARAMETERS) tag Selected bit rate from PICC to PCD              */
-#define RFAL_ISODEP_SPARAM_TAG_SEL_FRAME \
-    (0x85U) /*!< S(PARAMETERS) tag Selected framing options PICC to PCD            */
-
-#define RFAL_ISODEP_SPARAM_TAG_LEN \
-    (1) /*!< S(PARAMETERS) Tag Length                                          */
-#define RFAL_ISODEP_SPARAM_TAG_BRREQ_LEN \
-    (0U) /*!< S(PARAMETERS) tag Bit rates Request Length                        */
-#define RFAL_ISODEP_SPARAM_TAG_PICC2PCD_LEN \
-    (2U) /*!< S(PARAMETERS) bit rates from PCD to PICC Length                   */
-#define RFAL_ISODEP_SPARAM_TAG_PCD2PICC_LEN \
-    (2U) /*!< S(PARAMETERS) bit rates from PICC to PCD Length                   */
-#define RFAL_ISODEP_SPARAM_TAG_BRACK_LEN \
-    (0U) /*!< S(PARAMETERS) tag Bit rates Acknowledgement Length                */
-
-#define RFAL_ISODEP_ATS_TA_DPL_212 \
-    (0x01U) /*!< ATS TA DSI 212 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_DPL_424 \
-    (0x02U) /*!< ATS TA DSI 424 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_DPL_848 \
-    (0x04U) /*!< ATS TA DSI 848 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_DLP_212 \
-    (0x10U) /*!< ATS TA DSI 212 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_DLP_424 \
-    (0x20U) /*!< ATS TA DRI 424 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_DLP_848 \
-    (0x40U) /*!< ATS TA DRI 848 kbps support bit mask                              */
-#define RFAL_ISODEP_ATS_TA_SAME_D \
-    (0x80U) /*!< ATS TA same bit both directions bit mask                          */
-#define RFAL_ISODEP_ATS_TB_FWI_MASK \
-    (0xF0U) /*!< Mask bits for FWI (Frame Waiting Integer) in TB byte              */
-#define RFAL_ISODEP_ATS_TB_SFGI_MASK \
-    (0x0FU) /*!< Mask bits for SFGI (Start-Up Frame Guard Integer) in TB byte      */
-
-#define RFAL_ISODEP_ATS_T0_TA_PRESENCE_MASK \
-    (0x10U) /*!< Mask bit for TA presence                                          */
-#define RFAL_ISODEP_ATS_T0_TB_PRESENCE_MASK \
-    (0x20U) /*!< Mask bit for TB presence                                          */
-#define RFAL_ISODEP_ATS_T0_TC_PRESENCE_MASK \
-    (0x40U) /*!< Mask bit for TC presence                                          */
-#define RFAL_ISODEP_ATS_T0_FSCI_MASK \
-    (0x0FU) /*!< Mask bit for FSCI presence                                        */
-#define RFAL_ISODEP_ATS_T0_OFFSET \
-    (0x01U) /*!< Offset of T0 in ATS Response                                      */
-
-#define RFAL_ISODEP_MAX_I_RETRYS \
-    (2U) /*!< Number of retries for a I-Block     Digital 2.0   16.2.5.4                  */
-#define RFAL_ISODEP_MAX_R_RETRYS \
-    (3U) /*!< Number of retries for a R-Block     Digital 2.0 B9 - nRETRY ACK/NAK: [2,5]  */
-#define RFAL_ISODEP_MAX_WTX_NACK_RETRYS \
-    (3U) /*!< Number of S(WTX) replied with NACK  Digital 2.0 B9 - nRETRY WTX[2,5]        */
-#define RFAL_ISODEP_MAX_WTX_RETRYS \
-    (20U) /*!< Number of overall S(WTX) retries    Digital 2.0  16.2.5.2                   */
-#define RFAL_ISODEP_MAX_WTX_RETRYS_ULTD \
-    (255U) /*!< Use unlimited number of overall S(WTX)                                      */
-#define RFAL_ISODEP_MAX_DSL_RETRYS \
-    (0U) /*!< Number of retries for a S(DESELECT) Digital 2.0 B9 - nRETRY DESELECT: [0,5] */
-#define RFAL_ISODEP_RATS_RETRIES \
-    (1U) /*!< RATS retries upon fail              Digital 2.0 B7 - nRETRY RATS [0,1]      */
-
-/*! Frame Size for Proximity Card Integer definitions                                                               */
-typedef enum {
-    RFAL_ISODEP_FSXI_16 =
-        0, /*!< Frame Size for Proximity Card Integer with 16 bytes                         */
-    RFAL_ISODEP_FSXI_24 =
-        1, /*!< Frame Size for Proximity Card Integer with 24 bytes                         */
-    RFAL_ISODEP_FSXI_32 =
-        2, /*!< Frame Size for Proximity Card Integer with 32 bytes                         */
-    RFAL_ISODEP_FSXI_40 =
-        3, /*!< Frame Size for Proximity Card Integer with 40 bytes                         */
-    RFAL_ISODEP_FSXI_48 =
-        4, /*!< Frame Size for Proximity Card Integer with 48 bytes                         */
-    RFAL_ISODEP_FSXI_64 =
-        5, /*!< Frame Size for Proximity Card Integer with 64 bytes                         */
-    RFAL_ISODEP_FSXI_96 =
-        6, /*!< Frame Size for Proximity Card Integer with 96 bytes                         */
-    RFAL_ISODEP_FSXI_128 =
-        7, /*!< Frame Size for Proximity Card Integer with 128 bytes                        */
-    RFAL_ISODEP_FSXI_256 =
-        8, /*!< Frame Size for Proximity Card Integer with 256 bytes                        */
-    RFAL_ISODEP_FSXI_512 =
-        9, /*!< Frame Size for Proximity Card Integer with 512 bytes   ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSXI_1024 =
-        10, /*!< Frame Size for Proximity Card Integer with 1024 bytes  ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSXI_2048 =
-        11, /*!< Frame Size for Proximity Card Integer with 2048 bytes  ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSXI_4096 =
-        12 /*!< Frame Size for Proximity Card Integer with 4096 bytes  ISO14443-3 Amd2 2012 */
-} rfalIsoDepFSxI;
-
-/*! Frame Size for Proximity Card  definitions                                                             */
-typedef enum {
-    RFAL_ISODEP_FSX_16 =
-        16, /*!< Frame Size for Proximity Card with 16 bytes                         */
-    RFAL_ISODEP_FSX_24 =
-        24, /*!< Frame Size for Proximity Card with 24 bytes                         */
-    RFAL_ISODEP_FSX_32 =
-        32, /*!< Frame Size for Proximity Card with 32 bytes                         */
-    RFAL_ISODEP_FSX_40 =
-        40, /*!< Frame Size for Proximity Card with 40 bytes                         */
-    RFAL_ISODEP_FSX_48 =
-        48, /*!< Frame Size for Proximity Card with 48 bytes                         */
-    RFAL_ISODEP_FSX_64 =
-        64, /*!< Frame Size for Proximity Card with 64 bytes                         */
-    RFAL_ISODEP_FSX_96 =
-        96, /*!< Frame Size for Proximity Card with 96 bytes                         */
-    RFAL_ISODEP_FSX_128 =
-        128, /*!< Frame Size for Proximity Card with 128 bytes                        */
-    RFAL_ISODEP_FSX_256 =
-        256, /*!< Frame Size for Proximity Card with 256 bytes                        */
-    RFAL_ISODEP_FSX_512 =
-        512, /*!< Frame Size for Proximity Card with 512 bytes   ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSX_1024 =
-        1024, /*!< Frame Size for Proximity Card with 1024 bytes  ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSX_2048 =
-        2048, /*!< Frame Size for Proximity Card with 2048 bytes  ISO14443-3 Amd2 2012 */
-    RFAL_ISODEP_FSX_4096 =
-        4096, /*!< Frame Size for Proximity Card with 4096 bytes  ISO14443-3 Amd2 2012 */
-} rfalIsoDepFSx;
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * GLOBAL DATA TYPES
- ******************************************************************************
- */
-
-/*! RATS format  Digital 1.1 13.6.1                                                               */
-typedef struct {
-    uint8_t CMD; /*!< RATS command byte: 0xE0                  */
-    uint8_t PARAM; /*!< Param indicating FSDI and DID            */
-} rfalIsoDepRats;
-
-/*! ATS response format  Digital 1.1 13.6.2                                                       */
-typedef struct {
-    uint8_t TL; /*!< Length Byte, including TL byte itself    */
-    uint8_t T0; /*!< Format Byte T0 indicating if TA, TB, TC  */
-    uint8_t TA; /*!< Interface Byte TA(1)                     */
-    uint8_t TB; /*!< Interface Byte TB(1)                     */
-    uint8_t TC; /*!< Interface Byte TC(1)                     */
-    uint8_t HB[RFAL_ISODEP_ATS_HB_MAX_LEN]; /*!< Historical Bytes                         */
-} rfalIsoDepAts;
-
-/*! PPS Request format (Protocol and Parameter Selection) ISO14443-4  5.3                         */
-typedef struct {
-    uint8_t PPSS; /*!< Start Byte: [ 1101b | CID[4b] ]          */
-    uint8_t PPS0; /*!< Parameter 0:[ 000b | PPS1[1n] | 0001b ]  */
-    uint8_t PPS1; /*!< Parameter 1:[ 0000b | DSI[2b] | DRI[2b] ]*/
-} rfalIsoDepPpsReq;
-
-/*! PPS Response format (Protocol and Parameter Selection) ISO14443-4  5.4                        */
-typedef struct {
-    uint8_t PPSS; /*!< Start Byte:  [ 1101b | CID[4b] ]         */
-} rfalIsoDepPpsRes;
-
-/*! ATTRIB Command Format  Digital 1.1  15.6.1 */
-typedef struct {
-    uint8_t cmd; /*!< ATTRIB_REQ command byte           */
-    uint8_t nfcid0[RFAL_NFCB_NFCID0_LEN]; /*!< NFCID0 of the card to be selected */
-    struct {
-        uint8_t PARAM1; /*!< PARAM1 of ATTRIB command          */
-        uint8_t PARAM2; /*!< PARAM2 of ATTRIB command          */
-        uint8_t PARAM3; /*!< PARAM3 of ATTRIB command          */
-        uint8_t PARAM4; /*!< PARAM4 of ATTRIB command          */
-    } Param; /*!< Parameter of ATTRIB command       */
-    uint8_t HLInfo[RFAL_ISODEP_ATTRIB_HLINFO_LEN]; /*!< Higher Layer Information          */
-} rfalIsoDepAttribCmd;
-
-/*! ATTRIB Response Format  Digital 1.1  15.6.2 */
-typedef struct {
-    uint8_t mbliDid; /*!< Contains MBLI and DID             */
-    uint8_t HLInfo[RFAL_ISODEP_ATTRIB_HLINFO_LEN]; /*!< Higher Layer Information          */
-} rfalIsoDepAttribRes;
-
-/*! S(Parameters) Command Format  ISO14443-4 (2016) Table 4 */
-typedef struct {
-    uint8_t tag; /*!< S(PARAMETERS) Tag field        */
-    uint8_t length; /*!< S(PARAMETERS) Length field     */
-    uint8_t value[RFAL_ISODEP_SPARAM_VALUES_MAX_LEN]; /*!< S(PARAMETERS) Value field      */
-} rfalIsoDepSParameter;
-
-/*! Activation info as Poller and Listener for NFC-A and NFC-B                                    */
-typedef union { /*  PRQA S 0750 # MISRA 19.2 - Both members of the union will not be used concurrently, device is only of type A or B at a time. Thus no problem can occur. */
-
-    /*! NFC-A information                                                                         */
-    union { /*  PRQA S 0750 # MISRA 19.2 - Both members of the union will not be used concurrently, device is only PCD or PICC at a time. Thus no problem can occur. */
-        struct {
-            rfalIsoDepAts ATS; /*!< ATS response            (Poller mode)    */
-            uint8_t ATSLen; /*!< ATS response length     (Poller mode)    */
-        } Listener;
-        struct {
-            rfalIsoDepRats RATS; /*!< RATS request          (Listener mode)    */
-        } Poller;
-    } A;
-
-    /*! NFC-B information                                                                         */
-    union { /*  PRQA S 0750 # MISRA 19.2 - Both members of the union will not be used concurrently, device is only PCD or PICC at a time. Thus no problem can occur. */
-        struct {
-            rfalIsoDepAttribRes ATTRIB_RES; /*!< ATTRIB_RES              (Poller mode)    */
-            uint8_t ATTRIB_RESLen; /*!< ATTRIB_RES length       (Poller mode)    */
-        } Listener;
-        struct {
-            rfalIsoDepAttribCmd ATTRIB; /*!< ATTRIB request        (Listener mode)    */
-            uint8_t ATTRIBLen; /*!< ATTRIB request length (Listener mode)    */
-        } Poller;
-    } B;
-} rfalIsoDepActivation;
-
-/*! ISO-DEP device Info */
-typedef struct {
-    uint8_t FWI; /*!< Frame Waiting Integer                                */
-    uint32_t FWT; /*!< Frame Waiting Time (1/fc)                            */
-    uint32_t dFWT; /*!< Delta Frame Waiting Time (1/fc)                      */
-    uint32_t SFGI; /*!< Start-up Frame Guard time Integer                    */
-    uint32_t SFGT; /*!< Start-up Frame Guard Time (ms)                       */
-    uint8_t FSxI; /*!< Frame Size Device/Card Integer (FSDI or FSCI)        */
-    uint16_t FSx; /*!< Frame Size Device/Card (FSD or FSC)                  */
-    uint32_t MBL; /*!< Maximum Buffer Length (optional for NFC-B)           */
-    rfalBitRate DSI; /*!< Bit Rate coding from Listener (PICC) to Poller (PCD) */
-    rfalBitRate DRI; /*!< Bit Rate coding from Poller (PCD) to Listener (PICC) */
-    uint8_t DID; /*!< Device ID                                            */
-    uint8_t NAD; /*!< Node ADdress                                         */
-    bool supDID; /*!< DID supported flag                                   */
-    bool supNAD; /*!< NAD supported flag                                   */
-    bool supAdFt; /*!< Advanced Features supported flag                     */
-} rfalIsoDepInfo;
-
-/*! ISO-DEP Device structure */
-typedef struct {
-    rfalIsoDepActivation activation; /*!< Activation Info                                      */
-    rfalIsoDepInfo info; /*!< ISO-DEP (ISO14443-4) device Info                     */
-} rfalIsoDepDevice;
-
-/*! ATTRIB Response parameters */
-typedef struct {
-    uint8_t mbli; /*!< MBLI                                     */
-    uint8_t HLInfo[RFAL_ISODEP_ATTRIB_HLINFO_LEN]; /*!< Hi Layer Information                     */
-    uint8_t HLInfoLen; /*!< Hi Layer Information Length              */
-} rfalIsoDepAttribResParam;
-
-/*! ATS Response parameter */
-typedef struct {
-    uint8_t fsci; /*!< Frame Size of Proximity Card Integer     */
-    uint8_t fwi; /*!< Frame Waiting Time Integer               */
-    uint8_t sfgi; /*!< Start-Up Frame Guard Time Integer        */
-    bool didSupport; /*!< DID Supported                            */
-    uint8_t ta; /*!< Max supported bitrate both direction     */
-    uint8_t* hb; /*!< Historical Bytes data                    */
-    uint8_t hbLen; /*!< Historical Bytes Length                  */
-} rfalIsoDepAtsParam;
-
-/*! Structure of I-Block Buffer format from caller */
-typedef struct {
-    uint8_t prologue[RFAL_ISODEP_PROLOGUE_SIZE]; /*!< Prologue/SoD buffer                      */
-    uint8_t
-        inf[RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN]; /*!< INF/Payload buffer                       */
-} rfalIsoDepBufFormat;
-
-/*! Structure of APDU Buffer format from caller */
-typedef struct {
-    uint8_t prologue[RFAL_ISODEP_PROLOGUE_SIZE]; /*!< Prologue/SoD buffer                      */
-    uint8_t apdu[RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN]; /*!< APDU/Payload buffer                      */
-} rfalIsoDepApduBufFormat;
-
-/*! Listen Activation Parameters Structure */
-typedef struct {
-    rfalIsoDepBufFormat* rxBuf; /*!< Receive Buffer struct reference          */
-    uint16_t* rxLen; /*!< Received INF data length in Bytes        */
-    bool* isRxChaining; /*!< Received data is not complete            */
-    rfalIsoDepDevice* isoDepDev; /*!< ISO-DEP device info                      */
-} rfalIsoDepListenActvParam;
-
-/*! Structure of parameters used on ISO DEP Transceive */
-typedef struct {
-    rfalIsoDepBufFormat* txBuf; /*!< Transmit Buffer struct reference         */
-    uint16_t txBufLen; /*!< Transmit Buffer INF field length in Bytes*/
-    bool isTxChaining; /*!< Transmit data is not complete            */
-    rfalIsoDepBufFormat* rxBuf; /*!< Receive Buffer struct reference in Bytes */
-    uint16_t* rxLen; /*!< Received INF data length in Bytes        */
-    bool* isRxChaining; /*!< Received data is not complete            */
-    uint32_t FWT; /*!< FWT to be used (ignored in Listen Mode)  */
-    uint32_t dFWT; /*!< Delta FWT to be used                     */
-    uint16_t ourFSx; /*!< Our device Frame Size (FSD or FSC)       */
-    uint16_t FSx; /*!< Other device Frame Size (FSD or FSC)     */
-    uint8_t DID; /*!< Device ID (RFAL_ISODEP_NO_DID if no DID) */
-} rfalIsoDepTxRxParam;
-
-/*! Structure of parameters used on ISO DEP APDU Transceive */
-typedef struct {
-    rfalIsoDepApduBufFormat* txBuf; /*!< Transmit Buffer struct reference         */
-    uint16_t txBufLen; /*!< Transmit Buffer INF field length in Bytes*/
-    rfalIsoDepApduBufFormat* rxBuf; /*!< Receive Buffer struct reference in Bytes */
-    uint16_t* rxLen; /*!< Received INF data length in Bytes        */
-    rfalIsoDepBufFormat* tmpBuf; /*!< Temp buffer for Rx I-Blocks (internal)   */
-    uint32_t FWT; /*!< FWT to be used (ignored in Listen Mode)  */
-    uint32_t dFWT; /*!< Delta FWT to be used                     */
-    uint16_t FSx; /*!< Other device Frame Size (FSD or FSC)     */
-    uint16_t ourFSx; /*!< Our device Frame Size (FSD or FSC)       */
-    uint8_t DID; /*!< Device ID (RFAL_ISODEP_NO_DID if no DID) */
-} rfalIsoDepApduTxRxParam;
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTION PROTOTYPES
- ******************************************************************************
- */
-
-/*!
- ******************************************************************************
- * \brief Initialize the ISO-DEP protocol 
- * 
- * Initialize the ISO-DEP protocol layer with default config
- ******************************************************************************
- */
-void rfalIsoDepInitialize(void);
-
-/*!
- ******************************************************************************
- * \brief Initialize the ISO-DEP protocol 
- * 
- * Initialize the ISO-DEP protocol layer with additional parameters allowing
- * to customise the protocol layer for specific behaviours
- * 
-
- *  \param[in] compMode        : Compliance mode to be performed
- *  \param[in] maxRetriesR     : Number of retries for a R-Block
- *                                Digital 2.0 B9 - nRETRY ACK/NAK: [2,5]
- *  \param[in] maxRetriesSnWTX : Number of retries for a S(WTX) (only in case
- *                               of NAKs)   Digital 2.0 B9 - nRETRY WTX[2,5]    
- *  \param[in] maxRetriesSWTX  : Number of overall S(WTX) retries. 
- *                                Use RFAL_ISODEP_MAX_WTX_RETRYS_ULTD for disabling 
- *                                this limit check   Digital 2.0  16.2.5.2
- *  \param[in] maxRetriesSDSL  : Number of retries for a S(DESELECT)
- *                                Digital 2.0 B9 - nRETRY DESELECT: [0,5]
- *  \param[in] maxRetriesI     : Number of retries for a I-Block 
- *                                Digital 2.0  16.2.5.4
- *  \param[in] maxRetriesRATS  : Number of retries for RATS 
- *                                Digital 2.0 B7 - nRETRY RATS [0,1]
- *    
- ******************************************************************************
- */
-void rfalIsoDepInitializeWithParams(
-    rfalComplianceMode compMode,
-    uint8_t maxRetriesR,
-    uint8_t maxRetriesSnWTX,
-    uint8_t maxRetriesSWTX,
-    uint8_t maxRetriesSDSL,
-    uint8_t maxRetriesI,
-    uint8_t maxRetriesRATS);
-
-/*!
- *****************************************************************************
- *  \brief  FSxI to FSx
- *
- *  Convert Frame Size for proximity coupling Device Integer (FSxI) to 
- *  Frame Size for proximity coupling Device (FSx)
- *  
- *  FSD - maximum frame size for NFC Forum Device in Poll Mode
- *  FSC - maximum frame size for NFC Forum Device in Listen Mode
- *  
- *  FSxI = FSDI or FSCI
- *  FSx  = FSD or FSC
- *  
- *  The FSD/FSC value includes the header and CRC
- *
- *  \param[in] FSxI :  Frame Size for proximity coupling Device Integer
- *  
- *  \return fsx : Frame Size for proximity coupling Device (FSD or FSC)
- *
- *****************************************************************************
- */
-uint16_t rfalIsoDepFSxI2FSx(uint8_t FSxI);
-
-/*! 
- *****************************************************************************
- *  \brief  FWI to FWT
- *
- *  Convert Frame Waiting time Integer (FWI) to Frame Waiting Time (FWT) in
- *  1/fc units
- *
- *  \param[in] fwi : Frame Waiting time Integer
- *  
- *  \return fwt : Frame Waiting Time in 1/fc units
- *
- *****************************************************************************
- */
-uint32_t rfalIsoDepFWI2FWT(uint8_t fwi);
-
-/*! 
- *****************************************************************************
- *  \brief  Check if the buffer data contains a valid RATS command
- *
- *  Check if it is a  well formed RATS command with 2 bytes
- *  This function does not check the validity of FSDI and DID
- *
- *  \param[in] buf    : reference to buffer containing the data to be checked
- *  \param[in] bufLen : length of data in the buffer in bytes
- *
- *  \return true if the data indicates a RATS command; false otherwise
- *****************************************************************************
- */
-bool rfalIsoDepIsRats(const uint8_t* buf, uint8_t bufLen);
-
-/*! 
- *****************************************************************************
- *  \brief  Check if the buffer data contains a valid ATTRIB command
- *
- *  Check if it is a well formed ATTRIB command, but does not check the 
- *  validity of the information inside
- *
- *  \param[in] buf    : reference to buffer containing the data to be checked
- *  \param[in] bufLen : length of data in the buffer in bytes
- *
- *  \return true if the data indicates a ATTRIB command; false otherwise
- *****************************************************************************
- */
-bool rfalIsoDepIsAttrib(const uint8_t* buf, uint8_t bufLen);
-
-/*!
- *****************************************************************************
- * \brief Start Listen Activation Handling
- * 
- * Start Listen Activation Handling and setup to receive first I-block which may
- * contain complete or partial APDU after activation is completed 
- * 
- *  Pass in RATS for T4AT, or ATTRIB for T4BT, to handle ATS or ATTRIB Response respectively
- *  The Activation Handling handles ATS and ATTRIB Response; and additionally PPS Response 
- *  if a PPS is received for T4AT.
- *  The method uses the current RFAL state machine to determine if it is expecting RATS or ATTRIB
- * 
- *  Activation is completed if PPS Response is sent or if first PDU is received in T4T-A
- *  Activation is completed if ATTRIB Response is sent in T4T-B
- *  
- *  \ref rfalIsoDepListenGetActivationStatus provide status if activation is completed. 
- *  \ref rfalIsoDepStartTransceive shall be called right after activation is completed
- * 
- *  \param[in] atsParam       : reference to ATS parameters
- *  \param[in] attribResParam : reference to ATTRIB_RES parameters
- *  \param[in] buf            : reference to buffer containing RATS or ATTRIB
- *  \param[in] bufLen         : length in bytes of the given buffer
- *  \param[in] actParam       : reference to incoming reception information will be placed
- *  
- *  
- *  \warning Once the Activation has been completed the method 
- *  rfalIsoDepGetTransceiveStatus() must be called.
- *  If activation has completed due to reception of a data block (not PPS) the 
- *  buffer owned by the caller and passed on actParam must still contain this data.
- *  The first data will be processed (I-Block or S-DSL) by rfalIsoDepGetTransceiveStatus()
- *  inform the caller and then for the next transaction use rfalIsoDepStartTransceive()
- * 
- *  \return ERR_NONE    : RATS/ATTRIB is valid and activation has started
- *  \return ERR_PARAM   : Invalid parameters
- *  \return ERR_PROTO   : Invalid request
- *  \return ERR_NOTSUPP : Feature not supported
- *****************************************************************************
- */
-ReturnCode rfalIsoDepListenStartActivation(
-    rfalIsoDepAtsParam* atsParam,
-    const rfalIsoDepAttribResParam* attribResParam,
-    const uint8_t* buf,
-    uint16_t bufLen,
-    rfalIsoDepListenActvParam actParam);
-
-/*!
- *****************************************************************************
- *  \brief Get the current Activation Status
- * 
- *  \return ERR_NONE if Activation is already completed
- *  \return ERR_BUSY if Activation is ongoing
- *  \return ERR_LINK_LOSS if Remote Field is turned off
- *****************************************************************************
- */
-ReturnCode rfalIsoDepListenGetActivationStatus(void);
-
-/*!
- *****************************************************************************
- *  \brief Get the ISO-DEP Communication Information
- *  
- *  Gets the maximum INF length in bytes based on current Frame Size 
- *  for proximity coupling Device (FSD or FSC) excluding the header and CRC
- *
- *  \return maximum INF length in bytes
- *****************************************************************************
- */
-uint16_t rfalIsoDepGetMaxInfLen(void);
-
-/*!
- *****************************************************************************
- *  \brief ISO-DEP Start Transceive 
- *  
- *  This method triggers a ISO-DEP Transceive containing a complete or 
- *  partial APDU
- *  It transmits the given message and handles all protocol retransmitions,
- *  error handling and control messages
- *  
- *  The txBuf  contains a complete or partial APDU (INF) to be transmitted 
- *  The Prologue field will be manipulated by the Transceive
- *  
- *  If the buffer contains a partial APDU and is not the last block, 
- *  then isTxChaining must be set to true
- *  
- *  \param[in] param: reference parameters to be used for the Transceive
- *                     
- *  \return ERR_PARAM       : Bad request
- *  \return ERR_WRONG_STATE : The module is not in a proper state
- *  \return ERR_NONE        : The Transceive request has been started
- *****************************************************************************
- */
-ReturnCode rfalIsoDepStartTransceive(rfalIsoDepTxRxParam param);
-
-/*!
- *****************************************************************************
- *  \brief Get the Transceive status
- *  
- *  Returns the status of the ISO-DEP Transceive
- *  
- *  \warning  When the other device is performing chaining once a chained 
- *            block is received the error ERR_AGAIN is sent. At this point 
- *            caller must handle the received data immediately. 
- *            When ERR_AGAIN is returned an ACK has already been sent to 
- *            the other device and the next block might be incoming. 
- *            If rfalWorker() is called frequently it will place the next 
- *            block on the given buffer  
- *              
- *  
- *  \return ERR_NONE      : Transceive has been completed successfully
- *  \return ERR_BUSY      : Transceive is ongoing
- *  \return ERR_PROTO     : Protocol error occurred
- *  \return ERR_TIMEOUT   : Timeout error occurred
- *  \return ERR_SLEEP_REQ : Deselect has been received and responded
- *  \return ERR_NOMEM     : The received INF does not fit into the
- *                            receive buffer
- *  \return ERR_LINK_LOSS : Communication is lost because Reader/Writer 
- *                            has turned off its field
- *  \return ERR_AGAIN     : received one chaining block, continue to call
- *                            this method to retrieve the remaining blocks
- *****************************************************************************
- */
-ReturnCode rfalIsoDepGetTransceiveStatus(void);
-
-/*!
- *****************************************************************************
- *  \brief ISO-DEP Start APDU Transceive 
- *  
- *  This method triggers a ISO-DEP Transceive containing a complete APDU
- *  It transmits the given message and handles all protocol retransmitions,
- *  error handling and control messages
- *  
- *  The txBuf  contains a complete APDU to be transmitted 
- *  The Prologue field will be manipulated by the Transceive
- *  
- *  \warning the txBuf will be modified during the transmission
- *  \warning the maximum RF frame which can be received is limited by param.tmpBuf
- *  
- *  \param[in] param: reference parameters to be used for the Transceive
- *                     
- *  \return ERR_PARAM       : Bad request
- *  \return ERR_WRONG_STATE : The module is not in a proper state
- *  \return ERR_NONE        : The Transceive request has been started
- *****************************************************************************
- */
-ReturnCode rfalIsoDepStartApduTransceive(rfalIsoDepApduTxRxParam param);
-
-/*!
- *****************************************************************************
- *  \brief Get the APDU Transceive status
- *  
- *  \return ERR_NONE      : if Transceive has been completed successfully
- *  \return ERR_BUSY      : if Transceive is ongoing
- *  \return ERR_PROTO     : if a protocol error occurred
- *  \return ERR_TIMEOUT   : if a timeout error occurred
- *  \return ERR_SLEEP_REQ : if Deselect is received and responded
- *  \return ERR_NOMEM     : if the received INF does not fit into the 
- *                            receive buffer
- *  \return ERR_LINK_LOSS : if communication is lost because Reader/Writer 
- *                            has turned off its field
- *****************************************************************************
- */
-ReturnCode rfalIsoDepGetApduTransceiveStatus(void);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Send RATS
- *   
- *  This sends a RATS to make a NFC-A Listen Device to enter 
- *  ISO-DEP layer (ISO14443-4) and checks if the received ATS is valid
- *   
- *  \param[in]  FSDI   : Frame Size Device Integer to be used
- *  \param[in]  DID    : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID  
- *  \param[out] ats    : pointer to place the ATS Response
- *  \param[out] atsLen : pointer to place the ATS length
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, ATS received
- *****************************************************************************
- */
-ReturnCode rfalIsoDepRATS(rfalIsoDepFSxI FSDI, uint8_t DID, rfalIsoDepAts* ats, uint8_t* atsLen);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Send PPS
- *   
- *  This sends a PPS to make a NFC-A Listen Device change the communications
- *  bit rate from 106kbps to one of the supported bit rates
- *  Additionally checks if the received PPS response is valid
- *   
- *  \param[in]  DID    : Device ID
- *  \param[in]  DSI    : DSI code the divisor from Listener (PICC) to Poller (PCD)
- *  \param[in]  DRI    : DRI code the divisor from Poller (PCD) to Listener (PICC)
- *  \param[out] ppsRes : pointer to place the PPS Response
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, PPS Response received
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPPS(uint8_t DID, rfalBitRate DSI, rfalBitRate DRI, rfalIsoDepPpsRes* ppsRes);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Send ATTRIB
- *   
- *  This sends a ATTRIB to make a NFC-B Listen Device to enter 
- *  ISO-DEP layer (ISO14443-4) and checks if the received ATTRIB Response is valid
- *   
- *  \param[in]  nfcid0    : NFCID0 to be used for the ATTRIB 
- *  \param[in]  PARAM1    : ATTRIB PARAM1 byte (communication parameters) 
- *  \param[in]  DSI       : DSI code the divisor from Listener (PICC) to Poller (PCD)
- *  \param[in]  DRI       : DRI code the divisor from Poller (PCD) to Listener (PICC)
- *  \param[in]  FSDI      : PCD's Frame Size to be announced on the ATTRIB
- *  \param[in]  PARAM3    : ATTRIB PARAM1 byte (protocol type)
- *  \param[in]  DID       : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID
- *  \param[in]  HLInfo    : pointer to Higher layer INF (NULL if none)
- *  \param[in]  HLInfoLen : Length HLInfo
- *  \param[in]  fwt       : Frame Waiting Time to be used (from SENSB_RES)
- *  \param[out] attribRes    : pointer to place the ATTRIB Response
- *  \param[out] attribResLen : pointer to place the ATTRIB Response length
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, ATTRIB Response received
- *****************************************************************************
- */
-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);
-
-/*! 
- *****************************************************************************
- *  \brief  Deselects PICC
- *
- *  This function sends a deselect command to PICC and waits for it`s
- *  response in a blocking way
- *
- *  \return ERR_NONE   : Deselect successfully sent and acknowledged by PICC 
- *  \return ERR_TIMEOUT: No response rcvd from PICC 
- *
- *****************************************************************************
- */
-ReturnCode rfalIsoDepDeselect(void);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Poller Handle NFC-A Activation
- *   
- *  This performs a NFC-A Activation into ISO-DEP layer (ISO14443-4) with the given
- *  parameters. It sends RATS and if the higher bit rates are supported by 
- *  both devices it additionally sends PPS
- *  Once Activated all details of the device are provided on isoDepDev
- *   
- *  \param[in]  FSDI      : Frame Size Device Integer to be used
- *  \param[in]  DID       : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID
- *  \param[in]  maxBR     : Max bit rate supported by the Poller
- *  \param[out] isoDepDev : ISO-DEP information of the activated Listen device
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollAHandleActivation(
-    rfalIsoDepFSxI FSDI,
-    uint8_t DID,
-    rfalBitRate maxBR,
-    rfalIsoDepDevice* isoDepDev);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Poller Handle NFC-B Activation
- *   
- *  This performs a NFC-B Activation into ISO-DEP layer (ISO14443-4) with the given
- *  parameters. It sends ATTRIB and calculates supported higher bit rates of both 
- *  devices and performs activation.
- *  Once Activated all details of the device are provided on isoDepDev
- *   
- *  \param[in]  FSDI         : Frame Size Device Integer to be used
- *  \param[in]  DID          : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID
- *  \param[in]  maxBR        : Max bit rate supported by the Poller
- *  \param[in]  PARAM1       : ATTRIB PARAM1 byte (communication parameters)
- *  \param[in]  nfcbDev      : pointer to the NFC-B Device containing the SENSB_RES
- *  \param[in]  HLInfo       : pointer to Higher layer INF (NULL if none)
- *  \param[in]  HLInfoLen    : Length HLInfo
- *  \param[out] isoDepDev    : ISO-DEP information of the activated Listen device
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollBHandleActivation(
-    rfalIsoDepFSxI FSDI,
-    uint8_t DID,
-    rfalBitRate maxBR,
-    uint8_t PARAM1,
-    const rfalNfcbListenDevice* nfcbDev,
-    const uint8_t* HLInfo,
-    uint8_t HLInfoLen,
-    rfalIsoDepDevice* isoDepDev);
-
-/*! 
- *****************************************************************************
- *  \brief  ISO-DEP Poller Handle S(Parameters)
- *   
- *  This checks if PICC supports S(PARAMETERS), retrieves PICC's
- *  capabilities and sets the Bit Rate at the highest supported by both
- *  devices
- *   
- *  \param[out] isoDepDev    : ISO-DEP information of the activated Listen device
- *  \param[in]  maxTxBR      : Maximum Tx bit rate supported by PCD
- *  \param[in]  maxRxBR      : Maximum Rx bit rate supported by PCD
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, S(PARAMETERS) selection successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollHandleSParameters(
-    rfalIsoDepDevice* isoDepDev,
-    rfalBitRate maxTxBR,
-    rfalBitRate maxRxBR);
-
-/*!
- *****************************************************************************
- *  \brief  ISO-DEP Poller Start NFC-A Activation 
- *
- *  This starts a NFC-A Activation into ISO-DEP layer (ISO14443-4) with the given
- *  parameters. It sends RATS and if the higher bit rates are supported by
- *  both devices it additionally sends PPS
- *  Once Activated all details of the device are provided on isoDepDev
- *
- *
- *  \see rfalIsoDepPollAGetActivationStatus
- *
- *  \param[in]  FSDI      : Frame Size Device Integer to be used
- *  \param[in]  DID       : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID
- *  \param[in]  maxBR     : Max bit rate supported by the Poller
- *  \param[out] isoDepDev : ISO-DEP information of the activated Listen device
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, start of asynchronous operation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollAStartActivation(
-    rfalIsoDepFSxI FSDI,
-    uint8_t DID,
-    rfalBitRate maxBR,
-    rfalIsoDepDevice* isoDepDev);
-
-/*!
- *****************************************************************************
- *  \brief  ISO-DEP Poller Get NFC-A Activation Status
- *
- *  Returns the activation status started by rfalIsoDepPollAStartActivation
- *
- *  \see rfalIsoDepPollAStartActivation
- *
- *  \return ERR_BUSY         : Operation is ongoing
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollAGetActivationStatus(void);
-
-/*!
- *****************************************************************************
- *  \brief  ISO-DEP Poller Start NFC-B Activation 
- *
- *  This starts a NFC-B Activation into ISO-DEP layer (ISO14443-4) with the given
- *  parameters. It will send ATTRIB and calculate supported higher bit rates of both 
- *  devices and perform activation.
- *  Once Activated all details of the device are provided on isoDepDev
- *
- *  \see rfalIsoDepPollBGetActivationStatus
- *
- *  \param[in]  FSDI         : Frame Size Device Integer to be used
- *  \param[in]  DID          : Device ID to be used or RFAL_ISODEP_NO_DID for not use DID
- *  \param[in]  maxBR        : Max bit rate supported by the Poller
- *  \param[in]  PARAM1       : ATTRIB PARAM1 byte (communication parameters)
- *  \param[in]  nfcbDev      : pointer to the NFC-B Device containing the SENSB_RES
- *  \param[in]  HLInfo       : pointer to Higher layer INF (NULL if none)
- *  \param[in]  HLInfoLen    : Length HLInfo
- *  \param[out] isoDepDev    : ISO-DEP information of the activated Listen device
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, start of asynchronous operation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollBStartActivation(
-    rfalIsoDepFSxI FSDI,
-    uint8_t DID,
-    rfalBitRate maxBR,
-    uint8_t PARAM1,
-    const rfalNfcbListenDevice* nfcbDev,
-    const uint8_t* HLInfo,
-    uint8_t HLInfoLen,
-    rfalIsoDepDevice* isoDepDev);
-
-/*!
- *****************************************************************************
- *  \brief  ISO-DEP Poller Get NFC-B Activation Status
- *
- *  Returns the activation status started by rfalIsoDepPollBStartActivation
- *
- *  \see rfalIsoDepPollBStartActivation
- *
- *  \return ERR_BUSY         : Operation is ongoing
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalIsoDepPollBGetActivationStatus(void);
-
-#endif /* RFAL_ISODEP_H_ */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfc.h

@@ -1,425 +0,0 @@
-
-/******************************************************************************
-  * \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_nfc.h
- *
- *  \brief RFAL NFC device
- *  
- *  This module provides the required features to behave as an NFC Poller 
- *  or Listener device. It grants an easy to use interface for the following
- *  activities: Technology Detection, Collision Resolution, Activation,
- *  Data Exchange, and Deactivation
- *  
- *  This layer is influenced by (but not fully aligned with) the NFC Forum 
- *  specifications, in particular: Activity 2.0 and NCI 2.0
- *
- *  
- *    
- * \addtogroup RFAL
- * @{
- * 
- * \addtogroup RFAL-HL
- * \brief RFAL Higher Layer
- * @{
- * 
- * \addtogroup NFC
- * \brief RFAL NFC Device
- * @{
- *  
- */
-
-#ifndef RFAL_NFC_H
-#define RFAL_NFC_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-#include "rfal_nfca.h"
-#include "rfal_nfcb.h"
-#include "rfal_nfcf.h"
-#include "rfal_nfcv.h"
-#include "rfal_st25tb.h"
-#include "rfal_nfcDep.h"
-#include "rfal_isoDep.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-#define RFAL_NFC_TECH_NONE 0x0000U /*!< No technology             */
-#define RFAL_NFC_POLL_TECH_A 0x0001U /*!< NFC-A technology Flag     */
-#define RFAL_NFC_POLL_TECH_B 0x0002U /*!< NFC-B technology Flag     */
-#define RFAL_NFC_POLL_TECH_F 0x0004U /*!< NFC-F technology Flag     */
-#define RFAL_NFC_POLL_TECH_V 0x0008U /*!< NFC-V technology Flag     */
-#define RFAL_NFC_POLL_TECH_AP2P 0x0010U /*!< AP2P technology Flag      */
-#define RFAL_NFC_POLL_TECH_ST25TB 0x0020U /*!< ST25TB technology Flag    */
-#define RFAL_NFC_LISTEN_TECH_A 0x1000U /*!< NFC-V technology Flag     */
-#define RFAL_NFC_LISTEN_TECH_B 0x2000U /*!< NFC-V technology Flag     */
-#define RFAL_NFC_LISTEN_TECH_F 0x4000U /*!< NFC-V technology Flag     */
-#define RFAL_NFC_LISTEN_TECH_AP2P 0x8000U /*!< NFC-V technology Flag     */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*! Checks if a device is currently activated */
-#define rfalNfcIsDevActivated(st) \
-    (((st) >= RFAL_NFC_STATE_ACTIVATED) && ((st) < RFAL_NFC_STATE_DEACTIVATION))
-
-/*! Checks if a device is in discovery */
-#define rfalNfcIsInDiscovery(st) \
-    (((st) >= RFAL_NFC_STATE_START_DISCOVERY) && ((st) < RFAL_NFC_STATE_ACTIVATED))
-
-/*! Checks if remote device is in Poll mode */
-#define rfalNfcIsRemDevPoller(tp) \
-    (((tp) >= RFAL_NFC_POLL_TYPE_NFCA) && ((tp) <= RFAL_NFC_POLL_TYPE_AP2P))
-
-/*! Checks if remote device is in Listen mode */
-#define rfalNfcIsRemDevListener(tp) \
-    (((int16_t)(tp) >= (int16_t)RFAL_NFC_LISTEN_TYPE_NFCA) && ((tp) <= RFAL_NFC_LISTEN_TYPE_AP2P))
-
-/*
-******************************************************************************
-* GLOBAL ENUMS
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! Main state                                                                       */
-typedef enum {
-    RFAL_NFC_STATE_NOTINIT = 0, /*!< Not Initialized state       */
-    RFAL_NFC_STATE_IDLE = 1, /*!< Initialize state            */
-    RFAL_NFC_STATE_START_DISCOVERY = 2, /*!< Start Discovery loop state  */
-    RFAL_NFC_STATE_WAKEUP_MODE = 3, /*!< Wake-Up state               */
-    RFAL_NFC_STATE_POLL_TECHDETECT = 10, /*!< Technology Detection state  */
-    RFAL_NFC_STATE_POLL_COLAVOIDANCE = 11, /*!< Collision Avoidance state   */
-    RFAL_NFC_STATE_POLL_SELECT = 12, /*!< Wait for Selection state    */
-    RFAL_NFC_STATE_POLL_ACTIVATION = 13, /*!< Activation state            */
-    RFAL_NFC_STATE_LISTEN_TECHDETECT = 20, /*!< Listen Tech Detect          */
-    RFAL_NFC_STATE_LISTEN_COLAVOIDANCE = 21, /*!< Listen Collision Avoidance  */
-    RFAL_NFC_STATE_LISTEN_ACTIVATION = 22, /*!< Listen Activation state     */
-    RFAL_NFC_STATE_LISTEN_SLEEP = 23, /*!< Listen Sleep state          */
-    RFAL_NFC_STATE_ACTIVATED = 30, /*!< Activated state             */
-    RFAL_NFC_STATE_DATAEXCHANGE = 31, /*!< Data Exchange Start state   */
-    RFAL_NFC_STATE_DATAEXCHANGE_DONE = 33, /*!< Data Exchange terminated    */
-    RFAL_NFC_STATE_DEACTIVATION = 34 /*!< Deactivation state          */
-} rfalNfcState;
-
-/*! Device type                                                                       */
-typedef enum {
-    RFAL_NFC_LISTEN_TYPE_NFCA = 0, /*!< NFC-A Listener device type  */
-    RFAL_NFC_LISTEN_TYPE_NFCB = 1, /*!< NFC-B Listener device type  */
-    RFAL_NFC_LISTEN_TYPE_NFCF = 2, /*!< NFC-F Listener device type  */
-    RFAL_NFC_LISTEN_TYPE_NFCV = 3, /*!< NFC-V Listener device type  */
-    RFAL_NFC_LISTEN_TYPE_ST25TB = 4, /*!< ST25TB Listener device type */
-    RFAL_NFC_LISTEN_TYPE_AP2P = 5, /*!< AP2P Listener device type   */
-    RFAL_NFC_POLL_TYPE_NFCA = 10, /*!< NFC-A Poller device type    */
-    RFAL_NFC_POLL_TYPE_NFCB = 11, /*!< NFC-B Poller device type    */
-    RFAL_NFC_POLL_TYPE_NFCF = 12, /*!< NFC-F Poller device type    */
-    RFAL_NFC_POLL_TYPE_NFCV = 13, /*!< NFC-V Poller device type    */
-    RFAL_NFC_POLL_TYPE_AP2P = 15 /*!< AP2P Poller device type     */
-} rfalNfcDevType;
-
-/*! Device interface                                                                 */
-typedef enum {
-    RFAL_NFC_INTERFACE_RF = 0, /*!< RF Frame interface          */
-    RFAL_NFC_INTERFACE_ISODEP = 1, /*!< ISO-DEP interface           */
-    RFAL_NFC_INTERFACE_NFCDEP = 2 /*!< NFC-DEP interface           */
-} rfalNfcRfInterface;
-
-/*! Device struct containing all its details                                          */
-typedef struct {
-    rfalNfcDevType type; /*!< Device's type                */
-    union { /*  PRQA S 0750 # MISRA 19.2 - Members of the union will not be used concurrently, only one technology at a time */
-        rfalNfcaListenDevice nfca; /*!< NFC-A Listen Device instance */
-        rfalNfcbListenDevice nfcb; /*!< NFC-B Listen Device instance */
-        rfalNfcfListenDevice nfcf; /*!< NFC-F Listen Device instance */
-        rfalNfcvListenDevice nfcv; /*!< NFC-V Listen Device instance */
-        rfalSt25tbListenDevice st25tb; /*!< ST25TB Listen Device instance*/
-    } dev; /*!< Device's instance            */
-
-    uint8_t* nfcid; /*!< Device's NFCID               */
-    uint8_t nfcidLen; /*!< Device's NFCID length        */
-    rfalNfcRfInterface rfInterface; /*!< Device's interface           */
-
-    union { /*  PRQA S 0750 # MISRA 19.2 - Members of the union will not be used concurrently, only one protocol at a time */
-        rfalIsoDepDevice isoDep; /*!< ISO-DEP instance             */
-        rfalNfcDepDevice nfcDep; /*!< NFC-DEP instance             */
-    } proto; /*!< Device's protocol            */
-} rfalNfcDevice;
-
-/*! Discovery parameters                                                                                           */
-typedef struct {
-    rfalComplianceMode compMode; /*!< Compliance mode to be used                            */
-    uint16_t techs2Find; /*!< Technologies to search for                            */
-    uint16_t totalDuration; /*!< Duration of a whole Poll + Listen cycle               */
-    uint8_t devLimit; /*!< Max number of devices                                 */
-    rfalBitRate maxBR; /*!< Max Bit rate to be used for communications            */
-
-    rfalBitRate nfcfBR; /*!< Bit rate to poll for NFC-F                            */
-    uint8_t
-        nfcid3[RFAL_NFCDEP_NFCID3_LEN]; /*!< NFCID3 to be used on the ATR_REQ/ATR_RES              */
-    uint8_t GB[RFAL_NFCDEP_GB_MAX_LEN]; /*!< General bytes to be used on the ATR-REQ               */
-    uint8_t GBLen; /*!< Length of the General Bytes                           */
-    rfalBitRate ap2pBR; /*!< Bit rate to poll for AP2P                             */
-
-    rfalLmConfPA lmConfigPA; /*!< Configuration for Passive Listen mode NFC-A           */
-    rfalLmConfPF lmConfigPF; /*!< Configuration for Passive Listen mode NFC-A           */
-
-    void (*notifyCb)(rfalNfcState st); /*!< Callback to Notify upper layer                        */
-
-    bool wakeupEnabled; /*!< Enable Wake-Up mode before polling                    */
-    bool wakeupConfigDefault; /*!< Wake-Up mode default configuration                    */
-    rfalWakeUpConfig wakeupConfig; /*!< Wake-Up mode configuration                            */
-
-    bool activate_after_sak; // Set device to Active mode after SAK response
-} rfalNfcDiscoverParam;
-
-/*! Buffer union, only one interface is used at a time                                                             */
-typedef union { /*  PRQA S 0750 # MISRA 19.2 - Members of the union will not be used concurrently, only one interface at a time */
-    uint8_t rfBuf[RFAL_FEATURE_NFC_RF_BUF_LEN]; /*!< RF buffer                                    */
-    rfalIsoDepApduBufFormat isoDepBuf; /*!< ISO-DEP buffer format (with header/prologue) */
-    rfalNfcDepPduBufFormat nfcDepBuf; /*!< NFC-DEP buffer format (with header/prologue) */
-} rfalNfcBuffer;
-
-/*******************************************************************************/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  RFAL NFC Worker
- *  
- * It runs the internal state machine and runs the RFAL RF worker.
- *****************************************************************************
- */
-void rfalNfcWorker(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL NFC Initialize
- *  
- * It initializes this module and its dependencies
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcInitialize(void);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Discovery
- *  
- * It set the device in Discovery state.
- * In discovery it will Poll and/or Listen for the technologies configured, 
- * and perform Wake-up mode if configured to do so.
- *
- * The device list passed on disParams must not be empty.
- * The number of devices on the list is indicated by the devLimit and shall
- * be at >= 1.
- *
- * \param[in]  disParams    : discovery configuration parameters
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcDiscover(const rfalNfcDiscoverParam* disParams);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Get State
- *  
- * It returns the current state
- *
- * \return rfalNfcState : the current state
- *****************************************************************************
- */
-rfalNfcState rfalNfcGetState(void);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Get Devices Found
- *  
- * It returns the location of the device list and the number of 
- * devices found.
- *
- * \param[out]  devList     : device list location
- * \param[out]  devCnt      : number of devices found
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- *                            Discovery still ongoing
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcGetDevicesFound(rfalNfcDevice** devList, uint8_t* devCnt);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Get Active Device
- *  
- * It returns the location of the device current Active device
- *
- * \param[out]  dev           : device info location
- *
- * \return ERR_WRONG_STATE    : Incorrect state for this operation
- *                              No device activated
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcGetActiveDevice(rfalNfcDevice** dev);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Select Device
- *  
- * It selects the device to be activated.
- * It shall be called when more than one device has been identified to 
- * indiacte which device shall be active
- * 
- * \param[in]  devIdx       : device index to be activated
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- *                            Not in select state
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcSelect(uint8_t devIdx);
-
-/*!
- *****************************************************************************
- * \brief  RFAL NFC Start Data Exchange
- *  
- * After a device has been activated, it starts a data exchange.
- * It handles automatically which interface/protocol to be used and acts accordingly.
- *
- * In Listen mode the first frame/data shall be sent by the Reader/Initiator
- * therefore this method must be called first with txDataLen set to zero 
- * to retrieve the rxData and rcvLen locations.
- *
- *
- * \param[in]  txData       : data to be transmitted
- * \param[in]  txDataLen    : size of the data to be transmitted
- * \param[out] rxData       : location of the received data after operation is completed
- * \param[out] rvdLen       : location of thelength of the received data
- * \param[in]  fwt          : FWT to be used in case of RF interface.
- *                            If ISO-DEP or NFC-DEP interface is used, this will be ignored
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcDataExchangeStart(
-    uint8_t* txData,
-    uint16_t txDataLen,
-    uint8_t** rxData,
-    uint16_t** rvdLen,
-    uint32_t fwt,
-    uint32_t tx_flag);
-
-ReturnCode rfalNfcDataExchangeCustomStart(
-    uint8_t* txData,
-    uint16_t txDataLen,
-    uint8_t** rxData,
-    uint16_t** rvdLen,
-    uint32_t fwt,
-    uint32_t flags);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL NFC Get Data Exchange Status
- *  
- * Gets current Data Exchange status
- *
- * \return  ERR_NONE         : Transceive done with no error
- * \return  ERR_BUSY         : Transceive ongoing
- *  \return ERR_AGAIN        : received one chaining block, copy received data 
- *                             and continue to call this method to retrieve the 
- *                             remaining blocks
- * \return  ERR_XXXX         : Error occurred
- * \return  ERR_TIMEOUT      : No response
- * \return  ERR_FRAMING      : Framing error detected
- * \return  ERR_PAR          : Parity error detected
- * \return  ERR_CRC          : CRC error detected
- * \return  ERR_LINK_LOSS    : Link Loss - External Field is Off
- * \return  ERR_RF_COLLISION : Collision detected
- * \return  ERR_IO           : Internal error
- *****************************************************************************
- */
-ReturnCode rfalNfcDataExchangeGetStatus(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL NFC Deactivate
- *  
- * It triggers the deactivation procedure to terminate communications with 
- * remote device. At the end the field will be turned off.
- *
- * \param[in]  discovery    : TRUE if after deactivation go back into discovery
- *                          : FALSE if after deactivation remain in idle
- *
- * \return ERR_WRONG_STATE  : Incorrect state for this operation
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcDeactivate(bool discovery);
-
-#endif /* RFAL_NFC_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfcDep.h

@@ -1,831 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcDep.h
- *
- *  \author  Gustavo Patricio
- *
- *  \brief Implementation of NFC-DEP protocol
- *  
- *  NFC-DEP is also known as NFCIP - Near Field Communication 
- *  Interface and Protocol
- *  
- *  This implementation was based on the following specs:
- *    - NFC Forum Digital 1.1
- *    - ECMA 340 3rd Edition 2013
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup NFC-DEP
- * \brief RFAL NFC-DEP Module
- * @{
- */
-
-#ifndef RFAL_NFCDEP_H_
-#define RFAL_NFCDEP_H_
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_NFC_DEP
-#define RFAL_FEATURE_NFC_DEP \
-    false /*!< NFC-DEP module configuration missing. Disabled by default */
-#endif
-
-/* If module is disabled remove the need for the user to set lengths */
-#if !RFAL_FEATURE_NFC_DEP
-#undef RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN
-#undef RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN
-
-#define RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN 1U /*!< NFC-DEP Block/Payload length, set to "none" */
-#define RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN 1U /*!< NFC-DEP PDU length, set to "none"           */
-#endif /* !RFAL_FEATURE_NFC_DEP  */
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-#define RFAL_NFCDEP_FRAME_SIZE_MAX_LEN \
-    254U /*!< Maximum Frame Size   Digital 2.0 Table 90                      */
-#define RFAL_NFCDEP_DEPREQ_HEADER_LEN \
-    5U /*!< DEP_REQ header length: CMD_TYPE + CMD_CMD + PBF + DID + NAD    */
-
-/*! Length NFCIP DEP REQ or RES header (incl LEN)                                                                           */
-#define RFAL_NFCDEP_DEP_HEADER \
-    (RFAL_NFCDEP_LEN_LEN + RFAL_NFCDEP_CMDTYPE_LEN + RFAL_NFCDEP_CMD_LEN + RFAL_NFCDEP_DEP_PFB_LEN)
-#define RFAL_NFCDEP_HEADER \
-    (RFAL_NFCDEP_CMDTYPE_LEN + RFAL_NFCDEP_CMD_LEN) /*!< NFCIP header length           */
-#define RFAL_NFCDEP_SB_LEN \
-    1U /*!< SB length on NFCIP fram for NFC-A                              */
-#define RFAL_NFCDEP_LEN_LEN \
-    1U /*!< LEN length on NFCIP frame                                      */
-#define RFAL_NFCDEP_CMDTYPE_LEN \
-    1U /*!< Length of the cmd type (REQ | RES) on NFCIP frame              */
-#define RFAL_NFCDEP_CMD_LEN \
-    1U /*!< Length of the cmd on NFCIP frame                               */
-#define RFAL_NFCDEP_DID_LEN \
-    1U /*!< Length of did on NFCIP frame                                   */
-#define RFAL_NFCDEP_DEP_PFB_LEN \
-    1U /*!< Length of the PFB field on NFCIP frame                         */
-
-#define RFAL_NFCDEP_DSL_RLS_LEN_NO_DID               \
-    (RFAL_NFCDEP_LEN_LEN + RFAL_NFCDEP_CMDTYPE_LEN + \
-     RFAL_NFCDEP_CMD_LEN) /*!< Length of DSL_REQ and RLS_REQ with no DID */
-#define RFAL_NFCDEP_DSL_RLS_LEN_DID   \
-    (RFAL_NFCDEP_DSL_RLS_LEN_NO_DID + \
-     RFAL_NFCDEP_DID_LEN) /*!< Length of DSL_REQ and RLS_REQ with DID    */
-
-#define RFAL_NFCDEP_FS_VAL_MIN \
-    64U /*!< Minimum LR value                                               */
-#define RFAL_NFCDEP_LR_VAL_MASK \
-    0x03U /*!< Bit mask for a LR value                                        */
-#define RFAL_NFCDEP_PP_LR_MASK \
-    0x30U /*!< Bit mask for LR value in PP byte on a ATR REQ/RES              */
-#define RFAL_NFCDEP_PP_LR_SHIFT \
-    4U /*!< Position of LR value in PP byte on a ATR REQ/RES               */
-
-#define RFAL_NFCDEP_DID_MAX \
-    14U /*!< Max DID value Digital 14.6.2.3                                 */
-#define RFAL_NFCDEP_DID_KEEP \
-    0xFFU /*!< Keep DID value already configured                              */
-#define RFAL_NFCDEP_DID_NO \
-    0x00U /*!< No DID shall be used                                           */
-#define RFAL_NFCDEP_NAD_NO \
-    0x00U /*!< No NAD shall be used                                           */
-
-#define RFAL_NFCDEP_OPER_RTOX_REQ_DIS \
-    0x01U /*!< Operation config: RTOX REQ disable                             */
-#define RFAL_NFCDEP_OPER_RTOX_REQ_EN \
-    0x00U /*!< Operation config: RTOX REQ enable                              */
-
-#define RFAL_NFCDEP_OPER_ATN_DIS \
-    0x00U /*!< Operation config: ATN disable                                  */
-#define RFAL_NFCDEP_OPER_ATN_EN \
-    0x02U /*!< Operation config: ATN enable                                   */
-
-#define RFAL_NFCDEP_OPER_EMPTY_DEP_DIS \
-    0x04U /*!< Operation config: empty DEPs disable                           */
-#define RFAL_NFCDEP_OPER_EMPTY_DEP_EN \
-    0x00U /*!< Operation config: empty DEPs enable                            */
-
-#define RFAL_NFCDEP_OPER_FULL_MI_DIS \
-    0x00U /*!< Operation config: full chaining DEPs disable                   */
-#define RFAL_NFCDEP_OPER_FULL_MI_EN \
-    0x08U /*!< Operation config: full chaining DEPs enable                    */
-
-#define RFAL_NFCDEP_BRS_MAINTAIN \
-    0xC0U /*!< Value signalling that BR is to be maintained (no PSL)          */
-#define RFAL_NFCDEP_BRS_Dx_MASK \
-    0x07U /*!< Value signalling that BR is to be maintained (no PSL)          */
-#define RFAL_NFCDEP_BRS_DSI_POS \
-    3U /*!< Value signalling that BR is to be maintained (no PSL)          */
-
-#define RFAL_NFCDEP_WT_DELTA \
-    (16U - RFAL_NFCDEP_WT_DELTA_ADJUST) /*!< NFC-DEP dWRT (adjusted)  Digital 2.0 B.10  */
-#define RFAL_NFCDEP_WT_DELTA_ADJUST \
-    4U /*!< dWRT value adjustment                                          */
-
-#define RFAL_NFCDEP_ATR_REQ_NFCID3_POS \
-    2U /*!< NFCID3 offset in ATR_REQ frame                                 */
-#define RFAL_NFCDEP_NFCID3_LEN \
-    10U /*!< NFCID3 Length                                                  */
-
-#define RFAL_NFCDEP_LEN_MIN \
-    3U /*!< Minimum length byte LEN value                                  */
-#define RFAL_NFCDEP_LEN_MAX \
-    255U /*!< Maximum length byte LEN value                                  */
-
-#define RFAL_NFCDEP_ATRRES_HEADER_LEN \
-    2U /*!< ATR RES Header Len:  CmdType: 0xD5 + Cod: 0x01                 */
-#define RFAL_NFCDEP_ATRRES_MIN_LEN \
-    17U /*!< Minimum length for an ATR RES                                  */
-#define RFAL_NFCDEP_ATRRES_MAX_LEN \
-    64U /*!< Maximum length for an ATR RES  Digital 1.0 14.6.1              */
-#define RFAL_NFCDEP_ATRREQ_MIN_LEN \
-    16U /*!< Minimum length for an ATR REQ                                  */
-#define RFAL_NFCDEP_ATRREQ_MAX_LEN \
-    RFAL_NFCDEP_ATRRES_MAX_LEN /*!< Maximum length for an ATR REQ  Digital 1.0 14.6.1   */
-
-#define RFAL_NFCDEP_GB_MAX_LEN    \
-    (RFAL_NFCDEP_ATRREQ_MAX_LEN - \
-     RFAL_NFCDEP_ATRREQ_MIN_LEN) /*!< Maximum length the General Bytes on ATR  Digital 1.1  16.6.3 */
-
-#define RFAL_NFCDEP_WT_INI_DEFAULT \
-    RFAL_NFCDEP_WT_INI_MAX /*!< WT Initiator default value Digital 1.0 14.6.3.8        */
-#define RFAL_NFCDEP_WT_INI_MIN 0U /*!< WT Initiator minimum value Digital 1.0 14.6.3.8        */
-#define RFAL_NFCDEP_WT_INI_MAX 14U /*!< WT Initiator maximum value Digital 1.0 14.6.3.8 A.10   */
-#define RFAL_NFCDEP_RWT_INI_MAX \
-    rfalNfcDepWT2RWT(RFAL_NFCDEP_WT_INI_MAX) /*!< RWT Initiator maximum value   */
-
-#define RFAL_NFCDEP_WT_TRG_MAX_D10 8U /*!< WT target max Digital 1.0 14.6.3.8 A.10 */
-#define RFAL_NFCDEP_WT_TRG_MAX_D11 14U /*!< WT target max Digital 1.1 16.6.3.9 A.9  */
-#define RFAL_NFCDEP_WT_TRG_MAX_L13 10U /*!< WT target max [LLCP] 1.3 6.2.1          */
-#define RFAL_NFCDEP_WT_TRG_MAX \
-    RFAL_NFCDEP_WT_TRG_MAX_D11 /*!< WT target max Digital x.x | LLCP x.x    */
-#define RFAL_NFCDEP_RWT_TRG_MAX \
-    rfalNfcDepWT2RWT(RFAL_NFCDEP_WT_TRG_MAX) /*!< RWT Initiator maximum value         */
-
-/*! Maximum Frame Waiting Time = ((256 * 16/fc)*2^FWImax) = ((256*16/fc)*2^14) = (1048576 / 64)/fc = (100000h*64)/fc         */
-#define RFAL_NFCDEP_MAX_FWT ((uint32_t)1U << 20)
-
-#define RFAL_NFCDEP_WT_MASK \
-    0x0FU /*!< Bit mask for the Wait Time value                               */
-
-#define RFAL_NFCDEP_BR_MASK_106 \
-    0x01U /*!< Enable mask bit rate 106                                    */
-#define RFAL_NFCDEP_BR_MASK_212 \
-    0x02U /*!< Enable mask bit rate 242                                    */
-#define RFAL_NFCDEP_BR_MASK_424 \
-    0x04U /*!< Enable mask bit rate 424                                    */
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-#define rfalNfcDepWT2RWT(wt)                      \
-    ((uint32_t)1U                                 \
-     << (((uint32_t)(wt) & RFAL_NFCDEP_WT_MASK) + \
-         12U)) /*!< Converts WT value to RWT (1/fc)               */
-
-/*! Returns the BRS value from the given bit rate */
-#define rfalNfcDepDx2BRS(br)                                                  \
-    ((((uint8_t)(br) & RFAL_NFCDEP_BRS_Dx_MASK) << RFAL_NFCDEP_BRS_DSI_POS) | \
-     ((uint8_t)(br) & RFAL_NFCDEP_BRS_Dx_MASK))
-
-#define rfalNfcDepBRS2DRI(brs) \
-    (uint8_t)(                 \
-        (uint8_t)(brs) &       \
-        RFAL_NFCDEP_BRS_Dx_MASK) /*!< Returns the DRI value from the given BRS byte */
-#define rfalNfcDepBRS2DSI(brs)                        \
-    (uint8_t)(                                        \
-        ((uint8_t)(brs) >> RFAL_NFCDEP_BRS_DSI_POS) & \
-        RFAL_NFCDEP_BRS_Dx_MASK) /*!< Returns the DSI value from the given BRS byte */
-
-#define rfalNfcDepPP2LR(PPx)                      \
-    (((uint8_t)(PPx) & RFAL_NFCDEP_PP_LR_MASK) >> \
-     RFAL_NFCDEP_PP_LR_SHIFT) /*!< Returns the LR value from the given PPx byte  */
-#define rfalNfcDepLR2PP(LRx)                       \
-    (((uint8_t)(LRx) << RFAL_NFCDEP_PP_LR_SHIFT) & \
-     RFAL_NFCDEP_PP_LR_MASK) /*!< Returns the PP byte with the given LRx value  */
-
-/*! Returns the Frame size value from the given LRx value  */
-#define rfalNfcDepLR2FS(LRx) \
-    (uint16_t)(              \
-        MIN((RFAL_NFCDEP_FS_VAL_MIN * ((uint16_t)(LRx) + 1U)), RFAL_NFCDEP_FRAME_SIZE_MAX_LEN))
-
-/*! 
- *  Despite DIGITAL 1.0 14.6.2.1 stating that the last two bytes may filled with 
- *  any value, some devices (Samsung Google Nexus) only accept when these are 0 */
-#define rfalNfcDepSetNFCID(dst, src, len)           \
-    ST_MEMSET((dst), 0x00, RFAL_NFCDEP_NFCID3_LEN); \
-    if((len) > 0U) {                                \
-        ST_MEMCPY((dst), (src), (len));             \
-    }
-
-/*
- ******************************************************************************
- * GLOBAL ENUMERATIONS
- ******************************************************************************
- */
-
-/*! Enumeration of NFC-DEP bit rate in ATR    Digital 1.0 Table 93 and 94   */
-enum {
-    RFAL_NFCDEP_Bx_NO_HIGH_BR = 0x00, /*!< Peer supports no high bit rates      */
-    RFAL_NFCDEP_Bx_08_848 = 0x01, /*!< Peer also supports 848               */
-    RFAL_NFCDEP_Bx_16_1695 = 0x02, /*!< Peer also supports 1695              */
-    RFAL_NFCDEP_Bx_32_3390 = 0x04, /*!< Peer also supports 3390              */
-    RFAL_NFCDEP_Bx_64_6780 = 0x08 /*!< Peer also supports 6780              */
-};
-
-/*! Enumeration of NFC-DEP bit rate Divider in PSL   Digital 1.0 Table 100  */
-enum {
-    RFAL_NFCDEP_Dx_01_106 = RFAL_BR_106, /*!< Divisor D =  1 : bit rate = 106      */
-    RFAL_NFCDEP_Dx_02_212 = RFAL_BR_212, /*!< Divisor D =  2 : bit rate = 212      */
-    RFAL_NFCDEP_Dx_04_424 = RFAL_BR_424, /*!< Divisor D =  4 : bit rate = 424      */
-    RFAL_NFCDEP_Dx_08_848 = RFAL_BR_848, /*!< Divisor D =  8 : bit rate = 848      */
-    RFAL_NFCDEP_Dx_16_1695 = RFAL_BR_1695, /*!< Divisor D = 16 : bit rate = 1695     */
-    RFAL_NFCDEP_Dx_32_3390 = RFAL_BR_3390, /*!< Divisor D = 32 : bit rate = 3390     */
-    RFAL_NFCDEP_Dx_64_6780 = RFAL_BR_6780 /*!< Divisor D = 64 : bit rate = 6780     */
-};
-
-/*! Enumeration of  NFC-DEP Length Reduction (LR)   Digital 1.0 Table 91    */
-enum {
-    RFAL_NFCDEP_LR_64 = 0x00, /*!< Maximum payload size is  64 bytes    */
-    RFAL_NFCDEP_LR_128 = 0x01, /*!< Maximum payload size is 128 bytes    */
-    RFAL_NFCDEP_LR_192 = 0x02, /*!< Maximum payload size is 192 bytes    */
-    RFAL_NFCDEP_LR_254 = 0x03 /*!< Maximum payload size is 254 bytes    */
-};
-
-/*
- ******************************************************************************
- * GLOBAL DATA TYPES
- ******************************************************************************
- */
-
-/*! NFC-DEP callback to check if upper layer has deactivation pending   */
-typedef bool (*rfalNfcDepDeactCallback)(void);
-
-/*! Enumeration of the nfcip communication modes */
-typedef enum {
-    RFAL_NFCDEP_COMM_PASSIVE, /*!< Passive communication mode    */
-    RFAL_NFCDEP_COMM_ACTIVE /*!< Active communication mode     */
-} rfalNfcDepCommMode;
-
-/*! Enumeration of the nfcip roles */
-typedef enum {
-    RFAL_NFCDEP_ROLE_INITIATOR, /*!< Perform as Initiator          */
-    RFAL_NFCDEP_ROLE_TARGET /*!< Perform as Target             */
-} rfalNfcDepRole;
-
-/*! Struct that holds all NFCIP configs                                                      */
-typedef struct {
-    rfalNfcDepRole role; /*!< Current NFCIP role                                      */
-    rfalNfcDepCommMode commMode; /*!< Current NFCIP communication mode                        */
-    uint8_t oper; /*!< Operation config similar to NCI 1.0 Table 81            */
-
-    uint8_t did; /*!< Current Device ID (DID)                                 */
-    uint8_t nad; /*!< Current Node Addressing (NAD)                           */
-    uint8_t bs; /*!< Bit rate in Sending Direction                           */
-    uint8_t br; /*!< Bit rate in Receiving Direction                         */
-    uint8_t nfcid[RFAL_NFCDEP_NFCID3_LEN]; /*!< Pointer to the NFCID to be used    */
-    uint8_t nfcidLen; /*!< Length of the given NFCID in nfcid                      */
-    uint8_t gb[RFAL_NFCDEP_GB_MAX_LEN]; /*!< Pointer General Bytes (GB) to be used */
-    uint8_t gbLen; /*!< Length of the given GB in gb                            */
-    uint8_t lr; /*!< Length Reduction (LR) to be used                        */
-    uint8_t to; /*!< Timeout (TO)  to be used                                */
-    uint32_t fwt; /*!< Frame Waiting Time (FWT) to be used                     */
-    uint32_t dFwt; /*!< Delta Frame Waiting Time (dFWT) to be used              */
-} rfalNfcDepConfigs;
-
-/*! ATR_REQ command    Digital 1.1 16.6.2   */
-typedef struct {
-    uint8_t CMD1; /*!< Command format 0xD4                    */
-    uint8_t CMD2; /*!< Command Value                          */
-    uint8_t NFCID3[RFAL_NFCDEP_NFCID3_LEN]; /*!< NFCID3 value                           */
-    uint8_t DID; /*!< DID                                    */
-    uint8_t BSi; /*!< Sending Bitrate for Initiator          */
-    uint8_t BRi; /*!< Receiving Bitrate for Initiator        */
-    uint8_t PPi; /*!< Optional Parameters presence indicator */
-    uint8_t GBi[RFAL_NFCDEP_GB_MAX_LEN]; /*!< General Bytes                          */
-} rfalNfcDepAtrReq;
-
-/*! ATR_RES response    Digital 1.1 16.6.3  */
-typedef struct {
-    uint8_t CMD1; /*!< Response Byte 0xD5                     */
-    uint8_t CMD2; /*!< Command Value                          */
-    uint8_t NFCID3[RFAL_NFCDEP_NFCID3_LEN]; /*!< NFCID3 value                           */
-    uint8_t DID; /*!< DID                                    */
-    uint8_t BSt; /*!< Sending Bitrate for Initiator          */
-    uint8_t BRt; /*!< Receiving Bitrate for Initiator        */
-    uint8_t TO; /*!< Timeout                                */
-    uint8_t PPt; /*!< Optional Parameters presence indicator */
-    uint8_t GBt[RFAL_NFCDEP_GB_MAX_LEN]; /*!< General Bytes                          */
-} rfalNfcDepAtrRes;
-
-/*! Structure of transmit I-PDU Buffer format from caller                                    */
-typedef struct {
-    uint8_t prologue[RFAL_NFCDEP_DEPREQ_HEADER_LEN]; /*!< Prologue space for NFC-DEP header*/
-    uint8_t inf[RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN]; /*!< INF | Data area of the buffer    */
-} rfalNfcDepBufFormat;
-
-/*! Structure of APDU Buffer format from caller */
-typedef struct {
-    uint8_t prologue[RFAL_NFCDEP_DEPREQ_HEADER_LEN]; /*!< Prologue/SoD buffer                     */
-    uint8_t pdu[RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN]; /*!< Complete PDU/Payload buffer             */
-} rfalNfcDepPduBufFormat;
-
-/*! Activation info as Initiator and Target                                       */
-typedef union { /*  PRQA S 0750 # MISRA 19.2 - Both members of the union will not be used concurrently , device is only initiatior or target a time. No problem can occur. */
-    struct {
-        rfalNfcDepAtrRes ATR_RES; /*!< ATR RES            (Initiator mode)  */
-        uint8_t ATR_RESLen; /*!< ATR RES length     (Initiator mode)  */
-    } Target; /*!< Target                               */
-    struct {
-        rfalNfcDepAtrReq ATR_REQ; /*!< ATR REQ            (Target mode)     */
-        uint8_t ATR_REQLen; /*!< ATR REQ length     (Target mode)     */
-    } Initiator; /*!< Initiator                            */
-} rfalNfcDepActivation;
-
-/*! NFC-DEP device Info */
-typedef struct {
-    uint8_t GBLen; /*!< General Bytes length                       */
-    uint8_t WT; /*!< WT to be used (ignored in Listen Mode)     */
-    uint32_t FWT; /*!< FWT to be used (1/fc)(ignored Listen Mode) */
-    uint32_t dFWT; /*!< Delta FWT to be used (1/fc)                */
-    uint8_t LR; /*!< Length Reduction coding the max payload    */
-    uint16_t FS; /*!< Frame Size                                 */
-    rfalBitRate DSI; /*!< Bit Rate coding from Initiator  to Target  */
-    rfalBitRate DRI; /*!< Bit Rate coding from Target to Initiator   */
-    uint8_t DID; /*!< Device ID (RFAL_NFCDEP_DID_NO if no DID)   */
-    uint8_t NAD; /*!< Node ADdress (RFAL_NFCDEP_NAD_NO if no NAD)*/
-} rfalNfcDepInfo;
-
-/*! NFC-DEP Device structure */
-typedef struct {
-    rfalNfcDepActivation activation; /*!< Activation Info               */
-    rfalNfcDepInfo info; /*!< NFC-DEP device Info           */
-} rfalNfcDepDevice;
-
-/*! NFCIP Protocol structure for P2P Target
- *
- *   operParam : derives from NFC-Forum NCI NFC-DEP Operation Parameter
- *               NCI 1.1 Table 86: NFC-DEP Operation Parameter
- *               and it's a bit mask composed as:
- *                  [ 0000b 
- *                    | Chain SHALL use max. Transport Data Byte[1b] 
- *                    | I-PDU with no Transport Data SHALL NOT be sent [1b]
- *                    | NFC-DEP Target SHALL NOT send RTOX request [1b]
- *                  ]
- * 
- */
-typedef struct {
-    rfalNfcDepCommMode commMode; /*!< Initiator in Active P2P or Passive P2P*/
-    uint8_t operParam; /*!< NFC-DEP Operation Parameter           */
-    uint8_t* nfcid; /*!< Initiator's NFCID2 or NFCID3          */
-    uint8_t nfcidLen; /*!< Initiator's NFCID length (NFCID2/3)   */
-    uint8_t DID; /*!< Initiator's Device ID DID             */
-    uint8_t NAD; /*!< Initiator's Node ID NAD               */
-    uint8_t BS; /*!< Initiator's Bit Rates supported in Tx */
-    uint8_t BR; /*!< Initiator's Bit Rates supported in Rx */
-    uint8_t LR; /*!< Initiator's Length reduction          */
-    uint8_t* GB; /*!< Initiator's General Bytes (Gi)        */
-    uint8_t GBLen; /*!< Initiator's General Bytes length      */
-} rfalNfcDepAtrParam;
-
-/*! Structure of parameters to be passed in for nfcDepListenStartActivation       */
-typedef struct {
-    rfalNfcDepBufFormat* rxBuf; /*!< Receive Buffer struct reference      */
-    uint16_t* rxLen; /*!< Receive INF data length in bytes     */
-    bool* isRxChaining; /*!< Received data is not complete        */
-    rfalNfcDepDevice* nfcDepDev; /*!< NFC-DEP device info                  */
-} rfalNfcDepListenActvParam;
-
-/*! NFCIP Protocol structure for P2P Target
- *
- *   operParam : derives from NFC-Forum NCI NFC-DEP Operation Parameter
- *               NCI 1.1 Table 86: NFC-DEP Operation Parameter
- *               and it's a bit mask composed as:
- *                  [ 0000b 
- *                    | Chain SHALL use max. Transport Data Byte[1b] 
- *                    | I-PDU with no Transport Data SHALL NOT be sent [1b]
- *                    | NFC-DEP Target SHALL NOT send RTOX request [1b]
- *                  ]
- * 
- */
-typedef struct {
-    rfalNfcDepCommMode commMode; /*!< Target in Active P2P or Passive P2P   */
-    uint8_t nfcid3[RFAL_NFCDEP_NFCID3_LEN]; /*!< Target's NFCID3                       */
-    uint8_t bst; /*!< Target's Bit Rates supported in Tx    */
-    uint8_t brt; /*!< Target's Bit Rates supported in Rx    */
-    uint8_t to; /*!< Target's timeout (TO) value           */
-    uint8_t ppt; /*!< Target's Presence optional Params(PPt)*/
-    uint8_t GBt[RFAL_NFCDEP_GB_MAX_LEN]; /*!< Target's General Bytes (Gt)           */
-    uint8_t GBtLen; /*!< Target's General Bytes length         */
-    uint8_t operParam; /*!< NFC-DEP Operation Parameter           */
-} rfalNfcDepTargetParam;
-
-/*! Structure of parameters to be passed in for nfcDepStartIpduTransceive              */
-typedef struct {
-    rfalNfcDepBufFormat* txBuf; /*!< Transmit Buffer struct reference          */
-    uint16_t txBufLen; /*!< Transmit Buffer INF field length in bytes */
-    bool isTxChaining; /*!< Transmit data is not complete             */
-    rfalNfcDepBufFormat* rxBuf; /*!< Receive Buffer struct reference           */
-    uint16_t* rxLen; /*!< Receive INF data length                   */
-    bool* isRxChaining; /*!< Received data is not complete             */
-    uint32_t FWT; /*!< FWT to be used (ignored in Listen Mode)   */
-    uint32_t dFWT; /*!< Delta FWT to be used                      */
-    uint16_t FSx; /*!< Other device Frame Size (FSD or FSC)      */
-    uint8_t DID; /*!< Device ID (RFAL_ISODEP_NO_DID if no DID)  */
-} rfalNfcDepTxRxParam;
-
-/*! Structure of parameters used on NFC DEP PDU Transceive */
-typedef struct {
-    rfalNfcDepPduBufFormat* txBuf; /*!< Transmit Buffer struct reference         */
-    uint16_t txBufLen; /*!< Transmit Buffer INF field length in Bytes*/
-    rfalNfcDepPduBufFormat* rxBuf; /*!< Receive Buffer struct reference in Bytes */
-    uint16_t* rxLen; /*!< Received INF data length in Bytes        */
-    rfalNfcDepBufFormat* tmpBuf; /*!< Temp buffer for single PDUs (internal)   */
-    uint32_t FWT; /*!< FWT to be used (ignored in Listen Mode)  */
-    uint32_t dFWT; /*!< Delta FWT to be used                     */
-    uint16_t FSx; /*!< Other device Frame Size (FSD or FSC)     */
-    uint8_t DID; /*!< Device ID (RFAL_ISODEP_NO_DID if no DID) */
-} rfalNfcDepPduTxRxParam;
-
-/*
- * *****************************************************************************
- * GLOBAL VARIABLE DECLARATIONS
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTION PROTOTYPES
- ******************************************************************************
- */
-
-/*!
- ******************************************************************************
- * \brief NFCIP Initialize
- * 
- * This method resets all NFC-DEP inner states, counters and context and sets
- * default values
- * 
- ******************************************************************************
- */
-void rfalNfcDepInitialize(void);
-
-/*!
- ******************************************************************************
- * \brief Set deactivating callback
- * 
- * Sets the deactivating callback so that nfcip layer can check if upper layer
- * has a deactivation pending, and not perform error recovery upon specific
- * errors
- * 
- * \param[in] pFunc : method pointer to deactivation flag check 
- ******************************************************************************
- */
-void rfalNfcDepSetDeactivatingCallback(rfalNfcDepDeactCallback pFunc);
-
-/*!
- ******************************************************************************
- * \brief Calculate Response Waiting Time
- * 
- * Calculates the Response Waiting Time (RWT) from the given Waiting Time (WT)
- * 
- * \param[in]  wt : the WT value to calculate RWT
- * 
- * \return RWT value in 1/fc
- ******************************************************************************
- */
-uint32_t rfalNfcDepCalculateRWT(uint8_t wt);
-
-/*!
- ******************************************************************************
- * \brief NFC-DEP Initiator ATR (Attribute Request)
- * 
- * This method configures the NFC-DEP layer with given parameters and then
- * sends an ATR to the Target with and checks for a valid response response
- *
- * \param[in]   param     : parameters to initialize and compose the ATR
- * \param[out]  atrRes    : location to store the ATR_RES
- * \param[out]  atrResLen : length of the ATR_RES received
- * 
- * \return ERR_NONE    : No error
- * \return ERR_TIMEOUT : Timeout occurred
- * \return ERR_PROTO   : Protocol error occurred
- ******************************************************************************
- */
-ReturnCode
-    rfalNfcDepATR(const rfalNfcDepAtrParam* param, rfalNfcDepAtrRes* atrRes, uint8_t* atrResLen);
-
-/*!
- ******************************************************************************
- * \brief NFC-DEP Initiator PSL (Parameter Selection)
- * 
- * This method sends a PSL to the Target with the given parameters and checks
- * for a valid response response
- * 
- * The parameters must be coded according to  Digital 1.1  16.7.1
- * 
- * \param[in] BRS : the selected Bit Rates for Initiator and Target
- * \param[in] FSL : the maximum length of Commands and Responses
- * 
- * \return ERR_NONE    : No error
- * \return ERR_TIMEOUT : Timeout occurred
- * \return ERR_PROTO   : Protocol error occurred
- ******************************************************************************
- */
-ReturnCode rfalNfcDepPSL(uint8_t BRS, uint8_t FSL);
-
-/*!
- ******************************************************************************
- * \brief NFC-DEP Initiator DSL (Deselect)
- * 
- * This method checks if the NFCIP module is configured as initiator and if 
- * so sends a DSL REQ, waits  the target's response and checks it 
- * 
- * In case of performing as target no action is taken 
- * 
- * \return ERR_NONE       : No error
- * \return ERR_TIMEOUT    : Timeout occurred
- * \return ERR_MAX_RERUNS : Timeout occurred
- * \return ERR_PROTO      : Protocol error occurred
- ******************************************************************************
- */
-ReturnCode rfalNfcDepDSL(void);
-
-/*!
- ******************************************************************************
- * \brief NFC-DEP Initiator RLS (Release)
- * 
- * This method checks if the NFCIP module is configured as initiator and if 
- * so sends a RLS REQ, waits target's response and checks it 
- * 
- * In case of performing as target no action is taken 
- * 
- * \return ERR_NONE       : No error
- * \return ERR_TIMEOUT    : Timeout occurred
- * \return ERR_MAX_RERUNS : Timeout occurred
- * \return ERR_PROTO      : Protocol error occurred
- ******************************************************************************
- */
-ReturnCode rfalNfcDepRLS(void);
-
-/*! 
- *****************************************************************************
- *  \brief  NFC-DEP Initiator Handle  Activation
- *   
- *  This performs a Activation into NFC-DEP layer with the given
- *  parameters. It sends ATR_REQ and if the higher bit rates are supported by 
- *  both devices it additionally sends PSL
- *  Once Activated all details of the device are provided on nfcDepDev
- *   
- *  \param[in]  param     : required parameters to initialize and send ATR_REQ
- *  \param[in]  desiredBR : Desired bit rate supported by the Poller
- *  \param[out] nfcDepDev : NFC-DEP information of the activated Listen device
- *
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalNfcDepInitiatorHandleActivation(
-    rfalNfcDepAtrParam* param,
-    rfalBitRate desiredBR,
-    rfalNfcDepDevice* nfcDepDev);
-
-/*!
- ******************************************************************************
- * \brief Check if buffer contains valid ATR_REQ 
- * 
- * This method checks if the given ATR_REQ is valid
- * 
- * 
- * \param[in]  buf    : buffer holding Initiator's received request
- * \param[in]  bufLen : size of the msg contained on the buf in Bytes
- * \param[out] nfcid3 : pointer to where the NFCID3 may be outputted, 
- *                       nfcid3 has NFCF_SENSF_NFCID3_LEN as length
- *                       Pass NULL if output parameter not desired 
- *                       
- * \return true  : Valid ATR_REQ received, the ATR_RES has been computed in txBuf
- * \return false : Invalid protocol request
- * 
- ******************************************************************************
- */
-bool rfalNfcDepIsAtrReq(const uint8_t* buf, uint16_t bufLen, uint8_t* nfcid3);
-
-/*!
- ******************************************************************************
- * \brief Check is Target has received ATR 
- * 
- * This method checks if the NFCIP module is configured as target and if a
- * ATR REQ has been received ( whether is in activation or in data exchange)
- * 
- * \return true  : a ATR has already been received
- * \return false : no ATR has been received 
- ******************************************************************************
- */
-bool rfalNfcDepTargetRcvdATR(void);
-
-/*!
- *****************************************************************************
- * \brief NFCDEP Start Listen Activation Handling
- * 
- * Start Activation Handling and setup to receive first frame which may
- * contain complete or partial DEP-REQ after activation is completed 
- * 
- * Pass in ATR_REQ for NFC-DEP to handle ATR_RES. The Activation Handling 
- * handles ATR_RES and PSL_RES if a PSL_REQ is received
- * 
- * Activation is completed if PSL_RES is sent or if first I-PDU is received
- *  
- * \ref rfalNfcDepListenGetActivationStatus() provide status of the 
- *       ongoing activation
- * 
- * \warning nfcDepGetTransceiveStatus() shall be called right after activation 
- * is completed (i.e. rfalNfcDepListenGetActivationStatus() return ERR_NONE) 
- * to check for first received frame.
- * 
- * \param[in]  param       : Target parameters to be used
- * \param[in]  atrReq      : reference to buffer containing ATR_REQ 
- * \param[in]  atrReqLength: Length of ATR_REQ
- * \param[out] rxParam     : references to buffer, length and chaining indication 
- *                           for first complete LLCP to be received
- * 
- * \return ERR_NONE      : ATR_REQ is valid and activation ongoing
- * \return ERR_PARAM     : ATR_REQ or other params are invalid
- * \return ERR_LINK_LOSS : Remote Field is turned off
- *****************************************************************************
- */
-ReturnCode rfalNfcDepListenStartActivation(
-    const rfalNfcDepTargetParam* param,
-    const uint8_t* atrReq,
-    uint16_t atrReqLength,
-    rfalNfcDepListenActvParam rxParam);
-
-/*!
- *****************************************************************************
- * \brief Get the current NFC-DEP Activation Status
- * 
- * \return ERR_NONE      : Activation has completed successfully
- * \return ERR_BUSY      : Activation is ongoing
- * \return ERR_LINK_LOSS : Remote Field was turned off
- *****************************************************************************
- */
-ReturnCode rfalNfcDepListenGetActivationStatus(void);
-
-/*!
- *****************************************************************************
- * \brief Start Transceive 
- * 
- * Transceives a complete or partial DEP block
- * 
- * The txBuf contains complete or partial of DEP to be transmitted. 
- * The Prologue field of the I-PDU is handled internally
- * 
- * If the buffer contains partial LLCP and is not the last block, then 
- * isTxChaining must be set to true
- * 
- * \param[in] param: reference parameters to be used for the Transceive
- *                    
- * \return ERR_PARAM       : Bad request
- * \return ERR_WRONG_STATE : The module is not in a proper state
- * \return ERR_NONE        : The Transceive request has been started
- *****************************************************************************
- */
-ReturnCode rfalNfcDepStartTransceive(const rfalNfcDepTxRxParam* param);
-
-/*!
- *****************************************************************************
- * \brief Return the Transceive status
- *
- * Returns the status of the NFC-DEP Transceive
- * 
- * \warning  When the other device is performing chaining once a chained 
- *            block is received the error ERR_AGAIN is sent. At this point 
- *            caller must handle the received data immediately. 
- *            When ERR_AGAIN is returned an ACK has already been sent to 
- *            the other device and the next block might be incoming. 
- *            If rfalWorker() is called frequently it will place the next 
- *            block on the given buffer  
- * 
- * \return ERR_NONE      : Transceive has been completed successfully
- * \return ERR_BUSY      : Transceive is ongoing
- * \return ERR_PROTO     : Protocol error occurred
- * \return ERR_TIMEOUT   : Timeout error occurred
- * \return ERR_SLEEP_REQ : Deselect has been received and responded
- * \return ERR_NOMEM     : The received I-PDU does not fit into the
- *                            receive buffer
- * \return ERR_LINK_LOSS : Communication is lost because Reader/Writer 
- *                            has turned off its field
- * \return ERR_AGAIN     : received one chaining block, continue to call
- *                            this method to retrieve the remaining blocks
- *****************************************************************************
- */
-ReturnCode rfalNfcDepGetTransceiveStatus(void);
-
-/*!
- *****************************************************************************
- * \brief Start PDU Transceive 
- * 
- * This method triggers a NFC-DEP Transceive containing a complete PDU
- * It transmits the given message and handles all protocol retransmitions,
- * error handling and control messages
- * 
- * The txBuf  contains a complete PDU to be transmitted 
- * The Prologue field will be manipulated by the Transceive
- *  
- * \warning the txBuf will be modified during the transmission
- * \warning the maximum RF frame which can be received is limited by param.tmpBuf
- * 
- * \param[in] param: reference parameters to be used for the Transceive
- *                    
- * \return ERR_PARAM       : Bad request
- * \return ERR_WRONG_STATE : The module is not in a proper state
- * \return ERR_NONE        : The Transceive request has been started
- *****************************************************************************
- */
-ReturnCode rfalNfcDepStartPduTransceive(rfalNfcDepPduTxRxParam param);
-
-/*!
- *****************************************************************************
- * \brief Return the PSU Transceive status
- *
- * Returns the status of the NFC-DEP PDU Transceive
- * 
- * 
- * \return ERR_NONE      : Transceive has been completed successfully
- * \return ERR_BUSY      : Transceive is ongoing
- * \return ERR_PROTO     : Protocol error occurred
- * \return ERR_TIMEOUT   : Timeout error occurred
- * \return ERR_SLEEP_REQ : Deselect has been received and responded
- * \return ERR_NOMEM     : The received I-PDU does not fit into the
- *                            receive buffer
- * \return ERR_LINK_LOSS : Communication is lost because Reader/Writer 
- *                            has turned off its field
- *****************************************************************************
- */
-ReturnCode rfalNfcDepGetPduTransceiveStatus(void);
-
-#endif /* RFAL_NFCDEP_H_ */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfca.h

@@ -1,497 +0,0 @@
-
-/******************************************************************************
-  * \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.h
- *
- *  \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
- *  
- *  
- *  An usage example is provided here: \ref exampleRfalNfca.c
- *  \example exampleRfalNfca.c
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup NFC-A
- * \brief RFAL NFC-A Module
- * @{
- * 
- */
-
-#ifndef RFAL_NFCA_H
-#define RFAL_NFCA_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-#include "rfal_t1t.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCA_CASCADE_1_UID_LEN \
-    4U /*!< UID length of cascade level 1 only tag                            */
-#define RFAL_NFCA_CASCADE_2_UID_LEN \
-    7U /*!< UID length of cascade level 2 only tag                            */
-#define RFAL_NFCA_CASCADE_3_UID_LEN \
-    10U /*!< UID length of cascade level 3 only tag                            */
-
-#define RFAL_NFCA_SENS_RES_PLATFORM_MASK \
-    0x0FU /*!< SENS_RES (ATQA) platform configuration mask  Digital 1.1 Table 10 */
-#define RFAL_NFCA_SENS_RES_PLATFORM_T1T \
-    0x0CU /*!< SENS_RES (ATQA) T1T platform configuration  Digital 1.1 Table 10  */
-
-#define RFAL_NFCA_SEL_RES_CONF_MASK \
-    0x60U /*!< SEL_RES (SAK) platform configuration mask  Digital 1.1 Table 19   */
-#define RFAL_NFCA_SEL_RES_CONF_T2T \
-    0x00U /*!< SEL_RES (SAK) T2T configuration  Digital 1.1 Table 19             */
-#define RFAL_NFCA_SEL_RES_CONF_T4T \
-    0x20U /*!< SEL_RES (SAK) T4T configuration  Digital 1.1 Table 19             */
-#define RFAL_NFCA_SEL_RES_CONF_NFCDEP \
-    0x40U /*!< SEL_RES (SAK) NFC-DEP configuration  Digital 1.1 Table 19         */
-#define RFAL_NFCA_SEL_RES_CONF_T4T_NFCDEP \
-    0x60U /*!< SEL_RES (SAK) T4T and NFC-DEP configuration  Digital 1.1 Table 19 */
-
-/*! NFC-A minimum FDT(listen) = ((n * 128 + (84)) / fc) with n_min = 9      Digital 1.1  6.10.1
- *                            = (1236)/fc
- * Relax with 3etu: (3*128)/fc as with multiple NFC-A cards, response may take longer (JCOP cards)
- *                            = (1236 + 384)/fc = 1620 / fc                                      */
-#define RFAL_NFCA_FDTMIN 1620U
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*! Checks if device is a T1T given its SENS_RES */
-#define rfalNfcaIsSensResT1T(sensRes)                                                    \
-    ((((rfalNfcaSensRes*)(sensRes))->platformInfo & RFAL_NFCA_SENS_RES_PLATFORM_MASK) == \
-     RFAL_NFCA_SENS_RES_PLATFORM_T1T)
-
-/*! Checks if device is a T2T given its SENS_RES */
-#define rfalNfcaIsSelResT2T(selRes)                                      \
-    ((((rfalNfcaSelRes*)(selRes))->sak & RFAL_NFCA_SEL_RES_CONF_MASK) == \
-     RFAL_NFCA_SEL_RES_CONF_T2T)
-
-/*! Checks if device is a T4T given its SENS_RES */
-#define rfalNfcaIsSelResT4T(selRes)                                      \
-    ((((rfalNfcaSelRes*)(selRes))->sak & RFAL_NFCA_SEL_RES_CONF_MASK) == \
-     RFAL_NFCA_SEL_RES_CONF_T4T)
-
-/*! Checks if device supports NFC-DEP protocol given its SENS_RES */
-#define rfalNfcaIsSelResNFCDEP(selRes)                                   \
-    ((((rfalNfcaSelRes*)(selRes))->sak & RFAL_NFCA_SEL_RES_CONF_MASK) == \
-     RFAL_NFCA_SEL_RES_CONF_NFCDEP)
-
-/*! Checks if device supports ISO-DEP and NFC-DEP protocol given its SENS_RES */
-#define rfalNfcaIsSelResT4TNFCDEP(selRes)                                \
-    ((((rfalNfcaSelRes*)(selRes))->sak & RFAL_NFCA_SEL_RES_CONF_MASK) == \
-     RFAL_NFCA_SEL_RES_CONF_T4T_NFCDEP)
-
-/*! Checks if a NFC-A listener device supports multiple protocols (ISO-DEP and NFC-DEP) */
-#define rfalNfcaLisDevIsMultiProto(lisDev) \
-    (((rfalNfcaListenDevice*)(lisDev))->type == RFAL_NFCA_T4T_NFCDEP)
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-A Listen device types */
-typedef enum {
-    RFAL_NFCA_T1T =
-        0x01, /* Device configured for T1T  Digital 1.1 Table 9                               */
-    RFAL_NFCA_T2T =
-        0x00, /* Device configured for T2T  Digital 1.1 Table 19                              */
-    RFAL_NFCA_T4T =
-        0x20, /* Device configured for T4T  Digital 1.1 Table 19                              */
-    RFAL_NFCA_NFCDEP =
-        0x40, /* Device configured for NFC-DEP  Digital 1.1 Table 19                          */
-    RFAL_NFCA_T4T_NFCDEP =
-        0x60 /* Device configured for NFC-DEP and T4T  Digital 1.1 Table 19                  */
-} rfalNfcaListenDeviceType;
-
-/*! SENS_RES (ATQA) format  Digital 1.1  6.6.3 & Table 7 */
-typedef struct {
-    uint8_t
-        anticollisionInfo; /*!< SENS_RES Anticollision Information                                         */
-    uint8_t
-        platformInfo; /*!< SENS_RES Platform Information                                              */
-} rfalNfcaSensRes;
-
-/*! SDD_REQ (Anticollision) format   Digital 1.1  6.7.1 & Table 11 */
-typedef struct {
-    uint8_t
-        selCmd; /*!< SDD_REQ SEL_CMD: cascade Level                                             */
-    uint8_t
-        selPar; /*!< SDD_REQ SEL_PAR: Byte Count[4b] | Bit Count[4b] (NVB: Number of Valid Bits)*/
-} rfalNfcaSddReq;
-
-/*! SDD_RES (UID CLn) format   Digital 1.1  6.7.2 & Table 15 */
-typedef struct {
-    uint8_t nfcid1
-        [RFAL_NFCA_CASCADE_1_UID_LEN]; /*!< NFCID1 cascade level NFCID                                                 */
-    uint8_t bcc; /*!< BCC Exclusive-OR over first 4 bytes of SDD_RES                             */
-} rfalNfcaSddRes;
-
-/*! SEL_REQ (Select) format   Digital 1.1  6.8.1 & Table 17 */
-typedef struct {
-    uint8_t
-        selCmd; /*!< SDD_REQ SEL_CMD: cascade Level                                             */
-    uint8_t
-        selPar; /*!< SDD_REQ SEL_PAR: Byte Count[4b] | Bit Count[4b] (NVB: Number of Valid Bits)*/
-    uint8_t nfcid1
-        [RFAL_NFCA_CASCADE_1_UID_LEN]; /*!< NFCID1 data                                                                */
-    uint8_t bcc; /*!< Checksum calculated as exclusive-OR over the 4 bytes of NFCID1 CLn         */
-} rfalNfcaSelReq;
-
-/*! SEL_RES (SAK) format   Digital 1.1  6.8.2 & Table 19 */
-typedef struct {
-    uint8_t sak; /*!< Select Acknowledge                                                         */
-} rfalNfcaSelRes;
-
-/*! NFC-A listener device (PICC) struct  */
-typedef struct {
-    rfalNfcaListenDeviceType
-        type; /*!< NFC-A Listen device type                                                   */
-    rfalNfcaSensRes
-        sensRes; /*!< SENS_RES (ATQA)                                                            */
-    rfalNfcaSelRes
-        selRes; /*!< SEL_RES  (SAK)                                                             */
-    uint8_t
-        nfcId1Len; /*!< NFCID1 Length                                                              */
-    uint8_t nfcId1
-        [RFAL_NFCA_CASCADE_3_UID_LEN]; /*!< NFCID1   (UID)                                                             */
-#ifdef RFAL_FEATURE_T1T
-    rfalT1TRidRes
-        ridRes; /*!< RID_RES                                                                    */
-#endif /* RFAL_FEATURE_T1T */
-    bool isSleep; /*!< Device sleeping flag                                                       */
-} rfalNfcaListenDevice;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize NFC-A Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFC-A Poller/RW (ISO14443A PCD) including all default timings and bit rate
- * to 106 kbps
- 
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Check Presence
- *  
- * This method checks if a NFC-A Listen device (PICC) is present on the field
- * by sending an ALL_REQ (WUPA) or SENS_REQ (REQA)
- *  
- * \param[in]  cmd     : Indicate if to send an ALL_REQ or a SENS_REQ
- * \param[out] sensRes : If received, the SENS_RES
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_RF_COLLISION : Collision detected one or more device in the field
- * \return ERR_PAR          : Parity error detected, one or more device in the field
- * \return ERR_CRC          : CRC error detected, one or more device in the field
- * \return ERR_FRAMING      : Framing error detected, one or more device in the field
- * \return ERR_PROTO        : Protocol error detected, one or more device in the field
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_NONE         : No error, one or more device in the field
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerCheckPresence(rfal14443AShortFrameCmd cmd, rfalNfcaSensRes* sensRes);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Select
- *  
- * This method selects a NFC-A Listener device (PICC) 
- *  
- * \param[in]  nfcid1   : Listener device NFCID1 to be selected
- * \param[in]  nfcidLen : Length of the NFCID1 to be selected  
- * \param[out] selRes   : pointer to place the SEL_RES
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_PAR          : Parity error detected
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error, SEL_RES received
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerSelect(const uint8_t* nfcid1, uint8_t nfcidLen, rfalNfcaSelRes* selRes);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Sleep
- *  
- * This method sends a SLP_REQ (HLTA)
- * No response is expected afterwards   Digital 1.1  6.9.2.1 
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerSleep(void);
-
-/*!
- *****************************************************************************
- * \brief  NFC-A Technology Detection
- *  
- * This method performs NFC-A Technology Detection as defined in the spec
- * given in the compliance mode
- *  
- * \param[in]  compMode  : compliance mode to be performed
- * \param[out] sensRes   : location to store the SENS_RES, if received
- * 
- * When compMode is set to ISO compliance a SLP_REQ (HLTA) is not sent 
- * after detection. When set to EMV a ALL_REQ (WUPA) is sent instead of 
- * a SENS_REQ (REQA)
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error, one or more device in the field
- *****************************************************************************
- */
-ReturnCode
-    rfalNfcaPollerTechnologyDetection(rfalComplianceMode compMode, rfalNfcaSensRes* sensRes);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Collision Resolution
- *  
- * Collision resolution for one NFC-A Listener device/card (PICC) as 
- * defined in Activity 2.1  9.3.4
- * 
- * This method executes anti collision loop and select the device with higher NFCID1
- * 
- * When devLimit = 0 it is configured to perform collision detection only. Once a collision 
- * is detected the collision resolution is aborted immediately. If only one device is found
- * with no collisions, it will properly resolved. 
- *
- * \param[in]  devLimit    : device limit value (CON_DEVICES_LIMIT)
- * \param[out] collPending : pointer to collision pending flag (INT_COLL_PEND)
- * \param[out] selRes      : location to store the last Select Response from listener device (PICC)
- * \param[out] nfcId1      : location to store the NFCID1 (UID), ensure RFAL_NFCA_CASCADE_3_UID_LEN
- * \param[out] nfcId1Len   : pointer to length of NFCID1 (UID)
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_PROTO        : Card length invalid
- * \return ERR_IGNORE       : conDevLimit is 0 and there is a collision
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerSingleCollisionResolution(
-    uint8_t devLimit,
-    bool* collPending,
-    rfalNfcaSelRes* selRes,
-    uint8_t* nfcId1,
-    uint8_t* nfcId1Len);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Full Collision Resolution
- *  
- * Performs a full Collision resolution as defined in Activity 2.1  9.3.4
- *
- * \param[in]  compMode    : compliance mode to be performed
- * \param[in]  devLimit    : device limit value, and size nfcaDevList
- * \param[out] nfcaDevList : NFC-A listener device info
- * \param[out] devCnt      : Devices found counter
- *
- * When compMode is set to ISO compliance it assumes that the device is
- * not sleeping and therefore no ALL_REQ (WUPA) is sent at the beginning.
- * When compMode is set to NFC compliance an additional ALL_REQ (WUPA) is sent 
- * at the beginning.
- *  
- *  
- * When devLimit = 0 it is configured to perform collision detection only. Once a collision 
- * is detected the collision resolution is aborted immediately. If only one device is found
- * with no collisions, it will properly resolved.
- *
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerFullCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcaListenDevice* nfcaDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Full Collision Resolution with Sleep
- *  
- * Performs a full Collision resolution similar to rfalNfcaPollerFullCollisionResolution
- * but an additional SLP_REQ (HLTA) -> SENS_RES (REQA) is sent regardless if there 
- * was a collision.
- * This proprietary behaviour ensures proper activation of certain devices that suffer
- * from influence of Type B commands as foreseen in ISO14443-3 5.2.3 or were somehow
- * not detected by the first round of collision resolution
- *
- * \param[in]  devLimit    : device limit value, and size nfcaDevList
- * \param[out] nfcaDevList : NFC-A listener device info
- * \param[out] devCnt      : Devices found counter
- *  
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerSleepFullCollisionResolution(
-    uint8_t devLimit,
-    rfalNfcaListenDevice* nfcaDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A Poller Start Full Collision Resolution
- *  
- * This method starts the full Collision resolution as defined 
-  * in Activity 1.0 or 1.1  9.3.4
- *
- * \param[in]  compMode    : compliance mode to be performed
- * \param[in]  devLimit    : device limit value, and size nfcaDevList
- * \param[out] nfcaDevList : NFC-A listener device info
- * \param[out] devCnt      : Devices found counter
- *
- * When compMode is set to ISO compliance it assumes that the device is
- * not sleeping and therefore no ALL_REQ (WUPA) is sent at the beginning.
- * When compMode is set to NFC compliance an additional ALL_REQ (WUPA) is sent at 
- * the beginning.
- *  
- *  
- * When devLimit = 0 it is configured to perform collision detection only. Once a collision 
- * is detected the collision resolution is aborted immediately. If only one device is found
- * with no collisions, it will properly resolved.
- *
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerStartFullCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcaListenDevice* nfcaDevList,
-    uint8_t* devCnt);
-
-/*!
- *****************************************************************************
- *  \brief  NFC-A Get Full Collision Resolution Status
- *
- *  Returns the Collision Resolution status
- *
- *  \return ERR_BUSY         : Operation is ongoing
- *  \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- *  \return ERR_PARAM        : Invalid parameters
- *  \return ERR_IO           : Generic internal error
- *  \return ERR_TIMEOUT      : Timeout error
- *  \return ERR_PAR          : Parity error detected
- *  \return ERR_CRC          : CRC error detected
- *  \return ERR_FRAMING      : Framing error detected
- *  \return ERR_PROTO        : Protocol error detected
- *  \return ERR_NONE         : No error, activation successful
- *****************************************************************************
- */
-ReturnCode rfalNfcaPollerGetFullCollisionResolutionStatus(void);
-
-/*!
- *****************************************************************************
- * \brief NFC-A Listener is SLP_REQ 
- * 
- * Checks if the given buffer contains valid NFC-A SLP_REQ (HALT)
- * 
- * \param[in] buf: buffer containing data
- * \param[in] bufLen: length of the data in buffer to be checked
- * 
- * \return true if data in buf contains a SLP_REQ ; false otherwise
- *****************************************************************************
- */
-bool rfalNfcaListenerIsSleepReq(const uint8_t* buf, uint16_t bufLen);
-
-#endif /* RFAL_NFCA_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfcb.h

@@ -1,425 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcb.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-B (ISO14443B) helpers 
- *  
- *  It provides a NFC-B Poller (ISO14443B PCD) interface and 
- *  also provides some NFC-B Listener (ISO14443B PICC) helpers
- *
- *  The definitions and helpers methods provided by this module are only
- *  up to ISO14443-3 layer (excluding ATTRIB)
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup NFC-B
- * \brief RFAL NFC-B Module
- * @{
- * 
- */
-
-#ifndef RFAL_NFCB_H
-#define RFAL_NFCB_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCB_FWTSENSB 7680U /*!< NFC-B FWT(SENSB)  Digital 2.0  B.3        */
-#define RFAL_NFCB_DFWT 49152U /*!< NFC-B dFWT Delta 2.0  7.9.1.3 & B.3       */
-#define RFAL_NFCB_DTPOLL_10 rfalConvMsTo1fc(20) /*!< NFC-B Delta Tb Poll  Digital 1.0  A.2     */
-#define RFAL_NFCB_DTPOLL_20 rfalConvMsTo1fc(17) /*!< NFC-B Delta Tb Poll  Digital 2.1  B.3     */
-
-#define RFAL_NFCB_AFI 0x00U /*!< NFC-B default Application Family   Digital 1.1 7.6.1.1 */
-#define RFAL_NFCB_PARAM 0x00U /*!< NFC-B default SENSB_REQ PARAM                          */
-#define RFAL_NFCB_CRC_LEN 2U /*!< NFC-B CRC length and CRC_B(AID)   Digital 1.1 Table 28 */
-#define RFAL_NFCB_NFCID0_LEN 4U /*!< Length of NFC-B NFCID0                                 */
-#define RFAL_NFCB_CMD_LEN 1U /*!< Length of NFC-B Command                                */
-
-#define RFAL_NFCB_SENSB_RES_LEN 12U /*!< Standard length of SENSB_RES without SFGI byte         */
-#define RFAL_NFCB_SENSB_RES_EXT_LEN \
-    13U /*!< Extended length of SENSB_RES with SFGI byte            */
-
-#define RFAL_NFCB_SENSB_REQ_ADV_FEATURE \
-    0x20U /*!< Bit mask for Advance Feature in SENSB_REQ              */
-#define RFAL_NFCB_SENSB_RES_FSCI_MASK \
-    0x0FU /*!< Bit mask for FSCI value in SENSB_RES                   */
-#define RFAL_NFCB_SENSB_RES_FSCI_SHIFT \
-    4U /*!< Shift for FSCI value in SENSB_RES                      */
-#define RFAL_NFCB_SENSB_RES_PROTO_RFU_MASK \
-    0x08U /*!< Bit mask for Protocol Type RFU in SENSB_RES            */
-#define RFAL_NFCB_SENSB_RES_PROTO_TR2_MASK \
-    0x03U /*!< Bit mask for Protocol Type TR2 in SENSB_RES            */
-#define RFAL_NFCB_SENSB_RES_PROTO_TR2_SHIFT \
-    1U /*!< Shift for Protocol Type TR2 in SENSB_RES               */
-#define RFAL_NFCB_SENSB_RES_PROTO_ISO_MASK \
-    0x01U /*!< Bit mask Protocol Type ISO14443 Compliant in SENSB_RES */
-#define RFAL_NFCB_SENSB_RES_FWI_MASK \
-    0x0FU /*!< Bit mask for FWI value in SENSB_RES                    */
-#define RFAL_NFCB_SENSB_RES_FWI_SHIFT \
-    4U /*!< Bit mask for FWI value in SENSB_RES                    */
-#define RFAL_NFCB_SENSB_RES_ADC_MASK \
-    0x0CU /*!< Bit mask for ADC value in SENSB_RES                    */
-#define RFAL_NFCB_SENSB_RES_ADC_ADV_FEATURE_MASK \
-    0x08U /*!< Bit mask for ADC.Advanced Proto Features in SENSB_RES  */
-#define RFAL_NFCB_SENSB_RES_ADC_PROPRIETARY_MASK \
-    0x04U /*!< Bit mask for ADC.Proprietary Application in SENSB_RES  */
-#define RFAL_NFCB_SENSB_RES_FO_DID_MASK \
-    0x01U /*!< Bit mask for DID in SENSB_RES                          */
-#define RFAL_NFCB_SENSB_RES_FO_NAD_MASK \
-    0x02U /*!< Bit mask for DID in SENSB_RES                          */
-#define RFAL_NFCB_SENSB_RES_FO_MASK \
-    0x03U /*!< Bit mask for FO value in SENSB_RES (NAD and DID)       */
-#define RFAL_NFCB_SENSB_RES_SFGI_MASK \
-    0x0FU /*!< Bit mask for SFGI in SENSB_RES                         */
-#define RFAL_NFCB_SENSB_RES_SFGI_SHIFT \
-    4U /*!< Shift for SFGI in SENSB_RES                            */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*! Get device's FSCI given its SENSB_RES  Digital 1.1 7.6.2  */
-#define rfalNfcbGetFSCI(sensbRes)                                                                \
-    ((((rfalNfcbSensbRes*)(sensbRes))->protInfo.FsciProType >> RFAL_NFCB_SENSB_RES_FSCI_SHIFT) & \
-     RFAL_NFCB_SENSB_RES_FSCI_MASK)
-
-/*! Checks if the given NFC-B device indicates ISO-DEP support */
-#define rfalNfcbIsIsoDepSupported(dev)                                \
-    ((((rfalNfcbListenDevice*)(dev))->sensbRes.protInfo.FsciProType & \
-      RFAL_NFCB_SENSB_RES_PROTO_ISO_MASK) != 0U)
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! SENSB_REQ and ALLB_REQ param   Digital 1.1 7.6.1  */
-typedef enum {
-    RFAL_NFCB_SENS_CMD_ALLB_REQ = 0x08, /*!< ALLB_REQ  (WUPB)  */
-    RFAL_NFCB_SENS_CMD_SENSB_REQ = 0x00 /*!< SENSB_REQ (REQB)  */
-} rfalNfcbSensCmd;
-
-/*! Number of Slots (NI) codes used for NFC-B anti collision  Digital 1.1 Table 26 */
-typedef enum {
-    RFAL_NFCB_SLOT_NUM_1 = 0, /*!< N=0 :  1 slot   */
-    RFAL_NFCB_SLOT_NUM_2 = 1, /*!< N=1 :  2 slots  */
-    RFAL_NFCB_SLOT_NUM_4 = 2, /*!< N=2 :  4 slots  */
-    RFAL_NFCB_SLOT_NUM_8 = 3, /*!< N=3 :  8 slots  */
-    RFAL_NFCB_SLOT_NUM_16 = 4 /*!< N=4 : 16 slots  */
-} rfalNfcbSlots;
-
-/*! SENSB_RES (ATQB) Application Data Format   Digital 1.1 Table 28 */
-typedef struct {
-    uint8_t AFI; /*!< Application Family Identifier */
-    uint8_t CRC_B[RFAL_NFCB_CRC_LEN]; /*!< CRC_B of AID                  */
-    uint8_t numApps; /*!< Number of Applications        */
-} rfalNfcbSensbResAppData;
-
-/*! SENSB_RES Protocol Info format Digital 1.1 Table 29 */
-typedef struct {
-    uint8_t
-        BRC; /*!< Bit Rate Capability                                                            */
-    uint8_t
-        FsciProType; /*!< Frame Size Card Integer [4b] | Protocol Type[4 bits]                           */
-    uint8_t
-        FwiAdcFo; /*!< Frame Waiting Integer [4b] | Application Data Coding [2b] | Frame Options [2b] */
-    uint8_t
-        SFGI; /*!< Optional: Start-Up Frame Guard Time Integer[4b] | RFU [4b]                     */
-} rfalNfcbSensbResProtocolInfo;
-
-/*! SENSB_RES format   Digital 1.1  7.6.2 */
-typedef struct {
-    uint8_t cmd; /*!< SENSB_RES: 50h       */
-    uint8_t nfcid0[RFAL_NFCB_NFCID0_LEN]; /*!< NFC Identifier (PUPI)*/
-    rfalNfcbSensbResAppData appData; /*!< Application Data     */
-    rfalNfcbSensbResProtocolInfo protInfo; /*!< Protocol Information */
-} rfalNfcbSensbRes;
-
-/*! NFC-B listener device (PICC) struct  */
-typedef struct {
-    uint8_t sensbResLen; /*!< SENSB_RES length      */
-    rfalNfcbSensbRes sensbRes; /*!< SENSB_RES             */
-    bool isSleep; /*!< Device sleeping flag  */
-} rfalNfcbListenDevice;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize NFC-B Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFC-B Poller/RW (ISO14443B PCD) including all default timings
- * 
- * It sets NFC-B parameters (AFI, PARAM) to default values
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  Set NFC-B Poller parameters
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFCA Poller/RW (ISO14443A PCD) including all default timings
- * 
- * Additionally configures NFC-B specific parameters to be used on the 
- * following communications
- * 
- * \param[in]  AFI   : Application Family Identifier to be used
- * \param[in]  PARAM : PARAM to be used, it announces whether Advanced
- *                     Features or Extended SENSB_RES is supported
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerInitializeWithParams(uint8_t AFI, uint8_t PARAM);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Poller Check Presence
- *  
- * This method checks if a NFC-B Listen device (PICC) is present on the field
- * by sending an ALLB_REQ (WUPB) or SENSB_REQ (REQB)
- *  
- * \param[in]  cmd         : Indicate if to send an ALL_REQ or a SENS_REQ
- * \param[in]  slots       : The number of slots to be announced
- * \param[out] sensbRes    : If received, the SENSB_RES
- * \param[out] sensbResLen : If received, the SENSB_RES length
- * 
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_RF_COLLISION : Collision detected one or more device in the field
- * \return ERR_PAR          : Parity error detected, one or more device in the field
- * \return ERR_CRC          : CRC error detected, one or more device in the field
- * \return ERR_FRAMING      : Framing error detected, one or more device in the field
- * \return ERR_PROTO        : Protocol error detected, invalid SENSB_RES received
- * \return ERR_NONE         : No error, SENSB_RES received
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerCheckPresence(
-    rfalNfcbSensCmd cmd,
-    rfalNfcbSlots slots,
-    rfalNfcbSensbRes* sensbRes,
-    uint8_t* sensbResLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Poller Sleep
- *  
- * This function is used to send the SLPB_REQ (HLTB) command to put the PICC with 
- * the given NFCID0 to state HALT so that they do not reply to further SENSB_REQ 
- * commands (only to ALLB_REQ)
- * 
- * \param[in]  nfcid0       : NFCID of the device to be put to Sleep
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerSleep(const uint8_t* nfcid0);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Poller Slot Marker
- *  
- * This method selects a NFC-B Slot marker frame 
- *  
- * \param[in]  slotCode     : Slot Code [1-15] 
- * \param[out] sensbRes     : If received, the SENSB_RES
- * \param[out] sensbResLen  : If received, the SENSB_RES length
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_PAR          : Parity error detected
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error, SEL_RES received
- *****************************************************************************
- */
-ReturnCode
-    rfalNfcbPollerSlotMarker(uint8_t slotCode, rfalNfcbSensbRes* sensbRes, uint8_t* sensbResLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Technology Detection
- *  
- * This method performs NFC-B Technology Detection as defined in the spec
- * given in the compliance mode
- *  
- * \param[in]  compMode    : compliance mode to be performed
- * \param[out] sensbRes    : location to store the SENSB_RES, if received
- * \param[out] sensbResLen : length of the SENSB_RES, if received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error, one or more device in the field
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerTechnologyDetection(
-    rfalComplianceMode compMode,
-    rfalNfcbSensbRes* sensbRes,
-    uint8_t* sensbResLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Poller Collision Resolution
- *  
- * NFC-B Collision resolution  Listener device/card (PICC) as 
- * defined in Activity 1.1  9.3.5
- * 
- * This function is used to perform collision resolution for detection in case 
- * of multiple NFC Forum Devices with Technology B detected. 
- * Target with valid SENSB_RES will be stored in devInfo and nfcbDevCount incremented.  
- *
- * \param[in]  compMode    : compliance mode to be performed
- * \param[in]  devLimit    : device limit value, and size nfcbDevList
- * \param[out] nfcbDevList : NFC-B listener device info
- * \param[out] devCnt      : devices found counter
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcbListenDevice* nfcbDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B Poller Collision Resolution Slotted
- *  
- * NFC-B Collision resolution  Listener device/card (PICC). The sequence can 
- * be configured to be according to NFC Forum Activity 1.1  9.3.5, ISO10373
- * or EMVCo 
- * 
- * This function is used to perform collision resolution for detection in case 
- * of multiple NFC Forum Devices with Technology B are detected. 
- * Target with valid SENSB_RES will be stored in devInfo and nfcbDevCount incremented.  
- * 
- * This method provides the means to perform a collision resolution loop with specific
- * initial and end number of slots. This allows to user to start the loop already with 
- * greater number of slots, and or limit the end number of slots. At the end a flag
- * indicating whether there were collisions pending is returned.
- * 
- * If RFAL_COMPLIANCE_MODE_ISO is used \a initSlots must be set to RFAL_NFCB_SLOT_NUM_1
- *  
- *
- * \param[in]  compMode    : compliance mode to be performed
- * \param[in]  devLimit    : device limit value, and size nfcbDevList
- * \param[in]  initSlots   : number of slots to open initially 
- * \param[in]  endSlots    : number of slots when to stop collision resolution 
- * \param[out] nfcbDevList : NFC-B listener device info
- * \param[out] devCnt      : devices found counter
- * \param[out] colPending  : flag indicating whether collision are still pending
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcbPollerSlottedCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcbSlots initSlots,
-    rfalNfcbSlots endSlots,
-    rfalNfcbListenDevice* nfcbDevList,
-    uint8_t* devCnt,
-    bool* colPending);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-B TR2 code to FDT
- *    
- *  Converts the TR2 code as defined in Digital 1.1 Table 33 Minimum 
- *  TR2 Coding to Frame Delay Time (FDT) in 1/Fc
- *
- * \param[in]  tr2Code : TR2 code as defined in Digital 1.1 Table 33
- * 
- * \return FDT in 1/Fc
- *****************************************************************************
- */
-uint32_t rfalNfcbTR2ToFDT(uint8_t tr2Code);
-
-#endif /* RFAL_NFCB_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfcf.h

@@ -1,403 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcf.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-F Poller (FeliCa PCD) device
- *
- *  The definitions and helpers methods provided by this module are 
- *  aligned with NFC-F (FeliCa - JIS X6319-4)
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup NFC-F
- * \brief RFAL NFC-F Module
- * @{  
- *  
- */
-
-#ifndef RFAL_NFCF_H
-#define RFAL_NFCF_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCF_NFCID2_LEN 8U /*!< NFCID2 (FeliCa IDm) length                        */
-#define RFAL_NFCF_SENSF_RES_LEN_MIN 16U /*!< SENSF_RES minimum length                          */
-#define RFAL_NFCF_SENSF_RES_LEN_MAX 18U /*!< SENSF_RES maximum length                          */
-#define RFAL_NFCF_SENSF_RES_PAD0_LEN 2U /*!< SENSF_RES PAD0 length                             */
-#define RFAL_NFCF_SENSF_RES_PAD1_LEN 2U /*!< SENSF_RES PAD1 length                             */
-#define RFAL_NFCF_SENSF_RES_RD_LEN 2U /*!< SENSF_RES Request Data length                     */
-#define RFAL_NFCF_SENSF_RES_BYTE1 1U /*!< SENSF_RES first byte value                        */
-#define RFAL_NFCF_SENSF_SC_LEN 2U /*!< Felica SENSF_REQ System Code length               */
-#define RFAL_NFCF_SENSF_PARAMS_SC1_POS 0U /*!< System Code byte1 position in the SENSF_REQ       */
-#define RFAL_NFCF_SENSF_PARAMS_SC2_POS 1U /*!< System Code byte2 position in the SENSF_REQ       */
-#define RFAL_NFCF_SENSF_PARAMS_RC_POS 2U /*!< Request Code position in the SENSF_REQ            */
-#define RFAL_NFCF_SENSF_PARAMS_TSN_POS 3U /*!< Time Slot Number position in the SENSF_REQ        */
-#define RFAL_NFCF_POLL_MAXCARDS 16U /*!< Max number slots/cards 16                         */
-
-#define RFAL_NFCF_CMD_POS 0U /*!< Command/Response code length                      */
-#define RFAL_NFCF_CMD_LEN 1U /*!< Command/Response code length                      */
-#define RFAL_NFCF_LENGTH_LEN 1U /*!< LEN field length                                  */
-#define RFAL_NFCF_HEADER_LEN (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_CMD_LEN) /*!< Header length*/
-
-#define RFAL_NFCF_SENSF_NFCID2_BYTE1_POS \
-    0U /*!< NFCID2 byte1 position                             */
-#define RFAL_NFCF_SENSF_NFCID2_BYTE2_POS \
-    1U /*!< NFCID2 byte2 position                             */
-
-#define RFAL_NFCF_SENSF_NFCID2_PROT_TYPE_LEN \
-    2U /*!< NFCID2 length for byte 1 and byte 2 indicating NFC-DEP or T3T support */
-#define RFAL_NFCF_SENSF_NFCID2_BYTE1_NFCDEP \
-    0x01U /*!< NFCID2 byte1 NFC-DEP support            Digital 1.0 Table 44 */
-#define RFAL_NFCF_SENSF_NFCID2_BYTE2_NFCDEP \
-    0xFEU /*!< NFCID2 byte2 NFC-DEP support            Digital 1.0 Table 44 */
-
-#define RFAL_NFCF_SYSTEMCODE \
-    0xFFFFU /*!< SENSF_RES Default System Code            Digital 1.0 6.6.1.1 */
-
-#define RFAL_NFCF_BLOCK_LEN \
-    16U /*!< NFCF T3T Block size                        T3T 1.0  4.1      */
-#define RFAL_NFCF_CHECKUPDATE_RES_ST1_POS \
-    9U /*!< Check|Update Res Status Flag 1 position    T3T 1.0  Table 8  */
-#define RFAL_NFCF_CHECKUPDATE_RES_ST2_POS \
-    10U /*!< Check|Update Res Status Flag 2 position    T3T 1.0  Table 8  */
-#define RFAL_NFCF_CHECKUPDATE_RES_NOB_POS \
-    11U /*!< Check|Update Res Number of Blocks position T3T 1.0  Table 8  */
-
-#define RFAL_NFCF_STATUS_FLAG_SUCCESS \
-    0x00U /*!< Check response Number of Blocks position   T3T 1.0  Table 11 */
-#define RFAL_NFCF_STATUS_FLAG_ERROR \
-    0xFFU /*!< Check response Number of Blocks position   T3T 1.0  Table 11 */
-
-#define RFAL_NFCF_BLOCKLISTELEM_LEN \
-    0x80U /*!< Block List Element Length bit (2|3 bytes)      T3T 1.0 5.6.1 */
-
-#define RFAL_NFCF_SERVICECODE_RDONLY \
-    0x000BU /*!< NDEF Service Code as Read-Only                 T3T 1.0 7.2.1 */
-#define RFAL_NFCF_SERVICECODE_RDWR \
-    0x0009U /*!< NDEF Service Code as Read and Write            T3T 1.0 7.2.1 */
-
-/*! NFC-F Felica command set   JIS X6319-4  9.1 */
-enum {
-    RFAL_NFCF_CMD_POLLING =
-        0x00, /*!< SENSF_REQ (Felica Poll/REQC command to identify a card )       */
-    RFAL_NFCF_CMD_POLLING_RES =
-        0x01, /*!< SENSF_RES (Felica Poll/REQC command response )                 */
-    RFAL_NFCF_CMD_REQUEST_SERVICE =
-        0x02, /*!< verify the existence of Area and Service                       */
-    RFAL_NFCF_CMD_REQUEST_RESPONSE =
-        0x04, /*!< verify the existence of a card                                 */
-    RFAL_NFCF_CMD_READ_WITHOUT_ENCRYPTION =
-        0x06, /*!< read Block Data from a Service that requires no authentication */
-    RFAL_NFCF_CMD_READ_WITHOUT_ENCRYPTION_RES =
-        0x07, /*!< read Block Data response from a Service with no authentication */
-    RFAL_NFCF_CMD_WRITE_WITHOUT_ENCRYPTION =
-        0x08, /*!< write Block Data to a Service that requires no authentication  */
-    RFAL_NFCF_CMD_WRITE_WITHOUT_ENCRYPTION_RES =
-        0x09, /*!< write Block Data response to a Service with no authentication  */
-    RFAL_NFCF_CMD_REQUEST_SYSTEM_CODE =
-        0x0c, /*!< acquire the System Code registered to a card                   */
-    RFAL_NFCF_CMD_AUTHENTICATION1 =
-        0x10, /*!< authenticate a card                                            */
-    RFAL_NFCF_CMD_AUTHENTICATION2 =
-        0x12, /*!< allow a card to authenticate a Reader/Writer                   */
-    RFAL_NFCF_CMD_READ =
-        0x14, /*!< read Block Data from a Service that requires authentication    */
-    RFAL_NFCF_CMD_WRITE =
-        0x16, /*!< write Block Data to a Service that requires authentication     */
-};
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*! Checks if the given NFC-F device indicates NFC-DEP support */
-#define rfalNfcfIsNfcDepSupported(dev)                                                     \
-    ((((rfalNfcfListenDevice*)(dev))->sensfRes.NFCID2[RFAL_NFCF_SENSF_NFCID2_BYTE1_POS] == \
-      RFAL_NFCF_SENSF_NFCID2_BYTE1_NFCDEP) &&                                              \
-     (((rfalNfcfListenDevice*)(dev))->sensfRes.NFCID2[RFAL_NFCF_SENSF_NFCID2_BYTE2_POS] == \
-      RFAL_NFCF_SENSF_NFCID2_BYTE2_NFCDEP))
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-F SENSF_RES format  Digital 1.1  8.6.2 */
-typedef struct {
-    uint8_t CMD; /*!< Command Code: 01h  */
-    uint8_t NFCID2[RFAL_NFCF_NFCID2_LEN]; /*!< NFCID2             */
-    uint8_t PAD0[RFAL_NFCF_SENSF_RES_PAD0_LEN]; /*!< PAD0               */
-    uint8_t PAD1[RFAL_NFCF_SENSF_RES_PAD1_LEN]; /*!< PAD1               */
-    uint8_t MRTIcheck; /*!< MRTIcheck          */
-    uint8_t MRTIupdate; /*!< MRTIupdate         */
-    uint8_t PAD2; /*!< PAD2               */
-    uint8_t RD[RFAL_NFCF_SENSF_RES_RD_LEN]; /*!< Request Data       */
-} rfalNfcfSensfRes;
-
-/*! NFC-F poller device (PCD) struct  */
-typedef struct {
-    uint8_t NFCID2[RFAL_NFCF_NFCID2_LEN]; /*!< NFCID2             */
-} rfalNfcfPollDevice;
-
-/*! NFC-F listener device (PICC) struct  */
-typedef struct {
-    uint8_t sensfResLen; /*!< SENF_RES length    */
-    rfalNfcfSensfRes sensfRes; /*!< SENF_RES           */
-} rfalNfcfListenDevice;
-
-typedef uint16_t rfalNfcfServ; /*!< NFC-F Service Code */
-
-/*! NFC-F Block List Element (2 or 3 bytes element)       T3T 1.0 5.6.1 */
-typedef struct {
-    uint8_t conf; /*!<  Access Mode | Serv Code List Order */
-    uint16_t blockNum; /*!<  Block Number                       */
-} rfalNfcfBlockListElem;
-
-/*! Check Update Service list and Block list parameter */
-typedef struct {
-    uint8_t numServ; /*!< Number of Services */
-    rfalNfcfServ* servList; /*!< Service Code List  */
-    uint8_t numBlock; /*!< Number of Blocks   */
-    rfalNfcfBlockListElem* blockList; /*!< Block Number List  */
-} rfalNfcfServBlockListParam;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize NFC-F Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFC-F Poller/RW (FeliCa PCD) including all default timings
- * 
- * \param[in]  bitRate      : NFC-F bitrate to be initialize (212 or 424)
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Incorrect bitrate
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerInitialize(rfalBitRate bitRate);
-
-/*! 
- *****************************************************************************
- *  \brief NFC-F Poller Check Presence
- *  
- *  This function sends a Poll/SENSF command according to NFC Activity spec
- *  It detects if a NCF-F device is within range
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_NONE         : No error and some NFC-F device was detected
- *
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerCheckPresence(void);
-
-/*! 
- *****************************************************************************
- * \brief NFC-F Poller Poll
- * 
- * This function sends to all PICCs in field the POLL command with the given
- * number of slots.
- *
- * \param[in]  slots      : the number of slots to be performed
- * \param[in]  sysCode    : as given in FeliCa poll command  
- * \param[in]  reqCode    : FeliCa communication parameters
- * \param[out] cardList   : Parameter of type rfalFeliCaPollRes which will hold the cards found
- * \param[out] devCnt     : actual number of cards found
- * \param[out] collisions : number of collisions encountered
- *
- * \warning the list cardList has to be as big as the number of slots for the Poll
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_NONE         : No error and some NFC-F device was detected
- *
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerPoll(
-    rfalFeliCaPollSlots slots,
-    uint16_t sysCode,
-    uint8_t reqCode,
-    rfalFeliCaPollRes* cardList,
-    uint8_t* devCnt,
-    uint8_t* collisions);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-F Poller Full Collision Resolution
- *  
- * Performs a full Collision resolution as defined in Activity 1.1  9.3.4
- *
- * \param[in]  compMode    : compliance mode to be performed
- * \param[in]  devLimit    : device limit value, and size nfcaDevList
- * \param[out] nfcfDevList : NFC-F listener devices list
- * \param[out] devCnt      : Devices found counter
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcfListenDevice* nfcfDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-F Poller Check/Read
- *  
- * It computes a Check / Read command according to T3T 1.0 and JIS X6319-4 and 
- * sends it to PICC. If successfully, the rxBuf will contain the the number of 
- * blocks in the first byte followed by the blocks data.
- *
- * \param[in]  nfcid2      : nfcid2 of the device
- * \param[in]  servBlock   : parameter containing the list of Services and
- *                           Blocks to be addressed by this command
- * \param[out] rxBuf       : buffer to place check/read data 
- * \param[in]  rxBufLen    : size of the rxBuf
- * \param[out] rcvdLen     : length of data placed in rxBuf
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_REQUEST      : The request was executed with error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerCheck(
-    const uint8_t* nfcid2,
-    const rfalNfcfServBlockListParam* servBlock,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvdLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-F Poller Update/Write
- *  
- * It computes a Update / Write command according to T3T 1.0 and JIS X6319-4 and 
- * sends it to PICC.
- *
- * \param[in]  nfcid2      : nfcid2 of the device
- * \param[in]  servBlock   : parameter containing the list of Services and
- *                           Blocks to be addressed by this command
- * \param[in]  txBuf       : buffer where the request will be composed
- * \param[in]  txBufLen    : size of txBuf
- * \param[in]  blockData   : data to written on the given block(s)
- * \param[out] rxBuf       : buffer to place check/read data 
- * \param[in]  rxBufLen    : size of the rxBuf
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_REQUEST      : The request was executed with error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcfPollerUpdate(
-    const uint8_t* nfcid2,
-    const rfalNfcfServBlockListParam* servBlock,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    const uint8_t* blockData,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen);
-
-/*!
- *****************************************************************************
- * \brief NFC-F Listener is T3T Request  
- * 
- * This method checks if the given data is a valid T3T command (Read or Write) 
- * and in case a valid request has been received it may output the request's NFCID2
- * 
- * \param[in]   buf : buffer holding Initiator's received command
- * \param[in]   bufLen : length of received command in bytes
- * \param[out]  nfcid2 : pointer to where the NFCID2 may be outputted, 
- *                       nfcid2 has NFCF_SENSF_NFCID2_LEN as length
- *                       Pass NULL if output parameter not desired 
- * 
- * \return true  : Valid T3T command (Read or Write) received
- * \return false : Invalid protocol request
- * 
- *****************************************************************************
- */
-bool rfalNfcfListenerIsT3TReq(const uint8_t* buf, uint16_t bufLen, uint8_t* nfcid2);
-
-#endif /* RFAL_NFCF_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_nfcv.h

@@ -1,923 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcv.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-V Poller (ISO15693) device
- *
- *  The definitions and helpers methods provided by this module 
- *  are aligned with NFC-V Digital 2.1
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup NFC-V
- * \brief RFAL NFC-V Module
- * @{
- * 
- */
-
-#ifndef RFAL_NFCV_H
-#define RFAL_NFCV_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCV_UID_LEN 8U /*!< NFC-V UID length                                             */
-#define RFAL_NFCV_MAX_BLOCK_LEN \
-    32U /*!< Max Block size: can be of up to 256 bits  ISO 15693 2000  5  */
-#define RFAL_NFCV_BNO_LEN 1U /*!< NFC-V Block Number length                                    */
-#define RFAL_NFCV_CRC_LEN 2U /*!< NFC-V CRC length                                             */
-#define RFAL_NFCV_MAX_GEN_DATA_LEN \
-    (RFAL_NFCV_MAX_BLOCK_LEN + RFAL_NFCV_BNO_LEN + RFAL_NFCV_UID_LEN) /*!<Max data    */
-#define RFAL_NFCV_BLOCKNUM_LEN \
-    1U /*!< Block Number length on normal commands: 8 bits               */
-#define RFAL_NFCV_BLOCKNUM_EXTENDED_LEN \
-    2U /*!< Block Number length on extended commands: 16 bits            */
-#define RFAL_NFCV_PARAM_SKIP \
-    0U /*!< Skip proprietary Param Request                               */
-
-/*! NFC-V RequestFlags   ISO15693 2000 7.3.1 */
-enum {
-    RFAL_NFCV_REQ_FLAG_DEFAULT =
-        0x02U, /*!< Default Request Flags                                        */
-    RFAL_NFCV_REQ_FLAG_SUB_CARRIER =
-        0x01U, /*!< Sub Carrier flag                                             */
-    RFAL_NFCV_REQ_FLAG_DATA_RATE =
-        0x02U, /*!< Data Rate flag                                               */
-    RFAL_NFCV_REQ_FLAG_INVENTORY =
-        0x04U, /*!< Inventory flag                                               */
-    RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT =
-        0x08U, /*!< Protocol Extension flag                                      */
-    RFAL_NFCV_REQ_FLAG_SELECT =
-        0x10U, /*!< Select flag                                                  */
-    RFAL_NFCV_REQ_FLAG_ADDRESS =
-        0x20U, /*!< Address flag                                                 */
-    RFAL_NFCV_REQ_FLAG_OPTION =
-        0x40U, /*!< Option flag                                                  */
-    RFAL_NFCV_REQ_FLAG_RFU =
-        0x80U, /*!< RFU flag                                                     */
-    RFAL_NFCV_REQ_FLAG_AFI =
-        0x10U, /*!< AFI flag                                                     */
-    RFAL_NFCV_REQ_FLAG_NB_SLOTS =
-        0x20U, /*!< Number of Slots flag                                         */
-};
-
-/*! NFC-V Response Flags   ISO15693 2000 7.4.1 */
-enum {
-    RFAL_NFCV_RES_FLAG_ERROR =
-        0x01U, /*!< Error flag                                                   */
-    RFAL_NFCV_RES_FLAG_RFU1 =
-        0x02U, /*!< RFU flag                                                     */
-    RFAL_NFCV_RES_FLAG_RFU2 =
-        0x04U, /*!< RFU flag                                                     */
-    RFAL_NFCV_RES_FLAG_EXTENSION =
-        0x08U, /*!< Extension flag                                               */
-    RFAL_NFCV_RES_FLAG_RFU3 =
-        0x10U, /*!< RFU flag                                                     */
-    RFAL_NFCV_RES_FLAG_RFU4 =
-        0x20U, /*!< RFU flag                                                     */
-    RFAL_NFCV_RES_FLAG_RFU5 =
-        0x40U, /*!< RFU flag                                                     */
-    RFAL_NFCV_RES_FLAG_RFU6 =
-        0x80U /*!< RFU flag                                                     */
-};
-
-/*! NFC-V Error code  ISO15693 2000 7.4.2 */
-enum {
-    RFAL_NFCV_ERROR_CMD_NOT_SUPPORTED =
-        0x01U, /*!< The command is not supported, code is not recognised         */
-    RFAL_NFCV_ERROR_CMD_NOT_RECOGNIZED =
-        0x02U, /*!< The command is not recognised, format error occurred         */
-    RFAL_NFCV_ERROR_OPTION_NOT_SUPPORTED =
-        0x03U, /*!< The option is not supported                                  */
-    RFAL_NFCV_ERROR_UNKNOWN =
-        0x0FU, /*!< Unknown error                                                */
-    RFAL_NFCV_ERROR_BLOCK_NOT_AVALIABLE =
-        0x10U, /*!< The specified block is not available                         */
-    RFAL_NFCV_ERROR_BLOCK_ALREDY_LOCKED =
-        0x11U, /*!< The specified block is already locked                        */
-    RFAL_NFCV_ERROR_BLOCK_LOCKED =
-        0x12U, /*!< The specified block is locked                                */
-    RFAL_NFCV_ERROR_WRITE_FAILED =
-        0x13U, /*!< The specified block was not successfully programmed          */
-    RFAL_NFCV_ERROR_BLOCK_FAILED =
-        0x14U /*!< The specified block was not successfully locked              */
-};
-
-/*! NFC-V command set   ISO15693 2000 9.1 */
-enum {
-    RFAL_NFCV_CMD_INVENTORY =
-        0x01U, /*!< INVENTORY_REQ (Inventory) command                            */
-    RFAL_NFCV_CMD_SLPV =
-        0x02U, /*!< SLPV_REQ (Stay quiet) command                                */
-    RFAL_NFCV_CMD_READ_SINGLE_BLOCK =
-        0x20U, /*!< Read single block command                                    */
-    RFAL_NFCV_CMD_WRITE_SINGLE_BLOCK =
-        0x21U, /*!< Write single block command                                   */
-    RFAL_NFCV_CMD_LOCK_BLOCK =
-        0x22U, /*!< Lock block command                                           */
-    RFAL_NFCV_CMD_READ_MULTIPLE_BLOCKS =
-        0x23U, /*!< Read multiple blocks command                                 */
-    RFAL_NFCV_CMD_WRITE_MULTIPLE_BLOCKS =
-        0x24U, /*!< Write multiple blocks command                                */
-    RFAL_NFCV_CMD_SELECT =
-        0x25U, /*!< Select command                                               */
-    RFAL_NFCV_CMD_RESET_TO_READY =
-        0x26U, /*!< Reset To Ready command                                       */
-    RFAL_NFCV_CMD_GET_SYS_INFO =
-        0x2BU, /*!< Get System Information command                               */
-    RFAL_NFCV_CMD_EXTENDED_READ_SINGLE_BLOCK =
-        0x30U, /*!< Extended read single block command                           */
-    RFAL_NFCV_CMD_EXTENDED_WRITE_SINGLE_BLOCK =
-        0x31U, /*!< Extended write single block command                          */
-    RFAL_NFCV_CMD_EXTENDED_LOCK_SINGLE_BLOCK =
-        0x32U, /*!< Extended lock single block command                           */
-    RFAL_NFCV_CMD_EXTENDED_READ_MULTIPLE_BLOCK =
-        0x33U, /*!< Extended read multiple block command                         */
-    RFAL_NFCV_CMD_EXTENDED_WRITE_MULTIPLE_BLOCK =
-        0x34U, /*!< Extended read multiple block command                         */
-    RFAL_NFCV_CMD_EXTENDED_GET_SYS_INFO =
-        0x3BU /*!< Extended Get System Information command                      */
-};
-
-/*! ST25TV/ST25DV command set  */
-enum {
-    RFAL_NFCV_CMD_READ_CONFIGURATION =
-        0xA0U, /*!< Read configuration command                                 */
-    RFAL_NFCV_CMD_WRITE_CONFIGURATION =
-        0xA1U, /*!< Write configuration command                                */
-    RFAL_NFCV_CMD_SET_EAS =
-        0xA2U, /*!< Set EAS command                                            */
-    RFAL_NFCV_CMD_RESET_EAS =
-        0xA3U, /*!< Reset EAS command                                          */
-    RFAL_NFCV_CMD_LOCK_EAS =
-        0xA4U, /*!< Lock EAS command                                           */
-    RFAL_NFCV_CMD_ENABLE_EAS =
-        0xA5U, /*!< Enable EAS command                                         */
-    RFAL_NFCV_CMD_KILL = 0xA6U, /*!< Kill command                                               */
-    RFAL_NFCV_CMD_WRITE_EAS_ID =
-        0xA7U, /*!< Write EAS ID command                                       */
-    RFAL_NFCV_CMD_WRITE_EAS_CONFIG =
-        0xA8U, /*!< Write EAS CONFIG command                                   */
-    RFAL_NFCV_CMD_MANAGE_GPO =
-        0xA9U, /*!< Manage GPO command                                         */
-    RFAL_NFCV_CMD_WRITE_MESSAGE =
-        0xAAU, /*!< Write Message command                                      */
-    RFAL_NFCV_CMD_READ_MESSAGE_LENGTH =
-        0xABU, /*!< Read Message Length command                                */
-    RFAL_NFCV_CMD_READ_MESSAGE =
-        0xACU, /*!< Read Message command                                       */
-    RFAL_NFCV_CMD_READ_DYN_CONFIGURATION =
-        0xADU, /*!< Read Dynamic Configuration command                         */
-    RFAL_NFCV_CMD_WRITE_DYN_CONFIGURATION =
-        0xAEU, /*!< Write Dynamic Configuration command                        */
-    RFAL_NFCV_CMD_WRITE_PASSWORD =
-        0xB1U, /*!< Write Kill Password / Write Password command               */
-    RFAL_NFCV_CMD_LOCK_KILL =
-        0xB2U, /*!< Lock Kill command                                          */
-    RFAL_NFCV_CMD_PRESENT_PASSWORD =
-        0xB3U, /*!< Present Password command                                   */
-    RFAL_NFCV_CMD_GET_RANDOM_NUMBER =
-        0xB4U, /*!< Get Random Number command                                  */
-    RFAL_NFCV_CMD_FAST_READ_SINGLE_BLOCK =
-        0xC0U, /*!< Fast Read single block command                             */
-    RFAL_NFCV_CMD_FAST_READ_MULTIPLE_BLOCKS =
-        0xC3U, /*!< Fast Read multiple blocks command                          */
-    RFAL_NFCV_CMD_FAST_EXTENDED_READ_SINGLE_BLOCK =
-        0xC4U, /*!< Fast Extended Read single block command                    */
-    RFAL_NFCV_CMD_FAST_EXTENDED_READ_MULTIPLE_BLOCKS =
-        0xC5U, /*!< Fast Extended Read multiple blocks command                 */
-    RFAL_NFCV_CMD_FAST_WRITE_MESSAGE =
-        0xCAU, /*!< Fast Write Message                                         */
-    RFAL_NFCV_CMD_FAST_READ_MESSAGE_LENGTH =
-        0xCBU, /*!< Fast Read Message Length                                   */
-    RFAL_NFCV_CMD_FAST_READ_MESSAGE =
-        0xCCU, /*!< Fast Read Message                                          */
-    RFAL_NFCV_CMD_FAST_READ_DYN_CONFIGURATION =
-        0xCDU, /*!< Fast Read Dynamic configuration                            */
-    RFAL_NFCV_CMD_FAST_WRITE_DYN_CONFIGURATION =
-        0xCEU /*!< Fast Write Dynamic Configuration                           */
-};
-
-/*! ISO 15693 Get System info parameter request field ISO15693 2018 Table 94 */
-enum {
-    RFAL_NFCV_SYSINFO_DFSID =
-        0x01U, /*!< Get System info DFSID flag                                   */
-    RFAL_NFCV_SYSINFO_AFI =
-        0x02U, /*!< Get System info AFI flag                                     */
-    RFAL_NFCV_SYSINFO_MEMSIZE =
-        0x04U, /*!< Get System info MEMSIZE flag                                 */
-    RFAL_NFCV_SYSINFO_ICREF =
-        0x08U, /*!< Get System info ICREF flag                                   */
-    RFAL_NFCV_SYSINFO_MOI =
-        0x10U, /*!< Get System info MOI flag                                     */
-    RFAL_NFCV_SYSINFO_CMDLIST =
-        0x20U, /*!< Get System info CMDLIST flag                                 */
-    RFAL_NFCV_SYSINFO_CSI =
-        0x40U, /*!< Get System info CSI flag                                     */
-    RFAL_NFCV_SYSINFO_REQ_ALL =
-        0x7FU /*!< Get System info request of all parameters                    */
-};
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-V Number of slots  Digital 2.0  9.6.1 */
-typedef enum {
-    RFAL_NFCV_NUM_SLOTS_1 = 0x20, /*!< Number of slots: 1             */
-    RFAL_NFCV_NUM_SLOTS_16 = 0x00, /*!< Number of slots: 16            */
-} rfalNfcvNumSlots;
-
-/*! NFC-V INVENTORY_RES format   Digital 2.0  9.6.2 */
-typedef struct {
-    uint8_t RES_FLAG; /*!< Response Flags                 */
-    uint8_t DSFID; /*!< Data Storage Format Identifier */
-    uint8_t UID[RFAL_NFCV_UID_LEN]; /*!< NFC-V device UID               */
-    uint8_t crc[RFAL_CRC_LEN]; /*!< CRC                            */
-} rfalNfcvInventoryRes;
-
-/*! NFC-V Generic Req format  */
-typedef struct {
-    uint8_t REQ_FLAG; /*!< Request Flags      */
-    uint8_t CMD; /*!< Command code       */
-    union { /*  PRQA S 0750 # MISRA 19.2 - Both members are of the same type, just different names.  Thus no problem can occur. */
-        uint8_t UID[RFAL_NFCV_UID_LEN]; /*!< Mask Value         */
-        uint8_t data[RFAL_NFCV_MAX_GEN_DATA_LEN]; /*!< Data               */
-    } payload; /*!< Payload            */
-} rfalNfcvGenericReq;
-
-/*! NFC-V Generic Response format */
-typedef struct {
-    uint8_t RES_FLAG; /*!< Response Flags     */
-    uint8_t data[RFAL_NFCV_MAX_GEN_DATA_LEN]; /*!< Data               */
-} rfalNfcvGenericRes;
-
-/*! NFC-V listener device (VICC) struct  */
-typedef struct {
-    rfalNfcvInventoryRes InvRes; /*!< INVENTORY_RES                  */
-    bool isSleep; /*!< Device sleeping flag           */
-} rfalNfcvListenDevice;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize NFC-V Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFC-F Poller/RW (ISO15693) including all default timings 
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Incorrect bitrate
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Check Presence
- *  
- * This method checks if a NFC-V Listen device (VICC) is present on the field
- * by sending an Inventory (INVENTORY_REQ) 
- *  
- * \param[out] invRes : If received, the INVENTORY_RES
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detectedd
- * \return ERR_NONE         : No error, one or more device in the field
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerCheckPresence(rfalNfcvInventoryRes* invRes);
-
-/*! 
- *****************************************************************************
- * \brief NFC-F Poller Poll
- * 
- * This function sends to all VICCs in field the INVENTORY command with the 
- * given number of slots
- * 
- * If more than one slot is used the following EOF need to be handled
- * by the caller using rfalISO15693TransceiveEOFAnticollision()
- *
- * \param[in]  nSlots  : Number of Slots to be sent (1 or 16)
- * \param[in]  maskLen : Number bits on the Mask value
- * \param[in]  maskVal : location of the Mask value
- * \param[out] invRes  : location to place the INVENTORY_RES
- * \param[out] rcvdLen : number of bits received (without collision)
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_RF_COLLISION : Collision detected 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerInventory(
-    rfalNfcvNumSlots nSlots,
-    uint8_t maskLen,
-    const uint8_t* maskVal,
-    rfalNfcvInventoryRes* invRes,
-    uint16_t* rcvdLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Full Collision Resolution
- *  
- * Performs a full Collision resolution as defined in Activity 2.0   9.3.7
- * Once done, the devCnt will indicate how many (if any) devices have 
- * been identified and their details are contained on nfcvDevList
- *
- * \param[in]  compMode     : compliance mode to be performed
- * \param[in]  devLimit     : device limit value, and size nfcaDevList
- * \param[out] nfcvDevList  : NFC-v listener devices list
- * \param[out] devCnt       : Devices found counter
- *
- * When compMode is set to ISO the function immediately goes to 16 slots improving
- * chances to detect more than only one strong card.
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcvListenDevice* nfcvDevList,
-    uint8_t* devCnt);
-
-/*!
- *****************************************************************************
- * \brief  NFC-V Poller Full Collision Resolution With Sleep
- *
- * Performs a full Collision resolution which is different from Activity 2.0 9.3.7.
- * The implementation uses SLPV (StayQuiet) command to make sure all cards are found.
- * Once done, the devCnt will indicate how many (if any) devices have
- * been identified and their details are contained on nfcvDevList
- *
- * \param[in]  devLimit     : device limit value, and size nfcaDevList
- * \param[out] nfcvDevList  : NFC-v listener devices list
- * \param[out] devCnt       : Devices found counter
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerSleepCollisionResolution(
-    uint8_t devLimit,
-    rfalNfcvListenDevice* nfcvDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Sleep
- *  
- * This function is used to send the SLPV_REQ (Stay Quiet) command to put the VICC 
- * with the given UID to state QUIET so that they do not reply to more Inventory
- * 
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to Sleep
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerSleep(uint8_t flags, const uint8_t* uid);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Select
- *  
- * Selects a device (VICC) by its UID 
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be Selected
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerSelect(uint8_t flags, const uint8_t* uid);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Single Block
- *  
- * Reads a Single Block from a device (VICC)  
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to read
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Single Block
- *  
- * Writes a Single Block from a device (VICC)
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be written
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to write
- * \param[in]  wrData       : data to be written on the given block
- * \param[in]  blockLen     : number of bytes of a block
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Multiple Blocks
- *  
- * Reads Multiple Blocks from a device (VICC)  
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  firstBlockNum  : first block to be read
- * \param[in]  numOfBlocks    : number of block to read
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Multiple Blocks
- *  
- * Reads Multiple Blocks from a device (VICC)
- * In order to not limit the length of the Write multiple command, a buffer
- * must be provided where the request will be composed and then sent.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  firstBlockNum  : first block to be write
- * \param[in]  numOfBlocks    : number of consecutive blocks to write
- * \param[in]  txBuf          : buffer where the request will be composed
- * \param[in]  txBufLen       : length of txBuf
- * \param[in]  blockLen       : number of bytes of a block
- * \param[in]  wrData         : data to be written
- * \param[in]  wrDataLen      : length of the data do be written. Must be
- *                              aligned with number of blocks to write and
- *                              the size of a block
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerWriteMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t blockLen,
-    const uint8_t* wrData,
-    uint16_t wrDataLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Lock Single Block
- *  
- * Blocks a Single Block from a device (VICC) supporting extended commands
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to be locked
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerLockBlock(uint8_t flags, const uint8_t* uid, uint8_t blockNum);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Lock Single Block
- *  
- * Blocks a Single Block from a device (VICC) supporting extended commands
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to be locked (16 bits)
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode
-    rfalNfcvPollerExtendedLockSingleBlock(uint8_t flags, const uint8_t* uid, uint16_t blockNum);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Read Single Block
- *  
- * Reads a Single Block from a device (VICC) supporting extended commands
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to read (16 bits)
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerExtendedReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Write Single Block
- *  
- * Writes a Single Block from a device (VICC) supporting extended commands
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device
- *                             if UID is provided Addressed mode will be used
- * \param[in]  blockNum     : Number of the block to write (16 bits)
- * \param[in]  wrData       : data to be written on the given block
- * \param[in]  blockLen     : number of bytes of a block
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerExtendedWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Read Multiple Blocks
- *  
- * Reads Multiple Blocks from a device (VICC) supporting extended commands  
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  firstBlockNum  : first block to be read (16 bits)
- * \param[in]  numOfBlocks    : number of consecutive blocks to read (16 bits)
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerExtendedReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Extended Write Multiple Blocks
- *  
- * Writes Multiple Blocks from a device (VICC) supporting extended commands 
- * In order to not limit the length of the Write multiple command, a buffer
- * must be provided where the request will be composed and then sent.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  firstBlockNum  : first block to be write (16 bits)
- * \param[in]  numOfBlocks    : number of consecutive blocks to write (16 bits)
- * \param[in]  txBuf          : buffer where the request will be composed
- * \param[in]  txBufLen       : length of txBuf
- * \param[in]  blockLen       : number of bytes of a block
- * \param[in]  wrData         : data to be written
- * \param[in]  wrDataLen      : length of the data do be written. Must be
- *                              aligned with number of blocks to write and
- *                              the size of a block
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerExtendedWriteMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t blockLen,
-    const uint8_t* wrData,
-    uint16_t wrDataLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Get System Information
- *  
- * Sends Get System Information command  
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerGetSystemInformation(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Extended Get System Information
- *  
- * Sends Extended Get System Information command  
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  requestField   : Get System info parameter request field
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerExtendedGetSystemInformation(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t requestField,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Transceive Request
- *  
- * Performs a generic transceive with an ISO15693 tag
- *
- * \param[in]  cmd            : NFC-V command
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  param          : Prepend parameter on certain proprietary requests
- *                              For default commands skip: RFAL_NFCV_PARAM_SKIP
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if UID is provided Addressed mode will be used
- * \param[in]  data           : command parameters append after UID
- * \param[in]  dataLen        : command parameters Len
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalNfcvPollerTransceiveReq(
-    uint8_t cmd,
-    uint8_t flags,
-    uint8_t param,
-    const uint8_t* uid,
-    const uint8_t* data,
-    uint16_t dataLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-#endif /* RFAL_NFCV_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_rf.h

@@ -1,1724 +0,0 @@
-
-/******************************************************************************
-  * \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_rf.h
- *
- *  \author Gustavo Patricio 
- *
- *  \brief RF Abstraction Layer (RFAL)
- *  
- *  RFAL (RF Abstraction Layer) provides several functionalities required to 
- *  perform RF/NFC communications. <br>The RFAL encapsulates the different 
- *  RF ICs (ST25R3911, ST25R391x, etc) into a common and easy to use interface.
- *  
- *  It provides interfaces to configure the RF IC, set/get timings, modes, bit rates,
- *  specific handlings, execute listen mode, etc. 
- *  
- *  Furthermore it provides a common interface to perform a Transceive operations.
- *  The Transceive can be executed in a blocking or non blocking way.<br>
- *  Additionally few specific Transceive methods are available to cope with the
- *  specifics of these particular operations.
- *  
- *  The most common interfaces are:
- *    <br>&nbsp; rfalInitialize()
- *    <br>&nbsp; rfalSetFDTPoll()
- *    <br>&nbsp; rfalSetFDTListen()
- *    <br>&nbsp; rfalSetGT()
- *    <br>&nbsp; rfalSetBitRate()
- *    <br>&nbsp; rfalSetMode()
- *    <br>&nbsp; rfalFieldOnAndStartGT()
- *    <br>&nbsp; rfalFieldOff()
- *    <br>&nbsp; rfalStartTransceive()
- *    <br>&nbsp; rfalGetTransceiveStatus()
- *    <br>&nbsp; rfalTransceiveBlockingTxRx()
- *    
- *  An usage example is provided here: \ref exampleRfalPoller.c
- *  \example exampleRfalPoller.c
- *    
- * \addtogroup RFAL
- * @{
- * 
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- * 
- * \addtogroup RF
- * \brief RFAL RF Abstraction Layer
- * @{
- *  
- */
-
-#ifndef RFAL_RF_H
-#define RFAL_RF_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../platform.h"
-#include "../st_errno.h"
-#include "../source/st25r3916/rfal_features.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-#define RFAL_VERSION 0x020200U /*!< RFAL Current Version: v2.2.0                      */
-
-#define RFAL_FWT_NONE 0xFFFFFFFFU /*!< Disabled FWT: Wait forever for a response         */
-#define RFAL_GT_NONE RFAL_TIMING_NONE /*!< Disabled GT: No GT will be applied after Field On */
-
-#define RFAL_TIMING_NONE 0x00U /*!< Timing disabled | Don't apply                     */
-
-#define RFAL_1FC_IN_4096FC \
-    (uint32_t)4096U /*!< Number of 1/fc cycles in one 4096/fc              */
-#define RFAL_1FC_IN_512FC (uint32_t)512U /*!< Number of 1/fc cycles in one 512/fc               */
-#define RFAL_1FC_IN_64FC (uint32_t)64U /*!< Number of 1/fc cycles in one 64/fc                */
-#define RFAL_1FC_IN_8FC (uint32_t)8U /*!< Number of 1/fc cycles in one 8/fc                 */
-#define RFAL_US_IN_MS (uint32_t)1000U /*!< Number of us in one ms                            */
-#define RFAL_1MS_IN_1FC (uint32_t)13560U /*!< Number of 1/fc cycles in 1ms                      */
-#define RFAL_BITS_IN_BYTE (uint16_t)8U /*!< Number of bits in one byte                        */
-
-#define RFAL_CRC_LEN 2U /*!< RF CRC LEN                                        */
-
-/*! Default TxRx flags: Tx CRC automatic, Rx CRC removed, NFCIP1 mode off, AGC On, Tx Parity automatic, Rx Parity removed */
-#define RFAL_TXRX_FLAGS_DEFAULT                                                      \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_AUTO | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_REMV | \
-     (uint32_t)RFAL_TXRX_FLAGS_NFCIP1_OFF | (uint32_t)RFAL_TXRX_FLAGS_AGC_ON |       \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_REMV | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_AUTO | \
-     (uint32_t)RFAL_TXRX_FLAGS_NFCV_FLAG_AUTO)
-#define RFAL_TXRX_FLAGS_RAW                                                            \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP | \
-     (uint32_t)RFAL_TXRX_FLAGS_NFCIP1_OFF | (uint32_t)RFAL_TXRX_FLAGS_AGC_ON |         \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_KEEP | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_NONE |   \
-     (uint32_t)RFAL_TXRX_FLAGS_NFCV_FLAG_AUTO)
-
-#define RFAL_LM_MASK_NFCA \
-    ((uint32_t)1U         \
-     << (uint8_t)RFAL_MODE_LISTEN_NFCA) /*!< Bitmask for Listen Mode enabling NFCA    */
-#define RFAL_LM_MASK_NFCB \
-    ((uint32_t)1U         \
-     << (uint8_t)RFAL_MODE_LISTEN_NFCB) /*!< Bitmask for Listen Mode enabling NFCB    */
-#define RFAL_LM_MASK_NFCF \
-    ((uint32_t)1U         \
-     << (uint8_t)RFAL_MODE_LISTEN_NFCF) /*!< Bitmask for Listen Mode enabling NFCF    */
-#define RFAL_LM_MASK_ACTIVE_P2P \
-    ((uint32_t)1U               \
-     << (uint8_t)RFAL_MODE_LISTEN_ACTIVE_P2P) /*!< Bitmask for Listen Mode enabling AP2P    */
-
-#define RFAL_LM_SENS_RES_LEN 2U /*!< NFC-A SENS_RES (ATQA) length                      */
-#define RFAL_LM_SENSB_RES_LEN 13U /*!< NFC-B SENSB_RES (ATQB) length                     */
-#define RFAL_LM_SENSF_RES_LEN 19U /*!< NFC-F SENSF_RES  length                           */
-#define RFAL_LM_SENSF_SC_LEN 2U /*!< NFC-F System Code length                          */
-
-#define RFAL_NFCID3_LEN 10U /*!< NFCID3 length                                     */
-#define RFAL_NFCID2_LEN 8U /*!< NFCID2 length                                     */
-#define RFAL_NFCID1_TRIPLE_LEN 10U /*!< NFCID1 length                                     */
-#define RFAL_NFCID1_DOUBLE_LEN 7U /*!< NFCID1 length                                     */
-#define RFAL_NFCID1_SINGLE_LEN 4U /*!< NFCID1 length                                     */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*! Returns the maximum supported bit rate for RW mode. Caller must check if mode is supported before, as even if mode is not supported will return the min  */
-#define rfalGetMaxBrRW()                             \
-    (((RFAL_SUPPORT_BR_RW_6780) ?                    \
-          RFAL_BR_6780 :                             \
-          ((RFAL_SUPPORT_BR_RW_3390) ?               \
-               RFAL_BR_3390 :                        \
-               ((RFAL_SUPPORT_BR_RW_1695) ?          \
-                    RFAL_BR_1695 :                   \
-                    ((RFAL_SUPPORT_BR_RW_848) ?      \
-                         RFAL_BR_848 :               \
-                         ((RFAL_SUPPORT_BR_RW_424) ? \
-                              RFAL_BR_424 :          \
-                              ((RFAL_SUPPORT_BR_RW_212) ? RFAL_BR_212 : RFAL_BR_106)))))))
-
-/*! Returns the maximum supported bit rate for AP2P mode. Caller must check if mode is supported before, as even if mode is not supported will return the min  */
-#define rfalGetMaxBrAP2P()              \
-    (((RFAL_SUPPORT_BR_AP2P_848) ?      \
-          RFAL_BR_848 :                 \
-          ((RFAL_SUPPORT_BR_AP2P_424) ? \
-               RFAL_BR_424 :            \
-               ((RFAL_SUPPORT_BR_AP2P_212) ? RFAL_BR_212 : RFAL_BR_106))))
-
-/*! Returns the maximum supported bit rate for CE-A mode. Caller must check if mode is supported before, as even if mode is not supported will return the min  */
-#define rfalGetMaxBrCEA()               \
-    (((RFAL_SUPPORT_BR_CE_A_848) ?      \
-          RFAL_BR_848 :                 \
-          ((RFAL_SUPPORT_BR_CE_A_424) ? \
-               RFAL_BR_424 :            \
-               ((RFAL_SUPPORT_BR_CE_A_212) ? RFAL_BR_212 : RFAL_BR_106))))
-
-/*! Returns the maximum supported bit rate for CE-B mode. Caller must check if mode is supported before, as even if mode is not supported will return the min  */
-#define rfalGetMaxBrCEB()               \
-    (((RFAL_SUPPORT_BR_CE_B_848) ?      \
-          RFAL_BR_848 :                 \
-          ((RFAL_SUPPORT_BR_CE_B_424) ? \
-               RFAL_BR_424 :            \
-               ((RFAL_SUPPORT_BR_CE_B_212) ? RFAL_BR_212 : RFAL_BR_106))))
-
-/*! Returns the maximum supported bit rate for CE-F mode. Caller must check if mode is supported before, as even if mode is not supported will return the min  */
-#define rfalGetMaxBrCEF() (((RFAL_SUPPORT_BR_CE_F_424) ? RFAL_BR_424 : RFAL_BR_212))
-
-#define rfalIsModeActiveComm(md)            \
-    (((md) == RFAL_MODE_POLL_ACTIVE_P2P) || \
-     ((md) == RFAL_MODE_LISTEN_ACTIVE_P2P)) /*!< Checks if mode md is Active Communication  */
-#define rfalIsModePassiveComm(md) \
-    (!rfalIsModeActiveComm(md)) /*!< Checks if mode md is Passive Communication */
-#define rfalIsModePassiveListen(md)                                        \
-    (((md) == RFAL_MODE_LISTEN_NFCA) || ((md) == RFAL_MODE_LISTEN_NFCB) || \
-     ((md) == RFAL_MODE_LISTEN_NFCF)) /*!< Checks if mode md is Passive Listen        */
-#define rfalIsModePassivePoll(md) \
-    (rfalIsModePassiveComm(md) && \
-     !rfalIsModePassiveListen(md)) /*!< Checks if mode md is Passive Poll          */
-
-#define rfalConv1fcTo8fc(t) \
-    (uint32_t)((uint32_t)(t) / RFAL_1FC_IN_8FC) /*!< Converts the given t from 1/fc to 8/fc     */
-#define rfalConv8fcTo1fc(t) \
-    (uint32_t)((uint32_t)(t) * RFAL_1FC_IN_8FC) /*!< Converts the given t from 8/fc to 1/fc     */
-
-#define rfalConv1fcTo64fc(t) \
-    (uint32_t)((uint32_t)(t) / RFAL_1FC_IN_64FC) /*!< Converts the given t from 1/fc  to 64/fc   */
-#define rfalConv64fcTo1fc(t) \
-    (uint32_t)((uint32_t)(t) * RFAL_1FC_IN_64FC) /*!< Converts the given t from 64/fc to 1/fc    */
-
-#define rfalConv1fcTo512fc(t) \
-    (uint32_t)(               \
-        (uint32_t)(t) / RFAL_1FC_IN_512FC) /*!< Converts the given t from 1/fc  to 512/fc  */
-#define rfalConv512fcTo1fc(t) \
-    (uint32_t)(               \
-        (uint32_t)(t) * RFAL_1FC_IN_512FC) /*!< Converts the given t from 512/fc to 1/fc   */
-
-#define rfalConv1fcTo4096fc(t) \
-    (uint32_t)(                \
-        (uint32_t)(t) / RFAL_1FC_IN_4096FC) /*!< Converts the given t from 1/fc to 4096/fc  */
-#define rfalConv4096fcTo1fc(t) \
-    (uint32_t)(                \
-        (uint32_t)(t) * RFAL_1FC_IN_4096FC) /*!< Converts the given t from 4096/fc to 1/fc  */
-
-#define rfalConv1fcToMs(t) \
-    (uint32_t)((uint32_t)(t) / RFAL_1MS_IN_1FC) /*!< Converts the given t from 1/fc to ms       */
-#define rfalConvMsTo1fc(t) \
-    (uint32_t)((uint32_t)(t) * RFAL_1MS_IN_1FC) /*!< Converts the given t from ms to 1/fc       */
-
-#define rfalConv1fcToUs(t)                \
-    (uint32_t)(                           \
-        ((uint32_t)(t) * RFAL_US_IN_MS) / \
-        RFAL_1MS_IN_1FC) /*!< Converts the given t from 1/fc to us       */
-#define rfalConvUsTo1fc(t)                  \
-    (uint32_t)(                             \
-        ((uint32_t)(t) * RFAL_1MS_IN_1FC) / \
-        RFAL_US_IN_MS) /*!< Converts the given t from us to 1/fc       */
-
-#define rfalConv64fcToMs(t) \
-    (uint32_t)(             \
-        (uint32_t)(t) /     \
-        (RFAL_1MS_IN_1FC / RFAL_1FC_IN_64FC)) /*!< Converts the given t from 64/fc to ms      */
-#define rfalConvMsTo64fc(t) \
-    (uint32_t)(             \
-        (uint32_t)(t) *     \
-        (RFAL_1MS_IN_1FC / RFAL_1FC_IN_64FC)) /*!< Converts the given t from ms to 64/fc      */
-
-#define rfalConvBitsToBytes(n)                       \
-    (uint16_t)(                                      \
-        ((uint16_t)(n) + (RFAL_BITS_IN_BYTE - 1U)) / \
-        (RFAL_BITS_IN_BYTE)) /*!< Converts the given n from bits to bytes    */
-#define rfalConvBytesToBits(n) \
-    (uint32_t)(                \
-        (uint32_t)(n) * (RFAL_BITS_IN_BYTE)) /*!< Converts the given n from bytes to bits    */
-
-/*! Computes a Transceive context \a ctx with default flags and the lengths 
- * in bytes with the given arguments
- *    \a ctx   : Transceive context to be assigned  
- *    \a tB    : txBuf the pointer to the buffer to be sent
- *    \a tBL   : txBuf length in bytes
- *    \a rB    : rxBuf the pointer to the buffer to place the received frame
- *    \a rBL   : rxBuf length in bytes
- *    \a rBL   : rxBuf length in bytes
- *    \a t     : FWT to be used on this transceive in 1/fc
- */
-#define rfalCreateByteTxRxContext(ctx, tB, tBL, rB, rBL, rdL, t) \
-    (ctx).txBuf = (uint8_t*)(tB);                                \
-    (ctx).txBufLen = (uint16_t)rfalConvBytesToBits(tBL);         \
-    (ctx).rxBuf = (uint8_t*)(rB);                                \
-    (ctx).rxBufLen = (uint16_t)rfalConvBytesToBits(rBL);         \
-    (ctx).rxRcvdLen = (uint16_t*)(rdL);                          \
-    (ctx).flags = (uint32_t)RFAL_TXRX_FLAGS_DEFAULT;             \
-    (ctx).fwt = (uint32_t)(t);
-
-/*! Computes a Transceive context \a ctx using lengths in bytes 
- * with the given flags and arguments
- *    \a ctx   : Transceive context to be assigned  
- *    \a tB    : txBuf the pointer to the buffer to be sent
- *    \a tBL   : txBuf length in bytes
- *    \a rB    : rxBuf the pointer to the buffer to place the received frame
- *    \a rBL   : rxBuf length in bytes
- *    \a rBL   : rxBuf length in bytes
- *    \a t     : FWT to be used on this transceive in 1/fc
- */
-#define rfalCreateByteFlagsTxRxContext(ctx, tB, tBL, rB, rBL, rdL, fl, t) \
-    (ctx).txBuf = (uint8_t*)(tB);                                         \
-    (ctx).txBufLen = (uint16_t)rfalConvBytesToBits(tBL);                  \
-    (ctx).rxBuf = (uint8_t*)(rB);                                         \
-    (ctx).rxBufLen = (uint16_t)rfalConvBytesToBits(rBL);                  \
-    (ctx).rxRcvdLen = (uint16_t*)(rdL);                                   \
-    (ctx).flags = (uint32_t)(fl);                                         \
-    (ctx).fwt = (uint32_t)(t);
-
-#define rfalLogE(...) \
-    platformLog(__VA_ARGS__) /*!< Macro for the error log method                  */
-#define rfalLogW(...) \
-    platformLog(__VA_ARGS__) /*!< Macro for the warning log method                */
-#define rfalLogI(...) \
-    platformLog(__VA_ARGS__) /*!< Macro for the info log method                   */
-#define rfalLogD(...) \
-    platformLog(__VA_ARGS__) /*!< Macro for the debug log method                  */
-
-/*
-******************************************************************************
-* GLOBAL ENUMS
-******************************************************************************
-*/
-
-/* RFAL Guard Time (GT) default values                 */
-#define RFAL_GT_NFCA \
-    rfalConvMsTo1fc( \
-        5U) /*!< GTA  Digital 2.0  6.10.4.1 & B.2                                                                 */
-#define RFAL_GT_NFCB \
-    rfalConvMsTo1fc( \
-        5U) /*!< GTB  Digital 2.0  7.9.4.1  & B.3                                                                 */
-#define RFAL_GT_NFCF \
-    rfalConvMsTo1fc( \
-        20U) /*!< GTF  Digital 2.0  8.7.4.1  & B.4                                                                 */
-#define RFAL_GT_NFCV \
-    rfalConvMsTo1fc( \
-        5U) /*!< GTV  Digital 2.0  9.7.5.1  & B.5                                                                 */
-#define RFAL_GT_PICOPASS \
-    rfalConvMsTo1fc(     \
-        1U) /*!< GT Picopass                                                                                      */
-#define RFAL_GT_AP2P \
-    rfalConvMsTo1fc( \
-        5U) /*!< TIRFG  Ecma 340  11.1.1                                                                          */
-#define RFAL_GT_AP2P_ADJUSTED \
-    rfalConvMsTo1fc(          \
-        5U +                  \
-        25U) /*!< Adjusted GT for greater interoperability (Sony XPERIA P, Nokia N9, Huawei P2)                    */
-
-/* RFAL Frame Delay Time (FDT) Listen default values   */
-#define RFAL_FDT_LISTEN_NFCA_POLLER \
-    1172U /*!< FDTA,LISTEN,MIN (n=9) Last bit: Logic "1" - tnn,min/2 Digital 1.1  6.10 ;  EMV CCP Spec Book D v2.01  4.8.1.3   */
-#define RFAL_FDT_LISTEN_NFCB_POLLER \
-    1008U /*!< TR0B,MIN         Digital 1.1  7.1.3 & A.3  ; EMV CCP Spec Book D v2.01  4.8.1.3 & Table A.5                     */
-#define RFAL_FDT_LISTEN_NFCF_POLLER \
-    2672U /*!< TR0F,LISTEN,MIN  Digital 1.1  8.7.1.1 & A.4                                                                     */
-#define RFAL_FDT_LISTEN_NFCV_POLLER \
-    4310U /*!< FDTV,LISTEN,MIN  t1 min       Digital 2.1  B.5  ;  ISO15693-3 2009  9.1                                          */
-#define RFAL_FDT_LISTEN_PICOPASS_POLLER \
-    3400U /*!< ISO15693 t1 min - observed adjustment                                                                           */
-#define RFAL_FDT_LISTEN_AP2P_POLLER \
-    64U /*!< FDT AP2P No actual FDTListen is required as fields switch and collision avoidance                               */
-#define RFAL_FDT_LISTEN_NFCA_LISTENER \
-    1172U /*!< FDTA,LISTEN,MIN  Digital 1.1  6.10                                                                              */
-#define RFAL_FDT_LISTEN_NFCB_LISTENER \
-    1024U /*!< TR0B,MIN         Digital 1.1  7.1.3 & A.3  ;  EMV CCP Spec Book D v2.01  4.8.1.3 & Table A.5                    */
-#define RFAL_FDT_LISTEN_NFCF_LISTENER \
-    2688U /*!< TR0F,LISTEN,MIN  Digital 2.1  8.7.1.1 & B.4                                                                     */
-#define RFAL_FDT_LISTEN_AP2P_LISTENER \
-    64U /*!< FDT AP2P No actual FDTListen exists as fields switch and collision avoidance                                    */
-
-/*  RFAL Frame Delay Time (FDT) Poll default values    */
-#define RFAL_FDT_POLL_NFCA_POLLER \
-    6780U /*!< FDTA,POLL,MIN   Digital 1.1  6.10.3.1 & A.2                                                                     */
-#define RFAL_FDT_POLL_NFCA_T1T_POLLER \
-    384U /*!< RRDDT1T,MIN,B1  Digital 1.1  10.7.1 & A.5                                                                       */
-#define RFAL_FDT_POLL_NFCB_POLLER \
-    6780U /*!< FDTB,POLL,MIN = TR2B,MIN,DEFAULT Digital 1.1 7.9.3 & A.3  ;  EMVCo 3.0 FDTB,PCD,MIN  Table A.5                  */
-#define RFAL_FDT_POLL_NFCF_POLLER \
-    6800U /*!< FDTF,POLL,MIN   Digital 2.1  8.7.3 & B.4                                                                        */
-#define RFAL_FDT_POLL_NFCV_POLLER \
-    4192U /*!< FDTV,POLL  Digital 2.1  9.7.3.1  & B.5                                                                          */
-#define RFAL_FDT_POLL_PICOPASS_POLLER \
-    1790U /*!< FDT Max                                                                                                         */
-#define RFAL_FDT_POLL_AP2P_POLLER \
-    0U /*!< FDT AP2P No actual FDTPoll exists as fields switch and collision avoidance                                      */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! RFAL modes    */
-typedef enum {
-    RFAL_MODE_NONE = 0, /*!< No mode selected/defined                                         */
-    RFAL_MODE_POLL_NFCA =
-        1, /*!< Mode to perform as NFCA (ISO14443A) Poller (PCD)                 */
-    RFAL_MODE_POLL_NFCA_T1T =
-        2, /*!< Mode to perform as NFCA T1T (Topaz) Poller (PCD)                 */
-    RFAL_MODE_POLL_NFCB =
-        3, /*!< Mode to perform as NFCB (ISO14443B) Poller (PCD)                 */
-    RFAL_MODE_POLL_B_PRIME =
-        4, /*!< Mode to perform as B' Calypso (Innovatron) (PCD)                 */
-    RFAL_MODE_POLL_B_CTS =
-        5, /*!< Mode to perform as CTS Poller (PCD)                              */
-    RFAL_MODE_POLL_NFCF =
-        6, /*!< Mode to perform as NFCF (FeliCa) Poller (PCD)                    */
-    RFAL_MODE_POLL_NFCV =
-        7, /*!< Mode to perform as NFCV (ISO15963) Poller (PCD)                  */
-    RFAL_MODE_POLL_PICOPASS =
-        8, /*!< Mode to perform as PicoPass / iClass Poller (PCD)                */
-    RFAL_MODE_POLL_ACTIVE_P2P =
-        9, /*!< Mode to perform as Active P2P (ISO18092) Initiator               */
-    RFAL_MODE_LISTEN_NFCA =
-        10, /*!< Mode to perform as NFCA (ISO14443A) Listener (PICC)              */
-    RFAL_MODE_LISTEN_NFCB =
-        11, /*!< Mode to perform as NFCA (ISO14443B) Listener (PICC)              */
-    RFAL_MODE_LISTEN_NFCF =
-        12, /*!< Mode to perform as NFCA (ISO15963) Listener (PICC)               */
-    RFAL_MODE_LISTEN_ACTIVE_P2P =
-        13 /*!< Mode to perform as Active P2P (ISO18092) Target                  */
-} rfalMode;
-
-/*! RFAL Bit rates    */
-typedef enum {
-    RFAL_BR_106 = 0, /*!< Bit Rate 106 kbit/s (fc/128)                                     */
-    RFAL_BR_212 = 1, /*!< Bit Rate 212 kbit/s (fc/64)                                      */
-    RFAL_BR_424 = 2, /*!< Bit Rate 424 kbit/s (fc/32)                                      */
-    RFAL_BR_848 = 3, /*!< Bit Rate 848 kbit/s (fc/16)                                      */
-    RFAL_BR_1695 = 4, /*!< Bit Rate 1695 kbit/s (fc/8)                                      */
-    RFAL_BR_3390 = 5, /*!< Bit Rate 3390 kbit/s (fc/4)                                      */
-    RFAL_BR_6780 = 6, /*!< Bit Rate 6780 kbit/s (fc/2)                                      */
-    RFAL_BR_13560 = 7, /*!< Bit Rate 13560 kbit/s (fc)                                       */
-    RFAL_BR_52p97 = 0xEB, /*!< Bit Rate 52.97 kbit/s (fc/256) Fast Mode VICC->VCD               */
-    RFAL_BR_26p48 = 0xEC, /*!< Bit Rate 26,48 kbit/s (fc/512) NFCV VICC->VCD & VCD->VICC 1of4   */
-    RFAL_BR_1p66 = 0xED, /*!< Bit Rate 1,66 kbit/s (fc/8192) NFCV VCD->VICC 1of256             */
-    RFAL_BR_KEEP = 0xFF /*!< Value indicating to keep the same previous bit rate              */
-} rfalBitRate;
-
-/*! RFAL Compliance modes for upper modules  */
-typedef enum {
-    RFAL_COMPLIANCE_MODE_NFC, /*!< Perform with NFC Forum 1.1 compliance                            */
-    RFAL_COMPLIANCE_MODE_EMV, /*!< Perform with EMVCo compliance                                    */
-    RFAL_COMPLIANCE_MODE_ISO /*!< Perform with ISO10373 compliance                                 */
-} rfalComplianceMode;
-
-/*! RFAL main states flags    */
-typedef enum {
-    RFAL_STATE_IDLE = 0,
-    RFAL_STATE_INIT = 1,
-    RFAL_STATE_MODE_SET = 2,
-
-    RFAL_STATE_TXRX = 3,
-    RFAL_STATE_LM = 4,
-    RFAL_STATE_WUM = 5
-
-} rfalState;
-
-/*! RFAL transceive states    */
-typedef enum {
-    RFAL_TXRX_STATE_IDLE = 0,
-    RFAL_TXRX_STATE_INIT = 1,
-    RFAL_TXRX_STATE_START = 2,
-
-    RFAL_TXRX_STATE_TX_IDLE = 11,
-    RFAL_TXRX_STATE_TX_WAIT_GT = 12,
-    RFAL_TXRX_STATE_TX_WAIT_FDT = 13,
-    RFAL_TXRX_STATE_TX_TRANSMIT = 14,
-    RFAL_TXRX_STATE_TX_WAIT_WL = 15,
-    RFAL_TXRX_STATE_TX_RELOAD_FIFO = 16,
-    RFAL_TXRX_STATE_TX_WAIT_TXE = 17,
-    RFAL_TXRX_STATE_TX_DONE = 18,
-    RFAL_TXRX_STATE_TX_FAIL = 19,
-
-    RFAL_TXRX_STATE_RX_IDLE = 81,
-    RFAL_TXRX_STATE_RX_WAIT_EON = 82,
-    RFAL_TXRX_STATE_RX_WAIT_RXS = 83,
-    RFAL_TXRX_STATE_RX_WAIT_RXE = 84,
-    RFAL_TXRX_STATE_RX_READ_FIFO = 85,
-    RFAL_TXRX_STATE_RX_ERR_CHECK = 86,
-    RFAL_TXRX_STATE_RX_READ_DATA = 87,
-    RFAL_TXRX_STATE_RX_WAIT_EOF = 88,
-    RFAL_TXRX_STATE_RX_DONE = 89,
-    RFAL_TXRX_STATE_RX_FAIL = 90,
-
-} rfalTransceiveState;
-
-/*! RFAL transceive flags                                                                                                                    */
-enum {
-    RFAL_TXRX_FLAGS_CRC_TX_AUTO =
-        (0U
-         << 0), /*!< CRC will be generated automatic upon transmission                                     */
-    RFAL_TXRX_FLAGS_CRC_TX_MANUAL =
-        (1U
-         << 0), /*!< CRC was calculated manually, included in txBuffer                                     */
-    RFAL_TXRX_FLAGS_CRC_RX_KEEP =
-        (1U
-         << 1), /*!< Upon Reception keep the CRC in rxBuffer (reflected on rcvd length)                    */
-    RFAL_TXRX_FLAGS_CRC_RX_REMV =
-        (0U
-         << 1), /*!< Enable CRC check and remove the CRC from rxBuffer                                     */
-    RFAL_TXRX_FLAGS_NFCIP1_ON =
-        (1U
-         << 2), /*!< Enable NFCIP1 mode: Add SB(F0) and LEN bytes during Tx and skip SB(F0) byte during Rx */
-    RFAL_TXRX_FLAGS_NFCIP1_OFF =
-        (0U
-         << 2), /*!< Disable NFCIP1 mode: do not append protocol bytes while Tx nor skip while Rx          */
-    RFAL_TXRX_FLAGS_AGC_OFF =
-        (1U
-         << 3), /*!< Disable Automatic Gain Control, improving multiple devices collision detection        */
-    RFAL_TXRX_FLAGS_AGC_ON =
-        (0U
-         << 3), /*!< Enable Automatic Gain Control, improving single device reception                      */
-    RFAL_TXRX_FLAGS_PAR_RX_KEEP =
-        (1U
-         << 4), /*!< Disable Parity and CRC check and keep the Parity and CRC bits in the received buffer  */
-    RFAL_TXRX_FLAGS_PAR_RX_REMV =
-        (0U
-         << 0), /*!< Enable Parity check and remove the parity bits from the received buffer               */
-    RFAL_TXRX_FLAGS_PAR_TX_NONE =
-        (1U
-         << 5), /*!< Disable automatic Parity generation (ISO14443A) and use the one provided in the buffer*/
-    RFAL_TXRX_FLAGS_PAR_TX_AUTO =
-        (0U
-         << 5), /*!< Enable automatic Parity generation (ISO14443A)                                        */
-    RFAL_TXRX_FLAGS_NFCV_FLAG_MANUAL =
-        (1U
-         << 6), /*!< Disable automatic adaption of flag byte (ISO15693) according to current comm params   */
-    RFAL_TXRX_FLAGS_NFCV_FLAG_AUTO =
-        (0U
-         << 6), /*!< Enable automatic adaption of flag byte (ISO115693) according to current comm params   */
-};
-
-/*! RFAL error handling                                                                                                                      */
-typedef enum {
-    RFAL_ERRORHANDLING_NONE =
-        0, /*!< No special error handling will be performed                                           */
-    RFAL_ERRORHANDLING_NFC =
-        1, /*!< Error handling set to perform as NFC compliant device                                 */
-    RFAL_ERRORHANDLING_EMVCO =
-        2 /*!< Error handling set to perform as EMVCo compliant device                               */
-} rfalEHandling;
-
-/*! Struct that holds all context to be used on a Transceive                                                */
-typedef struct {
-    uint8_t* txBuf; /*!< (In)  Buffer where outgoing message is located       */
-    uint16_t txBufLen; /*!< (In)  Length of the outgoing message in bits         */
-
-    uint8_t* rxBuf; /*!< (Out) Buffer where incoming message will be placed   */
-    uint16_t rxBufLen; /*!< (In)  Maximum length of the incoming message in bits */
-    uint16_t* rxRcvdLen; /*!< (Out) Actual received length in bits                 */
-
-    uint32_t flags; /*!< (In)  TransceiveFlags indication special handling    */
-    uint32_t fwt; /*!< (In)  Frame Waiting Time in 1/fc                     */
-} rfalTransceiveContext;
-
-/*! System callback to indicate an event that requires a system reRun        */
-typedef void (*rfalUpperLayerCallback)(void);
-
-/*! Callback to be executed before a Transceive                              */
-typedef void (*rfalPreTxRxCallback)(void* context);
-
-/*! Callback to be executed after a Transceive                               */
-typedef void (*rfalPostTxRxCallback)(void* context);
-
-/** Callback to be executed on each RFAL state change */
-typedef void (*RfalStateChangedCallback)(void* context);
-
-/*******************************************************************************/
-/*  ISO14443A                                                                  */
-/*******************************************************************************/
-
-/*! RFAL ISO 14443A Short Frame Command */
-typedef enum {
-    RFAL_14443A_SHORTFRAME_CMD_WUPA = 0x52, /*!< ISO14443A WUPA / NFC-A ALL_REQ  */
-    RFAL_14443A_SHORTFRAME_CMD_REQA = 0x26 /*!< ISO14443A REQA / NFC-A SENS_REQ */
-} rfal14443AShortFrameCmd;
-
-/*******************************************************************************/
-
-/*******************************************************************************/
-/*  FeliCa                                                                     */
-/*******************************************************************************/
-
-#define RFAL_FELICA_LEN_LEN \
-    1U /*!< FeliCa LEN byte length                                              */
-#define RFAL_FELICA_POLL_REQ_LEN          \
-    (RFAL_FELICA_LEN_LEN + 1U + 2U + 1U + \
-     1U) /*!< FeliCa Poll Request length (LEN + CMD + SC + RC + TSN)              */
-#define RFAL_FELICA_POLL_RES_LEN          \
-    (RFAL_FELICA_LEN_LEN + 1U + 8U + 8U + \
-     2U) /*!< Maximum FeliCa Poll Response length (LEN + CMD + NFCID2 + PAD + RD) */
-#define RFAL_FELICA_POLL_MAX_SLOTS \
-    16U /*!< Maximum number of slots (TSN) on FeliCa Poll                        */
-
-/*! NFC-F RC (Request Code) codes  NFC Forum Digital 1.1 Table 42                                                                                                        */
-enum {
-    RFAL_FELICA_POLL_RC_NO_REQUEST =
-        0x00, /*!< RC: No System Code information requested                            */
-    RFAL_FELICA_POLL_RC_SYSTEM_CODE =
-        0x01, /*!< RC: System Code information requested                               */
-    RFAL_FELICA_POLL_RC_COM_PERFORMANCE =
-        0x02 /*!< RC: Advanced protocol features supported                            */
-};
-
-/*! NFC-F TSN (Time Slot Number) codes  NFC Forum Digital 1.1 Table 43   */
-typedef enum {
-    RFAL_FELICA_1_SLOT = 0, /*!< TSN with number of Time Slots: 1  */
-    RFAL_FELICA_2_SLOTS = 1, /*!< TSN with number of Time Slots: 2  */
-    RFAL_FELICA_4_SLOTS = 3, /*!< TSN with number of Time Slots: 4  */
-    RFAL_FELICA_8_SLOTS = 7, /*!< TSN with number of Time Slots: 8  */
-    RFAL_FELICA_16_SLOTS = 15 /*!< TSN with number of Time Slots: 16 */
-} rfalFeliCaPollSlots;
-
-/*! NFCF Poll Response  NFC Forum Digital 1.1 Table 44 */
-typedef uint8_t rfalFeliCaPollRes[RFAL_FELICA_POLL_RES_LEN];
-
-/*******************************************************************************/
-
-/*******************************************************************************/
-/*  Listen Mode                                                                */
-/*******************************************************************************/
-
-/*! RFAL Listen Mode NFCID Length */
-typedef enum {
-    RFAL_LM_NFCID_LEN_04 = RFAL_NFCID1_SINGLE_LEN, /*!< Listen mode indicates  4 byte NFCID */
-    RFAL_LM_NFCID_LEN_07 = RFAL_NFCID1_DOUBLE_LEN, /*!< Listen mode indicates  7 byte NFCID */
-    RFAL_LM_NFCID_LEN_10 = RFAL_NFCID1_TRIPLE_LEN, /*!< Listen mode indicates 10 byte NFCID */
-} rfalLmNfcidLen;
-
-/*! RFAL Listen Mode States */
-typedef enum {
-    RFAL_LM_STATE_NOT_INIT = 0x00, /*!< Not Initialized state                       */
-    RFAL_LM_STATE_POWER_OFF = 0x01, /*!< Power Off state                             */
-    RFAL_LM_STATE_IDLE = 0x02, /*!< Idle state  Activity 1.1  5.2               */
-    RFAL_LM_STATE_READY_A = 0x03, /*!< Ready A state  Activity 1.1  5.3 5.4 & 5.5  */
-    RFAL_LM_STATE_READY_B = 0x04, /*!< Ready B state  Activity 1.1  5.11 5.12      */
-    RFAL_LM_STATE_READY_F = 0x05, /*!< Ready F state  Activity 1.1  5.15           */
-    RFAL_LM_STATE_ACTIVE_A = 0x06, /*!< Active A state  Activity 1.1  5.6           */
-    RFAL_LM_STATE_CARDEMU_4A = 0x07, /*!< Card Emulation 4A state  Activity 1.1  5.10 */
-    RFAL_LM_STATE_CARDEMU_4B = 0x08, /*!< Card Emulation 4B state  Activity 1.1  5.14 */
-    RFAL_LM_STATE_CARDEMU_3 = 0x09, /*!< Card Emulation 3 state  Activity 1.1  5.18  */
-    RFAL_LM_STATE_TARGET_A = 0x0A, /*!< Target A state  Activity 1.1  5.9           */
-    RFAL_LM_STATE_TARGET_F = 0x0B, /*!< Target F state  Activity 1.1  5.17          */
-    RFAL_LM_STATE_SLEEP_A = 0x0C, /*!< Sleep A state  Activity 1.1  5.7            */
-    RFAL_LM_STATE_SLEEP_B = 0x0D, /*!< Sleep B state  Activity 1.1  5.13           */
-    RFAL_LM_STATE_READY_Ax = 0x0E, /*!< Ready A* state  Activity 1.1  5.3 5.4 & 5.5 */
-    RFAL_LM_STATE_ACTIVE_Ax = 0x0F, /*!< Active A* state  Activity 1.1  5.6          */
-    RFAL_LM_STATE_SLEEP_AF = 0x10, /*!< Sleep AF state  Activity 1.1  5.19          */
-} rfalLmState;
-
-/*! RFAL Listen Mode Passive A configs */
-typedef struct {
-    rfalLmNfcidLen nfcidLen; /*!< NFCID Len (4, 7 or 10 bytes)              */
-    uint8_t nfcid[RFAL_NFCID1_TRIPLE_LEN]; /*!< NFCID                                     */
-    uint8_t SENS_RES[RFAL_LM_SENS_RES_LEN]; /*!< NFC-106k; SENS_REQ Response               */
-    uint8_t SEL_RES; /*!< SEL_RES (SAK) with complete NFCID1 (UID)  */
-} rfalLmConfPA;
-
-/*! RFAL Listen Mode Passive B configs */
-typedef struct {
-    uint8_t SENSB_RES[RFAL_LM_SENSB_RES_LEN]; /*!< SENSF_RES                               */
-} rfalLmConfPB;
-
-/*! RFAL Listen Mode Passive F configs */
-typedef struct {
-    uint8_t SC[RFAL_LM_SENSF_SC_LEN]; /*!< System Code to listen for               */
-    uint8_t SENSF_RES[RFAL_LM_SENSF_RES_LEN]; /*!< SENSF_RES                               */
-} rfalLmConfPF;
-
-/*******************************************************************************/
-
-/*******************************************************************************/
-/*  Wake-Up Mode                                                               */
-/*******************************************************************************/
-
-#define RFAL_WUM_REFERENCE_AUTO 0xFFU /*!< Indicates new reference is set by the driver*/
-
-/*! RFAL Wake-Up Mode States */
-typedef enum {
-    RFAL_WUM_STATE_NOT_INIT = 0x00, /*!< Not Initialized state                       */
-    RFAL_WUM_STATE_ENABLED = 0x01, /*!< Wake-Up mode is enabled                     */
-    RFAL_WUM_STATE_ENABLED_WOKE = 0x02, /*!< Wake-Up mode enabled and has received IRQ(s)*/
-} rfalWumState;
-
-/*! RFAL Wake-Up Period/Timer */
-typedef enum {
-    RFAL_WUM_PERIOD_10MS = 0x00, /*!< Wake-Up timer 10ms                          */
-    RFAL_WUM_PERIOD_20MS = 0x01, /*!< Wake-Up timer 20ms                          */
-    RFAL_WUM_PERIOD_30MS = 0x02, /*!< Wake-Up timer 30ms                          */
-    RFAL_WUM_PERIOD_40MS = 0x03, /*!< Wake-Up timer 40ms                          */
-    RFAL_WUM_PERIOD_50MS = 0x04, /*!< Wake-Up timer 50ms                          */
-    RFAL_WUM_PERIOD_60MS = 0x05, /*!< Wake-Up timer 60ms                          */
-    RFAL_WUM_PERIOD_70MS = 0x06, /*!< Wake-Up timer 70ms                          */
-    RFAL_WUM_PERIOD_80MS = 0x07, /*!< Wake-Up timer 80ms                          */
-    RFAL_WUM_PERIOD_100MS = 0x10, /*!< Wake-Up timer 100ms                         */
-    RFAL_WUM_PERIOD_200MS = 0x11, /*!< Wake-Up timer 200ms                         */
-    RFAL_WUM_PERIOD_300MS = 0x12, /*!< Wake-Up timer 300ms                         */
-    RFAL_WUM_PERIOD_400MS = 0x13, /*!< Wake-Up timer 400ms                         */
-    RFAL_WUM_PERIOD_500MS = 0x14, /*!< Wake-Up timer 500ms                         */
-    RFAL_WUM_PERIOD_600MS = 0x15, /*!< Wake-Up timer 600ms                         */
-    RFAL_WUM_PERIOD_700MS = 0x16, /*!< Wake-Up timer 700ms                         */
-    RFAL_WUM_PERIOD_800MS = 0x17, /*!< Wake-Up timer 800ms                         */
-} rfalWumPeriod;
-
-/*! RFAL Wake-Up Period/Timer */
-typedef enum {
-    RFAL_WUM_AA_WEIGHT_4 = 0x00, /*!< Wake-Up Auto Average Weight 4              */
-    RFAL_WUM_AA_WEIGHT_8 = 0x01, /*!< Wake-Up Auto Average Weight 8              */
-    RFAL_WUM_AA_WEIGHT_16 = 0x02, /*!< Wake-Up Auto Average Weight 16             */
-    RFAL_WUM_AA_WEIGHT_32 = 0x03, /*!< Wake-Up Auto Average Weight 32             */
-} rfalWumAAWeight;
-
-/*! RFAL Wake-Up Mode configuration */
-typedef struct {
-    rfalWumPeriod period; /*!< Wake-Up Timer period;how often measurement(s) is performed */
-    bool irqTout; /*!< IRQ at every timeout will refresh the measurement(s)       */
-    bool swTagDetect; /*!< Use SW Tag Detection instead of HW Wake-Up mode            */
-
-    struct {
-        bool enabled; /*!< Inductive Amplitude measurement enabled                   */
-        uint8_t delta; /*!< Delta between the reference and measurement to wake-up    */
-        uint16_t reference; /*!< Reference to be used;RFAL_WUM_REFERENCE_AUTO sets it auto */
-        bool autoAvg; /*!< Use the HW Auto Averaging feature                         */
-        bool aaInclMeas; /*!< When AutoAvg is enabled, include IRQ measurement          */
-        rfalWumAAWeight aaWeight; /*!< When AutoAvg is enabled, last measure weight              */
-    } indAmp; /*!< Inductive Amplitude Configuration                         */
-    struct {
-        bool enabled; /*!< Inductive Phase measurement enabled                       */
-        uint8_t delta; /*!< Delta between the reference and measurement to wake-up    */
-        uint16_t reference; /*!< Reference to be used;RFAL_WUM_REFERENCE_AUTO sets it auto */
-        bool autoAvg; /*!< Use the HW Auto Averaging feature                         */
-        bool aaInclMeas; /*!< When AutoAvg is enabled, include IRQ measurement          */
-        rfalWumAAWeight aaWeight; /*!< When AutoAvg is enabled, last measure weight              */
-    } indPha; /*!< Inductive Phase Configuration                             */
-    struct {
-        bool enabled; /*!< Capacitive measurement enabled                            */
-        uint8_t delta; /*!< Delta between the reference and measurement to wake-up    */
-        uint16_t reference; /*!< Reference to be used;RFAL_WUM_REFERENCE_AUTO sets it auto */
-        bool autoAvg; /*!< Use the HW Auto Averaging feature                         */
-        bool aaInclMeas; /*!< When AutoAvg is enabled, include IRQ measurement          */
-        rfalWumAAWeight aaWeight; /*!< When AutoAvg is enabled, last measure weight              */
-    } cap; /*!< Capacitive Configuration                                  */
-} rfalWakeUpConfig;
-
-/*******************************************************************************/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Initialize
- *  
- * Initializes RFAL layer and the ST25R391x
- * Ensures that ST25R391x is properly connected and returns error if any problem 
- * is detected
- *
- * \warning rfalAnalogConfigInitialize() should be called before so that 
- *           the Analog config table has been previously initialized.
- *           
- * \return ERR_HW_MISMATCH  : Expected HW do not match or communication error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalInitialize(void);
-
-/*!
- *****************************************************************************
- * \brief  RFAL Calibrate 
- *  
- * Performs necessary calibration of RF chip in case it is indicated by current
- * register settings. E.g. antenna calibration and regulator calibration
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized
- * \return ERR_NONE         : No error
- * 
- *****************************************************************************
- */
-ReturnCode rfalCalibrate(void);
-
-/*!
- *****************************************************************************
- * \brief  RFAL Adjust Regulators 
- *  
- * Adjusts ST25R391x regulators 
- * 
- * \param[out]  result : the result of the calibrate antenna in mV
- *                       NULL if result not requested
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized
- * \return ERR_NONE         : No error
- * 
- *****************************************************************************
- */
-ReturnCode rfalAdjustRegulators(uint16_t* result);
-
-/*!
- *****************************************************************************
- * \brief RFAL Set System Callback
- *
- * Sets a callback for the driver to call when an event has occurred that 
- * may require the system to be notified
- * 
- * \param[in]  pFunc : method pointer for the upper layer callback 
- * 
- *****************************************************************************
- */
-void rfalSetUpperLayerCallback(rfalUpperLayerCallback pFunc);
-
-/*!
- *****************************************************************************
- * \brief RFAL Set Pre Tx Callback
- *
- * Sets a callback for the driver to call before a Transceive 
- * 
- * \param[in]  pFunc : method pointer for the Pre Tx callback 
- * 
- *****************************************************************************
- */
-void rfalSetPreTxRxCallback(rfalPreTxRxCallback pFunc);
-
-/*!
- *****************************************************************************
- * \brief RFAL Set Post Tx Callback
- *
- * Sets a callback for the driver to call after a Transceive 
- * 
- * \param[in]  pFunc : method pointer for the Post Tx callback 
- * 
- *****************************************************************************
- */
-void rfalSetPostTxRxCallback(rfalPostTxRxCallback pFunc);
-
-/** Set RFAL state changed callback
- *
- * @param cb    RfalStateChangedCallback instance
- * @param ctx   pointer to context
- */
-void rfal_set_state_changed_callback(RfalStateChangedCallback callback);
-
-/** Set callback context
- *
- * @param ctx pointer to context
- */
-void rfal_set_callback_context(void* context);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Deinitialize
- *  
- * Deinitializes RFAL layer and the ST25R391x
- *
- * \return ERR_NONE : No error
- * 
- *****************************************************************************
- */
-ReturnCode rfalDeinitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set Mode
- *  
- * Sets the mode that RFAL will operate on the following communications.
- * Proper initializations will be performed on the ST25R391x
- * 
- * \warning bit rate value RFAL_BR_KEEP is not allowed, only in rfalSetBitRate()
- * 
- * \warning the mode will be applied immediately on the RFchip regardless of 
- *          any ongoing operations like Transceive, ListenMode
- * 
- * \param[in]  mode : mode for the RFAL/RFchip to perform
- * \param[in]  txBR : transmit bit rate
- * \param[in]  rxBR : receive bit rate 
- * 
- * \see rfalIsGTExpired
- * \see rfalMode
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_NONE         : No error
- * 
- *****************************************************************************
- */
-ReturnCode rfalSetMode(rfalMode mode, rfalBitRate txBR, rfalBitRate rxBR);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Get Mode
- *  
- * Gets the mode that RFAL is set to operate
- * 
- * \see rfalMode
- *
- * \return rfalMode : The current RFAL mode
- *****************************************************************************
- */
-rfalMode rfalGetMode(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set Bit Rate
- *  
- * Sets the Tx and Rx bit rates with the given values 
- * The bit rate change is applied on the RF chip remaining in the same  
- * mode previous defined with rfalSetMode()
- * 
- * If no mode is defined bit rates will not be applied and an error 
- * is returned
- * 
- * \param[in]  txBR : transmit bit rate
- * \param[in]  rxBR : receive bit rate 
- * 
- * \see rfalSetMode
- * \see rfalMode
- * \see rfalBitRate
- *
- * \return ERR_WRONG_STATE     : RFAL not initialized
- * \return ERR_PARAM           : Invalid parameter
- * \return ERR_NOT_IMPLEMENTED : Mode not implemented
- * \return ERR_NONE            : No error
- * 
- *****************************************************************************
- */
-ReturnCode rfalSetBitRate(rfalBitRate txBR, rfalBitRate rxBR);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Get Bit Rate
- *  
- * Gets the Tx and Rx current bit rates 
- * 
- * If RFAL is not initialized or mode not set the bit rates return will 
- * be invalid RFAL_BR_KEEP
- * 
- * \param[out]  txBR : RFAL's current Tx Bit Rate
- * \param[out]  rxBR : RFAL's current Rx Bit Rate
- * 
- * \see rfalSetBitRate
- * \see rfalBitRate
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalGetBitRate(rfalBitRate* txBR, rfalBitRate* rxBR);
-
-/*! 
- *****************************************************************************
- * \brief Set Error Handling Mode
- *  
- *  Sets the error handling mode to be used by the RFAL
- *  
- * \param[in]  eHandling : the error handling mode
- * 
- *****************************************************************************
- */
-void rfalSetErrorHandling(rfalEHandling eHandling);
-
-/*! 
- *****************************************************************************
- * \brief Get Error Handling Mode
- *  
- *  Gets the error handling mode currently used by the RFAL 
- *  
- * \return rfalEHandling : Current error handling mode
- *****************************************************************************
- */
-rfalEHandling rfalGetErrorHandling(void);
-
-/*! 
- *****************************************************************************
- * \brief Set Observation Mode
- *  
- * Sets ST25R391x observation modes for RF debug purposes
- *
- * \param[in]  txMode : the observation mode to be used during transmission
- * \param[in]  rxMode : the observation mode to be used during reception
- * 
- * \warning The Observation Mode is an advanced feature and should be set 
- *          according to the documentation of the part number in use.
- *          Please refer to the corresponding Datasheet or Application Note(s)
- *****************************************************************************
- */
-void rfalSetObsvMode(uint8_t txMode, uint8_t rxMode);
-
-/*! 
- *****************************************************************************
- * \brief Get Observation Mode
- *  
- * Gets ST25R391x the current configured observation modes
- *
- * \param[in]  txMode : the current observation mode configured for transmission
- * \param[in]  rxMode : the current observation mode configured for reception
- * 
- *****************************************************************************
- */
-void rfalGetObsvMode(uint8_t* txMode, uint8_t* rxMode);
-
-/*! 
- *****************************************************************************
- * \brief Disable Observation Mode
- *  
- * Disables the ST25R391x observation mode
- *****************************************************************************
- */
-void rfalDisableObsvMode(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set FDT Poll
- *  
- * Sets the Frame Delay Time (FDT) to be used on the following
- * communications.
- * 
- * FDT Poll is the minimum time following a Poll Frame during 
- * which no subsequent Poll Frame can be sent (without a response from 
- * the Listener in between)
- * FDTx,PP,MIN - Digital 1.1  6.10.2  &  7.9.2  &  8.7.2
- * 
- * \param[in]  FDTPoll : Frame Delay Time in 1/fc cycles
- *
- *****************************************************************************
- */
-void rfalSetFDTPoll(uint32_t FDTPoll);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set FDT Poll
- *  
- * Gets the current Frame Delay Time (FDT) 
- * 
- * FDT Poll is the minimum time following a Poll Frame during 
- * which no subsequent Poll Frame can be sent (without a response from 
- * the Listener in between)
- * FDTx,PP,MIN - Digital 1.1  6.10.2  &  7.9.2  &  8.7.2
- *  
- * \return FDT : current FDT value in 1/fc cycles
- *
- *****************************************************************************
- */
-uint32_t rfalGetFDTPoll(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set FDT Listen
- *  
- * Sets the Frame Delay Time (FDT) Listen minimum to be used on the 
- * following communications.
- * 
- * FDT Listen is the minimum time between a Poll Frame and a Listen Frame
- * FDTx,LISTEN,MIN - Digital 1.1  6.10.1  &  7.9.1  &  8.7.1
- *  
- * \param[in]  FDTListen : Frame Delay Time in 1/fc cycles
- *
- *****************************************************************************
- */
-void rfalSetFDTListen(uint32_t FDTListen);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set FDT Listen
- *  
- * Gets the Frame Delay Time (FDT) Listen minimum  
- * 
- * FDT Listen is the minimum time between a Poll Frame and a Listen Frame
- * FDTx,LISTEN,MIN - Digital 1.1  6.10.1  &  7.9.1  &  8.7.1
- *  
- * \return FDT : current FDT value in 1/fc cycles
- *
- *****************************************************************************
- */
-uint32_t rfalGetFDTListen(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Get GT
- *  
- * Gets the current Guard Time (GT)
- *  
- * GT is the minimum time when a device in Listen Mode is exposed to an 
- * unmodulated carrier
- *  
- * \return GT :  Guard Time in 1/fc cycles
- *
- *****************************************************************************
- */
-uint32_t rfalGetGT(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set GT
- *  
- * Sets the Guard Time (GT) to be used on the following communications.
- * 
- * GT is the minimum time when a device in Listen Mode is exposed to an 
- * unmodulated carrier
- *  
- * \param[in]  GT : Guard Time in 1/fc cycles
- *                  RFAL_GT_NONE if no GT should be applied
- *
- *****************************************************************************
- */
-void rfalSetGT(uint32_t GT);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Is GT expired 
- *  
- * Checks whether the GT timer has expired
- *    
- * \return true  : GT has expired or not running
- * \return false : GT is still running
- *
- *****************************************************************************
- */
-bool rfalIsGTExpired(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Turn Field On and Start GT
- *  
- * Turns the Field On, performing Initial Collision Avoidance
- * 
- * After Field On, if GT was set before, it starts the GT timer to be 
- * used on the following communications.
- *  
- * \return ERR_RF_COLLISION : External field detected
- * \return ERR_NONE         : Field turned On
- *
- *****************************************************************************
- */
-ReturnCode rfalFieldOnAndStartGT(void);
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Turn Field Off
- *  
- * Turns the Field Off  
- *   
- * \return ERR_NONE : Field turned Off
- *****************************************************************************
- */
-ReturnCode rfalFieldOff(void);
-
-/*****************************************************************************
- *  Transceive                                                               *  
- *****************************************************************************/
-
-/*! 
- *****************************************************************************
- * \brief  RFAL Set transceive context
- *  
- * Set the context that will be used for the following Transceive
- * Output and input buffers have to be passed and all other details prior to 
- * the Transceive itself has been started
- * 
- * This method only sets the context, once set rfalWorker has
- * to be executed until is done
- * 
- * \param[in]  ctx : the context for the following Transceive
- * 
- * \see  rfalWorker
- * \see  rfalGetTransceiveStatus
- *
- * \return ERR_NONE        : Done with no error
- * \return ERR_WRONG_STATE : Not initialized properly 
- * \return ERR_PARAM       : Invalid parameter or configuration
- *****************************************************************************
- */
-ReturnCode rfalStartTransceive(const rfalTransceiveContext* ctx);
-
-/*! 
- *****************************************************************************
- * \brief  Get Transceive State
- *  
- * Gets current Transceive internal State
- *
- * \return rfalTransceiveState : the current Transceive internal State
- *****************************************************************************
- */
-rfalTransceiveState rfalGetTransceiveState(void);
-
-/*! 
- *****************************************************************************
- * \brief  Get Transceive Status
- *  
- * Gets current Transceive status
- *
- * \return  ERR_NONE         : Transceive done with no error
- * \return  ERR_BUSY         : Transceive ongoing
- * \return  ERR_XXXX         : Error occurred
- * \return  ERR_TIMEOUT      : No response
- * \return  ERR_FRAMING      : Framing error detected
- * \return  ERR_PAR          : Parity error detected
- * \return  ERR_CRC          : CRC error detected
- * \return  ERR_LINK_LOSS    : Link Loss - External Field is Off
- * \return  ERR_RF_COLLISION : Collision detected
- * \return  ERR_IO           : Internal error
- *****************************************************************************
- */
-ReturnCode rfalGetTransceiveStatus(void);
-
-/*! 
- *****************************************************************************
- * \brief  Is Transceive in Tx
- *  
- * Checks if Transceive is in Transmission state
- *
- * \return true   Transmission ongoing
- * \return false  Not in transmission state
- *****************************************************************************
- */
-bool rfalIsTransceiveInTx(void);
-
-/*! 
- *****************************************************************************
- * \brief  Is Transceive in Rx
- *  
- * Checks if Transceive is in Reception state 
- *
- * \return true   Transmission done/reception ongoing
- * \return false  Not in reception state
- *****************************************************************************
- */
-bool rfalIsTransceiveInRx(void);
-
-/*! 
- *****************************************************************************
- * \brief  Get Transceive RSSI
- *  
- * Gets the RSSI value of the last executed Transceive in mV
- *
- * \param[out]  rssi : RSSI value
- *
- * \return  ERR_NOTSUPP : Feature not supported
- * \return  ERR_PARAM   : Invalid parameter
- * \return  ERR_NONE    : No error
- *****************************************************************************
- */
-ReturnCode rfalGetTransceiveRSSI(uint16_t* rssi);
-
-/*! 
- *****************************************************************************
- *  \brief RFAL Worker
- *  
- *  This runs RFAL layer, which drives the actual Transceive procedure
- *  It MUST be executed frequently in order to execute the RFAL internal
- *  states and perform the requested operations
- *
- *****************************************************************************
- */
-void rfalWorker(void);
-
-/*****************************************************************************
- *  ISO1443A                                                                 *  
- *****************************************************************************/
-
-/*! 
- *****************************************************************************
- *  \brief Transceives an ISO14443A ShortFrame  
- *  
- *  Sends REQA to detect if there is any PICC in the field 
- *
- * \param[in]  txCmd:     Command to be sent:
- *                           0x52 WUPA / ALL_REQ
- *                           0x26 REQA / SENS_REQ
- *                           
- * \param[in]  txCmd    : type of short frame to be sent REQA or WUPA                          
- * \param[out] rxBuf    : buffer to place the response
- * \param[in]  rxBufLen : length of rxBuf
- * \param[out] rxRcvdLen: received length
- * \param[in]  fwt      : Frame Waiting Time in 1/fc
- * 
- * \warning If fwt is set to RFAL_FWT_NONE it will make endlessly for 
- *         a response, which on a blocking method may not be the 
- *         desired usage 
- * 
- * \return ERR_NONE if there is response
- * \return ERR_TIMEOUT if there is no response
- * \return ERR_COLLISION collision has occurred
- *  
- *****************************************************************************
- */
-ReturnCode rfalISO14443ATransceiveShortFrame(
-    rfal14443AShortFrameCmd txCmd,
-    uint8_t* rxBuf,
-    uint8_t rxBufLen,
-    uint16_t* rxRcvdLen,
-    uint32_t fwt);
-
-/*!
- *****************************************************************************
- * \brief Sends an ISO14443A Anticollision Frame 
- * 
- * This is use to perform ISO14443A anti-collision. 
- * \note Anticollision is sent without CRC
- * 
- * 
- * \param[in]   buf        : reference to ANTICOLLISION command (with known UID if any) to be sent (also out param)
- *                           reception will be place on this buf after bytesToSend 
- * \param[in]   bytesToSend: reference number of full bytes to be sent (including CMD byte and SEL_PAR)
- *                           if a collision occurs will contain the number of clear bytes  
- * \param[in]   bitsToSend : reference to number of bits (0-7) to be sent; and received (also out param)
- *                           if a collision occurs will indicate the number of clear bits (also out param)
- * \param[out]  rxLength   : reference to the return the received length
- * \param[in]   fwt        : Frame Waiting Time in 1/fc
- * 
- * \return ERR_NONE if there is no error
- *****************************************************************************
- */
-ReturnCode rfalISO14443ATransceiveAnticollisionFrame(
-    uint8_t* buf,
-    uint8_t* bytesToSend,
-    uint8_t* bitsToSend,
-    uint16_t* rxLength,
-    uint32_t fwt);
-
-/*****************************************************************************
- *  FeliCa                                                                   *  
- *****************************************************************************/
-
-/*!
- *****************************************************************************
- * \brief FeliCa Poll 
- * 
- * Sends a Poll Request and collects all Poll Responses according to the 
- * given slots  
- * 
- * 
- * \param[in]   slots             : number of slots for the Poll Request
- * \param[in]   sysCode           : system code (SC) for the Poll Request  
- * \param[in]   reqCode           : request code (RC) for the Poll Request
- * \param[out]  pollResList       : list of all responses
- * \param[in]   pollResListSize   : number of responses that can be placed in pollResList 
- * \param[out]  devicesDetected   : number of cards found
- * \param[out]  collisionsDetected: number of collisions detected
- * 
- * \return ERR_NONE if there is no error
- * \return ERR_TIMEOUT if there is no response
- *****************************************************************************
- */
-ReturnCode rfalFeliCaPoll(
-    rfalFeliCaPollSlots slots,
-    uint16_t sysCode,
-    uint8_t reqCode,
-    rfalFeliCaPollRes* pollResList,
-    uint8_t pollResListSize,
-    uint8_t* devicesDetected,
-    uint8_t* collisionsDetected);
-
-/*****************************************************************************
- *  ISO15693                                                                 *  
- *****************************************************************************/
-
-/*!
- *****************************************************************************
- * \brief Sends an ISO15693 Anticollision Frame 
- * 
- * This send the Anticollision|Inventory frame (INVENTORY_REQ)
- *
- * \warning rxBuf must be able to contain the payload and CRC
- * 
- * \param[in]  txBuf        : Buffer where outgoing message is located
- * \param[in]  txBufLen     : Length of the outgoing message in bytes
- * \param[out] rxBuf        : Buffer where incoming message will be placed
- * \param[in]  rxBufLen     : Maximum length of the incoming message in bytes
- * \param[out] actLen       : Actual received length in bits
- * 
- * \return  ERR_NONE        : Transceive done with no error
- * \return  ERR_WRONG_STATE : RFAL not initialized or mode not set
- * \return  ERR_IO          : Internal error
- *****************************************************************************
- */
-ReturnCode rfalISO15693TransceiveAnticollisionFrame(
-    uint8_t* txBuf,
-    uint8_t txBufLen,
-    uint8_t* rxBuf,
-    uint8_t rxBufLen,
-    uint16_t* actLen);
-
-/*!
- *****************************************************************************
- * \brief Sends an ISO15693 Anticollision EOF
- * 
- * This sends the Anticollision|Inventory EOF used as a slot marker
- * 
- * \warning rxBuf must be able to contain the payload and CRC
- * 
- * \param[out] rxBuf        : Buffer where incoming message will be placed
- * \param[in] rxBufLen      : Maximum length of the incoming message in bytes
- * \param[out] actLen       : Actual received length in bits
- * 
- * \return  ERR_NONE        : Transceive done with no error
- * \return  ERR_WRONG_STATE : RFAL not initialized or mode not set
- * \return  ERR_IO          : Internal error
- *****************************************************************************
- */
-ReturnCode
-    rfalISO15693TransceiveEOFAnticollision(uint8_t* rxBuf, uint8_t rxBufLen, uint16_t* actLen);
-
-/*!
- *****************************************************************************
- * \brief Sends an ISO15693 EOF
- *
- * This is method sends an ISO15693 (EoF) used for a Write operation
- * 
- * \warning rxBuf must be able to contain the payload and CRC
- * 
- * \param[out] rxBuf        : Buffer where incoming message will be placed
- * \param[in] rxBufLen      : Maximum length of the incoming message in bytes
- * \param[out] actLen       : Actual received length in bytes
- * 
- * \return  ERR_NONE        : Transceive done with no error
- * \return  ERR_IO          : Internal error
- *****************************************************************************
- */
-ReturnCode rfalISO15693TransceiveEOF(uint8_t* rxBuf, uint8_t rxBufLen, uint16_t* actLen);
-
-/*!
- *****************************************************************************
- * \brief Transceive Blocking Tx 
- *
- * This is method triggers a Transceive and executes it blocking until the 
- * Tx has been completed
- * 
- * \param[in]  txBuf    : Buffer where outgoing message is located
- * \param[in]  txBufLen : Length of the outgoing message in bytes
- * \param[out] rxBuf    : Buffer where incoming message will be placed
- * \param[in]  rxBufLen : Maximum length of the incoming message in bytes
- * \param[out] actLen   : Actual received length in bits
- * \param[in]  flags    : TransceiveFlags indication special handling
- * \param[in]  fwt      : Frame Waiting Time in 1/fc
- * 
- * \return  ERR_NONE         : Transceive done with no error
- * \return  ERR_BUSY         : Transceive ongoing
- * \return  ERR_XXXX         : Error occurred
- * \return  ERR_LINK_LOSS    : Link Loss - External Field is Off
- * \return  ERR_RF_COLLISION : Collision detected
- * \return  ERR_IO           : Internal error
- *****************************************************************************
- */
-ReturnCode rfalTransceiveBlockingTx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-/*!
- *****************************************************************************
- * \brief Transceive Blocking Rx 
- *
- * This is method executes the reception of an ongoing Transceive triggered 
- * before by rfalTransceiveBlockingTx()
- * 
- * \return  ERR_NONE         : Transceive done with no error
- * \return  ERR_BUSY         : Transceive ongoing
- * \return  ERR_XXXX         : Error occurred
- * \return  ERR_TIMEOUT      : No response
- * \return  ERR_FRAMING      : Framing error detected
- * \return  ERR_PAR          : Parity error detected
- * \return  ERR_CRC          : CRC error detected
- * \return  ERR_LINK_LOSS    : Link Loss - External Field is Off
- * \return  ERR_RF_COLLISION : Collision detected
- * \return  ERR_IO           : Internal error
- *****************************************************************************
- */
-ReturnCode rfalTransceiveBlockingRx(void);
-
-/*!
- *****************************************************************************
- * \brief Transceive Blocking 
- *
- * This is method triggers a Transceive and executes it blocking until it 
- * has been completed
- * 
- * \param[in]  txBuf    : Buffer where outgoing message is located
- * \param[in]  txBufLen : Length of the outgoing message in bytes
- * \param[out] rxBuf    : Buffer where incoming message will be placed
- * \param[in]  rxBufLen : Maximum length of the incoming message in bytes
- * \param[out] actLen   : Actual received length in bytes
- * \param[in]  flags    : TransceiveFlags indication special handling
- * \param[in]  fwt      : Frame Waiting Time in 1/fc
- * 
- * \return  ERR_NONE         : Transceive done with no error
- * \return  ERR_BUSY         : Transceive ongoing
- * \return  ERR_XXXX         : Error occurred
- * \return  ERR_TIMEOUT      : No response
- * \return  ERR_FRAMING      : Framing error detected
- * \return  ERR_PAR          : Parity error detected
- * \return  ERR_CRC          : CRC error detected
- * \return  ERR_LINK_LOSS    : Link Loss - External Field is Off
- * \return  ERR_RF_COLLISION : Collision detected
- * \return  ERR_IO           : Internal error
- *****************************************************************************
- */
-ReturnCode rfalTransceiveBlockingTxRx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-ReturnCode rfalTransceiveBitsBlockingTxRx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-ReturnCode rfalTransceiveBitsBlockingTx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-/*****************************************************************************
- *  Listen Mode                                                              *  
- *****************************************************************************/
-
-/*!
- *****************************************************************************
- * \brief Is external Field On
- * 
- * Checks if external field (other peer/device) is on/detected
- * 
- * \return true  External field is On
- * \return false No external field is detected
- * 
- *****************************************************************************
- */
-bool rfalIsExtFieldOn(void);
-
-/*!
- *****************************************************************************
- * \brief Listen Mode start
- * 
- * Configures RF Chip to go into listen mode enabling the given technologies
- * 
- * 
- * \param[in]  lmMask:    mask with the enabled/disabled listen modes
- *                        use: RFAL_LM_MASK_NFCA ; RFAL_LM_MASK_NFCB ; 
- *                             RFAL_LM_MASK_NFCF ; RFAL_LM_MASK_ACTIVE_P2P 
- * \param[in]  confA:     pointer to Passive A configurations (NULL if disabled)
- * \param[in]  confB:     pointer to Passive B configurations (NULL if disabled)
- * \param[in]  confF:     pointer to Passive F configurations (NULL if disabled)
- * \param[in]  rxBuf:     buffer to place incoming data
- * \param[in]  rxBufLen:  length in bits of rxBuf
- * \param[in]  rxLen:     pointer to write the data length in bits placed into rxBuf
- *  
- * 
- * \return ERR_PARAM    Invalid parameter
- * \return ERR_REQUEST  Invalid listen mode mask
- * \return ERR_NONE     Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalListenStart(
-    uint32_t lmMask,
-    const rfalLmConfPA* confA,
-    const rfalLmConfPB* confB,
-    const rfalLmConfPF* confF,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rxLen);
-
-/*!
- *****************************************************************************
- * \brief Listen Mode start Sleeping
- * 
- * 
- *****************************************************************************
- */
-ReturnCode
-    rfalListenSleepStart(rfalLmState sleepSt, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rxLen);
-
-/*!
- *****************************************************************************
- * \brief Listen Mode Stop
- * 
- * Disables the listen mode on the RF Chip 
- * 
- * \warning the listen mode will be disabled immediately on the RFchip regardless 
- *          of any ongoing operations like Transceive
- * 
- * \return ERR_NONE Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalListenStop(void);
-
-/*!
- *****************************************************************************
- * \brief Listen Mode get state
- *
- * Sets the new state of the Listen Mode and applies the necessary changes 
- * on the RF Chip
- *
- * \param[out]  dataFlag: indicates that Listen Mode has rcvd data and caller
- *                         must process it. The received message is located
- *                         at the rxBuf passed on rfalListenStart().
- *                         rfalListenSetState() will clear this flag
- *                         if NULL output parameter will no be written/returned
- * \param[out]  lastBR:   bit rate detected  of the last initiator request 
- *                         if NULL output parameter will no be written/returned
- * 
- * \return rfalLmState  RFAL_LM_STATE_NOT_INIT : LM not initialized properly
- *                      Any Other              : LM State
- * 
- *****************************************************************************
- */
-rfalLmState rfalListenGetState(bool* dataFlag, rfalBitRate* lastBR);
-
-/*!
- *****************************************************************************
- * \brief Listen Mode set state
- *
- * Sets the new state of the Listen Mode and applies the necessary changes 
- * on the RF Chip
- *  
- * \param[in] newSt : New state to go to
- * 
- * \return ERR_WRONG_STATE : Not initialized properly
- * \return ERR_PARAM       : Invalid parameter
- * \return ERR_NONE        : Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalListenSetState(rfalLmState newSt);
-
-/*****************************************************************************
- *  Wake-Up Mode                                                             *  
- *****************************************************************************/
-
-/*!
- *****************************************************************************
- * \brief Wake-Up Mode Start
- *
- * Sets the RF Chip in Low Power Wake-Up Mode according to the given 
- * configuration.
- * 
- * \param[in] config       : Generic Wake-Up configuration provided by lower 
- *                            layers. If NULL will automatically configure the 
- *                            Wake-Up mode
- * 
- * \return ERR_WRONG_STATE : Not initialized properly
- * \return ERR_PARAM       : Invalid parameter
- * \return ERR_NONE        : Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalWakeUpModeStart(const rfalWakeUpConfig* config);
-
-/*!
- *****************************************************************************
- * \brief Wake-Up Has Woke
- *
- * Returns true if the Wake-Up mode is enabled and it has already received 
- * the indication from the RF Chip that the surrounding environment has changed
- * and flagged at least one wake-Up interrupt
- * 
- * \return true  : Wake-Up mode enabled and has received a wake-up IRQ
- * \return false : no Wake-Up IRQ has been received
- * 
- *****************************************************************************
- */
-bool rfalWakeUpModeHasWoke(void);
-
-/*!
- *****************************************************************************
- * \brief Wake-Up Mode Stop
- *
- * Stops the Wake-Up Mode
- * 
- * \return ERR_WRONG_STATE : Not initialized properly
- * \return ERR_PARAM       : Invalid parameter
- * \return ERR_NONE        : Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalWakeUpModeStop(void);
-
-/*!
- *****************************************************************************
- * \brief Low Power Mode Start
- *
- * Sets the RF Chip in Low Power Mode. 
- * In this mode the RF Chip is placed in Low Power Mode, similar to Wake-up 
- * mode but no operation nor period measurement is performed.
- * Mode must be terminated by rfalLowPowerModeStop()
- * 
- * \return ERR_WRONG_STATE : Not initialized properly
- * \return ERR_PARAM       : Invalid parameter
- * \return ERR_NONE        : Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalLowPowerModeStart(void);
-
-/*!
- *****************************************************************************
- * \brief Low Power Mode Stop
- *
- * Stops the Low Power Mode re-enabling the device
- * 
- * \return ERR_WRONG_STATE : Not initialized properly
- * \return ERR_PARAM       : Invalid parameter
- * \return ERR_NONE        : Done with no error
- * 
- *****************************************************************************
- */
-ReturnCode rfalLowPowerModeStop(void);
-
-#endif /* RFAL_RF_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_st25tb.h

@@ -1,340 +0,0 @@
-
-/******************************************************************************
-  * \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_st25tb.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of ST25TB interface 
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup ST25TB
- * \brief RFAL ST25TB Module
- * @{
- * 
- */
-
-#ifndef RFAL_ST25TB_H
-#define RFAL_ST25TB_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-#include "rfal_nfcb.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_ST25TB_CHIP_ID_LEN 1U /*!< ST25TB chip ID length       */
-#define RFAL_ST25TB_CRC_LEN 2U /*!< ST25TB CRC length           */
-#define RFAL_ST25TB_UID_LEN 8U /*!< ST25TB Unique ID length     */
-#define RFAL_ST25TB_BLOCK_LEN 4U /*!< ST25TB Data Block length    */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-typedef uint8_t rfalSt25tbUID[RFAL_ST25TB_UID_LEN]; /*!< ST25TB UID type          */
-typedef uint8_t rfalSt25tbBlock[RFAL_ST25TB_BLOCK_LEN]; /*!< ST25TB Block type        */
-
-/*! ST25TB listener device (PICC) struct  */
-typedef struct {
-    uint8_t chipID; /*!< Device's session Chip ID */
-    rfalSt25tbUID UID; /*!< Device's UID             */
-    bool isDeselected; /*!< Device deselect flag     */
-} rfalSt25tbListenDevice;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize ST25TB Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * ST25TB Poller/RW including all default timings
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Check Presence
- *  
- * This method checks if a ST25TB Listen device (PICC) is present on the field
- * by sending an Initiate command
- * 
- * \param[out] chipId : if successfully retrieved, the device's chip ID
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_RF_COLLISION : Collision detected one or more device in the field
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerCheckPresence(uint8_t* chipId);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Collision Resolution
- *  
- * This method performs ST25TB Collision resolution, selects the each device,
- * retrieves its UID and then deselects.
- * In case only one device is identified the ST25TB device is left in select
- * state.
- *   
- * \param[in]  devLimit      : device limit value, and size st25tbDevList
- * \param[out] st25tbDevList : ST35TB listener device info
- * \param[out] devCnt        : Devices found counter
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_RF_COLLISION : Collision detected one or more device in the field
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerCollisionResolution(
-    uint8_t devLimit,
-    rfalSt25tbListenDevice* st25tbDevList,
-    uint8_t* devCnt);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Initiate
- *  
- * This method sends an Initiate command 
- * 
- * If a single device responds the chip ID will be retrieved
- *   
- * \param[out]  chipId      : chip ID of the device 
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerInitiate(uint8_t* chipId);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Pcall
- *  
- * This method sends a Pcall command 
- * If successful the device's chip ID will be retrieved
- *   
- * \param[out]  chipId      : Chip ID of the device 
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerPcall(uint8_t* chipId);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Slot Marker
- *  
- * This method sends a Slot Marker
- * 
- * If a single device responds the chip ID will be retrieved
- *
- * \param[in]  slotNum      : Slot Number    
- * \param[out]  chipIdRes   : Chip ID of the device 
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerSlotMarker(uint8_t slotNum, uint8_t* chipIdRes);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Select
- *  
- * This method sends a ST25TB Select command with the given chip ID.
- * 
- * If the device is already in Selected state and receives an incorrect chip 
- * ID, it goes into Deselected state
- *   
- * \param[in]  chipId       : chip ID of the device to be selected
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerSelect(uint8_t chipId);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Get UID
- *  
- * This method sends a Get_UID command
- * 
- * If a single device responds the chip UID will be retrieved
- *
- * \param[out]  UID      : UID of the found device
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerGetUID(rfalSt25tbUID* UID);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Read Block
- *  
- * This method reads a block of the ST25TB
- * 
- * \param[in]   blockAddress : address of the block to be read
- * \param[out]  blockData    : location to place the data read from block
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerReadBlock(uint8_t blockAddress, rfalSt25tbBlock* blockData);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Write Block
- *  
- * This method writes a block of the ST25TB
- * 
- * \param[in]  blockAddress : address of the block to be written
- * \param[in]  blockData    : data to be written on the block
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerWriteBlock(uint8_t blockAddress, const rfalSt25tbBlock* blockData);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Completion 
- *  
- * This method sends a completion command to the ST25TB. After the 
- * completion the card no longer will reply to any command.
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected, invalid SENSB_RES received
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerCompletion(void);
-
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Reset to Inventory
- *  
- * This method sends a Reset to Inventory command to the ST25TB.
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error
- * \return ERR_TIMEOUT      : Timeout error, no listener device detected
- * \return ERR_PROTO        : Protocol error detected, invalid SENSB_RES received
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalSt25tbPollerResetToInventory(void);
-
-#endif /* RFAL_ST25TB_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_st25xv.h

@@ -1,844 +0,0 @@
-
-/******************************************************************************
-  * \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_st25xv.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief NFC-V ST25 NFC-V Tag specific features
- *
- *  This module provides support for ST's specific features available on
- *  NFC-V (ISO15693) tag families: ST25D, ST25TV, M24LR
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup ST25xV
- * \brief RFAL ST25xV Module
- * @{
- * 
- */
-
-#ifndef RFAL_ST25xV_H
-#define RFAL_ST25xV_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_nfc.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCV_BLOCKNUM_M24LR_LEN \
-    2U /*!< Block Number length of MR24LR tags: 16 bits                */
-#define RFAL_NFCV_ST_IC_MFG_CODE \
-    0x02 /*!< ST IC Mfg code (used for custom commands)                  */
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Single Block (M24LR)
- *  
- * Reads a Single Block from a M24LR tag which has the number of blocks 
- * bigger than 256 (M24LR16 ; M24LR64)
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            default: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if not provided Select mode will be used 
- * \param[in]  blockNum     : Number of the block to read (16 bits)
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerM24LRReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Single Block (M24LR)
- *  
- * Reads a Single Block from a M24LR tag which has the number of blocks 
- * bigger than 256 (M24LR16 ; M24LR64) using ST Fast mode
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            default: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if not provided Select mode will be used 
- * \param[in]  blockNum     : Number of the block to read (16 bits)
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerM24LRFastReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Single Block (M24LR)
- *  
- * Writes a Single Block from a M24LR tag which has the number of blocks 
- * bigger than 256 (M24LR16 ; M24LR64)
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be written
- *                             if not provided Select mode will be used 
- * \param[in]  blockNum     : Number of the block to write (16 bits)
- * \param[in]  wrData       : data to be written on the given block
- * \param[in]  blockLen     : number of bytes of a block
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerM24LRWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Multiple Blocks (M24LR)
- *  
- * Reads Multiple Blocks from a device from a M24LR tag which has the number of blocks 
- * bigger than 256 (M24LR16 ; M24LR64)  
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  firstBlockNum  : first block to be read (16 bits)
- * \param[in]  numOfBlocks    : number of block to read
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerM24LRReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Multiple Blocks (M24LR)
- *  
- * Reads Multiple Blocks from a device from a M24LR tag which has the number of blocks 
- * bigger than 256 (M24LR16 ; M24LR64) using ST Fast mode
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  firstBlockNum  : first block to be read (16 bits)
- * \param[in]  numOfBlocks    : number of block to read
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerM24LRFastReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Single Block
- *  
- * Reads a Single Block from a device (VICC) using ST Fast mode
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if not provided Select mode will be used 
- * \param[in]  blockNum     : Number of the block to read
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Multiple Blocks
- *  
- * Reads Multiple Blocks from a device (VICC) using ST Fast mode
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  firstBlockNum  : first block to be read
- * \param[in]  numOfBlocks    : number of block to read
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Extended Read Single Block
- *  
- * Reads a Single Block from a device (VICC) supporting extended commands using ST Fast mode
- *
- * \param[in]  flags        : Flags to be used: Sub-carrier; Data_rate; Option
- *                            for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid          : UID of the device to be put to be read
- *                             if not provided Select mode will be used 
- * \param[in]  blockNum     : Number of the block to read (16 bits)
- * \param[out] rxBuf        : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen     : length of rxBuf
- * \param[out] rcvLen       : number of bytes received
- *  
- * \return ERR_WRONG_STATE  : RFAL not initialized or incorrect mode
- * \return ERR_PARAM        : Invalid parameters
- * \return ERR_IO           : Generic internal error 
- * \return ERR_CRC          : CRC error detected
- * \return ERR_FRAMING      : Framing error detected
- * \return ERR_PROTO        : Protocol error detected
- * \return ERR_TIMEOUT      : Timeout error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastExtendedReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Extended Read Multiple Blocks
- *  
- * Reads Multiple Blocks from a device (VICC) supporting extended commands using ST Fast mode
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  firstBlockNum  : first block to be read (16 bits)
- * \param[in]  numOfBlocks    : number of consecutive blocks to read (16 bits)
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastExtReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Configuration
- *  
- * Reads static configuration registers at the Pointer address
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[out] regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerReadConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Configuration
- *  
- * Writes static configuration registers at the Pointer address
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[in]  regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerWriteConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Dynamic Configuration
- *  
- * Reads dynamic registers at the Pointer address
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[out] regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerReadDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Dynamic Configuration
- *  
- * Writes dynamic registers at the Pointer address
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[in]  regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerWriteDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Dynamic Configuration
- *  
- * Reads dynamic registers at the Pointer address using ST Fast mode
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[out] regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastReadDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Write Dynamic Configuration
- *  
- * Writes dynamic registers at the Pointer address using ST Fast mode
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pointer        : Pointer address
- * \param[in]  regValue       : Register value
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastWriteDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Present Password
- *  
- * Sends the Present Password command
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  pwdNum         : Password number
- * \param[in]  pwd            : Password
- * \param[in]  pwdLen         : Password length
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerPresentPassword(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pwdNum,
-    const uint8_t* pwd,
-    uint8_t pwdLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Get Random Number
- *  
- *  Returns a 16 bit random number
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerGetRandomNumber(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Message length
- *  
- * Sends a Read Message Length message to retrieve the value of MB_LEN_Dyn 
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[out] msgLen         : Message Length
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerReadMessageLength(uint8_t flags, const uint8_t* uid, uint8_t* msgLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Message length
- *  
- * Sends a Fast Read Message Length message to retrieve the value of MB_LEN_Dyn using ST Fast mode.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[out] msgLen         : Message Length
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastReadMsgLength(uint8_t flags, const uint8_t* uid, uint8_t* msgLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Read Message
- *  
- * Reads up to 256 bytes in the Mailbox from the location
- * specified by MBpointer and sends back their value in the rxBuf response.
- * First MailBox location is '00'. When Number of bytes is set to 00h 
- * and MBPointer is equals to 00h, the MB_LEN bytes of the full message 
- * are returned. Otherwise, Read Message command returns (Number of Bytes + 1) bytes 
- * (i.e. 01h returns 2 bytes, FFh returns 256 bytes).
- * An error is reported if (Pointer + Nb of bytes + 1) is greater than the message length. 
- * RF Reading of the last byte of the mailbox message automatically clears b1 
- * of MB_CTRL_Dyn HOST_PUT_MSG, and allows RF to put a new message.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  mbPointer      : MPpointer
- * \param[in]  numBytes       : number of bytes
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerReadMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Read Message
- *  
- * Reads up to 256 bytes in the Mailbox from the location
- * specified by MBpointer and sends back their value in the rxBuf response using ST Fast mode.
- * First MailBox location is '00'. When Number of bytes is set to 00h 
- * and MBPointer is equals to 00h, the MB_LEN bytes of the full message 
- * are returned. Otherwise, Read Message command returns (Number of Bytes + 1) bytes 
- * (i.e. 01h returns 2 bytes, FFh returns 256 bytes).
- * An error is reported if (Pointer + Nb of bytes + 1) is greater than the message length. 
- * RF Reading of the last byte of the mailbox message automatically clears b1 
- * of MB_CTRL_Dyn  HOST_PUT_MSG, and allows RF to put a new message.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  mbPointer      : MPpointer
- * \param[in]  numBytes       : number of bytes
- * \param[out] rxBuf          : buffer to store response (also with RES_FLAGS)
- * \param[in]  rxBufLen       : length of rxBuf
- * \param[out] rcvLen         : number of bytes received
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastReadMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Write Message
- *  
- * Sends Write message Command
- *
- * On receiving the Write Message command, the ST25DVxxx puts the data contained 
- * in the request into the Mailbox buffer, update the MB_LEN_Dyn register, and 
- * set bit RF_PUT_MSG in MB_CTRL_Dyn register. It then reports if the write operation was successful 
- * in the response. The ST25DVxxx Mailbox contains up to 256 data bytes which are filled from the
- *  first location '00'. MSGlength parameter of the command is the number of 
- * Data bytes minus 1 (00 for 1 byte of data, FFh for 256 bytes of data). 
- * Write Message could be executed only when Mailbox is accessible by RF.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  msgLen         : MSGLen  number of Data bytes minus 1
- * \param[in]  msgData        : Message Data
- * \param[out] txBuf          : buffer to used to build the Write Message command 
- * \param[in]  txBufLen       : length of txBuf
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerWriteMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-V Poller Fast Write Message
- *  
- * Sends Fast Write message Command using ST Fast mode
- * 
- * On receiving the Write Message command, the ST25DVxxx puts the data contained 
- * in the request into the Mailbox buffer, update the MB_LEN_Dyn register, and 
- * set bit RF_PUT_MSG in MB_CTRL_Dyn register. It then reports if the write operation was successful 
- * in the response. The ST25DVxxx Mailbox contains up to 256 data bytes which are filled from the
- *  first location '00'. MSGlength parameter of the command is the number of 
- * Data bytes minus 1 (00 for 1 byte of data, FFh for 256 bytes of data). 
- * Write Message could be executed only when Mailbox is accessible by RF.
- *
- * \param[in]  flags          : Flags to be used: Sub-carrier; Data_rate; Option
- *                              for NFC-Forum use: RFAL_NFCV_REQ_FLAG_DEFAULT
- * \param[in]  uid            : UID of the device to be put to be read
- *                               if not provided Select mode will be used 
- * \param[in]  msgLen         : MSGLen  number of Data bytes minus 1
- * \param[in]  msgData        : Message Data
- * \param[out] txBuf          : buffer to used to build the Write Message command 
- * \param[in]  txBufLen       : length of txBuf
- *  
- * \return ERR_WRONG_STATE    : RFAL not initialized or incorrect mode
- * \return ERR_PARAM          : Invalid parameters
- * \return ERR_IO             : Generic internal error 
- * \return ERR_CRC            : CRC error detected
- * \return ERR_FRAMING        : Framing error detected
- * \return ERR_PROTO          : Protocol error detected
- * \return ERR_TIMEOUT        : Timeout error
- * \return ERR_NONE           : No error
- *****************************************************************************
- */
-ReturnCode rfalST25xVPollerFastWriteMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen);
-
-#endif /* RFAL_ST25xV_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_t1t.h

@@ -1,178 +0,0 @@
-
-/******************************************************************************
-  * \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_t1t.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Provides NFC-A T1T convenience methods and definitions
- *  
- *  This module provides an interface to perform as a NFC-A Reader/Writer
- *  to handle a Type 1 Tag T1T (Topaz)
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup T1T
- * \brief RFAL T1T Module
- * @{
- *  
- */
-
-#ifndef RFAL_T1T_H
-#define RFAL_T1T_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-#define RFAL_T1T_UID_LEN 4 /*!< T1T UID length of cascade level 1 only tag  */
-#define RFAL_T1T_HR_LENGTH 2 /*!< T1T HR(Header ROM) length                   */
-
-#define RFAL_T1T_HR0_NDEF_MASK 0xF0 /*!< T1T HR0 NDEF capability mask  T1T 1.2 2.2.2 */
-#define RFAL_T1T_HR0_NDEF_SUPPORT 0x10 /*!< T1T HR0 NDEF capable value    T1T 1.2 2.2.2 */
-
-/*! NFC-A T1T (Topaz) command set */
-typedef enum {
-    RFAL_T1T_CMD_RID = 0x78, /*!< T1T Read UID                                */
-    RFAL_T1T_CMD_RALL = 0x00, /*!< T1T Read All                                */
-    RFAL_T1T_CMD_READ = 0x01, /*!< T1T Read                                    */
-    RFAL_T1T_CMD_WRITE_E = 0x53, /*!< T1T Write with erase (single byte)          */
-    RFAL_T1T_CMD_WRITE_NE = 0x1A /*!< T1T Write with no erase (single byte)       */
-} rfalT1Tcmds;
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-A T1T (Topaz) RID_RES  Digital 1.1  10.6.2 & Table 50 */
-typedef struct {
-    uint8_t hr0; /*!< T1T Header ROM: HR0                         */
-    uint8_t hr1; /*!< T1T Header ROM: HR1                         */
-    uint8_t uid[RFAL_T1T_UID_LEN]; /*!< T1T UID                                     */
-} rfalT1TRidRes;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Initialize NFC-A T1T Poller mode
- *  
- * This methods configures RFAL RF layer to perform as a 
- * NFC-A T1T Poller/RW (Topaz) including all default timings 
- *
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT1TPollerInitialize(void);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T1T Poller RID
- *  
- * This method reads the UID of a NFC-A T1T Listener device  
- *
- *
- * \param[out]  ridRes : pointer to place the RID_RES
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT1TPollerRid(rfalT1TRidRes* ridRes);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T1T Poller RALL
- *  
- * This method send a Read All command to a NFC-A T1T Listener device  
- *
- *
- * \param[in]   uid       : the UID of the device to read data
- * \param[out]  rxBuf     : pointer to place the read data
- * \param[in]   rxBufLen  : size of rxBuf
- * \param[out]  rxRcvdLen : actual received data
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode
-    rfalT1TPollerRall(const uint8_t* uid, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rxRcvdLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T1T Poller Write
- *  
- * This method writes the given data on the address of a NFC-A T1T Listener device  
- *
- *
- * \param[in]   uid       : the UID of the device to read data
- * \param[in]   address   : address to write the data
- * \param[in]   data      : the data to be written
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT1TPollerWrite(const uint8_t* uid, uint8_t address, uint8_t data);
-
-#endif /* RFAL_T1T_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_t2t.h

@@ -1,150 +0,0 @@
-
-/******************************************************************************
-  * \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_t2t.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Provides NFC-A T2T convenience methods and definitions
- *  
- *  This module provides an interface to perform as a NFC-A Reader/Writer
- *  to handle a Type 2 Tag T2T
- *  
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup T2T
- * \brief RFAL T2T Module
- * @{
- *  
- */
-
-#ifndef RFAL_T2T_H
-#define RFAL_T2T_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_T2T_BLOCK_LEN 4U /*!< T2T block length           */
-#define RFAL_T2T_READ_DATA_LEN (4U * RFAL_T2T_BLOCK_LEN) /*!< T2T READ data length       */
-#define RFAL_T2T_WRITE_DATA_LEN RFAL_T2T_BLOCK_LEN /*!< T2T WRITE data length      */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T2T Poller Read
- *  
- * This method sends a Read command to a NFC-A T2T Listener device  
- *
- *
- * \param[in]   blockNum    : Number of the block to read
- * \param[out]  rxBuf       : pointer to place the read data
- * \param[in]   rxBufLen    : size of rxBuf (RFAL_T2T_READ_DATA_LEN)
- * \param[out]  rcvLen   : actual received data
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode
-    rfalT2TPollerRead(uint8_t blockNum, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rcvLen);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T2T Poller Write
- *  
- * This method sends a Write command to a NFC-A T2T Listener device  
- *
- *
- * \param[in]  blockNum     : Number of the block to write
- * \param[in]  wrData       : data to be written on the given block
- *                            size must be of RFAL_T2T_WRITE_DATA_LEN
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT2TPollerWrite(uint8_t blockNum, const uint8_t* wrData);
-
-/*! 
- *****************************************************************************
- * \brief  NFC-A T2T Poller Sector Select 
- *  
- * This method sends a Sector Select commands to a NFC-A T2T Listener device  
- *
- * \param[in]  sectorNum    : Sector Number
- * 
- * \return ERR_WRONG_STATE  : RFAL not initialized or mode not set
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT2TPollerSectorSelect(uint8_t sectorNum);
-
-#endif /* RFAL_T2T_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/include/rfal_t4t.h

@@ -1,395 +0,0 @@
-
-/******************************************************************************
-  * \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_t4t.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Provides convenience methods and definitions for T4T (ISO7816-4)
- *  
- *  This module provides an interface to exchange T4T APDUs according to 
- *  NFC Forum T4T and ISO7816-4
- *  
- *  This implementation was based on the following specs:
- *    - ISO/IEC 7816-4  3rd Edition 2013-04-15
- *    - NFC Forum T4T Technical Specification 1.0 2017-08-28
- *  
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-AL
- * \brief RFAL Abstraction Layer
- * @{
- *
- * \addtogroup T4T
- * \brief RFAL T4T Module
- * @{
- *  
- */
-
-#ifndef RFAL_T4T_H
-#define RFAL_T4T_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../platform.h"
-#include "../st_errno.h"
-#include "rfal_rf.h"
-#include "rfal_isoDep.h"
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_T4T_MAX_CAPDU_PROLOGUE_LEN \
-    4U /*!< Command-APDU prologue length (CLA INS P1 P2)                    */
-#define RFAL_T4T_LE_LEN 1U /*!< Le Expected Response Length (short field coding)                */
-#define RFAL_T4T_LC_LEN 1U /*!< Lc Data field length  (short field coding)                      */
-#define RFAL_T4T_MAX_RAPDU_SW1SW2_LEN \
-    2U /*!< SW1 SW2 length                                                  */
-#define RFAL_T4T_CLA 0x00U /*!< Class byte (contains 00h because secure message are not used)   */
-
-#define RFAL_T4T_ISO7816_P1_SELECT_BY_DF_NAME \
-    0x04U /*!< P1 value for Select by name                                     */
-#define RFAL_T4T_ISO7816_P1_SELECT_BY_FILEID \
-    0x00U /*!< P1 value for Select by file identifier                          */
-#define RFAL_T4T_ISO7816_P2_SELECT_FIRST_OR_ONLY_OCCURENCE \
-    0x00U /*!<      b2b1 P2 value for First or only occurrence                 */
-#define RFAL_T4T_ISO7816_P2_SELECT_RETURN_FCI_TEMPLATE \
-    0x00U /*!< b4b3      P2 value for Return FCI template                      */
-#define RFAL_T4T_ISO7816_P2_SELECT_NO_RESPONSE_DATA \
-    0x0CU /*!< b4b3      P2 value for No response data                         */
-
-#define RFAL_T4T_ISO7816_STATUS_COMPLETE \
-    0x9000U /*!< Command completed \ Normal processing - No further qualification*/
-
-/*
-******************************************************************************
-* GLOBAL VARIABLES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-/*! NFC-A T4T Command-APDU structure */
-typedef struct {
-    uint8_t CLA; /*!< Class byte                                         */
-    uint8_t INS; /*!< Instruction byte                                   */
-    uint8_t P1; /*!< Parameter byte 1                                   */
-    uint8_t P2; /*!< Parameter byte 2                                   */
-    uint8_t Lc; /*!< Data field length                                  */
-    bool LcFlag; /*!< Lc flag (append Lc when true)                      */
-    uint8_t Le; /*!< Expected Response Length                           */
-    bool LeFlag; /*!< Le flag (append Le when true)                      */
-
-    rfalIsoDepApduBufFormat* cApduBuf; /*!< Command-APDU buffer  (Tx)                          */
-    uint16_t* cApduLen; /*!< Command-APDU Length                                */
-} rfalT4tCApduParam;
-
-/*! NFC-A T4T Response-APDU structure */
-typedef struct {
-    rfalIsoDepApduBufFormat* rApduBuf; /*!< Response-APDU buffer (Rx)                          */
-    uint16_t rcvdLen; /*!< Full response length                               */
-    uint16_t rApduBodyLen; /*!< Response body length                               */
-    uint16_t statusWord; /*!< R-APDU Status Word SW1|SW2                         */
-} rfalT4tRApduParam;
-
-/*! NFC-A T4T command set    T4T 1.0 & ISO7816-4 2013 Table 4 */
-typedef enum {
-    RFAL_T4T_INS_SELECT = 0xA4U, /*!< T4T Select                                         */
-    RFAL_T4T_INS_READBINARY = 0xB0U, /*!< T4T ReadBinary                                     */
-    RFAL_T4T_INS_UPDATEBINARY = 0xD6U, /*!< T4T UpdateBinay                                    */
-    RFAL_T4T_INS_READBINARY_ODO = 0xB1U, /*!< T4T ReadBinary using ODO                           */
-    RFAL_T4T_INS_UPDATEBINARY_ODO =
-        0xD7U /*!< T4T UpdateBinay using ODO                          */
-} rfalT4tCmds;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose APDU
- *  
- * This method computes a C-APDU according to NFC Forum T4T and ISO7816-4.
- * 
- * If C-APDU contains data to be sent, it must be placed inside the buffer
- *   rfalT4tTxRxApduParam.txRx.cApduBuf.apdu and signaled by Lc
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * \see rfalT4TPollerParseRAPDU()
- *
- * \warning The ISO-DEP module is used to perform the tranceive. Usually 
- *          activation has been done via ISO-DEP activatiavtion. If not
- *          please call rfalIsoDepInitialize() before.
- * 
- * \param[in,out] apduParam : APDU parameters
- *                            apduParam.cApduLen will contain the APDU length 
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeCAPDU(const rfalT4tCApduParam* apduParam);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Parse R-APDU
- *  
- * This method parses a R-APDU according to NFC Forum T4T and ISO7816-4.
- * It will extract the data length and check if the Status word is expected.
- *
- * \param[in,out] apduParam : APDU parameters
- *                            apduParam.rApduBodyLen will contain the data length 
- *                            apduParam.statusWord will contain the SW1 and SW2 
- * 
- * \return ERR_REQUEST      : Status word (SW1 SW2) different from 9000
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerParseRAPDU(rfalT4tRApduParam* apduParam);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Select Application APDU
- *  
- * This method computes a Select Application APDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      aid      : Application ID to be used
- * \param[in]      aidLen   : Application ID length
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeSelectAppl(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* aid,
-    uint8_t aidLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Select File APDU
- *  
- * This method computes a Select File APDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      fid      : File ID to be used
- * \param[in]      fidLen   : File ID length
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeSelectFile(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* fid,
-    uint8_t fidLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Select File APDU for Mapping Version 1
- *  
- * This method computes a Select File APDU according to NFC Forum T4TOP_v1.0
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      fid      : File ID to be used
- * \param[in]      fidLen   : File ID length
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeSelectFileV1Mapping(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* fid,
-    uint8_t fidLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Read Data APDU
- *  
- * This method computes a Read Data APDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      offset   : File offset
- * \param[in]      expLen   : Expected length (Le)
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeReadData(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint16_t offset,
-    uint8_t expLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Read Data ODO APDU
- *  
- * This method computes a Read Data ODO APDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      offset   : File offset
- * \param[in]      expLen   : Expected length (Le)
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeReadDataODO(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint32_t offset,
-    uint8_t expLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Write Data APDU
- *  
- * This method computes a Write Data APDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      offset   : File offset
- * \param[in]      data     : Data to be written
- * \param[in]      dataLen  : Data length to be written (Lc)
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeWriteData(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint16_t offset,
-    const uint8_t* data,
-    uint8_t dataLen,
-    uint16_t* cApduLen);
-
-/*! 
- *****************************************************************************
- * \brief  T4T Compose Write Data ODO APDU
- *  
- * This method computes a Write Data ODO sAPDU according to NFC Forum T4T
- *
- * To transceive the formed APDU the ISO-DEP layer shall be used
- *
- * \see rfalIsoDepStartApduTransceive()
- * \see rfalIsoDepGetApduTransceiveStatus()
- * 
- * \param[out]     cApduBuf : buffer where the C-APDU will be placed
- * \param[in]      offset   : File offset
- * \param[in]      data     : Data to be written
- * \param[in]      dataLen  : Data length to be written (Lc)
- * \param[out]     cApduLen : Composed C-APDU length
- * 
- * \return ERR_PARAM        : Invalid parameter
- * \return ERR_PROTO        : Protocol error
- * \return ERR_NONE         : No error
- *****************************************************************************
- */
-ReturnCode rfalT4TPollerComposeWriteDataODO(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint32_t offset,
-    const uint8_t* data,
-    uint8_t dataLen,
-    uint16_t* cApduLen);
-
-#endif /* RFAL_T4T_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/platform.c

@@ -1,105 +0,0 @@
-#include "platform.h"
-#include <assert.h>
-#include <furi.h>
-#include <furi_hal_spi.h>
-
-typedef struct {
-    FuriThread* thread;
-    volatile PlatformIrqCallback callback;
-    bool need_spi_lock;
-} RfalPlatform;
-
-static volatile RfalPlatform rfal_platform = {
-    .thread = NULL,
-    .callback = NULL,
-    .need_spi_lock = true,
-};
-
-void nfc_isr(void* _ctx) {
-    UNUSED(_ctx);
-    if(rfal_platform.callback && platformGpioIsHigh(ST25R_INT_PORT, ST25R_INT_PIN)) {
-        furi_thread_flags_set(furi_thread_get_id(rfal_platform.thread), 0x1);
-    }
-}
-
-int32_t rfal_platform_irq_thread(void* context) {
-    UNUSED(context);
-
-    while(1) {
-        uint32_t flags = furi_thread_flags_wait(0x1, FuriFlagWaitAny, FuriWaitForever);
-        if(flags & 0x1) {
-            rfal_platform.callback();
-        }
-    }
-}
-
-void platformEnableIrqCallback() {
-    furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeInterruptRise, GpioPullDown, GpioSpeedLow);
-    furi_hal_gpio_enable_int_callback(&gpio_nfc_irq_rfid_pull);
-}
-
-void platformDisableIrqCallback() {
-    furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_disable_int_callback(&gpio_nfc_irq_rfid_pull);
-}
-
-void platformSetIrqCallback(PlatformIrqCallback callback) {
-    rfal_platform.callback = callback;
-
-    if(!rfal_platform.thread) {
-        rfal_platform.thread =
-            furi_thread_alloc_ex("RfalIrqDriver", 1024, rfal_platform_irq_thread, NULL);
-        furi_thread_mark_as_service(rfal_platform.thread);
-        furi_thread_set_priority(rfal_platform.thread, FuriThreadPriorityIsr);
-        furi_thread_start(rfal_platform.thread);
-    }
-
-    furi_hal_gpio_remove_int_callback(&gpio_nfc_irq_rfid_pull);
-
-    furi_hal_gpio_add_int_callback(&gpio_nfc_irq_rfid_pull, nfc_isr, NULL);
-    // Disable interrupt callback as the pin is shared between 2 apps
-    // It is enabled in rfalLowPowerModeStop()
-    furi_hal_gpio_disable_int_callback(&gpio_nfc_irq_rfid_pull);
-}
-
-bool platformSpiTxRx(const uint8_t* txBuf, uint8_t* rxBuf, uint16_t len) {
-    bool ret = false;
-    if(txBuf && rxBuf) {
-        ret =
-            furi_hal_spi_bus_trx(&furi_hal_spi_bus_handle_nfc, (uint8_t*)txBuf, rxBuf, len, 1000);
-    } else if(txBuf) {
-        ret = furi_hal_spi_bus_tx(&furi_hal_spi_bus_handle_nfc, (uint8_t*)txBuf, len, 1000);
-    } else if(rxBuf) {
-        ret = furi_hal_spi_bus_rx(&furi_hal_spi_bus_handle_nfc, (uint8_t*)rxBuf, len, 1000);
-    }
-
-    return ret;
-}
-
-// Until we completely remove RFAL, NFC works with SPI from rfal_platform_irq_thread and nfc_worker
-// threads. Some nfc features already stop using RFAL and work with SPI from nfc_worker only.
-// rfal_platform_spi_acquire() and rfal_platform_spi_release() functions are used to lock SPI for a
-// long term without locking it for each SPI transaction. This is needed for time critical communications.
-void rfal_platform_spi_acquire() {
-    platformDisableIrqCallback();
-    rfal_platform.need_spi_lock = false;
-    furi_hal_spi_acquire(&furi_hal_spi_bus_handle_nfc);
-}
-
-void rfal_platform_spi_release() {
-    furi_hal_spi_release(&furi_hal_spi_bus_handle_nfc);
-    rfal_platform.need_spi_lock = true;
-    platformEnableIrqCallback();
-}
-
-void platformProtectST25RComm() {
-    if(rfal_platform.need_spi_lock) {
-        furi_hal_spi_acquire(&furi_hal_spi_bus_handle_nfc);
-    }
-}
-
-void platformUnprotectST25RComm() {
-    if(rfal_platform.need_spi_lock) {
-        furi_hal_spi_release(&furi_hal_spi_bus_handle_nfc);
-    }
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/platform.h

@@ -1,188 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <limits.h>
-#include "timer.h"
-#include "math.h"
-#include <furi_hal_gpio.h>
-#include <furi_hal_light.h>
-#include <furi_hal_spi.h>
-
-typedef void (*PlatformIrqCallback)();
-void platformSetIrqCallback(PlatformIrqCallback cb);
-void platformEnableIrqCallback();
-void platformDisableIrqCallback();
-
-bool platformSpiTxRx(const uint8_t* txBuf, uint8_t* rxBuf, uint16_t len);
-void platformProtectST25RComm();
-void platformUnprotectST25RComm();
-void rfal_platform_spi_acquire();
-void rfal_platform_spi_release();
-
-#define ST25R_SS_PIN NFC_CS_Pin
-#define ST25R_SS_PORT NFC_CS_GPIO_Port
-
-#define ST25R_INT_PIN NFC_IRQ_Pin
-#define ST25R_INT_PORT NFC_IRQ_GPIO_Port
-
-#define RFAL_ANALOG_CONFIG_CUSTOM \
-    true /*!< Enable/Disable RFAL custom analog configuration                           */
-
-#define RFAL_FEATURE_LISTEN_MODE \
-    true /*!< Enable/Disable RFAL support for Listen Mode                               */
-#define RFAL_FEATURE_WAKEUP_MODE \
-    true /*!< Enable/Disable RFAL support for the Wake-Up mode                          */
-#define RFAL_FEATURE_LOWPOWER_MODE \
-    true /*!< Enable/Disable RFAL support for the Low Power mode                        */
-#define RFAL_FEATURE_NFCA \
-    true /*!< Enable/Disable RFAL support for NFC-A (ISO14443A)                         */
-#define RFAL_FEATURE_NFCB \
-    true /*!< Enable/Disable RFAL support for NFC-B (ISO14443B)                         */
-#define RFAL_FEATURE_NFCF \
-    true /*!< Enable/Disable RFAL support for NFC-F (FeliCa)                            */
-#define RFAL_FEATURE_NFCV \
-    true /*!< Enable/Disable RFAL support for NFC-V (ISO15693)                          */
-#define RFAL_FEATURE_T1T \
-    true /*!< Enable/Disable RFAL support for T1T (Topaz)                               */
-#define RFAL_FEATURE_T2T \
-    true /*!< Enable/Disable RFAL support for T2T (MIFARE Ultralight)                   */
-#define RFAL_FEATURE_T4T \
-    true /*!< Enable/Disable RFAL support for T4T                                       */
-#define RFAL_FEATURE_ST25TB \
-    true /*!< Enable/Disable RFAL support for ST25TB                                    */
-#define RFAL_FEATURE_ST25xV \
-    true /*!< Enable/Disable RFAL support for ST25TV/ST25DV                             */
-#define RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG \
-    false /*!< Enable/Disable Analog Configs to be dynamically updated (RAM)             */
-#define RFAL_FEATURE_DPO \
-    false /*!< Enable/Disable RFAL Dynamic Power Output upport                           */
-#define RFAL_FEATURE_ISO_DEP \
-    true /*!< Enable/Disable RFAL support for ISO-DEP (ISO14443-4)                      */
-#define RFAL_FEATURE_ISO_DEP_POLL \
-    true /*!< Enable/Disable RFAL support for Poller mode (PCD) ISO-DEP (ISO14443-4)    */
-#define RFAL_FEATURE_ISO_DEP_LISTEN \
-    true /*!< Enable/Disable RFAL support for Listen mode (PICC) ISO-DEP (ISO14443-4)   */
-#define RFAL_FEATURE_NFC_DEP \
-    true /*!< Enable/Disable RFAL support for NFC-DEP (NFCIP1/P2P)                      */
-
-#define RFAL_FEATURE_ISO_DEP_IBLOCK_MAX_LEN \
-    256U /*!< ISO-DEP I-Block max length. Please use values as defined by rfalIsoDepFSx */
-#define RFAL_FEATURE_NFC_DEP_BLOCK_MAX_LEN \
-    254U /*!< NFC-DEP Block/Payload length. Allowed values: 64, 128, 192, 254           */
-#define RFAL_FEATURE_NFC_RF_BUF_LEN \
-    256U /*!< RF buffer length used by RFAL NFC layer                                   */
-
-#define RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN \
-    512U /*!< ISO-DEP APDU max length.                                                  */
-#define RFAL_FEATURE_NFC_DEP_PDU_MAX_LEN \
-    512U /*!< NFC-DEP PDU max length.                                                   */
-
-#define platformIrqST25RSetCallback(cb) platformSetIrqCallback(cb)
-
-#define platformProtectST25RIrqStatus() \
-    platformProtectST25RComm() /*!< Protect unique access to IRQ status var - IRQ disable on single thread environment (MCU) ; Mutex lock on a multi thread environment */
-#define platformUnprotectST25RIrqStatus() \
-    platformUnprotectST25RComm() /*!< Unprotect the IRQ status var - IRQ enable on a single thread environment (MCU) ; Mutex unlock on a multi thread environment         */
-
-#define platformGpioSet(port, pin) \
-    furi_hal_gpio_write_port_pin(  \
-        port, pin, true) /*!< Turns the given GPIO High                   */
-#define platformGpioClear(port, pin) \
-    furi_hal_gpio_write_port_pin(    \
-        port, pin, false) /*!< Turns the given GPIO Low                    */
-
-#define platformGpioIsHigh(port, pin)          \
-    (furi_hal_gpio_read_port_pin(port, pin) == \
-     true) /*!< Checks if the given LED is High             */
-#define platformGpioIsLow(port, pin) \
-    (!platformGpioIsHigh(port, pin)) /*!< Checks if the given LED is Low              */
-
-#define platformTimerCreate(t) \
-    timerCalculateTimer(t) /*!< Create a timer with the given time (ms)     */
-#define platformTimerIsExpired(timer) \
-    timerIsExpired(timer) /*!< Checks if the given timer is expired        */
-#define platformDelay(t) furi_delay_ms(t) /*!< Performs a delay for the given time (ms)    */
-
-#define platformGetSysTick() furi_get_tick() /*!< Get System Tick (1 tick = 1 ms)             */
-
-#define platformAssert(exp) assert_param(exp) /*!< Asserts whether the given expression is true*/
-
-#define platformSpiSelect() \
-    platformGpioClear(      \
-        ST25R_SS_PORT, ST25R_SS_PIN) /*!< SPI SS\CS: Chip|Slave Select                */
-#define platformSpiDeselect() \
-    platformGpioSet(          \
-        ST25R_SS_PORT, ST25R_SS_PIN) /*!< SPI SS\CS: Chip|Slave Deselect              */
-
-#define platformI2CTx(txBuf, len, last, txOnly) /*!< I2C Transmit                                */
-#define platformI2CRx(txBuf, len) /*!< I2C Receive                                 */
-#define platformI2CStart() /*!< I2C Start condition                         */
-#define platformI2CStop() /*!< I2C Stop condition                          */
-#define platformI2CRepeatStart() /*!< I2C Repeat Start                            */
-#define platformI2CSlaveAddrWR(add) /*!< I2C Slave address for Write operation       */
-#define platformI2CSlaveAddrRD(add) /*!< I2C Slave address for Read operation        */
-
-#define platformLog(...) /*!< Log  method                                 */
-
-/*
- ******************************************************************************
- * RFAL OPTIONAL MACROS            (Do not change)
- ******************************************************************************
- */
-#ifndef platformProtectST25RIrqStatus
-#define platformProtectST25RIrqStatus() /*!< Protect unique access to IRQ status var - IRQ disable on single thread environment (MCU) ; Mutex lock on a multi thread environment */
-#endif /* platformProtectST25RIrqStatus */
-
-#ifndef platformUnprotectST25RIrqStatus
-#define platformUnprotectST25RIrqStatus() /*!< Unprotect the IRQ status var - IRQ enable on a single thread environment (MCU) ; Mutex unlock on a multi thread environment         */
-#endif /* platformUnprotectST25RIrqStatus */
-
-#ifndef platformProtectWorker
-#define platformProtectWorker() /* Protect RFAL Worker/Task/Process from concurrent execution on multi thread platforms   */
-#endif /* platformProtectWorker */
-
-#ifndef platformUnprotectWorker
-#define platformUnprotectWorker() /* Unprotect RFAL Worker/Task/Process from concurrent execution on multi thread platforms */
-#endif /* platformUnprotectWorker */
-
-#ifndef platformIrqST25RPinInitialize
-#define platformIrqST25RPinInitialize() /*!< Initializes ST25R IRQ pin                    */
-#endif /* platformIrqST25RPinInitialize */
-
-#ifndef platformIrqST25RSetCallback
-#define platformIrqST25RSetCallback(cb) /*!< Sets ST25R ISR callback                      */
-#endif /* platformIrqST25RSetCallback */
-
-#ifndef platformLedsInitialize
-#define platformLedsInitialize() /*!< Initializes the pins used as LEDs to outputs */
-#endif /* platformLedsInitialize */
-
-#ifndef platformLedOff
-#define platformLedOff(port, pin) /*!< Turns the given LED Off                      */
-#endif /* platformLedOff */
-
-#ifndef platformLedOn
-#define platformLedOn(port, pin) /*!< Turns the given LED On                       */
-#endif /* platformLedOn */
-
-#ifndef platformLedToogle
-#define platformLedToogle(port, pin) /*!< Toggles the given LED                        */
-#endif /* platformLedToogle */
-
-#ifndef platformGetSysTick
-#define platformGetSysTick() /*!< Get System Tick (1 tick = 1 ms)              */
-#endif /* platformGetSysTick */
-
-#ifndef platformTimerDestroy
-#define platformTimerDestroy(timer) /*!< Stops and released the given timer           */
-#endif /* platformTimerDestroy */
-
-#ifndef platformAssert
-#define platformAssert(exp) /*!< Asserts whether the given expression is true */
-#endif /* platformAssert */
-
-#ifndef platformErrorHandle
-#define platformErrorHandle() /*!< Global error handler or trap                 */
-#endif /* platformErrorHandle */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/custom_analog_config.c

@@ -1,777 +0,0 @@
-#include "st25r3916/rfal_analogConfigTbl.h"
-
-const uint8_t rfalAnalogConfigCustomSettings[] = {
-    /****** Default Analog Configuration for Chip-Specific Reset ******/
-    MODE_ENTRY_16_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_INIT),
-        ST25R3916_REG_IO_CONF1,
-        (ST25R3916_REG_IO_CONF1_out_cl_mask | ST25R3916_REG_IO_CONF1_lf_clk_off),
-        0x07 /* Disable MCU_CLK */
-        ,
-        ST25R3916_REG_IO_CONF2,
-        (ST25R3916_REG_IO_CONF2_miso_pd1 | ST25R3916_REG_IO_CONF2_miso_pd2),
-        0x18 /* SPI Pull downs */
-        // , ST25R3916_REG_IO_CONF2,  ST25R3916_REG_IO_CONF2_aat_en, ST25R3916_REG_IO_CONF2_aat_en                                                /* Enable AAT */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_d_res_mask,
-        0x00 /* Set RFO resistance Active Tx */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        0xFF,
-        0x80 /* Use minimum non-overlap */
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_105mV /* Lower activation threshold (higher than deactivation)*/
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_105mV /* Lower activation threshold (higher than deactivation)*/
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_75mV /* Lower deactivation threshold */
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_75mV /* Lower deactivation threshold */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        ST25R3916_REG_AUX_MOD_lm_ext,
-        ST25R3916_REG_AUX_MOD_lm_ext /* Disable External Load Modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        ST25R3916_REG_AUX_MOD_lm_dri,
-        ST25R3916_REG_AUX_MOD_lm_dri /* Use internal Load Modulation */
-        ,
-        ST25R3916_REG_PASSIVE_TARGET,
-        ST25R3916_REG_PASSIVE_TARGET_fdel_mask,
-        (5U
-         << ST25R3916_REG_PASSIVE_TARGET_fdel_shift) /* Adjust the FDT to be aligned with the bitgrid  */
-        ,
-        ST25R3916_REG_PT_MOD,
-        (ST25R3916_REG_PT_MOD_ptm_res_mask | ST25R3916_REG_PT_MOD_pt_res_mask),
-        0x0f /* Reduce RFO resistance in Modulated state */
-        ,
-        ST25R3916_REG_EMD_SUP_CONF,
-        ST25R3916_REG_EMD_SUP_CONF_rx_start_emv,
-        ST25R3916_REG_EMD_SUP_CONF_rx_start_emv_on /* Enable start on first 4 bits */
-        ,
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        0x84U,
-        0x10,
-        0x10 /* Avoid chip internal overheat protection */
-        )
-
-    /****** Default Analog Configuration for Chip-Specific Poll Common ******/
-    ,
-    MODE_ENTRY_9_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_12percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x00 /* Use AM via regulator */
-        ,
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 106 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x08,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x51,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 212 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x88 /* Use Resistive AM */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        ST25R3916_REG_RES_AM_MOD_md_res_mask,
-        0x7F /* Set Resistive modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 212 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x02,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x14,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 424 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x88 /* Use Resistive AM */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        ST25R3916_REG_RES_AM_MOD_md_res_mask,
-        0x7F /* Set Resistive modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 424 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 848 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_40percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x00 /* Use AM via regulator */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 848 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x44,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Anticolision setting ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_ANTICOL),
-        ST25R3916_REG_CORR_CONF1,
-        ST25R3916_REG_CORR_CONF1_corr_s6,
-        0x00 /* Set collision detection level different from data */
-        )
-
-#ifdef RFAL_USE_COHE
-    /****** Default Analog Configuration for Poll NFC-B Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Coherent Receiver */
-        )
-#else
-    /****** Default Analog Configuration for Poll NFC-B Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        )
-#endif /*RFAL_USE_COHE*/
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 106 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x04,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x1B,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 212 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x02,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x14,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 424 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 848 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x44,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#ifdef RFAL_USE_COHE
-
-    /****** Default Analog Configuration for Poll NFC-F Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Pulse Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#else
-    /****** Default Analog Configuration for Poll NFC-F Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#endif /*RFAL_USE_COHE*/
-
-        ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV | RFAL_ANALOG_CONFIG_BITRATE_1OF4 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK */
-        )
-
-#ifdef RFAL_USE_COHE
-    /****** Default Analog Configuration for Poll NFC-V Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Pulse Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x01)
-#else
-    /****** Default Analog Configuration for Poll NFC-V Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x01)
-#endif /*RFAL_USE_COHE*/
-
-    /****** Default Analog Configuration for Poll AP2P Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll AP2P Tx 212 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Poll AP2P Tx 424 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Chip-Specific Listen On ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_ON),
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x00 /* Set Antenna Tuning (Listener): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0xff /* Set Antenna Tuning (Listener): ANTL */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_12percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Rx Common ******/
-    ,
-    MODE_ENTRY_3_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        ST25R3916_REG_RX_CONF1_lp_mask,
-        ST25R3916_REG_RX_CONF1_lp_1200khz /* Set Rx filter configuration */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        ST25R3916_REG_RX_CONF1_hz_mask,
-        ST25R3916_REG_RX_CONF1_hz_12_200khz /* Set Rx filter configuration */
-        ,
-        ST25R3916_REG_RX_CONF2,
-        ST25R3916_REG_RX_CONF2_amd_sel,
-        ST25R3916_REG_RX_CONF2_amd_sel_mixer /* AM demodulator: mixer */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_106 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 212 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_212 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 424 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_424 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-};
-
-const uint16_t rfalAnalogConfigCustomSettingsLength = sizeof(rfalAnalogConfigCustomSettings);

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_analogConfig.c

@@ -1,480 +0,0 @@
-
-/******************************************************************************
-  * \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_analogConfig.c
- *
- *  \author bkam
- *
- *  \brief Functions to manage and set analog settings.
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_analogConfig.h"
-#include "../include/rfal_chip.h"
-#include "../st_errno.h"
-#include "../platform.h"
-#include "../utils.h"
-
-/* Check whether the Default Analog settings are to be used or custom ones */
-#ifdef RFAL_ANALOG_CONFIG_CUSTOM
-extern const uint8_t* rfalAnalogConfigCustomSettings;
-extern const uint16_t rfalAnalogConfigCustomSettingsLength;
-#else
-#include "st25r3916/rfal_analogConfigTbl.h"
-#endif
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-
-#define RFAL_TEST_REG 0x0080U /*!< Test Register indicator  */
-
-/*
- ******************************************************************************
- * MACROS
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * LOCAL DATA TYPES
- ******************************************************************************
- */
-
-#if RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG
-static uint8_t
-    gRfalAnalogConfig[RFAL_ANALOG_CONFIG_TBL_SIZE]; /*!< Analog Configuration Settings List */
-#endif /* RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG */
-
-/*! Struct for Analog Config Look Up Table Update */
-typedef struct {
-    const uint8_t*
-        currentAnalogConfigTbl; /*!< Reference to start of current Analog Configuration      */
-    uint16_t configTblSize; /*!< Total size of Analog Configuration                      */
-    bool ready; /*!< Indicate if Look Up Table is complete and ready for use */
-} rfalAnalogConfigMgmt;
-
-static rfalAnalogConfigMgmt gRfalAnalogConfigMgmt; /*!< Analog Configuration LUT management */
-
-/*
- ******************************************************************************
- * LOCAL TABLES
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * LOCAL FUNCTION PROTOTYPES
- ******************************************************************************
- */
-static rfalAnalogConfigNum
-    rfalAnalogConfigSearch(rfalAnalogConfigId configId, uint16_t* configOffset);
-
-#if RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG
-static void rfalAnalogConfigPtrUpdate(const uint8_t* analogConfigTbl);
-#endif /* RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG */
-
-/*
- ******************************************************************************
- * GLOBAL VARIABLE DEFINITIONS
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTIONS
- ******************************************************************************
- */
-
-void rfalAnalogConfigInitialize(void) {
-    /* Use default Analog configuration settings in Flash by default. */
-
-/* Check whether the Default Analog settings are to be used or custom ones */
-#ifdef RFAL_ANALOG_CONFIG_CUSTOM
-    gRfalAnalogConfigMgmt.currentAnalogConfigTbl = (const uint8_t*)&rfalAnalogConfigCustomSettings;
-    gRfalAnalogConfigMgmt.configTblSize = rfalAnalogConfigCustomSettingsLength;
-#else
-    gRfalAnalogConfigMgmt.currentAnalogConfigTbl =
-        (const uint8_t*)&rfalAnalogConfigDefaultSettings;
-    gRfalAnalogConfigMgmt.configTblSize = sizeof(rfalAnalogConfigDefaultSettings);
-#endif
-
-    gRfalAnalogConfigMgmt.ready = true;
-} /* rfalAnalogConfigInitialize() */
-
-bool rfalAnalogConfigIsReady(void) {
-    return gRfalAnalogConfigMgmt.ready;
-}
-
-ReturnCode rfalAnalogConfigListWriteRaw(const uint8_t* configTbl, uint16_t configTblSize) {
-#if RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG
-
-    /* Check if the Configuration Table exceed the Table size */
-    if(configTblSize >= RFAL_ANALOG_CONFIG_TBL_SIZE) {
-        rfalAnalogConfigInitialize(); /* Revert to default Analog Configuration */
-        return ERR_NOMEM;
-    }
-
-    /* Check for invalid parameters */
-    if((configTbl == NULL) || (configTblSize == 0U)) {
-        return ERR_PARAM;
-    }
-
-    /* NOTE: Function does not check for the validity of the Table contents (conf IDs, conf sets, register address)  */
-    ST_MEMCPY(gRfalAnalogConfig, configTbl, configTblSize);
-
-    /* Update the total size of configuration settings */
-    gRfalAnalogConfigMgmt.configTblSize = configTblSize;
-
-    rfalAnalogConfigPtrUpdate(gRfalAnalogConfig);
-    return ERR_NONE;
-
-#else
-
-    // If Analog Configuration Update is to be disabled
-    NO_WARNING(configTbl);
-    NO_WARNING(configTblSize);
-    return ERR_REQUEST;
-
-#endif /* RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG */
-}
-
-ReturnCode rfalAnalogConfigListWrite(uint8_t more, const rfalAnalogConfig* config) {
-#if RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG
-
-    rfalAnalogConfigId configId;
-    rfalAnalogConfigNum numConfig;
-    uint8_t configSize;
-
-    if(true == gRfalAnalogConfigMgmt.ready) { /* First Update to the Configuration list. */
-        gRfalAnalogConfigMgmt.ready = false; // invalidate the config List
-        gRfalAnalogConfigMgmt.configTblSize = 0; // Clear the config List
-    }
-
-    configId = GETU16(config->id);
-
-    /* Check validity of the Configuration ID. */
-    if((RFAL_ANALOG_CONFIG_TECH_RFU <= RFAL_ANALOG_CONFIG_ID_GET_TECH(configId)) ||
-       ((RFAL_ANALOG_CONFIG_BITRATE_6780 < RFAL_ANALOG_CONFIG_ID_GET_BITRATE(configId)) &&
-        (RFAL_ANALOG_CONFIG_BITRATE_1OF4 > RFAL_ANALOG_CONFIG_ID_GET_BITRATE(configId))) ||
-       (RFAL_ANALOG_CONFIG_BITRATE_1OF256 < RFAL_ANALOG_CONFIG_ID_GET_BITRATE(configId))) {
-        rfalAnalogConfigInitialize(); /* Revert to default Analog Configuration */
-        return ERR_PARAM;
-    }
-
-    numConfig = config->num;
-    configSize = (uint8_t)(sizeof(rfalAnalogConfigId) + sizeof(rfalAnalogConfigNum) +
-                           (numConfig * sizeof(rfalAnalogConfigRegAddrMaskVal)));
-
-    /* Check if the Configuration Set exceed the Table size. */
-    if(RFAL_ANALOG_CONFIG_TBL_SIZE <= (gRfalAnalogConfigMgmt.configTblSize + configSize)) {
-        rfalAnalogConfigInitialize(); /* Revert to default Analog Configuration */
-        return ERR_NOMEM;
-    }
-
-    /* NOTE: Function does not check for the validity of the Register Address. */
-    ST_MEMCPY(
-        &gRfalAnalogConfig[gRfalAnalogConfigMgmt.configTblSize],
-        (const uint8_t*)config,
-        configSize);
-
-    /* Increment the total size of configuration settings. */
-    gRfalAnalogConfigMgmt.configTblSize += configSize;
-
-    /* Check if it is the last Analog Configuration to load. */
-    if(RFAL_ANALOG_CONFIG_UPDATE_LAST ==
-       more) { /* Update the Analog Configuration to the new settings. */
-        rfalAnalogConfigPtrUpdate(gRfalAnalogConfig);
-    }
-
-    return ERR_NONE;
-
-#else
-
-    // If Analog Configuration Update is to be disabled
-    NO_WARNING(config);
-    NO_WARNING(more);
-    return ERR_DISABLED;
-
-#endif /* RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG */
-
-} /* rfalAnalogConfigListUpdate() */
-
-ReturnCode
-    rfalAnalogConfigListReadRaw(uint8_t* tblBuf, uint16_t tblBufLen, uint16_t* configTblSize) {
-    /* Check if the the current table will fit into the given buffer */
-    if(tblBufLen < gRfalAnalogConfigMgmt.configTblSize) {
-        return ERR_NOMEM;
-    }
-
-    /* Check for invalid parameters */
-    if(configTblSize == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Copy the whole Table to the given buffer */
-    if(gRfalAnalogConfigMgmt.configTblSize > 0U) /* MISRA 21.18 */
-    {
-        ST_MEMCPY(
-            tblBuf,
-            gRfalAnalogConfigMgmt.currentAnalogConfigTbl,
-            gRfalAnalogConfigMgmt.configTblSize);
-    }
-    *configTblSize = gRfalAnalogConfigMgmt.configTblSize;
-
-    return ERR_NONE;
-}
-
-ReturnCode rfalAnalogConfigListRead(
-    rfalAnalogConfigOffset* configOffset,
-    uint8_t* more,
-    rfalAnalogConfig* config,
-    rfalAnalogConfigNum numConfig) {
-    uint16_t configSize;
-    rfalAnalogConfigOffset offset = *configOffset;
-    rfalAnalogConfigNum numConfigSet;
-
-    /* Check if the number of register-mask-value settings for the respective Configuration ID will fit into the buffer passed in. */
-    if(gRfalAnalogConfigMgmt.currentAnalogConfigTbl[offset + sizeof(rfalAnalogConfigId)] >
-       numConfig) {
-        return ERR_NOMEM;
-    }
-
-    /* Get the number of Configuration set */
-    numConfigSet =
-        gRfalAnalogConfigMgmt.currentAnalogConfigTbl[offset + sizeof(rfalAnalogConfigId)];
-
-    /* Pass Configuration Register-Mask-Value sets */
-    configSize =
-        (sizeof(rfalAnalogConfigId) + sizeof(rfalAnalogConfigNum) +
-         (uint16_t)(numConfigSet * sizeof(rfalAnalogConfigRegAddrMaskVal)));
-    ST_MEMCPY((uint8_t*)config, &gRfalAnalogConfigMgmt.currentAnalogConfigTbl[offset], configSize);
-    *configOffset = offset + configSize;
-
-    /* Check if it is the last Analog Configuration in the Table.*/
-    *more = (uint8_t)((*configOffset >= gRfalAnalogConfigMgmt.configTblSize) ?
-                          RFAL_ANALOG_CONFIG_UPDATE_LAST :
-                          RFAL_ANALOG_CONFIG_UPDATE_MORE);
-
-    return ERR_NONE;
-} /* rfalAnalogConfigListRead() */
-
-ReturnCode rfalSetAnalogConfig(rfalAnalogConfigId configId) {
-    rfalAnalogConfigOffset configOffset = 0;
-    rfalAnalogConfigNum numConfigSet;
-    const rfalAnalogConfigRegAddrMaskVal* configTbl;
-    ReturnCode retCode = ERR_NONE;
-    rfalAnalogConfigNum i;
-
-    if(true != gRfalAnalogConfigMgmt.ready) {
-        return ERR_REQUEST;
-    }
-
-    /* Search LUT for the specific Configuration ID. */
-    while(true) {
-        numConfigSet = rfalAnalogConfigSearch(configId, &configOffset);
-        if(RFAL_ANALOG_CONFIG_LUT_NOT_FOUND == numConfigSet) {
-            break;
-        }
-
-        configTbl =
-            (rfalAnalogConfigRegAddrMaskVal*)((uint32_t)
-                                                  gRfalAnalogConfigMgmt.currentAnalogConfigTbl +
-                                              (uint32_t)configOffset);
-        /* Increment the offset to the next index to search from. */
-        configOffset += (uint16_t)(numConfigSet * sizeof(rfalAnalogConfigRegAddrMaskVal));
-
-        if((gRfalAnalogConfigMgmt.configTblSize + 1U) <
-           configOffset) { /* Error check make sure that the we do not access outside the configuration Table Size */
-            return ERR_NOMEM;
-        }
-
-        for(i = 0; i < numConfigSet; i++) {
-            if((GETU16(configTbl[i].addr) & RFAL_TEST_REG) != 0U) {
-                EXIT_ON_ERR(
-                    retCode,
-                    rfalChipChangeTestRegBits(
-                        (GETU16(configTbl[i].addr) & ~RFAL_TEST_REG),
-                        configTbl[i].mask,
-                        configTbl[i].val));
-            } else {
-                EXIT_ON_ERR(
-                    retCode,
-                    rfalChipChangeRegBits(
-                        GETU16(configTbl[i].addr), configTbl[i].mask, configTbl[i].val));
-            }
-        }
-
-    } /* while(found Analog Config Id) */
-
-    return retCode;
-
-} /* rfalSetAnalogConfig() */
-
-uint16_t rfalAnalogConfigGenModeID(rfalMode md, rfalBitRate br, uint16_t dir) {
-    uint16_t id;
-
-    /* Assign Poll/Listen Mode */
-    id = ((md >= RFAL_MODE_LISTEN_NFCA) ? RFAL_ANALOG_CONFIG_LISTEN : RFAL_ANALOG_CONFIG_POLL);
-
-    /* Assign Technology */
-    switch(md) {
-    case RFAL_MODE_POLL_NFCA:
-    case RFAL_MODE_POLL_NFCA_T1T:
-    case RFAL_MODE_LISTEN_NFCA:
-        id |= RFAL_ANALOG_CONFIG_TECH_NFCA;
-        break;
-
-    case RFAL_MODE_POLL_NFCB:
-    case RFAL_MODE_POLL_B_PRIME:
-    case RFAL_MODE_POLL_B_CTS:
-    case RFAL_MODE_LISTEN_NFCB:
-        id |= RFAL_ANALOG_CONFIG_TECH_NFCB;
-        break;
-
-    case RFAL_MODE_POLL_NFCF:
-    case RFAL_MODE_LISTEN_NFCF:
-        id |= RFAL_ANALOG_CONFIG_TECH_NFCF;
-        break;
-
-    case RFAL_MODE_POLL_NFCV:
-    case RFAL_MODE_POLL_PICOPASS:
-        id |= RFAL_ANALOG_CONFIG_TECH_NFCV;
-        break;
-
-    case RFAL_MODE_POLL_ACTIVE_P2P:
-    case RFAL_MODE_LISTEN_ACTIVE_P2P:
-        id |= RFAL_ANALOG_CONFIG_TECH_AP2P;
-        break;
-
-    default:
-        id = RFAL_ANALOG_CONFIG_TECH_CHIP;
-        break;
-    }
-
-    /* Assign Bitrate */
-    id |=
-        (((((uint16_t)(br) >= (uint16_t)RFAL_BR_52p97) ? (uint16_t)(br) : ((uint16_t)(br) + 1U))
-          << RFAL_ANALOG_CONFIG_BITRATE_SHIFT) &
-         RFAL_ANALOG_CONFIG_BITRATE_MASK);
-
-    /* Assign Direction */
-    id |= ((dir << RFAL_ANALOG_CONFIG_DIRECTION_SHIFT) & RFAL_ANALOG_CONFIG_DIRECTION_MASK);
-
-    return id;
-
-} /* rfalAnalogConfigGenModeID() */
-
-/*
- ******************************************************************************
- * LOCAL FUNCTIONS
- ******************************************************************************
- */
-
-/*! 
- *****************************************************************************
- * \brief  Update the link to Analog Configuration LUT
- *  
- * Update the link to the Analog Configuration LUT for the subsequent search 
- * of Analog Settings.
- * 
- * \param[in]  analogConfigTbl: reference to the start of the new Analog Configuration Table
- *
- *****************************************************************************
- */
-#if RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG
-static void rfalAnalogConfigPtrUpdate(const uint8_t* analogConfigTbl) {
-    gRfalAnalogConfigMgmt.currentAnalogConfigTbl = analogConfigTbl;
-    gRfalAnalogConfigMgmt.ready = true;
-
-} /* rfalAnalogConfigPtrUpdate() */
-#endif /* RFAL_FEATURE_DYNAMIC_ANALOG_CONFIG */
-
-/*! 
- *****************************************************************************
- * \brief  Search the Analog Configuration LUT for a specific Configuration ID.
- *  
- * Search the Analog Configuration LUT for the Configuration ID.
- * 
- * \param[in]  configId: Configuration ID to search for.
- * \param[in]  configOffset: Configuration Offset in Table
- * 
- * \return number of Configuration Sets
- * \return #RFAL_ANALOG_CONFIG_LUT_NOT_FOUND in case Configuration ID is not found.
- *****************************************************************************
- */
-static rfalAnalogConfigNum
-    rfalAnalogConfigSearch(rfalAnalogConfigId configId, uint16_t* configOffset) {
-    rfalAnalogConfigId foundConfigId;
-    rfalAnalogConfigId configIdMaskVal;
-    const uint8_t* configTbl;
-    const uint8_t* currentConfigTbl;
-    uint16_t i;
-
-    currentConfigTbl = gRfalAnalogConfigMgmt.currentAnalogConfigTbl;
-    configIdMaskVal =
-        ((RFAL_ANALOG_CONFIG_POLL_LISTEN_MODE_MASK | RFAL_ANALOG_CONFIG_BITRATE_MASK) |
-         ((RFAL_ANALOG_CONFIG_TECH_CHIP == RFAL_ANALOG_CONFIG_ID_GET_TECH(configId)) ?
-              (RFAL_ANALOG_CONFIG_TECH_MASK | RFAL_ANALOG_CONFIG_CHIP_SPECIFIC_MASK) :
-              configId) |
-         ((RFAL_ANALOG_CONFIG_NO_DIRECTION == RFAL_ANALOG_CONFIG_ID_GET_DIRECTION(configId)) ?
-              RFAL_ANALOG_CONFIG_DIRECTION_MASK :
-              configId));
-
-    /* When specific ConfigIDs are to be used, override search mask */
-    if((RFAL_ANALOG_CONFIG_ID_GET_DIRECTION(configId) == RFAL_ANALOG_CONFIG_DPO)) {
-        configIdMaskVal =
-            (RFAL_ANALOG_CONFIG_POLL_LISTEN_MODE_MASK | RFAL_ANALOG_CONFIG_TECH_MASK |
-             RFAL_ANALOG_CONFIG_BITRATE_MASK | RFAL_ANALOG_CONFIG_DIRECTION_MASK);
-    }
-
-    i = *configOffset;
-    while(i < gRfalAnalogConfigMgmt.configTblSize) {
-        configTbl = &currentConfigTbl[i];
-        foundConfigId = GETU16(configTbl);
-        if(configId == (foundConfigId & configIdMaskVal)) {
-            *configOffset =
-                (uint16_t)(i + sizeof(rfalAnalogConfigId) + sizeof(rfalAnalogConfigNum));
-            return configTbl[sizeof(rfalAnalogConfigId)];
-        }
-
-        /* If Config Id does not match, increment to next Configuration Id */
-        i += (uint16_t)(sizeof(rfalAnalogConfigId) + sizeof(rfalAnalogConfigNum) +
-                        (configTbl[sizeof(rfalAnalogConfigId)] *
-                         sizeof(rfalAnalogConfigRegAddrMaskVal)));
-    } /* for */
-
-    return RFAL_ANALOG_CONFIG_LUT_NOT_FOUND;
-} /* rfalAnalogConfigSearch() */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_crc.c

@@ -1,82 +0,0 @@
-
-/******************************************************************************
-  * \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_crc.c
- *
- *  \author Oliver Regenfelder
- *
- *  \brief CRC calculation implementation
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../include/rfal_crc.h"
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static uint16_t rfalCrcUpdateCcitt(uint16_t crcSeed, uint8_t dataByte);
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-uint16_t rfalCrcCalculateCcitt(uint16_t preloadValue, const uint8_t* buf, uint16_t length) {
-    uint16_t crc = preloadValue;
-    uint16_t index;
-
-    for(index = 0; index < length; index++) {
-        crc = rfalCrcUpdateCcitt(crc, buf[index]);
-    }
-
-    return crc;
-}
-
-/*
-******************************************************************************
-* LOCAL FUNCTIONS
-******************************************************************************
-*/
-static uint16_t rfalCrcUpdateCcitt(uint16_t crcSeed, uint8_t dataByte) {
-    uint16_t crc = crcSeed;
-    uint8_t dat = dataByte;
-
-    dat ^= (uint8_t)(crc & 0xFFU);
-    dat ^= (dat << 4);
-
-    crc = (crc >> 8) ^ (((uint16_t)dat) << 8) ^ (((uint16_t)dat) << 3) ^ (((uint16_t)dat) >> 4);
-
-    return crc;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_dpo.c

@@ -1,232 +0,0 @@
-
-/******************************************************************************
-  * @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:
-  *
-  *        http://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_dpo.c
- *
- *  \author Martin Zechleitner
- *
- *  \brief Functions to manage and set dynamic power settings.
- *  
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "st25r3916/rfal_dpoTbl.h"
-#include "../include/rfal_dpo.h"
-#include "../platform.h"
-#include "../include/rfal_rf.h"
-#include "../include/rfal_chip.h"
-#include "../include/rfal_analogConfig.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_DPO
-#define RFAL_FEATURE_DPO \
-    false /* Dynamic Power Module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_DPO
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-#define RFAL_DPO_ANALOGCONFIG_SHIFT 13U
-#define RFAL_DPO_ANALOGCONFIG_MASK 0x6000U
-
-/*
- ******************************************************************************
- * LOCAL DATA TYPES
- ******************************************************************************
- */
-
-static bool gRfalDpoIsEnabled = false;
-static uint8_t* gRfalCurrentDpo;
-static uint8_t gRfalDpoTableEntries;
-static uint8_t gRfalDpo[RFAL_DPO_TABLE_SIZE_MAX];
-static uint8_t gRfalDpoTableEntry;
-static rfalDpoMeasureFunc gRfalDpoMeasureCallback = NULL;
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTIONS
- ******************************************************************************
- */
-void rfalDpoInitialize(void) {
-    /* Use the default Dynamic Power values */
-    gRfalCurrentDpo = (uint8_t*)rfalDpoDefaultSettings;
-    gRfalDpoTableEntries = (sizeof(rfalDpoDefaultSettings) / RFAL_DPO_TABLE_PARAMETER);
-
-    ST_MEMCPY(gRfalDpo, gRfalCurrentDpo, sizeof(rfalDpoDefaultSettings));
-
-    /* by default use amplitude measurement */
-    gRfalDpoMeasureCallback = rfalChipMeasureAmplitude;
-
-    /* by default DPO is disabled */
-    gRfalDpoIsEnabled = false;
-
-    gRfalDpoTableEntry = 0;
-}
-
-void rfalDpoSetMeasureCallback(rfalDpoMeasureFunc pMeasureFunc) {
-    gRfalDpoMeasureCallback = pMeasureFunc;
-}
-
-/*******************************************************************************/
-ReturnCode rfalDpoTableWrite(rfalDpoEntry* powerTbl, uint8_t powerTblEntries) {
-    uint8_t entry = 0;
-
-    /* check if the table size parameter is too big */
-    if((powerTblEntries * RFAL_DPO_TABLE_PARAMETER) > RFAL_DPO_TABLE_SIZE_MAX) {
-        return ERR_NOMEM;
-    }
-
-    /* check if the first increase entry is 0xFF */
-    if((powerTblEntries == 0) || (powerTbl == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /* check if the entries of the dynamic power table are valid */
-    for(entry = 0; entry < powerTblEntries; entry++) {
-        if(powerTbl[entry].inc < powerTbl[entry].dec) {
-            return ERR_PARAM;
-        }
-    }
-
-    /* copy the data set  */
-    ST_MEMCPY(gRfalDpo, powerTbl, (powerTblEntries * RFAL_DPO_TABLE_PARAMETER));
-    gRfalCurrentDpo = gRfalDpo;
-    gRfalDpoTableEntries = powerTblEntries;
-
-    if(gRfalDpoTableEntry > powerTblEntries) {
-        /* is always greater then zero, otherwise we already returned ERR_PARAM */
-        gRfalDpoTableEntry = (powerTblEntries - 1);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalDpoTableRead(rfalDpoEntry* tblBuf, uint8_t tblBufEntries, uint8_t* tableEntries) {
-    /* wrong request */
-    if((tblBuf == NULL) || (tblBufEntries < gRfalDpoTableEntries) || (tableEntries == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /* Copy the whole Table to the given buffer */
-    ST_MEMCPY(tblBuf, gRfalCurrentDpo, (tblBufEntries * RFAL_DPO_TABLE_PARAMETER));
-    *tableEntries = gRfalDpoTableEntries;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalDpoAdjust(void) {
-    uint8_t refValue = 0;
-    uint16_t modeID;
-    rfalBitRate br;
-    rfalDpoEntry* dpoTable = (rfalDpoEntry*)gRfalCurrentDpo;
-
-    /* Check if the Power Adjustment is disabled and                  *
-     * if the callback to the measurement method is properly set      */
-    if((gRfalCurrentDpo == NULL) || (!gRfalDpoIsEnabled) || (gRfalDpoMeasureCallback == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /* Ensure that the current mode is Passive Poller */
-    if(!rfalIsModePassivePoll(rfalGetMode())) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Ensure a proper measure reference value */
-    if(ERR_NONE != gRfalDpoMeasureCallback(&refValue)) {
-        return ERR_IO;
-    }
-
-    if(refValue >= dpoTable[gRfalDpoTableEntry].inc) { /* Increase the output power */
-        /* the top of the table represents the highest amplitude value*/
-        if(gRfalDpoTableEntry == 0) {
-            /* maximum driver value has been reached */
-        } else {
-            /* go up in the table to decrease the driver resistance */
-            gRfalDpoTableEntry--;
-        }
-    } else if(refValue <= dpoTable[gRfalDpoTableEntry].dec) { /* decrease the output power */
-        /* The bottom is the highest possible value */
-        if((gRfalDpoTableEntry + 1) >= gRfalDpoTableEntries) {
-            /* minimum driver value has been reached */
-        } else {
-            /* go down in the table to increase the driver resistance */
-            gRfalDpoTableEntry++;
-        }
-    } else {
-        /* Fall through to always write dpo and its associated analog configs */
-    }
-
-    /* Get the new value for RFO resistance form the table and apply the new RFO resistance setting */
-    rfalChipSetRFO(dpoTable[gRfalDpoTableEntry].rfoRes);
-
-    /* Apply the DPO Analog Config according to this treshold */
-    /* Technology field is being extended for DPO: 2msb are used for treshold step (only 4 allowed) */
-    rfalGetBitRate(&br, NULL); /* Obtain current Tx bitrate       */
-    modeID = rfalAnalogConfigGenModeID(
-        rfalGetMode(), br, RFAL_ANALOG_CONFIG_DPO); /* Generate Analog Config mode ID  */
-    modeID |=
-        ((gRfalDpoTableEntry << RFAL_DPO_ANALOGCONFIG_SHIFT) &
-         RFAL_DPO_ANALOGCONFIG_MASK); /* Add DPO treshold step|level     */
-    rfalSetAnalogConfig(modeID); /* Apply DPO Analog Config         */
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-rfalDpoEntry* rfalDpoGetCurrentTableEntry(void) {
-    rfalDpoEntry* dpoTable = (rfalDpoEntry*)gRfalCurrentDpo;
-    return &dpoTable[gRfalDpoTableEntry];
-}
-
-/*******************************************************************************/
-void rfalDpoSetEnabled(bool enable) {
-    gRfalDpoIsEnabled = enable;
-}
-
-/*******************************************************************************/
-bool rfalDpoIsEnabled(void) {
-    return gRfalDpoIsEnabled;
-}
-
-#endif /* RFAL_FEATURE_DPO */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_iso15693_2.c

@@ -1,516 +0,0 @@
-
-/******************************************************************************
-  * \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_iso15693_2.c
- *
- *  \author Ulrich Herrmann
- *
- *  \brief Implementation of ISO-15693-2
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../include/rfal_iso15693_2.h"
-#include "../include/rfal_crc.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_NFCV
-#define RFAL_FEATURE_NFCV false /* NFC-V module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_NFCV
-
-/*
-******************************************************************************
-* LOCAL MACROS
-******************************************************************************
-*/
-
-#define ISO_15693_DEBUG(...) /*!< Macro for the log method  */
-
-/*
-******************************************************************************
-* LOCAL DEFINES
-******************************************************************************
-*/
-#define ISO15693_DAT_SOF_1_4 0x21 /* LSB constants */
-#define ISO15693_DAT_EOF_1_4 0x04
-#define ISO15693_DAT_00_1_4 0x02
-#define ISO15693_DAT_01_1_4 0x08
-#define ISO15693_DAT_10_1_4 0x20
-#define ISO15693_DAT_11_1_4 0x80
-
-#define ISO15693_DAT_SOF_1_256 0x81
-#define ISO15693_DAT_EOF_1_256 0x04
-#define ISO15693_DAT_SLOT0_1_256 0x02
-#define ISO15693_DAT_SLOT1_1_256 0x08
-#define ISO15693_DAT_SLOT2_1_256 0x20
-#define ISO15693_DAT_SLOT3_1_256 0x80
-
-#define ISO15693_PHY_DAT_MANCHESTER_1 0xaaaa
-
-#define ISO15693_PHY_BIT_BUFFER_SIZE \
-    1000 /*!< size of the receiving buffer. Might be adjusted if longer datastreams are expected. */
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-static iso15693PhyConfig_t iso15693PhyConfig; /*!< current phy configuration */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static ReturnCode iso15693PhyVCDCode1Of4(
-    const uint8_t data,
-    uint8_t* outbuffer,
-    uint16_t maxOutBufLen,
-    uint16_t* outBufLen);
-static ReturnCode iso15693PhyVCDCode1Of256(
-    const uint8_t data,
-    uint8_t* outbuffer,
-    uint16_t maxOutBufLen,
-    uint16_t* outBufLen);
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-ReturnCode iso15693PhyConfigure(
-    const iso15693PhyConfig_t* config,
-    const struct iso15693StreamConfig** needed_stream_config) {
-    static struct iso15693StreamConfig stream_config = {
-        /* MISRA 8.9 */
-        .useBPSK = 0, /* 0: subcarrier, 1:BPSK */
-        .din = 5, /* 2^5*fc = 423750 Hz: divider for the in subcarrier frequency */
-        .dout = 7, /*!< 2^7*fc = 105937 : divider for the in subcarrier frequency */
-        .report_period_length = 3, /*!< 8=2^3 the length of the reporting period */
-    };
-
-    /* make a copy of the configuration */
-    ST_MEMCPY((uint8_t*)&iso15693PhyConfig, (const uint8_t*)config, sizeof(iso15693PhyConfig_t));
-
-    if(config->speedMode <= 3U) { /* If valid speed mode adjust report period accordingly */
-        stream_config.report_period_length = (3U - (uint8_t)config->speedMode);
-    } else { /* If invalid default to normal (high) speed */
-        stream_config.report_period_length = 3;
-    }
-
-    *needed_stream_config = &stream_config;
-
-    return ERR_NONE;
-}
-
-ReturnCode iso15693PhyGetConfiguration(iso15693PhyConfig_t* config) {
-    ST_MEMCPY(config, &iso15693PhyConfig, sizeof(iso15693PhyConfig_t));
-
-    return ERR_NONE;
-}
-
-ReturnCode iso15693VCDCode(
-    uint8_t* buffer,
-    uint16_t length,
-    bool sendCrc,
-    bool sendFlags,
-    bool picopassMode,
-    uint16_t* subbit_total_length,
-    uint16_t* offset,
-    uint8_t* outbuf,
-    uint16_t outBufSize,
-    uint16_t* actOutBufSize) {
-    ReturnCode err = ERR_NONE;
-    uint8_t eof, sof;
-    uint8_t transbuf[2];
-    uint16_t crc = 0;
-    ReturnCode (*txFunc)(
-        const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen);
-    uint8_t crc_len;
-    uint8_t* outputBuf;
-    uint16_t outputBufSize;
-
-    crc_len = (uint8_t)((sendCrc) ? 2 : 0);
-
-    *actOutBufSize = 0;
-
-    if(ISO15693_VCD_CODING_1_4 == iso15693PhyConfig.coding) {
-        sof = ISO15693_DAT_SOF_1_4;
-        eof = ISO15693_DAT_EOF_1_4;
-        txFunc = iso15693PhyVCDCode1Of4;
-        *subbit_total_length =
-            ((1U /* SOF */
-              + ((length + (uint16_t)crc_len) * 4U) + 1U) /* EOF */
-            );
-        if(outBufSize < 5U) { /* 5 should be safe: enough for sof + 1byte data in 1of4 */
-            return ERR_NOMEM;
-        }
-    } else {
-        sof = ISO15693_DAT_SOF_1_256;
-        eof = ISO15693_DAT_EOF_1_256;
-        txFunc = iso15693PhyVCDCode1Of256;
-        *subbit_total_length =
-            ((1U /* SOF */
-              + ((length + (uint16_t)crc_len) * 64U) + 1U) /* EOF */
-            );
-
-        if(*offset != 0U) {
-            if(outBufSize < 64U) { /* 64 should be safe: enough a single byte data in 1of256 */
-                return ERR_NOMEM;
-            }
-        } else {
-            if(outBufSize <
-               65U) { /* At beginning of a frame we need at least 65 bytes to start: enough for sof + 1byte data in 1of256 */
-                return ERR_NOMEM;
-            }
-        }
-    }
-
-    if(length == 0U) {
-        *subbit_total_length = 1;
-    }
-
-    if((length != 0U) && (0U == *offset) && sendFlags && !picopassMode) {
-        /* set high datarate flag */
-        buffer[0] |= (uint8_t)ISO15693_REQ_FLAG_HIGH_DATARATE;
-        /* clear sub-carrier flag - we only support single sub-carrier */
-        buffer[0] = (uint8_t)(buffer[0] & ~ISO15693_REQ_FLAG_TWO_SUBCARRIERS); /* MISRA 10.3 */
-    }
-
-    outputBuf = outbuf; /* MISRA 17.8: Use intermediate variable */
-    outputBufSize = outBufSize; /* MISRA 17.8: Use intermediate variable */
-
-    /* Send SOF if at 0 offset */
-    if((length != 0U) && (0U == *offset)) {
-        *outputBuf = sof;
-        (*actOutBufSize)++;
-        outputBufSize--;
-        outputBuf++;
-    }
-
-    while((*offset < length) && (err == ERR_NONE)) {
-        uint16_t filled_size;
-        /* send data */
-        err = txFunc(buffer[*offset], outputBuf, outputBufSize, &filled_size);
-        (*actOutBufSize) += filled_size;
-        outputBuf = &outputBuf[filled_size]; /* MISRA 18.4: Avoid pointer arithmetic */
-        outputBufSize -= filled_size;
-        if(err == ERR_NONE) {
-            (*offset)++;
-        }
-    }
-    if(err != ERR_NONE) {
-        return ERR_AGAIN;
-    }
-
-    while((err == ERR_NONE) && sendCrc && (*offset < (length + 2U))) {
-        uint16_t filled_size;
-        if(0U == crc) {
-            crc = rfalCrcCalculateCcitt(
-                (uint16_t)((picopassMode) ?
-                               0xE012U :
-                               0xFFFFU), /* In PicoPass Mode a different Preset Value is used   */
-                ((picopassMode) ?
-                     (buffer + 1U) :
-                     buffer), /* CMD byte is not taken into account in PicoPass mode */
-                ((picopassMode) ?
-                     (length - 1U) :
-                     length)); /* CMD byte is not taken into account in PicoPass mode */
-
-            crc = (uint16_t)((picopassMode) ? crc : ~crc);
-        }
-        /* send crc */
-        transbuf[0] = (uint8_t)(crc & 0xffU);
-        transbuf[1] = (uint8_t)((crc >> 8) & 0xffU);
-        err = txFunc(transbuf[*offset - length], outputBuf, outputBufSize, &filled_size);
-        (*actOutBufSize) += filled_size;
-        outputBuf = &outputBuf[filled_size]; /* MISRA 18.4: Avoid pointer arithmetic */
-        outputBufSize -= filled_size;
-        if(err == ERR_NONE) {
-            (*offset)++;
-        }
-    }
-    if(err != ERR_NONE) {
-        return ERR_AGAIN;
-    }
-
-    if((!sendCrc && (*offset == length)) || (sendCrc && (*offset == (length + 2U)))) {
-        *outputBuf = eof;
-        (*actOutBufSize)++;
-        outputBufSize--;
-        outputBuf++;
-    } else {
-        return ERR_AGAIN;
-    }
-
-    return err;
-}
-
-ReturnCode iso15693VICCDecode(
-    const uint8_t* inBuf,
-    uint16_t inBufLen,
-    uint8_t* outBuf,
-    uint16_t outBufLen,
-    uint16_t* outBufPos,
-    uint16_t* bitsBeforeCol,
-    uint16_t ignoreBits,
-    bool picopassMode) {
-    ReturnCode err = ERR_NONE;
-    uint16_t crc;
-    uint16_t mp; /* Current bit position in manchester bit inBuf*/
-    uint16_t bp; /* Current bit position in outBuf */
-
-    *bitsBeforeCol = 0;
-    *outBufPos = 0;
-
-    /* first check for valid SOF. Since it starts with 3 unmodulated pulses it is 0x17. */
-    if((inBuf[0] & 0x1fU) != 0x17U) {
-        ISO_15693_DEBUG("0x%x\n", iso15693PhyBitBuffer[0]);
-        return ERR_FRAMING;
-    }
-    ISO_15693_DEBUG("SOF\n");
-
-    if(outBufLen == 0U) {
-        return ERR_NONE;
-    }
-
-    mp = 5; /* 5 bits were SOF, now manchester starts: 2 bits per payload bit */
-    bp = 0;
-
-    ST_MEMSET(outBuf, 0, outBufLen);
-
-    if(inBufLen == 0U) {
-        return ERR_CRC;
-    }
-
-    for(; mp < ((inBufLen * 8U) - 2U); mp += 2U) {
-        bool isEOF = false;
-
-        uint8_t man;
-        man = (inBuf[mp / 8U] >> (mp % 8U)) & 0x1U;
-        man |= ((inBuf[(mp + 1U) / 8U] >> ((mp + 1U) % 8U)) & 0x1U) << 1;
-        if(1U == man) {
-            bp++;
-        }
-        if(2U == man) {
-            outBuf[bp / 8U] = (uint8_t)(outBuf[bp / 8U] | (1U << (bp % 8U))); /* MISRA 10.3 */
-            bp++;
-        }
-        if((bp % 8U) == 0U) { /* Check for EOF */
-            ISO_15693_DEBUG("ceof %hhx %hhx\n", inBuf[mp / 8U], inBuf[mp / 8 + 1]);
-            if(((inBuf[mp / 8U] & 0xe0U) == 0xa0U) &&
-               (inBuf[(mp / 8U) + 1U] == 0x03U)) { /* Now we know that it was 10111000 = EOF */
-                ISO_15693_DEBUG("EOF\n");
-                isEOF = true;
-            }
-        }
-        if(((0U == man) || (3U == man)) && !isEOF) {
-            if(bp >= ignoreBits) {
-                err = ERR_RF_COLLISION;
-            } else {
-                /* ignored collision: leave as 0 */
-                bp++;
-            }
-        }
-        if((bp >= (outBufLen * 8U)) || (err == ERR_RF_COLLISION) ||
-           isEOF) { /* Don't write beyond the end */
-            break;
-        }
-    }
-
-    *outBufPos = (bp / 8U);
-    *bitsBeforeCol = bp;
-
-    if(err != ERR_NONE) {
-        return err;
-    }
-
-    if((bp % 8U) != 0U) {
-        return ERR_CRC;
-    }
-
-    if(*outBufPos > 2U) {
-        /* finally, check crc */
-        ISO_15693_DEBUG("Calculate CRC, val: 0x%x, outBufLen: ", *outBuf);
-        ISO_15693_DEBUG("0x%x ", *outBufPos - 2);
-
-        crc = rfalCrcCalculateCcitt(((picopassMode) ? 0xE012U : 0xFFFFU), outBuf, *outBufPos - 2U);
-        crc = (uint16_t)((picopassMode) ? crc : ~crc);
-
-        if(((crc & 0xffU) == outBuf[*outBufPos - 2U]) &&
-           (((crc >> 8U) & 0xffU) == outBuf[*outBufPos - 1U])) {
-            err = ERR_NONE;
-            ISO_15693_DEBUG("OK\n");
-        } else {
-            ISO_15693_DEBUG("error! Expected: 0x%x, got ", crc);
-            ISO_15693_DEBUG("0x%hhx 0x%hhx\n", outBuf[*outBufPos - 2], outBuf[*outBufPos - 1]);
-            err = ERR_CRC;
-        }
-    } else {
-        err = ERR_CRC;
-    }
-
-    return err;
-}
-
-/*
-******************************************************************************
-* LOCAL FUNCTIONS
-******************************************************************************
-*/
-/*! 
- *****************************************************************************
- *  \brief  Perform 1 of 4 coding and send coded data
- *
- *  This function takes \a length bytes from \a buffer, perform 1 of 4 coding
- *  (see ISO15693-2 specification) and sends the data using stream mode.
- *
- *  \param[in] sendSof : send SOF prior to data.
- *  \param[in] buffer : data to send.
- *  \param[in] length : number of bytes to send.
- *
- *  \return ERR_IO : Error during communication.
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-static ReturnCode iso15693PhyVCDCode1Of4(
-    const uint8_t data,
-    uint8_t* outbuffer,
-    uint16_t maxOutBufLen,
-    uint16_t* outBufLen) {
-    uint8_t tmp;
-    ReturnCode err = ERR_NONE;
-    uint16_t a;
-    uint8_t* outbuf = outbuffer;
-
-    *outBufLen = 0;
-
-    if(maxOutBufLen < 4U) {
-        return ERR_NOMEM;
-    }
-
-    tmp = data;
-    for(a = 0; a < 4U; a++) {
-        switch(tmp & 0x3U) {
-        case 0:
-            *outbuf = ISO15693_DAT_00_1_4;
-            break;
-        case 1:
-            *outbuf = ISO15693_DAT_01_1_4;
-            break;
-        case 2:
-            *outbuf = ISO15693_DAT_10_1_4;
-            break;
-        case 3:
-            *outbuf = ISO15693_DAT_11_1_4;
-            break;
-        default:
-            /* MISRA 16.4: mandatory default statement */
-            break;
-        }
-        outbuf++;
-        (*outBufLen)++;
-        tmp >>= 2;
-    }
-    return err;
-}
-
-/*! 
- *****************************************************************************
- *  \brief  Perform 1 of 256 coding and send coded data
- *
- *  This function takes \a length bytes from \a buffer, perform 1 of 256 coding
- *  (see ISO15693-2 specification) and sends the data using stream mode.
- *  \note This function sends SOF prior to the data.
- *
- *  \param[in] sendSof : send SOF prior to data.
- *  \param[in] buffer : data to send.
- *  \param[in] length : number of bytes to send.
- *
- *  \return ERR_IO : Error during communication.
- *  \return ERR_NONE : No error.
- *
- *****************************************************************************
- */
-static ReturnCode iso15693PhyVCDCode1Of256(
-    const uint8_t data,
-    uint8_t* outbuffer,
-    uint16_t maxOutBufLen,
-    uint16_t* outBufLen) {
-    uint8_t tmp;
-    ReturnCode err = ERR_NONE;
-    uint16_t a;
-    uint8_t* outbuf = outbuffer;
-
-    *outBufLen = 0;
-
-    if(maxOutBufLen < 64U) {
-        return ERR_NOMEM;
-    }
-
-    tmp = data;
-    for(a = 0; a < 64U; a++) {
-        switch(tmp) {
-        case 0:
-            *outbuf = ISO15693_DAT_SLOT0_1_256;
-            break;
-        case 1:
-            *outbuf = ISO15693_DAT_SLOT1_1_256;
-            break;
-        case 2:
-            *outbuf = ISO15693_DAT_SLOT2_1_256;
-            break;
-        case 3:
-            *outbuf = ISO15693_DAT_SLOT3_1_256;
-            break;
-        default:
-            *outbuf = 0;
-            break;
-        }
-        outbuf++;
-        (*outBufLen)++;
-        tmp -= 4U;
-    }
-
-    return err;
-}
-
-#endif /* RFAL_FEATURE_NFCV */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_isoDep.c

@@ -1,3045 +0,0 @@
-
-/******************************************************************************
-  * \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 "../include/rfal_isoDep.h"
-#include "../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(PARAMETERS) 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 /* Unexpected 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 -> toggle 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 within 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 * 8;
-
-        /* 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 */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfc.c

@@ -1,2126 +0,0 @@
-/**
-  ******************************************************************************
-  *
-  * COPYRIGHT(c) 2020 STMicroelectronics
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/*! \file rfal_nfc.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief RFAL NFC device  
- *  
- *  This module provides the required features to behave as an NFC Poller 
- *  or Listener device. It grants an easy to use interface for the following
- *  activities: Technology Detection, Collision Resollution, Activation,
- *  Data Exchange, and Deactivation
- *  
- *  This layer is influenced by (but not fully aligned with) the NFC Forum 
- *  specifications, in particular: Activity 2.0 and NCI 2.0
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_nfc.h"
-#include "../utils.h"
-#include "../include/rfal_analogConfig.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-#define RFAL_NFC_MAX_DEVICES 5U /* Max number of devices supported */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-#define rfalNfcNfcNotify(st) \
-    if(gNfcDev.disc.notifyCb != NULL) gNfcDev.disc.notifyCb(st)
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! Buffer union, only one interface is used at a time                                                             */
-typedef union { /*  PRQA S 0750 # MISRA 19.2 - Members of the union will not be used concurrently, only one interface at a time */
-    rfalIsoDepBufFormat isoDepBuf; /*!< ISO-DEP buffer format (with header/prologue)       */
-    rfalNfcDepBufFormat nfcDepBuf; /*!< NFC-DEP buffer format (with header/prologue)       */
-} rfalNfcTmpBuffer;
-
-typedef struct {
-    rfalNfcState state; /* Main state                                      */
-    uint16_t techsFound; /* Technologies found bitmask                      */
-    uint16_t techs2do; /* Technologies still to be performed              */
-    rfalBitRate ap2pBR; /* Bit rate to poll for AP2P                       */
-    uint8_t selDevIdx; /* Selected device index                           */
-    rfalNfcDevice* activeDev; /* Active device pointer                           */
-    rfalNfcDiscoverParam disc; /* Discovery parameters                            */
-    rfalNfcDevice devList[RFAL_NFC_MAX_DEVICES]; /*!< Location of device list          */
-    uint8_t devCnt; /* Devices found counter                           */
-    uint32_t discTmr; /* Discovery Total duration timer                  */
-    ReturnCode dataExErr; /* Last Data Exchange error                        */
-    bool discRestart; /* Restart discover after deactivation flag        */
-    bool isRxChaining; /* Flag indicating Other device is chaining        */
-    uint32_t lmMask; /* Listen Mode mask                                */
-    bool isTechInit; /* Flag indicating technology has been set         */
-    bool isOperOngoing; /* Flag indicating operation is ongoing             */
-
-    rfalNfcBuffer txBuf; /* Tx buffer for Data Exchange                     */
-    rfalNfcBuffer rxBuf; /* Rx buffer for Data Exchange                     */
-    uint16_t rxLen; /* Length of received data on Data Exchange        */
-
-#if RFAL_FEATURE_NFC_DEP || RFAL_FEATURE_ISO_DEP
-    rfalNfcTmpBuffer tmpBuf; /* Tmp buffer for Data Exchange                    */
-#endif /* RFAL_FEATURE_NFC_DEP || RFAL_FEATURE_ISO_DEP */
-
-} rfalNfc;
-
-/*
- ******************************************************************************
- * LOCAL VARIABLES
- ******************************************************************************
- */
-#ifdef RFAL_TEST_MODE
-rfalNfc gNfcDev;
-#else /* RFAL_TEST_MODE */
-static rfalNfc gNfcDev;
-#endif /* RFAL_TEST_MODE */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static ReturnCode rfalNfcPollTechDetetection(void);
-static ReturnCode rfalNfcPollCollResolution(void);
-static ReturnCode rfalNfcPollActivation(uint8_t devIt);
-static ReturnCode rfalNfcDeactivation(void);
-
-#if RFAL_FEATURE_NFC_DEP
-static ReturnCode rfalNfcNfcDepActivate(
-    rfalNfcDevice* device,
-    rfalNfcDepCommMode commMode,
-    const uint8_t* atrReq,
-    uint16_t atrReqLen);
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-#if RFAL_FEATURE_LISTEN_MODE
-static ReturnCode rfalNfcListenActivation(void);
-#endif /* RFAL_FEATURE_LISTEN_MODE*/
-
-/*******************************************************************************/
-ReturnCode rfalNfcInitialize(void) {
-    ReturnCode err;
-
-    gNfcDev.state = RFAL_NFC_STATE_NOTINIT;
-
-    rfalAnalogConfigInitialize(); /* Initialize RFAL's Analog Configs */
-    EXIT_ON_ERR(err, rfalInitialize()); /* Initialize RFAL */
-
-    gNfcDev.state = RFAL_NFC_STATE_IDLE; /* Go to initialized */
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcDiscover(const rfalNfcDiscoverParam* disParams) {
-    /* Check if initialization has been performed */
-    if(gNfcDev.state != RFAL_NFC_STATE_IDLE) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check valid parameters */
-    if((disParams == NULL) || (disParams->devLimit > RFAL_NFC_MAX_DEVICES) ||
-       (disParams->devLimit == 0U) ||
-       ((disParams->maxBR > RFAL_BR_1695) && (disParams->maxBR != RFAL_BR_KEEP)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_F) != 0U) &&
-        (disParams->nfcfBR != RFAL_BR_212) && (disParams->nfcfBR != RFAL_BR_424)) ||
-       ((((disParams->techs2Find & RFAL_NFC_POLL_TECH_AP2P) != 0U) &&
-         (disParams->ap2pBR > RFAL_BR_424)) ||
-        (disParams->GBLen > RFAL_NFCDEP_GB_MAX_LEN))) {
-        return ERR_PARAM;
-    }
-
-    if((((disParams->techs2Find & RFAL_NFC_POLL_TECH_A) != 0U) && !((bool)RFAL_FEATURE_NFCA)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_B) != 0U) && !((bool)RFAL_FEATURE_NFCB)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_F) != 0U) && !((bool)RFAL_FEATURE_NFCF)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_V) != 0U) && !((bool)RFAL_FEATURE_NFCV)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_ST25TB) != 0U) &&
-        !((bool)RFAL_FEATURE_ST25TB)) ||
-       (((disParams->techs2Find & RFAL_NFC_POLL_TECH_AP2P) != 0U) &&
-        !((bool)RFAL_FEATURE_NFC_DEP)) ||
-       (((disParams->techs2Find & RFAL_NFC_LISTEN_TECH_A) != 0U) && !((bool)RFAL_FEATURE_NFCA)) ||
-       (((disParams->techs2Find & RFAL_NFC_LISTEN_TECH_B) != 0U) && !((bool)RFAL_FEATURE_NFCB)) ||
-       (((disParams->techs2Find & RFAL_NFC_LISTEN_TECH_F) != 0U) && !((bool)RFAL_FEATURE_NFCF)) ||
-       (((disParams->techs2Find & RFAL_NFC_LISTEN_TECH_AP2P) != 0U) &&
-        !((bool)RFAL_FEATURE_NFC_DEP))) {
-        return ERR_DISABLED; /*  PRQA S  2880 # MISRA 2.1 - Unreachable code due to configuration option being set/unset  */
-    }
-
-    /* Initialize context for discovery */
-    gNfcDev.activeDev = NULL;
-    gNfcDev.techsFound = RFAL_NFC_TECH_NONE;
-    gNfcDev.devCnt = 0;
-    gNfcDev.discRestart = true;
-    gNfcDev.isTechInit = false;
-    gNfcDev.disc = *disParams;
-
-    /* Calculate Listen Mask */
-    gNfcDev.lmMask = 0U;
-    gNfcDev.lmMask |=
-        (((gNfcDev.disc.techs2Find & RFAL_NFC_LISTEN_TECH_A) != 0U) ? RFAL_LM_MASK_NFCA : 0U);
-    gNfcDev.lmMask |=
-        (((gNfcDev.disc.techs2Find & RFAL_NFC_LISTEN_TECH_B) != 0U) ? RFAL_LM_MASK_NFCB : 0U);
-    gNfcDev.lmMask |=
-        (((gNfcDev.disc.techs2Find & RFAL_NFC_LISTEN_TECH_F) != 0U) ? RFAL_LM_MASK_NFCF : 0U);
-    gNfcDev.lmMask |=
-        (((gNfcDev.disc.techs2Find & RFAL_NFC_LISTEN_TECH_AP2P) != 0U) ? RFAL_LM_MASK_ACTIVE_P2P :
-                                                                         0U);
-
-#if !RFAL_FEATURE_LISTEN_MODE
-    /* Check if Listen Mode is supported/Enabled */
-    if(gNfcDev.lmMask != 0U) {
-        return ERR_DISABLED;
-    }
-#endif
-
-    gNfcDev.state = RFAL_NFC_STATE_START_DISCOVERY;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcDeactivate(bool discovery) {
-    /* Check for valid state */
-    if(gNfcDev.state <= RFAL_NFC_STATE_IDLE) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check if discovery is to continue afterwards */
-    if((discovery == true) && (gNfcDev.disc.techs2Find != RFAL_NFC_TECH_NONE)) {
-        /* If so let the state machine continue*/
-        gNfcDev.discRestart = discovery;
-        gNfcDev.state = RFAL_NFC_STATE_DEACTIVATION;
-    } else {
-        /* Otherwise deactivate immediately and go to IDLE */
-        rfalNfcDeactivation();
-        gNfcDev.state = RFAL_NFC_STATE_IDLE;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcSelect(uint8_t devIdx) {
-    /* Check for valid state */
-    if(gNfcDev.state != RFAL_NFC_STATE_POLL_SELECT) {
-        return ERR_WRONG_STATE;
-    }
-
-    gNfcDev.selDevIdx = devIdx;
-    gNfcDev.state = RFAL_NFC_STATE_POLL_ACTIVATION;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-rfalNfcState rfalNfcGetState(void) {
-    return gNfcDev.state;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcGetDevicesFound(rfalNfcDevice** devList, uint8_t* devCnt) {
-    /* Check for valid state */
-    if(gNfcDev.state < RFAL_NFC_STATE_POLL_SELECT) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check valid parameters */
-    if((devList == NULL) || (devCnt == NULL)) {
-        return ERR_PARAM;
-    }
-
-    *devCnt = gNfcDev.devCnt;
-    *devList = gNfcDev.devList;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcGetActiveDevice(rfalNfcDevice** dev) {
-    /* Check for valid state */
-    if(gNfcDev.state < RFAL_NFC_STATE_ACTIVATED) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check valid parameter */
-    if(dev == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Check for valid state */
-    if((gNfcDev.devCnt == 0U) || (gNfcDev.activeDev == NULL)) {
-        return ERR_REQUEST;
-    }
-
-    *dev = gNfcDev.activeDev;
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-void rfalNfcWorker(void) {
-    ReturnCode err;
-
-    rfalWorker(); /* Execute RFAL process  */
-
-    switch(gNfcDev.state) {
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_NOTINIT:
-    case RFAL_NFC_STATE_IDLE:
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_START_DISCOVERY:
-
-        /* Initialize context for discovery cycle */
-        gNfcDev.devCnt = 0;
-        gNfcDev.selDevIdx = 0;
-        gNfcDev.techsFound = RFAL_NFC_TECH_NONE;
-        gNfcDev.techs2do = gNfcDev.disc.techs2Find;
-        gNfcDev.state = RFAL_NFC_STATE_POLL_TECHDETECT;
-
-#if RFAL_FEATURE_WAKEUP_MODE
-        /* Check if Low power Wake-Up is to be performed */
-        if(gNfcDev.disc.wakeupEnabled) {
-            /* Initialize Low power Wake-up mode and wait */
-            err = rfalWakeUpModeStart(
-                (gNfcDev.disc.wakeupConfigDefault ? NULL : &gNfcDev.disc.wakeupConfig));
-            if(err == ERR_NONE) {
-                gNfcDev.state = RFAL_NFC_STATE_WAKEUP_MODE;
-                rfalNfcNfcNotify(gNfcDev.state); /* Notify caller that WU was started */
-            }
-        }
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_WAKEUP_MODE:
-
-#if RFAL_FEATURE_WAKEUP_MODE
-        /* Check if the Wake-up mode has woke */
-        if(rfalWakeUpModeHasWoke()) {
-            rfalWakeUpModeStop(); /* Disable Wake-up mode           */
-            gNfcDev.state = RFAL_NFC_STATE_POLL_TECHDETECT; /* Go to Technology detection     */
-
-            rfalNfcNfcNotify(gNfcDev.state); /* Notify caller that WU has woke */
-        }
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_POLL_TECHDETECT:
-
-        /* Start total duration timer */
-        platformTimerDestroy(gNfcDev.discTmr);
-        gNfcDev.discTmr = (uint32_t)platformTimerCreate(gNfcDev.disc.totalDuration);
-
-        err =
-            rfalNfcPollTechDetetection(); /* Perform Technology Detection                         */
-        if(err != ERR_BUSY) /* Wait until all technologies are performed            */
-        {
-            if((err != ERR_NONE) ||
-               (gNfcDev.techsFound ==
-                RFAL_NFC_TECH_NONE)) /* Check if any error occurred or no techs were found   */
-            {
-                rfalFieldOff();
-                gNfcDev.state =
-                    RFAL_NFC_STATE_LISTEN_TECHDETECT; /* Nothing found as poller, go to listener */
-                break;
-            }
-
-            gNfcDev.techs2do =
-                gNfcDev.techsFound; /* Store the found technologies for collision resolution */
-            gNfcDev.state =
-                RFAL_NFC_STATE_POLL_COLAVOIDANCE; /* One or more devices found, go to Collision Avoidance  */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_POLL_COLAVOIDANCE:
-
-        err =
-            rfalNfcPollCollResolution(); /* Resolve any eventual collision                       */
-        if(err != ERR_BUSY) /* Wait until all technologies are performed            */
-        {
-            if((err != ERR_NONE) ||
-               (gNfcDev.devCnt == 0U)) /* Check if any error occurred or no devices were found */
-            {
-                gNfcDev.state = RFAL_NFC_STATE_DEACTIVATION;
-                break; /* Unable to retrieve any device, restart loop          */
-            }
-
-            /* Check if more than one device has been found */
-            if(gNfcDev.devCnt > 1U) {
-                /* If more than one device was found inform upper layer to choose which one to activate */
-                if(gNfcDev.disc.notifyCb != NULL) {
-                    gNfcDev.state = RFAL_NFC_STATE_POLL_SELECT;
-                    gNfcDev.disc.notifyCb(gNfcDev.state);
-                    break;
-                }
-            }
-
-            /* If only one device or no callback has been set, activate the first device found */
-            gNfcDev.selDevIdx = 0U;
-            gNfcDev.state = RFAL_NFC_STATE_POLL_ACTIVATION;
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_POLL_ACTIVATION:
-
-        err = rfalNfcPollActivation(gNfcDev.selDevIdx);
-        if(err != ERR_BUSY) /* Wait until all Activation is complete */
-        {
-            if(err != ERR_NONE) /* Activation failed selected device  */
-            {
-                gNfcDev.state =
-                    RFAL_NFC_STATE_DEACTIVATION; /* If Activation failed, restart loop */
-                break;
-            }
-
-            gNfcDev.state = RFAL_NFC_STATE_ACTIVATED; /* Device has been properly activated */
-            rfalNfcNfcNotify(
-                gNfcDev.state); /* Inform upper layer that a device has been activated */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_DATAEXCHANGE:
-
-        rfalNfcDataExchangeGetStatus(); /* Run the internal state machine */
-
-        if(gNfcDev.dataExErr != ERR_BUSY) /* If Dataexchange has terminated */
-        {
-            gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE_DONE; /* Go to done state               */
-            rfalNfcNfcNotify(gNfcDev.state); /* And notify caller              */
-        }
-        if(gNfcDev.dataExErr == ERR_SLEEP_REQ) /* Check if Listen mode has to go to Sleep */
-        {
-            gNfcDev.state = RFAL_NFC_STATE_LISTEN_SLEEP; /* Go to Listen Sleep state       */
-            rfalNfcNfcNotify(gNfcDev.state); /* And notify caller              */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_DEACTIVATION:
-
-        rfalNfcDeactivation(); /* Deactivate current device */
-
-        gNfcDev.state =
-            ((gNfcDev.discRestart) ? RFAL_NFC_STATE_START_DISCOVERY : RFAL_NFC_STATE_IDLE);
-        rfalNfcNfcNotify(gNfcDev.state); /* Notify caller             */
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_LISTEN_TECHDETECT:
-
-        if(platformTimerIsExpired(gNfcDev.discTmr)) {
-#if RFAL_FEATURE_LISTEN_MODE
-            rfalListenStop();
-#else
-            rfalFieldOff();
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-            gNfcDev.state = RFAL_NFC_STATE_START_DISCOVERY; /* Restart the discovery loop */
-            rfalNfcNfcNotify(gNfcDev.state); /* Notify caller             */
-            break;
-        }
-
-#if RFAL_FEATURE_LISTEN_MODE
-
-        if(gNfcDev.lmMask != 0U) /* Check if configured to perform Listen mode */
-        {
-            err = rfalListenStart(
-                gNfcDev.lmMask,
-                &gNfcDev.disc.lmConfigPA,
-                NULL,
-                &gNfcDev.disc.lmConfigPF,
-                (uint8_t*)&gNfcDev.rxBuf.rfBuf,
-                (uint16_t)rfalConvBytesToBits(sizeof(gNfcDev.rxBuf.rfBuf)),
-                &gNfcDev.rxLen);
-            if(err == ERR_NONE) {
-                gNfcDev.state =
-                    RFAL_NFC_STATE_LISTEN_COLAVOIDANCE; /* Wait for listen mode to be activated */
-            }
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_LISTEN_COLAVOIDANCE:
-
-        if(platformTimerIsExpired(
-               gNfcDev.discTmr)) /* Check if the total duration has been reached */
-        {
-            rfalListenStop();
-            gNfcDev.state = RFAL_NFC_STATE_START_DISCOVERY; /* Restart the discovery loop */
-            rfalNfcNfcNotify(gNfcDev.state); /* Notify caller             */
-            break;
-        }
-
-        /* Check for external field */
-        if(rfalListenGetState(NULL, NULL) >= RFAL_LM_STATE_IDLE) {
-            gNfcDev.state =
-                RFAL_NFC_STATE_LISTEN_ACTIVATION; /* Wait for listen mode to be activated */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_LISTEN_ACTIVATION:
-    case RFAL_NFC_STATE_LISTEN_SLEEP:
-
-        err = rfalNfcListenActivation();
-        if(err != ERR_BUSY) {
-            if(err == ERR_NONE) {
-                gNfcDev.activeDev =
-                    gNfcDev.devList; /* Assign the active device to be used further on */
-                gNfcDev.devCnt++;
-
-                gNfcDev.state = RFAL_NFC_STATE_ACTIVATED; /* Device has been properly activated */
-                rfalNfcNfcNotify(
-                    gNfcDev.state); /* Inform upper layer that a device has been activated */
-            } else {
-                rfalListenStop();
-                gNfcDev.state = RFAL_NFC_STATE_START_DISCOVERY; /* Restart the discovery loop */
-                rfalNfcNfcNotify(gNfcDev.state); /* Notify caller             */
-            }
-        }
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-        break;
-
-    /*******************************************************************************/
-    case RFAL_NFC_STATE_ACTIVATED:
-    case RFAL_NFC_STATE_POLL_SELECT:
-    case RFAL_NFC_STATE_DATAEXCHANGE_DONE:
-    default:
-        return;
-    }
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcDataExchangeStart(
-    uint8_t* txData,
-    uint16_t txDataLen,
-    uint8_t** rxData,
-    uint16_t** rvdLen,
-    uint32_t fwt,
-    uint32_t flags) {
-    ReturnCode err;
-    rfalTransceiveContext ctx;
-
-    /*******************************************************************************/
-    /* The Data Exchange is divided in two different moments, the trigger/Start of *
-     *  the transfer followed by the check until its completion                    */
-    if((gNfcDev.state >= RFAL_NFC_STATE_ACTIVATED) && (gNfcDev.activeDev != NULL)) {
-        /*******************************************************************************/
-        /* In Listen mode is the Poller that initiates the communicatation             */
-        /* Assign output parameters and rfalNfcDataExchangeGetStatus will return       */
-        /* incoming data from Poller/Initiator                                         */
-        if((gNfcDev.state == RFAL_NFC_STATE_ACTIVATED) &&
-           rfalNfcIsRemDevPoller(gNfcDev.activeDev->type)) {
-            if(txDataLen > 0U) {
-                return ERR_WRONG_STATE;
-            }
-
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-            *rxData =
-                (uint8_t*)((gNfcDev.activeDev->rfInterface == RFAL_NFC_INTERFACE_ISODEP) ?
-                               gNfcDev.rxBuf.isoDepBuf.apdu :
-                               ((gNfcDev.activeDev->rfInterface == RFAL_NFC_INTERFACE_NFCDEP) ?
-                                    gNfcDev.rxBuf.nfcDepBuf.pdu :
-                                    gNfcDev.rxBuf.rfBuf));
-            if(gNfcDev.disc.activate_after_sak) {
-                gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE_DONE;
-            }
-            return ERR_NONE;
-        }
-
-        /*******************************************************************************/
-        switch(gNfcDev.activeDev
-                   ->rfInterface) /* Check which RF interface shall be used/has been activated */
-        {
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_RF:
-
-            rfalCreateByteFlagsTxRxContext(
-                ctx,
-                (uint8_t*)txData,
-                txDataLen,
-                gNfcDev.rxBuf.rfBuf,
-                sizeof(gNfcDev.rxBuf.rfBuf),
-                &gNfcDev.rxLen,
-                flags,
-                fwt);
-            if(flags == RFAL_TXRX_FLAGS_RAW) {
-                ctx.txBufLen = txDataLen;
-            }
-            *rxData = (uint8_t*)gNfcDev.rxBuf.rfBuf;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-            err = rfalStartTransceive(&ctx);
-            break;
-
-#if RFAL_FEATURE_ISO_DEP
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_ISODEP: {
-            rfalIsoDepApduTxRxParam isoDepTxRx;
-
-            if(txDataLen > sizeof(gNfcDev.txBuf.isoDepBuf.apdu)) {
-                return ERR_NOMEM;
-            }
-
-            if(txDataLen > 0U) {
-                ST_MEMCPY((uint8_t*)gNfcDev.txBuf.isoDepBuf.apdu, txData, txDataLen);
-            }
-
-            isoDepTxRx.DID = RFAL_ISODEP_NO_DID;
-            isoDepTxRx.ourFSx = RFAL_ISODEP_FSX_KEEP;
-            isoDepTxRx.FSx = gNfcDev.activeDev->proto.isoDep.info.FSx;
-            isoDepTxRx.dFWT = gNfcDev.activeDev->proto.isoDep.info.dFWT;
-            isoDepTxRx.FWT = gNfcDev.activeDev->proto.isoDep.info.FWT;
-            isoDepTxRx.txBuf = &gNfcDev.txBuf.isoDepBuf;
-            isoDepTxRx.txBufLen = txDataLen;
-            isoDepTxRx.rxBuf = &gNfcDev.rxBuf.isoDepBuf;
-            isoDepTxRx.rxLen = &gNfcDev.rxLen;
-            isoDepTxRx.tmpBuf = &gNfcDev.tmpBuf.isoDepBuf;
-            *rxData = (uint8_t*)gNfcDev.rxBuf.isoDepBuf.apdu;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-
-            /*******************************************************************************/
-            /* Trigger a RFAL ISO-DEP Transceive                                           */
-            err = rfalIsoDepStartApduTransceive(isoDepTxRx);
-            break;
-        }
-#endif /* RFAL_FEATURE_ISO_DEP */
-
-#if RFAL_FEATURE_NFC_DEP
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_NFCDEP: {
-            rfalNfcDepPduTxRxParam nfcDepTxRx;
-
-            if(txDataLen > sizeof(gNfcDev.txBuf.nfcDepBuf.pdu)) {
-                return ERR_NOMEM;
-            }
-
-            if(txDataLen > 0U) {
-                ST_MEMCPY((uint8_t*)gNfcDev.txBuf.nfcDepBuf.pdu, txData, txDataLen);
-            }
-
-            nfcDepTxRx.DID = RFAL_NFCDEP_DID_KEEP;
-            nfcDepTxRx.FSx =
-                rfalNfcIsRemDevListener(gNfcDev.activeDev->type) ?
-                    rfalNfcDepLR2FS((uint8_t)rfalNfcDepPP2LR(
-                        gNfcDev.activeDev->proto.nfcDep.activation.Target.ATR_RES.PPt)) :
-                    rfalNfcDepLR2FS((uint8_t)rfalNfcDepPP2LR(
-                        gNfcDev.activeDev->proto.nfcDep.activation.Initiator.ATR_REQ.PPi));
-            nfcDepTxRx.dFWT = gNfcDev.activeDev->proto.nfcDep.info.dFWT;
-            nfcDepTxRx.FWT = gNfcDev.activeDev->proto.nfcDep.info.FWT;
-            nfcDepTxRx.txBuf = &gNfcDev.txBuf.nfcDepBuf;
-            nfcDepTxRx.txBufLen = txDataLen;
-            nfcDepTxRx.rxBuf = &gNfcDev.rxBuf.nfcDepBuf;
-            nfcDepTxRx.rxLen = &gNfcDev.rxLen;
-            nfcDepTxRx.tmpBuf = &gNfcDev.tmpBuf.nfcDepBuf;
-            *rxData = (uint8_t*)gNfcDev.rxBuf.nfcDepBuf.pdu;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-
-            /*******************************************************************************/
-            /* Trigger a RFAL NFC-DEP Transceive                                           */
-            err = rfalNfcDepStartPduTransceive(nfcDepTxRx);
-            break;
-        }
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-        /*******************************************************************************/
-        default:
-            err = ERR_PARAM;
-            break;
-        }
-
-        /* If a transceive has successfuly started flag Data Exchange as ongoing */
-        if(err == ERR_NONE) {
-            gNfcDev.dataExErr = ERR_BUSY;
-            gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE;
-        }
-
-        return err;
-    }
-
-    return ERR_WRONG_STATE;
-}
-
-ReturnCode rfalNfcDataExchangeCustomStart(
-    uint8_t* txData,
-    uint16_t txDataLen,
-    uint8_t** rxData,
-    uint16_t** rvdLen,
-    uint32_t fwt,
-    uint32_t flags) {
-    ReturnCode err;
-    rfalTransceiveContext ctx;
-
-    /*******************************************************************************/
-    /* The Data Exchange is divided in two different moments, the trigger/Start of *
-     *  the transfer followed by the check until its completion                    */
-    if((gNfcDev.state >= RFAL_NFC_STATE_ACTIVATED) && (gNfcDev.activeDev != NULL)) {
-        /*******************************************************************************/
-        /* In Listen mode is the Poller that initiates the communicatation             */
-        /* Assign output parameters and rfalNfcDataExchangeGetStatus will return       */
-        /* incoming data from Poller/Initiator                                         */
-        if((gNfcDev.state == RFAL_NFC_STATE_ACTIVATED) &&
-           rfalNfcIsRemDevPoller(gNfcDev.activeDev->type)) {
-            if(txDataLen > 0U) {
-                return ERR_WRONG_STATE;
-            }
-
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-            *rxData =
-                (uint8_t*)((gNfcDev.activeDev->rfInterface == RFAL_NFC_INTERFACE_ISODEP) ?
-                               gNfcDev.rxBuf.isoDepBuf.apdu :
-                               ((gNfcDev.activeDev->rfInterface == RFAL_NFC_INTERFACE_NFCDEP) ?
-                                    gNfcDev.rxBuf.nfcDepBuf.pdu :
-                                    gNfcDev.rxBuf.rfBuf));
-            if(gNfcDev.disc.activate_after_sak) {
-                gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE_DONE;
-            }
-            return ERR_NONE;
-        }
-
-        /*******************************************************************************/
-        switch(gNfcDev.activeDev
-                   ->rfInterface) /* Check which RF interface shall be used/has been activated */
-        {
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_RF:
-            ctx.rxBuf = gNfcDev.rxBuf.rfBuf;
-            ctx.rxBufLen = 8 * sizeof(gNfcDev.rxBuf.rfBuf);
-            ctx.rxRcvdLen = &gNfcDev.rxLen;
-            ctx.txBuf = txData;
-            ctx.txBufLen = txDataLen;
-            ctx.flags = flags;
-            ctx.fwt = fwt;
-            *rxData = (uint8_t*)gNfcDev.rxBuf.rfBuf;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-            err = rfalStartTransceive(&ctx);
-            break;
-
-#if RFAL_FEATURE_ISO_DEP
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_ISODEP: {
-            rfalIsoDepApduTxRxParam isoDepTxRx;
-            uint16_t tx_bytes = txDataLen / 8;
-
-            if(tx_bytes > sizeof(gNfcDev.txBuf.isoDepBuf.apdu)) {
-                return ERR_NOMEM;
-            }
-
-            if(tx_bytes > 0U) {
-                ST_MEMCPY((uint8_t*)gNfcDev.txBuf.isoDepBuf.apdu, txData, tx_bytes);
-            }
-
-            isoDepTxRx.DID = RFAL_ISODEP_NO_DID;
-            isoDepTxRx.ourFSx = RFAL_ISODEP_FSX_KEEP;
-            isoDepTxRx.FSx = gNfcDev.activeDev->proto.isoDep.info.FSx;
-            isoDepTxRx.dFWT = gNfcDev.activeDev->proto.isoDep.info.dFWT;
-            isoDepTxRx.FWT = gNfcDev.activeDev->proto.isoDep.info.FWT;
-            isoDepTxRx.txBuf = &gNfcDev.txBuf.isoDepBuf;
-            isoDepTxRx.txBufLen = tx_bytes;
-            isoDepTxRx.rxBuf = &gNfcDev.rxBuf.isoDepBuf;
-            isoDepTxRx.rxLen = &gNfcDev.rxLen;
-            isoDepTxRx.tmpBuf = &gNfcDev.tmpBuf.isoDepBuf;
-            *rxData = (uint8_t*)gNfcDev.rxBuf.isoDepBuf.apdu;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-
-            /*******************************************************************************/
-            /* Trigger a RFAL ISO-DEP Transceive                                           */
-            err = rfalIsoDepStartApduTransceive(isoDepTxRx);
-            break;
-        }
-#endif /* RFAL_FEATURE_ISO_DEP */
-
-#if RFAL_FEATURE_NFC_DEP
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_NFCDEP: {
-            rfalNfcDepPduTxRxParam nfcDepTxRx;
-
-            if(txDataLen > sizeof(gNfcDev.txBuf.nfcDepBuf.pdu)) {
-                return ERR_NOMEM;
-            }
-
-            if(txDataLen > 0U) {
-                ST_MEMCPY((uint8_t*)gNfcDev.txBuf.nfcDepBuf.pdu, txData, txDataLen);
-            }
-
-            nfcDepTxRx.DID = RFAL_NFCDEP_DID_KEEP;
-            nfcDepTxRx.FSx =
-                rfalNfcIsRemDevListener(gNfcDev.activeDev->type) ?
-                    rfalNfcDepLR2FS((uint8_t)rfalNfcDepPP2LR(
-                        gNfcDev.activeDev->proto.nfcDep.activation.Target.ATR_RES.PPt)) :
-                    rfalNfcDepLR2FS((uint8_t)rfalNfcDepPP2LR(
-                        gNfcDev.activeDev->proto.nfcDep.activation.Initiator.ATR_REQ.PPi));
-            nfcDepTxRx.dFWT = gNfcDev.activeDev->proto.nfcDep.info.dFWT;
-            nfcDepTxRx.FWT = gNfcDev.activeDev->proto.nfcDep.info.FWT;
-            nfcDepTxRx.txBuf = &gNfcDev.txBuf.nfcDepBuf;
-            nfcDepTxRx.txBufLen = txDataLen;
-            nfcDepTxRx.rxBuf = &gNfcDev.rxBuf.nfcDepBuf;
-            nfcDepTxRx.rxLen = &gNfcDev.rxLen;
-            nfcDepTxRx.tmpBuf = &gNfcDev.tmpBuf.nfcDepBuf;
-            *rxData = (uint8_t*)gNfcDev.rxBuf.nfcDepBuf.pdu;
-            *rvdLen = (uint16_t*)&gNfcDev.rxLen;
-
-            /*******************************************************************************/
-            /* Trigger a RFAL NFC-DEP Transceive                                           */
-            err = rfalNfcDepStartPduTransceive(nfcDepTxRx);
-            break;
-        }
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-        /*******************************************************************************/
-        default:
-            err = ERR_PARAM;
-            break;
-        }
-
-        /* If a transceive has successfuly started flag Data Exchange as ongoing */
-        if(err == ERR_NONE) {
-            gNfcDev.dataExErr = ERR_BUSY;
-            gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE;
-        }
-
-        return err;
-    }
-
-    return ERR_WRONG_STATE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcDataExchangeGetStatus(void) {
-    /*******************************************************************************/
-    /* Check if it's the first frame received in Listen mode */
-    if(gNfcDev.state == RFAL_NFC_STATE_ACTIVATED) {
-        /* Continue data exchange as normal */
-        gNfcDev.dataExErr = ERR_BUSY;
-        gNfcDev.state = RFAL_NFC_STATE_DATAEXCHANGE;
-
-        /* Check if we performing in T3T CE */
-        if((gNfcDev.activeDev->type == RFAL_NFC_POLL_TYPE_NFCF) &&
-           (gNfcDev.activeDev->rfInterface == RFAL_NFC_INTERFACE_RF)) {
-            /* The first frame has been retrieved by rfalListenMode, flag data immediately                  */
-            /* Can only call rfalGetTransceiveStatus() after starting a transceive with rfalStartTransceive */
-            gNfcDev.dataExErr = ERR_NONE;
-        }
-    }
-
-    /*******************************************************************************/
-    /* Check if we are in we have been placed to sleep, and return last error     */
-    if(gNfcDev.state == RFAL_NFC_STATE_LISTEN_SLEEP) {
-        return gNfcDev.dataExErr; /* ERR_SLEEP_REQ */
-    }
-
-    /*******************************************************************************/
-    /* Check if Data exchange has been started */
-    if((gNfcDev.state != RFAL_NFC_STATE_DATAEXCHANGE) &&
-       (gNfcDev.state != RFAL_NFC_STATE_DATAEXCHANGE_DONE)) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check if Data exchange is still ongoing */
-    if(gNfcDev.dataExErr == ERR_BUSY) {
-        switch(gNfcDev.activeDev->rfInterface) {
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_RF:
-            gNfcDev.dataExErr = rfalGetTransceiveStatus();
-            break;
-
-#if RFAL_FEATURE_ISO_DEP
-        /*******************************************************************************/
-        case RFAL_NFC_INTERFACE_ISODEP:
-            gNfcDev.dataExErr = rfalIsoDepGetApduTransceiveStatus();
-            break;
-#endif /* RFAL_FEATURE_ISO_DEP */
-
-            /*******************************************************************************/
-#if RFAL_FEATURE_NFC_DEP
-        case RFAL_NFC_INTERFACE_NFCDEP:
-            gNfcDev.dataExErr = rfalNfcDepGetPduTransceiveStatus();
-            break;
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-        /*******************************************************************************/
-        default:
-            gNfcDev.dataExErr = ERR_PARAM;
-            break;
-        }
-
-#if RFAL_FEATURE_LISTEN_MODE
-        /*******************************************************************************/
-        /* If a Sleep request has been received (Listen Mode) go to sleep immediately  */
-        if(gNfcDev.dataExErr == ERR_SLEEP_REQ) {
-            EXIT_ON_ERR(
-                gNfcDev.dataExErr,
-                rfalListenSleepStart(
-                    RFAL_LM_STATE_SLEEP_A,
-                    gNfcDev.rxBuf.rfBuf,
-                    sizeof(gNfcDev.rxBuf.rfBuf),
-                    &gNfcDev.rxLen));
-
-            /* If set Sleep was successful keep restore the Sleep request signal */
-            gNfcDev.dataExErr = ERR_SLEEP_REQ;
-        }
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-    }
-
-    return gNfcDev.dataExErr;
-}
-
-/*!
- ******************************************************************************
- * \brief Poller Technology Detection
- * 
- * This method implements the Technology Detection / Poll for different 
- * device technologies.
- * 
- * \return  ERR_NONE         : Operation completed with no error
- * \return  ERR_BUSY         : Operation ongoing
- * \return  ERR_XXXX         : Error occurred
- * 
- ******************************************************************************
- */
-static ReturnCode rfalNfcPollTechDetetection(void) {
-    ReturnCode err;
-
-    err = ERR_NONE;
-
-    /* Suppress warning when specific RFAL features have been disabled */
-    NO_WARNING(err);
-
-    /*******************************************************************************/
-    /* AP2P Technology Detection                                                   */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_AP2P) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_AP2P) != 0U)) {
-#if RFAL_FEATURE_NFC_DEP
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(
-                err,
-                rfalSetMode(RFAL_MODE_POLL_ACTIVE_P2P, gNfcDev.disc.ap2pBR, gNfcDev.disc.ap2pBR));
-            rfalSetErrorHandling(RFAL_ERRORHANDLING_NFC);
-            rfalSetFDTListen(RFAL_FDT_LISTEN_AP2P_POLLER);
-            rfalSetFDTPoll(RFAL_TIMING_NONE);
-            rfalSetGT(RFAL_GT_AP2P_ADJUSTED);
-            EXIT_ON_ERR(err, rfalFieldOnAndStartGT()); /* Turns the Field On and starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_AP2P;
-
-            err = rfalNfcNfcDepActivate(
-                gNfcDev.devList, RFAL_NFCDEP_COMM_ACTIVE, NULL, 0); /* Poll for NFC-A devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_AP2P;
-
-                gNfcDev.devList->type = RFAL_NFC_LISTEN_TYPE_AP2P;
-                gNfcDev.devList->rfInterface = RFAL_NFC_INTERFACE_NFCDEP;
-                gNfcDev.devCnt++;
-
-                return ERR_NONE;
-            }
-
-            gNfcDev.isTechInit = false;
-            rfalFieldOff();
-        }
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFC_DEP */
-    }
-
-    /*******************************************************************************/
-    /* Passive NFC-A Technology Detection                                          */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_A) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_A) != 0U)) {
-#if RFAL_FEATURE_NFCA
-
-        rfalNfcaSensRes sensRes;
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcaPollerInitialize()); /* Initialize RFAL for NFC-A */
-            EXIT_ON_ERR(err, rfalFieldOnAndStartGT()); /* Turns the Field On and starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            err = rfalNfcaPollerTechnologyDetection(
-                gNfcDev.disc.compMode, &sensRes); /* Poll for NFC-A devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_A;
-            }
-
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_A;
-        }
-
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFCA */
-    }
-
-    /*******************************************************************************/
-    /* Passive NFC-B Technology Detection                                          */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_B) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_B) != 0U)) {
-#if RFAL_FEATURE_NFCB
-
-        rfalNfcbSensbRes sensbRes;
-        uint8_t sensbResLen;
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcbPollerInitialize()); /* Initialize RFAL for NFC-B */
-            EXIT_ON_ERR(
-                err, rfalFieldOnAndStartGT()); /* As field is already On only starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            err = rfalNfcbPollerTechnologyDetection(
-                gNfcDev.disc.compMode, &sensbRes, &sensbResLen); /* Poll for NFC-B devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_B;
-            }
-
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_B;
-        }
-
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFCB */
-    }
-
-    /*******************************************************************************/
-    /* Passive NFC-F Technology Detection                                          */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_F) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_F) != 0U)) {
-#if RFAL_FEATURE_NFCF
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(
-                err,
-                rfalNfcfPollerInitialize(gNfcDev.disc.nfcfBR)); /* Initialize RFAL for NFC-F */
-            EXIT_ON_ERR(
-                err, rfalFieldOnAndStartGT()); /* As field is already On only starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            err = rfalNfcfPollerCheckPresence(); /* Poll for NFC-F devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_F;
-            }
-
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_F;
-        }
-
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFCF */
-    }
-
-    /*******************************************************************************/
-    /* Passive NFC-V Technology Detection                                          */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_V) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_V) != 0U)) {
-#if RFAL_FEATURE_NFCV
-
-        rfalNfcvInventoryRes invRes;
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcvPollerInitialize()); /* Initialize RFAL for NFC-V */
-            EXIT_ON_ERR(
-                err, rfalFieldOnAndStartGT()); /* As field is already On only starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            err = rfalNfcvPollerCheckPresence(&invRes); /* Poll for NFC-V devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_V;
-            }
-
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_V;
-        }
-
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFCV */
-    }
-
-    /*******************************************************************************/
-    /* Passive Proprietary Technology ST25TB                                       */
-    /*******************************************************************************/
-    if(((gNfcDev.disc.techs2Find & RFAL_NFC_POLL_TECH_ST25TB) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_ST25TB) != 0U)) {
-#if RFAL_FEATURE_ST25TB
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalSt25tbPollerInitialize()); /* Initialize RFAL for NFC-V */
-            EXIT_ON_ERR(
-                err, rfalFieldOnAndStartGT()); /* As field is already On only starts GT timer */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(rfalIsGTExpired()) /* Wait until Guard Time is fulfilled */
-        {
-            err = rfalSt25tbPollerCheckPresence(NULL); /* Poll for ST25TB devices */
-            if(err == ERR_NONE) {
-                gNfcDev.techsFound |= RFAL_NFC_POLL_TECH_ST25TB;
-            }
-
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_ST25TB;
-        }
-
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_ST25TB */
-    }
-
-    return ERR_NONE;
-}
-
-/*!
- ******************************************************************************
- * \brief Poller Collision Resolution
- * 
- * This method implements the Collision Resolution on all technologies that
- * have been detected before.
- * 
- * \return  ERR_NONE         : Operation completed with no error
- * \return  ERR_BUSY         : Operation ongoing
- * \return  ERR_XXXX         : Error occurred
- * 
- ******************************************************************************
- */
-static ReturnCode rfalNfcPollCollResolution(void) {
-    uint8_t i;
-    static uint8_t devCnt;
-    ReturnCode err;
-
-    err = ERR_NONE;
-    i = 0;
-
-    /* Suppress warning when specific RFAL features have been disabled */
-    NO_WARNING(err);
-    NO_WARNING(devCnt);
-    NO_WARNING(i);
-
-    /* Check if device limit has been reached */
-    if(gNfcDev.devCnt >= gNfcDev.disc.devLimit) {
-        return ERR_NONE;
-    }
-
-    /*******************************************************************************/
-    /* NFC-A Collision Resolution                                                  */
-    /*******************************************************************************/
-#if RFAL_FEATURE_NFCA
-    if(((gNfcDev.techsFound & RFAL_NFC_POLL_TECH_A) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_A) !=
-        0U)) /* If a NFC-A device was found/detected, perform Collision Resolution */
-    {
-        static rfalNfcaListenDevice nfcaDevList[RFAL_NFC_MAX_DEVICES];
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcaPollerInitialize()); /* Initialize RFAL for NFC-A */
-            EXIT_ON_ERR(err, rfalFieldOnAndStartGT()); /* Turns the Field On and starts GT timer */
-
-            gNfcDev.isTechInit = true; /* Technology has been initialized */
-            gNfcDev.isOperOngoing = false; /* No operation currently ongoing  */
-        }
-
-        if(!rfalIsGTExpired()) {
-            return ERR_BUSY;
-        }
-
-        if(!gNfcDev.isOperOngoing) {
-            EXIT_ON_ERR(
-                err,
-                rfalNfcaPollerStartFullCollisionResolution(
-                    gNfcDev.disc.compMode,
-                    (gNfcDev.disc.devLimit - gNfcDev.devCnt),
-                    nfcaDevList,
-                    &devCnt));
-
-            gNfcDev.isOperOngoing = true;
-            return ERR_BUSY;
-        }
-
-        err = rfalNfcaPollerGetFullCollisionResolutionStatus();
-        if(err != ERR_BUSY) {
-            gNfcDev.isTechInit = false;
-            gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_A;
-
-            if((err == ERR_NONE) && (devCnt != 0U)) {
-                for(i = 0; i < devCnt;
-                    i++) /* Copy devices found form local Nfca list into global device list */
-                {
-                    gNfcDev.devList[gNfcDev.devCnt].type = RFAL_NFC_LISTEN_TYPE_NFCA;
-                    gNfcDev.devList[gNfcDev.devCnt].dev.nfca = nfcaDevList[i];
-                    gNfcDev.devCnt++;
-                }
-            }
-        }
-
-        return ERR_BUSY;
-    }
-#endif /* RFAL_FEATURE_NFCA */
-
-    /*******************************************************************************/
-    /* NFC-B Collision Resolution                                                  */
-    /*******************************************************************************/
-#if RFAL_FEATURE_NFCB
-    if(((gNfcDev.techsFound & RFAL_NFC_POLL_TECH_B) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_B) !=
-        0U)) /* If a NFC-B device was found/detected, perform Collision Resolution */
-    {
-        rfalNfcbListenDevice nfcbDevList[RFAL_NFC_MAX_DEVICES];
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcbPollerInitialize()); /* Initialize RFAL for NFC-B */
-            EXIT_ON_ERR(
-                err,
-                rfalFieldOnAndStartGT()); /* Ensure GT again as other technologies have also been polled */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(!rfalIsGTExpired()) {
-            return ERR_BUSY;
-        }
-
-        devCnt = 0;
-        gNfcDev.isTechInit = false;
-        gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_B;
-
-        err = rfalNfcbPollerCollisionResolution(
-            gNfcDev.disc.compMode, (gNfcDev.disc.devLimit - gNfcDev.devCnt), nfcbDevList, &devCnt);
-        if((err == ERR_NONE) && (devCnt != 0U)) {
-            for(i = 0; i < devCnt;
-                i++) /* Copy devices found form local Nfcb list into global device list */
-            {
-                gNfcDev.devList[gNfcDev.devCnt].type = RFAL_NFC_LISTEN_TYPE_NFCB;
-                gNfcDev.devList[gNfcDev.devCnt].dev.nfcb = nfcbDevList[i];
-                gNfcDev.devCnt++;
-            }
-        }
-
-        return ERR_BUSY;
-    }
-#endif /* RFAL_FEATURE_NFCB*/
-
-    /*******************************************************************************/
-    /* NFC-F Collision Resolution                                                  */
-    /*******************************************************************************/
-#if RFAL_FEATURE_NFCF
-    if(((gNfcDev.techsFound & RFAL_NFC_POLL_TECH_F) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_F) !=
-        0U)) /* If a NFC-F device was found/detected, perform Collision Resolution */
-    {
-        rfalNfcfListenDevice nfcfDevList[RFAL_NFC_MAX_DEVICES];
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(
-                err,
-                rfalNfcfPollerInitialize(gNfcDev.disc.nfcfBR)); /* Initialize RFAL for NFC-F */
-            EXIT_ON_ERR(
-                err,
-                rfalFieldOnAndStartGT()); /* Ensure GT again as other technologies have also been polled */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(!rfalIsGTExpired()) {
-            return ERR_BUSY;
-        }
-
-        devCnt = 0;
-        gNfcDev.isTechInit = false;
-        gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_F;
-
-        err = rfalNfcfPollerCollisionResolution(
-            gNfcDev.disc.compMode, (gNfcDev.disc.devLimit - gNfcDev.devCnt), nfcfDevList, &devCnt);
-        if((err == ERR_NONE) && (devCnt != 0U)) {
-            for(i = 0; i < devCnt;
-                i++) /* Copy devices found form local Nfcf list into global device list */
-            {
-                gNfcDev.devList[gNfcDev.devCnt].type = RFAL_NFC_LISTEN_TYPE_NFCF;
-                gNfcDev.devList[gNfcDev.devCnt].dev.nfcf = nfcfDevList[i];
-                gNfcDev.devCnt++;
-            }
-        }
-
-        return ERR_BUSY;
-    }
-#endif /* RFAL_FEATURE_NFCF */
-
-    /*******************************************************************************/
-    /* NFC-V Collision Resolution                                                  */
-    /*******************************************************************************/
-#if RFAL_FEATURE_NFCV
-    if(((gNfcDev.techsFound & RFAL_NFC_POLL_TECH_V) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_V) !=
-        0U)) /* If a NFC-V device was found/detected, perform Collision Resolution */
-    {
-        rfalNfcvListenDevice nfcvDevList[RFAL_NFC_MAX_DEVICES];
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalNfcvPollerInitialize()); /* Initialize RFAL for NFC-V */
-            EXIT_ON_ERR(
-                err,
-                rfalFieldOnAndStartGT()); /* Ensure GT again as other technologies have also been polled */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(!rfalIsGTExpired()) {
-            return ERR_BUSY;
-        }
-
-        devCnt = 0;
-        gNfcDev.isTechInit = false;
-        gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_V;
-
-        err = rfalNfcvPollerCollisionResolution(
-            RFAL_COMPLIANCE_MODE_NFC,
-            (gNfcDev.disc.devLimit - gNfcDev.devCnt),
-            nfcvDevList,
-            &devCnt);
-        if((err == ERR_NONE) && (devCnt != 0U)) {
-            for(i = 0; i < devCnt;
-                i++) /* Copy devices found form local Nfcf list into global device list */
-            {
-                gNfcDev.devList[gNfcDev.devCnt].type = RFAL_NFC_LISTEN_TYPE_NFCV;
-                gNfcDev.devList[gNfcDev.devCnt].dev.nfcv = nfcvDevList[i];
-                gNfcDev.devCnt++;
-            }
-        }
-
-        return ERR_BUSY;
-    }
-#endif /* RFAL_FEATURE_NFCV */
-
-    /*******************************************************************************/
-    /* ST25TB Collision Resolution                                                 */
-    /*******************************************************************************/
-#if RFAL_FEATURE_ST25TB
-    if(((gNfcDev.techsFound & RFAL_NFC_POLL_TECH_ST25TB) != 0U) &&
-       ((gNfcDev.techs2do & RFAL_NFC_POLL_TECH_ST25TB) !=
-        0U)) /* If a ST25TB device was found/detected, perform Collision Resolution */
-    {
-        rfalSt25tbListenDevice st25tbDevList[RFAL_NFC_MAX_DEVICES];
-
-        if(!gNfcDev.isTechInit) {
-            EXIT_ON_ERR(err, rfalSt25tbPollerInitialize()); /* Initialize RFAL for ST25TB */
-            EXIT_ON_ERR(
-                err,
-                rfalFieldOnAndStartGT()); /* Ensure GT again as other technologies have also been polled */
-            gNfcDev.isTechInit = true;
-        }
-
-        if(!rfalIsGTExpired()) {
-            return ERR_BUSY;
-        }
-
-        devCnt = 0;
-        gNfcDev.isTechInit = false;
-        gNfcDev.techs2do &= ~RFAL_NFC_POLL_TECH_ST25TB;
-
-        err = rfalSt25tbPollerCollisionResolution(
-            (gNfcDev.disc.devLimit - gNfcDev.devCnt), st25tbDevList, &devCnt);
-        if((err == ERR_NONE) && (devCnt != 0U)) {
-            for(i = 0; i < devCnt;
-                i++) /* Copy devices found form local Nfcf list into global device list */
-            {
-                gNfcDev.devList[gNfcDev.devCnt].type = RFAL_NFC_LISTEN_TYPE_ST25TB;
-                gNfcDev.devList[gNfcDev.devCnt].dev.st25tb = st25tbDevList[i];
-                gNfcDev.devCnt++;
-            }
-        }
-
-        return ERR_BUSY;
-    }
-#endif /* RFAL_FEATURE_ST25TB */
-
-    return ERR_NONE; /* All technologies have been performed */
-}
-
-/*!
- ******************************************************************************
- * \brief Poller Activation
- * 
- * This method Activates a given device according to it's type and 
- * protocols supported
- *  
- * \param[in]  devIt : device's position on the list to be activated 
- * 
- * \return  ERR_NONE         : Operation completed with no error
- * \return  ERR_BUSY         : Operation ongoing
- * \return  ERR_XXXX         : Error occurred
- * 
- ******************************************************************************
- */
-static ReturnCode rfalNfcPollActivation(uint8_t devIt) {
-    ReturnCode err;
-
-    err = ERR_NONE;
-
-    /* Suppress warning when specific RFAL features have been disabled */
-    NO_WARNING(err);
-
-    if(devIt > gNfcDev.devCnt) {
-        return ERR_WRONG_STATE;
-    }
-
-    switch(gNfcDev.devList[devIt].type) {
-        /*******************************************************************************/
-        /* AP2P Activation                                                             */
-        /*******************************************************************************/
-#if RFAL_FEATURE_NFC_DEP
-    case RFAL_NFC_LISTEN_TYPE_AP2P:
-        /* Activation has already been performed (ATR_REQ) */
-
-        gNfcDev.devList[devIt].nfcid =
-            gNfcDev.devList[devIt].proto.nfcDep.activation.Target.ATR_RES.NFCID3;
-        gNfcDev.devList[devIt].nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
-        break;
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-        /*******************************************************************************/
-        /* Passive NFC-A Activation                                                    */
-        /*******************************************************************************/
-#if RFAL_FEATURE_NFCA
-    case RFAL_NFC_LISTEN_TYPE_NFCA:
-
-        if(!gNfcDev.isTechInit) {
-            rfalNfcaPollerInitialize();
-            gNfcDev.isTechInit = true;
-            gNfcDev.isOperOngoing = false;
-            return ERR_BUSY;
-        }
-
-        if(gNfcDev.devList[devIt].dev.nfca.isSleep) /* Check if desired device is in Sleep */
-        {
-            rfalNfcaSensRes sensRes;
-            rfalNfcaSelRes selRes;
-
-            if(!gNfcDev.isOperOngoing) {
-                /* Wake up all cards  */
-                EXIT_ON_ERR(
-                    err, rfalNfcaPollerCheckPresence(RFAL_14443A_SHORTFRAME_CMD_WUPA, &sensRes));
-                gNfcDev.isOperOngoing = true;
-            } else {
-                /* Select specific device */
-                EXIT_ON_ERR(
-                    err,
-                    rfalNfcaPollerSelect(
-                        gNfcDev.devList[devIt].dev.nfca.nfcId1,
-                        gNfcDev.devList[devIt].dev.nfca.nfcId1Len,
-                        &selRes));
-                gNfcDev.devList[devIt].dev.nfca.isSleep = false;
-                gNfcDev.isOperOngoing = false;
-            }
-            return ERR_BUSY;
-        }
-
-        /* Set NFCID */
-        gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.nfca.nfcId1;
-        gNfcDev.devList[devIt].nfcidLen = gNfcDev.devList[devIt].dev.nfca.nfcId1Len;
-
-        /*******************************************************************************/
-        /* Perform protocol specific activation                                        */
-        switch(gNfcDev.devList[devIt].dev.nfca.type) {
-        /*******************************************************************************/
-        case RFAL_NFCA_T1T:
-
-            /* No further activation needed for T1T (RID already performed) */
-
-            gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.nfca.ridRes.uid;
-            gNfcDev.devList[devIt].nfcidLen = RFAL_T1T_UID_LEN;
-
-            gNfcDev.devList[devIt].rfInterface = RFAL_NFC_INTERFACE_RF;
-            break;
-
-        case RFAL_NFCA_T2T:
-
-            /* No further activation needed for a T2T */
-
-            gNfcDev.devList[devIt].rfInterface = RFAL_NFC_INTERFACE_RF;
-            break;
-
-        /*******************************************************************************/
-        case RFAL_NFCA_T4T: /* Device supports ISO-DEP */
-
-#if RFAL_FEATURE_ISO_DEP && RFAL_FEATURE_ISO_DEP_POLL
-            if(!gNfcDev.isOperOngoing) {
-                /* Perform ISO-DEP (ISO14443-4) activation: RATS and PPS if supported */
-                rfalIsoDepInitialize();
-                EXIT_ON_ERR(
-                    err,
-                    rfalIsoDepPollAStartActivation(
-                        (rfalIsoDepFSxI)RFAL_ISODEP_FSDI_DEFAULT,
-                        RFAL_ISODEP_NO_DID,
-                        gNfcDev.disc.maxBR,
-                        &gNfcDev.devList[devIt].proto.isoDep));
-
-                gNfcDev.isOperOngoing = true;
-                return ERR_BUSY;
-            }
-
-            err = rfalIsoDepPollAGetActivationStatus();
-            if(err != ERR_NONE) {
-                return err;
-            }
-
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_ISODEP; /* NFC-A T4T device activated */
-#else
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_RF; /* No ISO-DEP supported activate using RF interface */
-#endif /* RFAL_FEATURE_ISO_DEP_POLL */
-            break;
-
-        /*******************************************************************************/
-        case RFAL_NFCA_T4T_NFCDEP: /* Device supports both T4T and NFC-DEP */
-        case RFAL_NFCA_NFCDEP: /* Device supports NFC-DEP */
-
-#if RFAL_FEATURE_NFC_DEP
-            /* Perform NFC-DEP (P2P) activation: ATR and PSL if supported */
-            EXIT_ON_ERR(
-                err,
-                rfalNfcNfcDepActivate(&gNfcDev.devList[devIt], RFAL_NFCDEP_COMM_PASSIVE, NULL, 0));
-
-            gNfcDev.devList[devIt].nfcid =
-                gNfcDev.devList[devIt].proto.nfcDep.activation.Target.ATR_RES.NFCID3;
-            gNfcDev.devList[devIt].nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
-
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_NFCDEP; /* NFC-A P2P device activated */
-#else
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_RF; /* No NFC-DEP supported activate using RF interface */
-#endif /* RFAL_FEATURE_NFC_DEP */
-            break;
-
-        /*******************************************************************************/
-        default:
-            return ERR_WRONG_STATE;
-        }
-        break;
-#endif /* RFAL_FEATURE_NFCA */
-
-        /*******************************************************************************/
-        /* Passive NFC-B Activation                                                    */
-        /*******************************************************************************/
-#if RFAL_FEATURE_NFCB
-    case RFAL_NFC_LISTEN_TYPE_NFCB:
-
-        if(!gNfcDev.isTechInit) {
-            rfalNfcbPollerInitialize();
-            gNfcDev.isTechInit = true;
-            gNfcDev.isOperOngoing = false;
-            return ERR_BUSY;
-        }
-
-        if(gNfcDev.devList[devIt].dev.nfcb.isSleep) /* Check if desired device is in Sleep */
-        {
-            rfalNfcbSensbRes sensbRes;
-            uint8_t sensbResLen;
-
-            /* Wake up all cards. SENSB_RES may return collision but the NFCID0 is available to explicitly select NFC-B card via ATTRIB; so error will be ignored here */
-            rfalNfcbPollerCheckPresence(
-                RFAL_NFCB_SENS_CMD_ALLB_REQ, RFAL_NFCB_SLOT_NUM_1, &sensbRes, &sensbResLen);
-        }
-
-        /* Set NFCID */
-        gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.nfcb.sensbRes.nfcid0;
-        gNfcDev.devList[devIt].nfcidLen = RFAL_NFCB_NFCID0_LEN;
-
-#if RFAL_FEATURE_ISO_DEP && RFAL_FEATURE_ISO_DEP_POLL
-        /* Check if device supports  ISO-DEP (ISO14443-4) */
-        if((gNfcDev.devList[devIt].dev.nfcb.sensbRes.protInfo.FsciProType &
-            RFAL_NFCB_SENSB_RES_PROTO_ISO_MASK) != 0U) {
-            if(!gNfcDev.isOperOngoing) {
-                rfalIsoDepInitialize();
-                /* Perform ISO-DEP (ISO14443-4) activation: ATTRIB    */
-                EXIT_ON_ERR(
-                    err,
-                    rfalIsoDepPollBStartActivation(
-                        (rfalIsoDepFSxI)RFAL_ISODEP_FSDI_DEFAULT,
-                        RFAL_ISODEP_NO_DID,
-                        gNfcDev.disc.maxBR,
-                        0x00,
-                        &gNfcDev.devList[devIt].dev.nfcb,
-                        NULL,
-                        0,
-                        &gNfcDev.devList[devIt].proto.isoDep));
-
-                gNfcDev.isOperOngoing = true;
-                return ERR_BUSY;
-            }
-
-            err = rfalIsoDepPollBGetActivationStatus();
-            if(err != ERR_NONE) {
-                return err;
-            }
-
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_ISODEP; /* NFC-B T4T device activated */
-            break;
-        }
-
-#endif /* RFAL_FEATURE_ISO_DEP_POLL */
-
-        gNfcDev.devList[devIt].rfInterface =
-            RFAL_NFC_INTERFACE_RF; /* NFC-B device activated     */
-        break;
-
-#endif /* RFAL_FEATURE_NFCB */
-
-        /*******************************************************************************/
-        /* Passive NFC-F Activation                                                    */
-        /*******************************************************************************/
-#if RFAL_FEATURE_NFCF
-    case RFAL_NFC_LISTEN_TYPE_NFCF:
-
-        rfalNfcfPollerInitialize(gNfcDev.disc.nfcfBR);
-
-#if RFAL_FEATURE_NFC_DEP
-        if(rfalNfcfIsNfcDepSupported(&gNfcDev.devList[devIt].dev.nfcf)) {
-            /* Perform NFC-DEP (P2P) activation: ATR and PSL if supported */
-            EXIT_ON_ERR(
-                err,
-                rfalNfcNfcDepActivate(&gNfcDev.devList[devIt], RFAL_NFCDEP_COMM_PASSIVE, NULL, 0));
-
-            /* Set NFCID */
-            gNfcDev.devList[devIt].nfcid =
-                gNfcDev.devList[devIt].proto.nfcDep.activation.Target.ATR_RES.NFCID3;
-            gNfcDev.devList[devIt].nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
-
-            gNfcDev.devList[devIt].rfInterface =
-                RFAL_NFC_INTERFACE_NFCDEP; /* NFC-F P2P device activated */
-            break;
-        }
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-        /* Set NFCID */
-        gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.nfcf.sensfRes.NFCID2;
-        gNfcDev.devList[devIt].nfcidLen = RFAL_NFCF_NFCID2_LEN;
-
-        gNfcDev.devList[devIt].rfInterface =
-            RFAL_NFC_INTERFACE_RF; /* NFC-F T3T device activated */
-        break;
-#endif /* RFAL_FEATURE_NFCF */
-
-        /*******************************************************************************/
-        /* Passive NFC-V Activation                                                    */
-        /*******************************************************************************/
-#if RFAL_FEATURE_NFCV
-    case RFAL_NFC_LISTEN_TYPE_NFCV:
-
-        rfalNfcvPollerInitialize();
-
-        /* No specific activation needed for a T5T */
-
-        /* Set NFCID */
-        gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.nfcv.InvRes.UID;
-        gNfcDev.devList[devIt].nfcidLen = RFAL_NFCV_UID_LEN;
-
-        gNfcDev.devList[devIt].rfInterface =
-            RFAL_NFC_INTERFACE_RF; /* NFC-V T5T device activated */
-        break;
-#endif /* RFAL_FEATURE_NFCV */
-
-        /*******************************************************************************/
-        /* Passive ST25TB Activation                                                   */
-        /*******************************************************************************/
-#if RFAL_FEATURE_ST25TB
-    case RFAL_NFC_LISTEN_TYPE_ST25TB:
-
-        rfalSt25tbPollerInitialize();
-
-        /* No specific activation needed for a ST25TB */
-
-        /* Set NFCID */
-        gNfcDev.devList[devIt].nfcid = gNfcDev.devList[devIt].dev.st25tb.UID;
-        gNfcDev.devList[devIt].nfcidLen = RFAL_ST25TB_UID_LEN;
-
-        gNfcDev.devList[devIt].rfInterface = RFAL_NFC_INTERFACE_RF; /* ST25TB device activated */
-        break;
-#endif /* RFAL_FEATURE_ST25TB */
-
-    /*******************************************************************************/
-    default:
-        return ERR_WRONG_STATE;
-    }
-
-    gNfcDev.activeDev = &gNfcDev.devList[devIt]; /* Assign active device to be used further on */
-    return ERR_NONE;
-}
-
-/*!
- ******************************************************************************
- * \brief Listener Activation
- * 
- * This method handles the listen mode Activation according to the different 
- * protocols the Reader/Initiator performs
- * 
- * \return  ERR_NONE   : Operation completed with no error
- * \return  ERR_BUSY   : Operation ongoing
- * \return  ERR_PROTO  : Unexpected frame received
- * \return  ERR_XXXX   : Error occurred
- * 
- ******************************************************************************
- */
-#if RFAL_FEATURE_LISTEN_MODE
-static ReturnCode rfalNfcListenActivation(void) {
-    bool isDataRcvd;
-    ReturnCode ret;
-    rfalLmState lmSt;
-    rfalBitRate bitRate;
-#if RFAL_FEATURE_NFC_DEP
-    uint8_t hdrLen;
-
-    /* Set the header length in NFC-A */
-    hdrLen = (RFAL_NFCDEP_SB_LEN + RFAL_NFCDEP_LEN_LEN);
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-    lmSt = rfalListenGetState(&isDataRcvd, &bitRate);
-
-    switch(lmSt) {
-#if RFAL_FEATURE_NFCA
-    /*******************************************************************************/
-    case RFAL_LM_STATE_ACTIVE_A: /* NFC-A CE activation */
-    case RFAL_LM_STATE_ACTIVE_Ax:
-
-        if(isDataRcvd) /* Check if Reader/Initator has sent some data */
-        {
-            /* Check if received data is a Sleep request */
-            if(rfalNfcaListenerIsSleepReq(
-                   gNfcDev.rxBuf.rfBuf,
-                   rfalConvBitsToBytes(gNfcDev.rxLen))) /* Check if received data is a SLP_REQ */
-            {
-                /* Set the Listen Mode in Sleep state */
-                EXIT_ON_ERR(
-                    ret,
-                    rfalListenSleepStart(
-                        RFAL_LM_STATE_SLEEP_A,
-                        gNfcDev.rxBuf.rfBuf,
-                        sizeof(gNfcDev.rxBuf.rfBuf),
-                        &gNfcDev.rxLen));
-            }
-
-            else if(gNfcDev.disc.activate_after_sak) {
-                gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_NFCA;
-                rfalListenSetState(RFAL_LM_STATE_ACTIVE_A);
-                return ERR_NONE;
-            }
-#if RFAL_FEATURE_ISO_DEP && RFAL_FEATURE_ISO_DEP_LISTEN
-            /* Check if received data is a valid RATS */
-            else if(rfalIsoDepIsRats(
-                        gNfcDev.rxBuf.rfBuf, (uint8_t)rfalConvBitsToBytes(gNfcDev.rxLen))) {
-                rfalIsoDepAtsParam atsParam;
-                rfalIsoDepListenActvParam rxParam;
-
-                /* Set ATS parameters */
-                atsParam.fsci = (uint8_t)RFAL_ISODEP_DEFAULT_FSCI;
-                atsParam.fwi = RFAL_ISODEP_DEFAULT_FWI;
-                atsParam.sfgi = RFAL_ISODEP_DEFAULT_SFGI;
-                atsParam.didSupport = false;
-                atsParam.ta = RFAL_ISODEP_ATS_TA_SAME_D;
-                atsParam.hb = NULL;
-                atsParam.hbLen = 0;
-
-                /* Set Rx parameters */
-                rxParam.rxBuf =
-                    (rfalIsoDepBufFormat*)&gNfcDev.rxBuf
-                        .isoDepBuf; /*  PRQA S 0310 # MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication */
-                rxParam.rxLen = &gNfcDev.rxLen;
-                rxParam.isoDepDev = &gNfcDev.devList->proto.isoDep;
-                rxParam.isRxChaining = &gNfcDev.isRxChaining;
-
-                rfalListenSetState(RFAL_LM_STATE_CARDEMU_4A); /* Set next state CE T4T */
-                rfalIsoDepInitialize(); /* Initialize ISO-DEP layer to handle ISO14443-a activation / RATS */
-
-                /* Set ISO-DEP layer to digest RATS and handle activation */
-                EXIT_ON_ERR(
-                    ret,
-                    rfalIsoDepListenStartActivation(
-                        &atsParam, NULL, gNfcDev.rxBuf.rfBuf, gNfcDev.rxLen, rxParam));
-            }
-#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */
-
-#if RFAL_FEATURE_NFC_DEP
-
-            /* Check if received data is a valid ATR_REQ */
-            else if(rfalNfcDepIsAtrReq(
-                        &gNfcDev.rxBuf.rfBuf[hdrLen],
-                        (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen),
-                        gNfcDev.devList->nfcid)) {
-                gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_NFCA;
-                EXIT_ON_ERR(
-                    ret,
-                    rfalNfcNfcDepActivate(
-                        gNfcDev.devList,
-                        RFAL_NFCDEP_COMM_PASSIVE,
-                        &gNfcDev.rxBuf.rfBuf[hdrLen],
-                        (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen)));
-            }
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-            else {
-                return ERR_PROTO;
-            }
-        }
-        return ERR_BUSY;
-
-#endif /* RFAL_FEATURE_NFCA */
-
-#if RFAL_FEATURE_ISO_DEP && RFAL_FEATURE_ISO_DEP_LISTEN
-    /*******************************************************************************/
-    case RFAL_LM_STATE_CARDEMU_4A: /* T4T ISO-DEP activation */
-
-        ret = rfalIsoDepListenGetActivationStatus();
-        if(ret == ERR_NONE) {
-            gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_NFCA;
-            gNfcDev.devList->rfInterface = RFAL_NFC_INTERFACE_ISODEP;
-            gNfcDev.devList->nfcid = NULL;
-            gNfcDev.devList->nfcidLen = 0;
-        }
-        return ret;
-#endif /* RFAL_FEATURE_ISO_DEP_LISTEN */
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_READY_F: /* NFC-F CE activation */
-
-        if(isDataRcvd) /* Wait for the first received data */
-        {
-#if RFAL_FEATURE_NFC_DEP
-            /* Set the header length in NFC-F */
-            hdrLen = RFAL_NFCDEP_LEN_LEN;
-
-            if(rfalNfcDepIsAtrReq(
-                   &gNfcDev.rxBuf.rfBuf[hdrLen],
-                   (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen),
-                   gNfcDev.devList->nfcid)) {
-                gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_NFCF;
-                EXIT_ON_ERR(
-                    ret,
-                    rfalNfcNfcDepActivate(
-                        gNfcDev.devList,
-                        RFAL_NFCDEP_COMM_PASSIVE,
-                        &gNfcDev.rxBuf.rfBuf[hdrLen],
-                        (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen)));
-            } else
-#endif /* RFAL_FEATURE_NFC_DEP */
-            {
-                rfalListenSetState(
-                    RFAL_LM_STATE_CARDEMU_3); /* First data already received - set T3T CE */
-            }
-        }
-        return ERR_BUSY;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_CARDEMU_3: /* T3T activated */
-
-        gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_NFCF;
-        gNfcDev.devList->rfInterface = RFAL_NFC_INTERFACE_RF;
-        gNfcDev.devList->nfcid = NULL;
-        gNfcDev.devList->nfcidLen = 0;
-
-        return ERR_NONE;
-
-#if RFAL_FEATURE_NFC_DEP
-    /*******************************************************************************/
-    case RFAL_LM_STATE_TARGET_A: /* NFC-DEP activation */
-    case RFAL_LM_STATE_TARGET_F:
-
-        ret = rfalNfcDepListenGetActivationStatus();
-        if(ret == ERR_NONE) {
-            gNfcDev.devList->rfInterface = RFAL_NFC_INTERFACE_NFCDEP;
-            gNfcDev.devList->nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
-        }
-        return ret;
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_IDLE: /* AP2P activation */
-        if(isDataRcvd) /* Check if Reader/Initator has sent some data */
-        {
-            if((gNfcDev.lmMask & RFAL_LM_MASK_ACTIVE_P2P) != 0U) /* Check if AP2P is enabled */
-            {
-#if RFAL_FEATURE_NFC_DEP
-                /* Calculate the header length in NFC-A or NFC-F mode*/
-                hdrLen =
-                    ((bitRate == RFAL_BR_106) ? (RFAL_NFCDEP_SB_LEN + RFAL_NFCDEP_LEN_LEN) :
-                                                RFAL_NFCDEP_LEN_LEN);
-
-                if(rfalNfcDepIsAtrReq(
-                       &gNfcDev.rxBuf.rfBuf[hdrLen],
-                       (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen),
-                       NULL)) {
-                    gNfcDev.devList->type = RFAL_NFC_POLL_TYPE_AP2P;
-                    rfalSetMode((RFAL_MODE_LISTEN_ACTIVE_P2P), bitRate, bitRate);
-                    EXIT_ON_ERR(
-                        ret,
-                        rfalNfcNfcDepActivate(
-                            gNfcDev.devList,
-                            RFAL_NFCDEP_COMM_ACTIVE,
-                            &gNfcDev.rxBuf.rfBuf[hdrLen],
-                            (rfalConvBitsToBytes(gNfcDev.rxLen) - hdrLen)));
-                } else
-#endif /* RFAL_FEATURE_NFC_DEP */
-                {
-                    return ERR_PROTO;
-                }
-            }
-        }
-        return ERR_BUSY;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_READY_A:
-    case RFAL_LM_STATE_READY_Ax:
-    case RFAL_LM_STATE_SLEEP_A:
-    case RFAL_LM_STATE_SLEEP_AF:
-        return ERR_BUSY;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_POWER_OFF:
-        return ERR_LINK_LOSS;
-
-    default: /* Wait for activation */
-        break;
-    }
-
-    return ERR_INTERNAL;
-}
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-/*!
- ******************************************************************************
- * \brief Poller NFC DEP Activate
- * 
- * This method performs NFC-DEP Activation 
- *  
- * \param[in]  device    : device info
- * \param[in]  commMode  : communication mode (Passive/Active)
- * \param[in]  atrReq    : received ATR_REQ
- * \param[in]  atrReqLen : received ATR_REQ size
- * 
- * \return  ERR_NONE     : Operation completed with no error
- * \return  ERR_BUSY     : Operation ongoing
- * \return  ERR_XXXX     : Error occurred
- * 
- ******************************************************************************
- */
-#if RFAL_FEATURE_NFC_DEP
-static ReturnCode rfalNfcNfcDepActivate(
-    rfalNfcDevice* device,
-    rfalNfcDepCommMode commMode,
-    const uint8_t* atrReq,
-    uint16_t atrReqLen) {
-    rfalNfcDepAtrParam initParam;
-
-    /* Suppress warnings if Listen mode is disabled */
-    NO_WARNING(atrReq);
-    NO_WARNING(atrReqLen);
-
-    /* If we are in Poll mode */
-    if(rfalNfcIsRemDevListener(device->type)) {
-        /*******************************************************************************/
-        /* If Passive F use the NFCID2 retrieved from SENSF                            */
-        if(device->type == RFAL_NFC_LISTEN_TYPE_NFCF) {
-            initParam.nfcid = device->dev.nfcf.sensfRes.NFCID2;
-            initParam.nfcidLen = RFAL_NFCF_NFCID2_LEN;
-        } else {
-            initParam.nfcid = gNfcDev.disc.nfcid3;
-            initParam.nfcidLen = RFAL_NFCDEP_NFCID3_LEN;
-        }
-
-        initParam.BS = RFAL_NFCDEP_Bx_NO_HIGH_BR;
-        initParam.BR = RFAL_NFCDEP_Bx_NO_HIGH_BR;
-        initParam.DID = RFAL_NFCDEP_DID_NO;
-        initParam.NAD = RFAL_NFCDEP_NAD_NO;
-        initParam.LR = RFAL_NFCDEP_LR_254;
-        initParam.GB = gNfcDev.disc.GB;
-        initParam.GBLen = gNfcDev.disc.GBLen;
-        initParam.commMode = commMode;
-        initParam.operParam =
-            (RFAL_NFCDEP_OPER_FULL_MI_EN | RFAL_NFCDEP_OPER_EMPTY_DEP_DIS |
-             RFAL_NFCDEP_OPER_ATN_EN | RFAL_NFCDEP_OPER_RTOX_REQ_EN);
-
-        rfalNfcDepInitialize();
-        /* Perform NFC-DEP (P2P) activation: ATR and PSL if supported */
-        return rfalNfcDepInitiatorHandleActivation(
-            &initParam, gNfcDev.disc.maxBR, &device->proto.nfcDep);
-    }
-    /* If we are in Listen mode */
-#if RFAL_FEATURE_LISTEN_MODE
-    else if(rfalNfcIsRemDevPoller(device->type)) {
-        rfalNfcDepListenActvParam actvParams;
-        rfalNfcDepTargetParam targetParam;
-
-        ST_MEMCPY(targetParam.nfcid3, (uint8_t*)gNfcDev.disc.nfcid3, RFAL_NFCDEP_NFCID3_LEN);
-        targetParam.bst = RFAL_NFCDEP_Bx_NO_HIGH_BR;
-        targetParam.brt = RFAL_NFCDEP_Bx_NO_HIGH_BR;
-        targetParam.to = RFAL_NFCDEP_WT_TRG_MAX_L13; /* [LLCP] 1.3 6.2.1 */
-        targetParam.ppt = rfalNfcDepLR2PP(RFAL_NFCDEP_LR_254);
-        if(gNfcDev.disc.GBLen >= RFAL_NFCDEP_GB_MAX_LEN) {
-            return ERR_PARAM;
-        }
-        targetParam.GBtLen = gNfcDev.disc.GBLen;
-        if(gNfcDev.disc.GBLen > 0U) {
-            ST_MEMCPY(targetParam.GBt, gNfcDev.disc.GB, gNfcDev.disc.GBLen);
-        }
-        targetParam.operParam =
-            (RFAL_NFCDEP_OPER_FULL_MI_EN | RFAL_NFCDEP_OPER_EMPTY_DEP_DIS |
-             RFAL_NFCDEP_OPER_ATN_EN | RFAL_NFCDEP_OPER_RTOX_REQ_EN);
-        targetParam.commMode = commMode;
-
-        /* Set activation buffer (including header) for NFC-DEP */
-        actvParams.rxBuf =
-            (rfalNfcDepBufFormat*)&gNfcDev.rxBuf
-                .nfcDepBuf; /*  PRQA S 0310 # MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication */
-        actvParams.rxLen = &gNfcDev.rxLen;
-        actvParams.isRxChaining = &gNfcDev.isRxChaining;
-        actvParams.nfcDepDev = &gNfcDev.devList->proto.nfcDep;
-
-        rfalListenSetState(
-            ((device->type == RFAL_NFC_POLL_TYPE_NFCA) ? RFAL_LM_STATE_TARGET_A :
-                                                         RFAL_LM_STATE_TARGET_F));
-
-        rfalNfcDepInitialize();
-        /* Perform NFC-DEP (P2P) activation: send ATR_RES and handle activation */
-        return rfalNfcDepListenStartActivation(&targetParam, atrReq, atrReqLen, actvParams);
-    }
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-    else {
-        return ERR_INTERNAL;
-    }
-}
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-/*!
- ******************************************************************************
- * \brief Poller NFC Deactivate
- * 
- * This method Deactivates the device if a deactivation procedure exists 
- * 
- * \return  ERR_NONE  : Operation completed with no error
- * \return  ERR_BUSY  : Operation ongoing
- * \return  ERR_XXXX  : Error occurred
- * 
- ******************************************************************************
- */
-static ReturnCode rfalNfcDeactivation(void) {
-    /* Check if a device has been activated */
-    if(gNfcDev.activeDev != NULL) {
-        if(rfalNfcIsRemDevListener(
-               gNfcDev.activeDev->type)) /* Listen mode no additional deactivation to be performed*/
-        {
-#ifndef RFAL_NFC_SKIP_DEACT
-            switch(gNfcDev.activeDev->rfInterface) {
-            /*******************************************************************************/
-            case RFAL_NFC_INTERFACE_RF:
-                break; /* No specific deactivation to be performed */
-
-                /*******************************************************************************/
-#if RFAL_FEATURE_ISO_DEP && RFAL_FEATURE_ISO_DEP_POLL
-            case RFAL_NFC_INTERFACE_ISODEP:
-                rfalIsoDepDeselect(); /* Send a Deselect to device */
-                break;
-#endif /* RFAL_FEATURE_ISO_DEP_POLL */
-
-                /*******************************************************************************/
-#if RFAL_FEATURE_NFC_DEP
-            case RFAL_NFC_INTERFACE_NFCDEP:
-                switch(gNfcDev.activeDev->type) {
-                case RFAL_NFC_LISTEN_TYPE_AP2P:
-                    rfalNfcDepRLS(); /* Send a Release to device */
-                    break;
-                default:
-                    rfalNfcDepDSL(); /* Send a Deselect to device */
-                    break;
-                }
-                break;
-#endif /* RFAL_FEATURE_NFC_DEP */
-
-            default:
-                return ERR_REQUEST;
-            }
-#endif /* RFAL_NFC_SKIP_DEACT */
-        }
-    }
-
-#if RFAL_FEATURE_WAKEUP_MODE
-    rfalWakeUpModeStop();
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-#if RFAL_FEATURE_LISTEN_MODE
-    rfalListenStop();
-#else
-    rfalFieldOff();
-#endif
-
-    gNfcDev.activeDev = NULL;
-    return ERR_NONE;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfcDep.c

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

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfca.c

@@ -1,891 +0,0 @@
-
-/******************************************************************************
-  * \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 */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfcb.c

@@ -1,519 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcb.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-B (ISO14443B) helpers 
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_nfcb.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_NFCB
-#define RFAL_FEATURE_NFCB false /* NFC-B module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_NFCB
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCB_SENSB_REQ_EXT_SENSB_RES_SUPPORTED \
-    0x10U /*!< Bit mask for Extended SensB Response support in SENSB_REQ */
-#define RFAL_NFCB_SENSB_RES_PROT_TYPE_RFU \
-    0x08U /*!< Bit mask for Protocol Type RFU in SENSB_RES               */
-#define RFAL_NFCB_SLOT_MARKER_SC_SHIFT \
-    4U /*!< Slot Code position on SLOT_MARKER APn                     */
-
-#define RFAL_NFCB_SLOTMARKER_SLOTCODE_MIN \
-    1U /*!< SLOT_MARKER Slot Code minimum   Digital 1.1  Table 37     */
-#define RFAL_NFCB_SLOTMARKER_SLOTCODE_MAX \
-    16U /*!< SLOT_MARKER Slot Code maximum   Digital 1.1  Table 37     */
-
-#define RFAL_NFCB_ACTIVATION_FWT \
-    (RFAL_NFCB_FWTSENSB + RFAL_NFCB_DTPOLL_20) /*!< FWT(SENSB) + dTbPoll  Digital 2.0  7.9.1.3  */
-
-/*! Advanced and Extended bit mask in Parameter of SENSB_REQ */
-#define RFAL_NFCB_SENSB_REQ_PARAM \
-    (RFAL_NFCB_SENSB_REQ_ADV_FEATURE | RFAL_NFCB_SENSB_REQ_EXT_SENSB_RES_SUPPORTED)
-
-/*! NFC-B commands definition */
-enum {
-    RFAL_NFCB_CMD_SENSB_REQ = 0x05, /*!< SENSB_REQ (REQB) & SLOT_MARKER  Digital 1.1 Table 24 */
-    RFAL_NFCB_CMD_SENSB_RES = 0x50, /*!< SENSB_RES (ATQB) & SLOT_MARKER  Digital 1.1 Table 27 */
-    RFAL_NFCB_CMD_SLPB_REQ = 0x50, /*!< SLPB_REQ (HLTB command)  Digital 1.1 Table 38        */
-    RFAL_NFCB_CMD_SLPB_RES = 0x00 /*!< SLPB_RES (HLTB Answer)   Digital 1.1 Table 39        */
-};
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-#define rfalNfcbNI2NumberOfSlots(ni) \
-    (uint8_t)(1U << (ni)) /*!< Converts the Number of slots Identifier to slot number */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! ALLB_REQ (WUPB) and SENSB_REQ (REQB) Command Format   Digital 1.1  7.6.1 */
-typedef struct {
-    uint8_t cmd; /*!< xxxxB_REQ: 05h       */
-    uint8_t AFI; /*!< NFC Identifier       */
-    uint8_t PARAM; /*!< Application Data     */
-} rfalNfcbSensbReq;
-
-/*! SLOT_MARKER Command format  Digital 1.1  7.7.1 */
-typedef struct {
-    uint8_t APn; /*!< Slot number 2..16 | 0101b */
-} rfalNfcbSlotMarker;
-
-/*! SLPB_REQ (HLTB) Command Format   Digital 1.1  7.8.1 */
-typedef struct {
-    uint8_t cmd; /*!< SLPB_REQ: 50h        */
-    uint8_t nfcid0[RFAL_NFCB_NFCID0_LEN]; /*!< NFC Identifier (PUPI)*/
-} rfalNfcbSlpbReq;
-
-/*! SLPB_RES (HLTB) Response Format   Digital 1.1  7.8.2 */
-typedef struct {
-    uint8_t cmd; /*!< SLPB_RES: 00h        */
-} rfalNfcbSlpbRes;
-
-/*! RFAL NFC-B instance */
-typedef struct {
-    uint8_t AFI; /*!< AFI to be used       */
-    uint8_t PARAM; /*!< PARAM to be used     */
-} rfalNfcb;
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static ReturnCode rfalNfcbCheckSensbRes(const rfalNfcbSensbRes* sensbRes, uint8_t sensbResLen);
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-static rfalNfcb gRfalNfcb; /*!< RFAL NFC-B Instance */
-
-/*
-******************************************************************************
-* LOCAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-static ReturnCode rfalNfcbCheckSensbRes(const rfalNfcbSensbRes* sensbRes, uint8_t sensbResLen) {
-    /* Check response length */
-    if(((sensbResLen != RFAL_NFCB_SENSB_RES_LEN) &&
-        (sensbResLen != RFAL_NFCB_SENSB_RES_EXT_LEN))) {
-        return ERR_PROTO;
-    }
-
-    /* Check SENSB_RES and Protocol Type   Digital 1.1 7.6.2.19 */
-    if(((sensbRes->protInfo.FsciProType & RFAL_NFCB_SENSB_RES_PROT_TYPE_RFU) != 0U) ||
-       (sensbRes->cmd != (uint8_t)RFAL_NFCB_CMD_SENSB_RES)) {
-        return ERR_PROTO;
-    }
-    return ERR_NONE;
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerInitialize(void) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(ret, rfalSetMode(RFAL_MODE_POLL_NFCB, RFAL_BR_106, RFAL_BR_106));
-    rfalSetErrorHandling(RFAL_ERRORHANDLING_NFC);
-
-    rfalSetGT(RFAL_GT_NFCB);
-    rfalSetFDTListen(RFAL_FDT_LISTEN_NFCB_POLLER);
-    rfalSetFDTPoll(RFAL_FDT_POLL_NFCB_POLLER);
-
-    gRfalNfcb.AFI = RFAL_NFCB_AFI;
-    gRfalNfcb.PARAM = RFAL_NFCB_PARAM;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerInitializeWithParams(uint8_t AFI, uint8_t PARAM) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(ret, rfalNfcbPollerInitialize());
-
-    gRfalNfcb.AFI = AFI;
-    gRfalNfcb.PARAM = (PARAM & RFAL_NFCB_SENSB_REQ_PARAM);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerCheckPresence(
-    rfalNfcbSensCmd cmd,
-    rfalNfcbSlots slots,
-    rfalNfcbSensbRes* sensbRes,
-    uint8_t* sensbResLen) {
-    uint16_t rxLen;
-    ReturnCode ret;
-    rfalNfcbSensbReq sensbReq;
-
-    /* Check if the command requested and given the slot number are valid */
-    if(((RFAL_NFCB_SENS_CMD_SENSB_REQ != cmd) && (RFAL_NFCB_SENS_CMD_ALLB_REQ != cmd)) ||
-       (slots > RFAL_NFCB_SLOT_NUM_16) || (sensbRes == NULL) || (sensbResLen == NULL)) {
-        return ERR_PARAM;
-    }
-
-    *sensbResLen = 0;
-    ST_MEMSET(sensbRes, 0x00, sizeof(rfalNfcbSensbRes));
-
-    /* Compute SENSB_REQ */
-    sensbReq.cmd = RFAL_NFCB_CMD_SENSB_REQ;
-    sensbReq.AFI = gRfalNfcb.AFI;
-    sensbReq.PARAM =
-        (((uint8_t)gRfalNfcb.PARAM & RFAL_NFCB_SENSB_REQ_PARAM) | (uint8_t)cmd | (uint8_t)slots);
-
-    /* Send SENSB_REQ and disable AGC to detect collisions */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&sensbReq,
-        sizeof(rfalNfcbSensbReq),
-        (uint8_t*)sensbRes,
-        sizeof(rfalNfcbSensbRes),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCB_FWTSENSB);
-
-    *sensbResLen = (uint8_t)rxLen;
-
-    /*  Check if a transmission error was detected */
-    if((ret == ERR_CRC) || (ret == ERR_FRAMING)) {
-        /* Invalidate received frame as an error was detected (CollisionResolution checks if valid) */
-        *sensbResLen = 0;
-        return ERR_NONE;
-    }
-
-    if(ret == ERR_NONE) {
-        return rfalNfcbCheckSensbRes(sensbRes, *sensbResLen);
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerSleep(const uint8_t* nfcid0) {
-    uint16_t rxLen;
-    ReturnCode ret;
-    rfalNfcbSlpbReq slpbReq;
-    rfalNfcbSlpbRes slpbRes;
-
-    if(nfcid0 == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Compute SLPB_REQ */
-    slpbReq.cmd = RFAL_NFCB_CMD_SLPB_REQ;
-    ST_MEMCPY(slpbReq.nfcid0, nfcid0, RFAL_NFCB_NFCID0_LEN);
-
-    EXIT_ON_ERR(
-        ret,
-        rfalTransceiveBlockingTxRx(
-            (uint8_t*)&slpbReq,
-            sizeof(rfalNfcbSlpbReq),
-            (uint8_t*)&slpbRes,
-            sizeof(rfalNfcbSlpbRes),
-            &rxLen,
-            RFAL_TXRX_FLAGS_DEFAULT,
-            RFAL_NFCB_ACTIVATION_FWT));
-
-    /* Check SLPB_RES */
-    if((rxLen != sizeof(rfalNfcbSlpbRes)) || (slpbRes.cmd != (uint8_t)RFAL_NFCB_CMD_SLPB_RES)) {
-        return ERR_PROTO;
-    }
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode
-    rfalNfcbPollerSlotMarker(uint8_t slotCode, rfalNfcbSensbRes* sensbRes, uint8_t* sensbResLen) {
-    ReturnCode ret;
-    rfalNfcbSlotMarker slotMarker;
-    uint16_t rxLen;
-
-    /* Check parameters */
-    if((sensbRes == NULL) || (sensbResLen == NULL) ||
-       (slotCode < RFAL_NFCB_SLOTMARKER_SLOTCODE_MIN) ||
-       (slotCode > RFAL_NFCB_SLOTMARKER_SLOTCODE_MAX)) {
-        return ERR_PARAM;
-    }
-    /* Compose and send SLOT_MARKER with disabled AGC to detect collisions  */
-    slotMarker.APn =
-        ((slotCode << RFAL_NFCB_SLOT_MARKER_SC_SHIFT) | (uint8_t)RFAL_NFCB_CMD_SENSB_REQ);
-
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&slotMarker,
-        sizeof(rfalNfcbSlotMarker),
-        (uint8_t*)sensbRes,
-        sizeof(rfalNfcbSensbRes),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCB_ACTIVATION_FWT);
-
-    *sensbResLen = (uint8_t)rxLen;
-
-    /* Check if a transmission error was detected */
-    if((ret == ERR_CRC) || (ret == ERR_FRAMING)) {
-        return ERR_RF_COLLISION;
-    }
-
-    if(ret == ERR_NONE) {
-        return rfalNfcbCheckSensbRes(sensbRes, *sensbResLen);
-    }
-
-    return ret;
-}
-
-ReturnCode rfalNfcbPollerTechnologyDetection(
-    rfalComplianceMode compMode,
-    rfalNfcbSensbRes* sensbRes,
-    uint8_t* sensbResLen) {
-    NO_WARNING(compMode);
-
-    return rfalNfcbPollerCheckPresence(
-        RFAL_NFCB_SENS_CMD_SENSB_REQ, RFAL_NFCB_SLOT_NUM_1, sensbRes, sensbResLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcbListenDevice* nfcbDevList,
-    uint8_t* devCnt) {
-    bool colPending; /* dummy */
-    return rfalNfcbPollerSlottedCollisionResolution(
-        compMode,
-        devLimit,
-        RFAL_NFCB_SLOT_NUM_1,
-        RFAL_NFCB_SLOT_NUM_16,
-        nfcbDevList,
-        devCnt,
-        &colPending);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcbPollerSlottedCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcbSlots initSlots,
-    rfalNfcbSlots endSlots,
-    rfalNfcbListenDevice* nfcbDevList,
-    uint8_t* devCnt,
-    bool* colPending) {
-    ReturnCode ret;
-    uint8_t slotsNum;
-    uint8_t slotCode;
-    uint8_t curDevCnt;
-
-    /* Check parameters. In ISO | Activity 1.0 mode the initial slots must be 1 as continuation of Technology Detection */
-    if((nfcbDevList == NULL) || (devCnt == NULL) || (colPending == NULL) ||
-       (initSlots > RFAL_NFCB_SLOT_NUM_16) || (endSlots > RFAL_NFCB_SLOT_NUM_16) ||
-       ((compMode == RFAL_COMPLIANCE_MODE_ISO) && (initSlots != RFAL_NFCB_SLOT_NUM_1))) {
-        return ERR_PARAM;
-    }
-
-    /* Initialise as no error in case Activity 1.0 where the previous SENSB_RES from technology detection should be used */
-    ret = ERR_NONE;
-    *devCnt = 0;
-    curDevCnt = 0;
-    *colPending = false;
-
-    /* Send ALLB_REQ   Activity 1.1   9.3.5.2 and 9.3.5.3  (Symbol 1 and 2) */
-    if(compMode != RFAL_COMPLIANCE_MODE_ISO) {
-        ret = rfalNfcbPollerCheckPresence(
-            RFAL_NFCB_SENS_CMD_ALLB_REQ,
-            initSlots,
-            &nfcbDevList->sensbRes,
-            &nfcbDevList->sensbResLen);
-        if((ret != ERR_NONE) && (initSlots == RFAL_NFCB_SLOT_NUM_1)) {
-            return ret;
-        }
-    }
-
-    /* Check if there was a transmission error on WUPB  EMVCo 2.6  9.3.3.1 */
-    if((compMode == RFAL_COMPLIANCE_MODE_EMV) && (nfcbDevList->sensbResLen == 0U)) {
-        return ERR_FRAMING;
-    }
-
-    for(slotsNum = (uint8_t)initSlots; slotsNum <= (uint8_t)endSlots; slotsNum++) {
-        do {
-            /* Activity 1.1  9.3.5.23  -  Symbol 22 */
-            if((compMode == RFAL_COMPLIANCE_MODE_NFC) && (curDevCnt != 0U)) {
-                rfalNfcbPollerSleep(nfcbDevList[((*devCnt) - (uint8_t)1U)].sensbRes.nfcid0);
-                nfcbDevList[((*devCnt) - (uint8_t)1U)].isSleep = true;
-            }
-
-            /* Send SENSB_REQ with number of slots if not the first Activity 1.1  9.3.5.24  -  Symbol 23 */
-            if((slotsNum != (uint8_t)initSlots) || *colPending) {
-                /* PRQA S 4342 1 # MISRA 10.5 - Layout of rfalNfcbSlots and above loop guarantee that no invalid enum values are created. */
-                ret = rfalNfcbPollerCheckPresence(
-                    RFAL_NFCB_SENS_CMD_SENSB_REQ,
-                    (rfalNfcbSlots)slotsNum,
-                    &nfcbDevList[*devCnt].sensbRes,
-                    &nfcbDevList[*devCnt].sensbResLen);
-            }
-
-            /* Activity 1.1  9.3.5.6  -  Symbol 5 */
-            slotCode = 0;
-            curDevCnt = 0;
-            *colPending = false;
-
-            do {
-                /* Activity 1.1  9.3.5.26  -  Symbol 25 */
-                if(slotCode != 0U) {
-                    ret = rfalNfcbPollerSlotMarker(
-                        slotCode,
-                        &nfcbDevList[*devCnt].sensbRes,
-                        &nfcbDevList[*devCnt].sensbResLen);
-                }
-
-                /* Activity 1.1  9.3.5.7 and 9.3.5.8  -  Symbol 6 */
-                if(ret != ERR_TIMEOUT) {
-                    /* Activity 1.1  9.3.5.8  -  Symbol 7 */
-                    if((rfalNfcbCheckSensbRes(
-                            &nfcbDevList[*devCnt].sensbRes, nfcbDevList[*devCnt].sensbResLen) ==
-                        ERR_NONE) &&
-                       (ret == ERR_NONE)) {
-                        nfcbDevList[*devCnt].isSleep = false;
-
-                        if(compMode == RFAL_COMPLIANCE_MODE_EMV) {
-                            (*devCnt)++;
-                            return ret;
-                        } else if(compMode == RFAL_COMPLIANCE_MODE_ISO) {
-                            /* Activity 1.0  9.3.5.8  -  Symbol 7 */
-                            (*devCnt)++;
-                            curDevCnt++;
-
-                            /* Activity 1.0  9.3.5.10  -  Symbol 9 */
-                            if((*devCnt >= devLimit) ||
-                               (slotsNum == (uint8_t)RFAL_NFCB_SLOT_NUM_1)) {
-                                return ret;
-                            }
-
-                            /* Activity 1.0  9.3.5.11  -  Symbol 10 */
-                            rfalNfcbPollerSleep(nfcbDevList[*devCnt - 1U].sensbRes.nfcid0);
-                            nfcbDevList[*devCnt - 1U].isSleep = true;
-                        } else if(compMode == RFAL_COMPLIANCE_MODE_NFC) {
-                            /* Activity 1.1  9.3.5.10 and 9.3.5.11  -  Symbol 9 and Symbol 11*/
-                            if(curDevCnt != 0U) {
-                                rfalNfcbPollerSleep(
-                                    nfcbDevList[(*devCnt) - (uint8_t)1U].sensbRes.nfcid0);
-                                nfcbDevList[(*devCnt) - (uint8_t)1U].isSleep = true;
-                            }
-
-                            /* Activity 1.1  9.3.5.12  -  Symbol 11 */
-                            (*devCnt)++;
-                            curDevCnt++;
-
-                            /* Activity 1.1  9.3.5.6  -  Symbol 13 */
-                            if((*devCnt >= devLimit) ||
-                               (slotsNum == (uint8_t)RFAL_NFCB_SLOT_NUM_1)) {
-                                return ret;
-                            }
-                        } else {
-                            /* MISRA 15.7 - Empty else */
-                        }
-                    } else {
-                        /* If deviceLimit is set to 0 the NFC Forum Device is configured to perform collision detection only  Activity 1.0 and 1.1  9.3.5.5  - Symbol 4 */
-                        if((devLimit == 0U) && (slotsNum == (uint8_t)RFAL_NFCB_SLOT_NUM_1)) {
-                            return ERR_RF_COLLISION;
-                        }
-
-                        /* Activity 1.1  9.3.5.9  -  Symbol 8 */
-                        *colPending = true;
-                    }
-                }
-
-                /* Activity 1.1  9.3.5.15  -  Symbol 14 */
-                slotCode++;
-            } while(slotCode < rfalNfcbNI2NumberOfSlots(slotsNum));
-
-            /* Activity 1.1  9.3.5.17  -  Symbol 16 */
-            if(!(*colPending)) {
-                return ERR_NONE;
-            }
-
-            /* Activity 1.1  9.3.5.18  -  Symbol 17 */
-        } while(
-            curDevCnt !=
-            0U); /* If a collision is detected and card(s) were found on this loop keep the same number of available slots */
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-uint32_t rfalNfcbTR2ToFDT(uint8_t tr2Code) {
-    /*******************************************************************************/
-    /* MISRA 8.9 An object should be defined at block scope if its identifier only appears in a single function */
-    /*! TR2 Table according to Digital 1.1 Table 33 */
-    const uint16_t rfalNfcbTr2Table[] = {1792, 3328, 5376, 9472};
-    /*******************************************************************************/
-
-    return rfalNfcbTr2Table[(tr2Code & RFAL_NFCB_SENSB_RES_PROTO_TR2_MASK)];
-}
-
-#endif /* RFAL_FEATURE_NFCB */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfcf.c

@@ -1,587 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcf.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-F Poller (FeliCa PCD) device
- *
- *  The definitions and helpers methods provided by this module are 
- *  aligned with NFC-F (FeliCa - JIS X6319-4)
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_nfcf.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_NFCF
-#define RFAL_FEATURE_NFCF false /* NFC-F module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_NFCF
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-#define RFAL_NFCF_SENSF_REQ_LEN_MIN \
-    5U /*!< SENSF_RES minimum length                              */
-
-#define RFAL_NFCF_READ_WO_ENCRYPTION_MIN_LEN \
-    15U /*!< Minimum length for a Check Command         T3T  5.4.1 */
-#define RFAL_NFCF_WRITE_WO_ENCRYPTION_MIN_LEN \
-    31U /*!< Minimum length for an Update Command       T3T  5.5.1 */
-
-#define RFAL_NFCF_CHECK_RES_MIN_LEN \
-    11U /*!< CHECK Response minimum length       T3T 1.0  Table 8  */
-#define RFAL_NFCF_UPDATE_RES_MIN_LEN \
-    11U /*!< UPDATE Response minimum length      T3T 1.0  Table 8  */
-
-#define RFAL_NFCF_CHECK_REQ_MAX_LEN \
-    86U /*!< Max length of a Check request        T3T 1.0  Table 7 */
-#define RFAL_NFCF_CHECK_REQ_MAX_SERV \
-    15U /*!< Max Services number on Check request T3T 1.0  5.4.1.5 */
-#define RFAL_NFCF_CHECK_REQ_MAX_BLOCK \
-    15U /*!< Max Blocks number on Check request  T3T 1.0  5.4.1.10 */
-#define RFAL_NFCF_UPDATE_REQ_MAX_SERV \
-    15U /*!< Max Services number Update request  T3T 1.0  5.4.1.5  */
-#define RFAL_NFCF_UPDATE_REQ_MAX_BLOCK \
-    13U /*!< Max Blocks number on Update request T3T 1.0  5.4.1.10 */
-
-/*! MRT Check | Uupdate = (Tt3t x ((A+1) + n (B+1)) x 4^E) + dRWTt3t    T3T  5.8
-    Max values used: A = 7 ; B = 7 ; E = 3 ; n = 15 (NFC Forum n = 15, JIS n = 32)
-*/
-#define RFAL_NFCF_MRT_CHECK_UPDATE ((4096 * (8 + (15 * 8)) * 64) + 16)
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-#define rfalNfcfSlots2CardNum(s) \
-    ((uint8_t)(s) + 1U) /*!< Converts Time Slot Number (TSN) into num of slots  */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! Structure/Buffer to hold the SENSF_RES with LEN byte prepended                                 */
-typedef struct {
-    uint8_t LEN; /*!< NFC-F LEN byte                      */
-    rfalNfcfSensfRes SENSF_RES; /*!< SENSF_RES                           */
-} rfalNfcfSensfResBuf;
-
-/*! Greedy collection for NFCF GRE_POLL_F  Activity 1.0 Table 10                                   */
-typedef struct {
-    uint8_t pollFound; /*!< Number of devices found by the Poll */
-    uint8_t pollCollision; /*!< Number of collisions detected       */
-    rfalFeliCaPollRes POLL_F[RFAL_NFCF_POLL_MAXCARDS]; /*!< GRE_POLL_F   Activity 1.0 Table 10  */
-} rfalNfcfGreedyF;
-
-/*! NFC-F SENSF_REQ format  Digital 1.1  8.6.1                     */
-typedef struct {
-    uint8_t CMD; /*!< Command code: 00h  */
-    uint8_t SC[RFAL_NFCF_SENSF_SC_LEN]; /*!< System Code        */
-    uint8_t RC; /*!< Request Code       */
-    uint8_t TSN; /*!< Time Slot Number   */
-} rfalNfcfSensfReq;
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-static rfalNfcfGreedyF gRfalNfcfGreedyF; /*!< Activity's NFCF Greedy collection */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static void rfalNfcfComputeValidSENF(
-    rfalNfcfListenDevice* outDevInfo,
-    uint8_t* curDevIdx,
-    uint8_t devLimit,
-    bool overwrite,
-    bool* nfcDepFound);
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-/*******************************************************************************/
-static void rfalNfcfComputeValidSENF(
-    rfalNfcfListenDevice* outDevInfo,
-    uint8_t* curDevIdx,
-    uint8_t devLimit,
-    bool overwrite,
-    bool* nfcDepFound) {
-    uint8_t tmpIdx;
-    bool duplicate;
-    const rfalNfcfSensfResBuf* sensfBuf;
-    rfalNfcfSensfResBuf sensfCopy;
-
-    /*******************************************************************************/
-    /* Go through all responses check if valid and duplicates                      */
-    /*******************************************************************************/
-    while((gRfalNfcfGreedyF.pollFound > 0U) && ((*curDevIdx) < devLimit)) {
-        duplicate = false;
-        gRfalNfcfGreedyF.pollFound--;
-
-        /* MISRA 11.3 - Cannot point directly into different object type, use local copy */
-        ST_MEMCPY(
-            (uint8_t*)&sensfCopy,
-            (uint8_t*)&gRfalNfcfGreedyF.POLL_F[gRfalNfcfGreedyF.pollFound],
-            sizeof(rfalNfcfSensfResBuf));
-
-        /* Point to received SENSF_RES */
-        sensfBuf = &sensfCopy;
-
-        /* Check for devices that are already in device list */
-        for(tmpIdx = 0; tmpIdx < (*curDevIdx); tmpIdx++) {
-            if(ST_BYTECMP(
-                   sensfBuf->SENSF_RES.NFCID2,
-                   outDevInfo[tmpIdx].sensfRes.NFCID2,
-                   RFAL_NFCF_NFCID2_LEN) == 0) {
-                duplicate = true;
-                break;
-            }
-        }
-
-        /* If is a duplicate skip this (and not to overwrite)*/
-        if(duplicate && !overwrite) {
-            continue;
-        }
-
-        /* Check if response length is OK */
-        if(((sensfBuf->LEN - RFAL_NFCF_HEADER_LEN) < RFAL_NFCF_SENSF_RES_LEN_MIN) ||
-           ((sensfBuf->LEN - RFAL_NFCF_HEADER_LEN) > RFAL_NFCF_SENSF_RES_LEN_MAX)) {
-            continue;
-        }
-
-        /* Check if the response is a SENSF_RES / Polling response */
-        if(sensfBuf->SENSF_RES.CMD != (uint8_t)RFAL_NFCF_CMD_POLLING_RES) {
-            continue;
-        }
-
-        /* Check if is an overwrite request or new device*/
-        if(duplicate && overwrite) {
-            /* overwrite deviceInfo/GRE_SENSF_RES with SENSF_RES */
-            outDevInfo[tmpIdx].sensfResLen = (sensfBuf->LEN - RFAL_NFCF_LENGTH_LEN);
-            ST_MEMCPY(
-                &outDevInfo[tmpIdx].sensfRes,
-                &sensfBuf->SENSF_RES,
-                outDevInfo[tmpIdx].sensfResLen);
-            continue;
-        } else {
-            /* fill deviceInfo/GRE_SENSF_RES with new SENSF_RES */
-            outDevInfo[(*curDevIdx)].sensfResLen = (sensfBuf->LEN - RFAL_NFCF_LENGTH_LEN);
-            ST_MEMCPY(
-                &outDevInfo[(*curDevIdx)].sensfRes,
-                &sensfBuf->SENSF_RES,
-                outDevInfo[(*curDevIdx)].sensfResLen);
-        }
-
-        /* Check if this device supports NFC-DEP and signal it (ACTIVITY 1.1   9.3.6.63) */
-        *nfcDepFound = rfalNfcfIsNfcDepSupported(&outDevInfo[(*curDevIdx)]);
-
-        (*curDevIdx)++;
-    }
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerInitialize(rfalBitRate bitRate) {
-    ReturnCode ret;
-
-    if((bitRate != RFAL_BR_212) && (bitRate != RFAL_BR_424)) {
-        return ERR_PARAM;
-    }
-
-    EXIT_ON_ERR(ret, rfalSetMode(RFAL_MODE_POLL_NFCF, bitRate, bitRate));
-    rfalSetErrorHandling(RFAL_ERRORHANDLING_NFC);
-
-    rfalSetGT(RFAL_GT_NFCF);
-    rfalSetFDTListen(RFAL_FDT_LISTEN_NFCF_POLLER);
-    rfalSetFDTPoll(RFAL_FDT_POLL_NFCF_POLLER);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerPoll(
-    rfalFeliCaPollSlots slots,
-    uint16_t sysCode,
-    uint8_t reqCode,
-    rfalFeliCaPollRes* cardList,
-    uint8_t* devCnt,
-    uint8_t* collisions) {
-    return rfalFeliCaPoll(
-        slots, sysCode, reqCode, cardList, rfalNfcfSlots2CardNum(slots), devCnt, collisions);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerCheckPresence(void) {
-    gRfalNfcfGreedyF.pollFound = 0;
-    gRfalNfcfGreedyF.pollCollision = 0;
-
-    /* ACTIVITY 1.0 & 1.1 - 9.2.3.17 SENSF_REQ  must be with number of slots equal to 4
-     *                                SC must be 0xFFFF
-     *                                RC must be 0x00 (No system code info required) */
-    return rfalFeliCaPoll(
-        RFAL_FELICA_4_SLOTS,
-        RFAL_NFCF_SYSTEMCODE,
-        RFAL_FELICA_POLL_RC_NO_REQUEST,
-        gRfalNfcfGreedyF.POLL_F,
-        rfalNfcfSlots2CardNum(RFAL_FELICA_4_SLOTS),
-        &gRfalNfcfGreedyF.pollFound,
-        &gRfalNfcfGreedyF.pollCollision);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcfListenDevice* nfcfDevList,
-    uint8_t* devCnt) {
-    ReturnCode ret;
-    bool nfcDepFound;
-
-    if((nfcfDevList == NULL) || (devCnt == NULL)) {
-        return ERR_PARAM;
-    }
-
-    *devCnt = 0;
-    nfcDepFound = false;
-
-    /*******************************************************************************************/
-    /* ACTIVITY 1.0 - 9.3.6.3 Copy valid SENSF_RES in GRE_POLL_F into GRE_SENSF_RES            */
-    /* ACTIVITY 1.0 - 9.3.6.6 The NFC Forum Device MUST remove all entries from GRE_SENSF_RES[]*/
-    /* ACTIVITY 1.1 - 9.3.63.59 Populate GRE_SENSF_RES with data from GRE_POLL_F               */
-    /*                                                                                         */
-    /* CON_DEVICES_LIMIT = 0 Just check if devices from Tech Detection exceeds -> always true  */
-    /* Allow the number of slots open on Technology Detection                                  */
-    /*******************************************************************************************/
-    rfalNfcfComputeValidSENF(
-        nfcfDevList,
-        devCnt,
-        ((devLimit == 0U) ? rfalNfcfSlots2CardNum(RFAL_FELICA_4_SLOTS) : devLimit),
-        false,
-        &nfcDepFound);
-
-    /*******************************************************************************/
-    /* ACTIVITY 1.0 - 9.3.6.4                                                      */
-    /* ACTIVITY 1.1 - 9.3.63.60 Check if devices found are lower than the limit    */
-    /* and send a SENSF_REQ if so                                                  */
-    /*******************************************************************************/
-    if(*devCnt < devLimit) {
-        /* ACTIVITY 1.0 - 9.3.6.5  Copy valid SENSF_RES and then to remove it
-         * ACTIVITY 1.1 - 9.3.6.65 Copy and filter duplicates                                           
-         * For now, due to some devices keep generating different nfcid2, we use 1.0  
-         * Phones detected: Samsung Galaxy Nexus,Samsung Galaxy S3,Samsung Nexus S */
-        *devCnt = 0;
-
-        ret = rfalNfcfPollerPoll(
-            RFAL_FELICA_16_SLOTS,
-            RFAL_NFCF_SYSTEMCODE,
-            RFAL_FELICA_POLL_RC_NO_REQUEST,
-            gRfalNfcfGreedyF.POLL_F,
-            &gRfalNfcfGreedyF.pollFound,
-            &gRfalNfcfGreedyF.pollCollision);
-        if(ret == ERR_NONE) {
-            rfalNfcfComputeValidSENF(nfcfDevList, devCnt, devLimit, false, &nfcDepFound);
-        }
-
-        /*******************************************************************************/
-        /* ACTIVITY 1.1 -  9.3.6.63 Check if any device supports NFC DEP               */
-        /*******************************************************************************/
-        if(nfcDepFound && (compMode == RFAL_COMPLIANCE_MODE_NFC)) {
-            ret = rfalNfcfPollerPoll(
-                RFAL_FELICA_16_SLOTS,
-                RFAL_NFCF_SYSTEMCODE,
-                RFAL_FELICA_POLL_RC_SYSTEM_CODE,
-                gRfalNfcfGreedyF.POLL_F,
-                &gRfalNfcfGreedyF.pollFound,
-                &gRfalNfcfGreedyF.pollCollision);
-            if(ret == ERR_NONE) {
-                rfalNfcfComputeValidSENF(nfcfDevList, devCnt, devLimit, true, &nfcDepFound);
-            }
-        }
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerCheck(
-    const uint8_t* nfcid2,
-    const rfalNfcfServBlockListParam* servBlock,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvdLen) {
-    uint8_t txBuf[RFAL_NFCF_CHECK_REQ_MAX_LEN];
-    uint8_t msgIt;
-    uint8_t i;
-    ReturnCode ret;
-    const uint8_t* checkRes;
-
-    /* Check parameters */
-    if((nfcid2 == NULL) || (rxBuf == NULL) || (servBlock == NULL) || (servBlock->numBlock == 0U) ||
-       (servBlock->numBlock > RFAL_NFCF_CHECK_REQ_MAX_BLOCK) || (servBlock->numServ == 0U) ||
-       (servBlock->numServ > RFAL_NFCF_CHECK_REQ_MAX_SERV) ||
-       (rxBufLen < (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_CHECK_RES_MIN_LEN))) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-
-    /*******************************************************************************/
-    /* Compose CHECK command/request                                               */
-
-    txBuf[msgIt++] = RFAL_NFCF_CMD_READ_WITHOUT_ENCRYPTION; /* Command Code    */
-
-    ST_MEMCPY(&txBuf[msgIt], nfcid2, RFAL_NFCF_NFCID2_LEN); /* NFCID2          */
-    msgIt += RFAL_NFCF_NFCID2_LEN;
-
-    txBuf[msgIt++] = servBlock->numServ; /* NoS             */
-    for(i = 0; i < servBlock->numServ; i++) {
-        txBuf[msgIt++] = (uint8_t)((servBlock->servList[i] >> 0U) & 0xFFU); /* Service Code    */
-        txBuf[msgIt++] = (uint8_t)((servBlock->servList[i] >> 8U) & 0xFFU);
-    }
-
-    txBuf[msgIt++] = servBlock->numBlock; /* NoB             */
-    for(i = 0; i < servBlock->numBlock; i++) {
-        txBuf[msgIt++] =
-            servBlock->blockList[i].conf; /* Block list element conf (Flag|Access|Service) */
-        if((servBlock->blockList[i].conf & 0x80U) !=
-           0U) /* Check if 2 or 3 byte block list element       */
-        {
-            txBuf[msgIt++] =
-                (uint8_t)(servBlock->blockList[i].blockNum & 0xFFU); /* 1byte Block Num */
-        } else {
-            txBuf[msgIt++] =
-                (uint8_t)((servBlock->blockList[i].blockNum >> 0U) & 0xFFU); /* 2byte Block Num */
-            txBuf[msgIt++] = (uint8_t)((servBlock->blockList[i].blockNum >> 8U) & 0xFFU);
-        }
-    }
-
-    /*******************************************************************************/
-    /* Transceive CHECK command/request                                            */
-    ret = rfalTransceiveBlockingTxRx(
-        txBuf,
-        msgIt,
-        rxBuf,
-        rxBufLen,
-        rcvdLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCF_MRT_CHECK_UPDATE);
-
-    if(ret == ERR_NONE) {
-        /* Skip LEN byte */
-        checkRes = (rxBuf + RFAL_NFCF_LENGTH_LEN);
-
-        /* Check response length */
-        if(*rcvdLen < (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_CHECKUPDATE_RES_ST2_POS)) {
-            ret = ERR_PROTO;
-        }
-        /* Check for a valid response */
-        else if(
-            (checkRes[RFAL_NFCF_CMD_POS] != (uint8_t)RFAL_NFCF_CMD_READ_WITHOUT_ENCRYPTION_RES) ||
-            (checkRes[RFAL_NFCF_CHECKUPDATE_RES_ST1_POS] != RFAL_NFCF_STATUS_FLAG_SUCCESS) ||
-            (checkRes[RFAL_NFCF_CHECKUPDATE_RES_ST2_POS] != RFAL_NFCF_STATUS_FLAG_SUCCESS)) {
-            ret = ERR_REQUEST;
-        }
-        /* CHECK succesfull, remove header */
-        else {
-            (*rcvdLen) -= (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_CHECKUPDATE_RES_NOB_POS);
-
-            if(*rcvdLen > 0U) {
-                ST_MEMMOVE(rxBuf, &checkRes[RFAL_NFCF_CHECKUPDATE_RES_NOB_POS], (*rcvdLen));
-            }
-        }
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcfPollerUpdate(
-    const uint8_t* nfcid2,
-    const rfalNfcfServBlockListParam* servBlock,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    const uint8_t* blockData,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen) {
-    uint8_t i;
-    uint16_t msgIt;
-    uint16_t rcvdLen;
-    uint16_t auxLen;
-    const uint8_t* updateRes;
-    ReturnCode ret;
-
-    /* Check parameters */
-    if((nfcid2 == NULL) || (rxBuf == NULL) || (servBlock == NULL) || (txBuf == NULL) ||
-       (servBlock->numBlock == 0U) || (servBlock->numBlock > RFAL_NFCF_UPDATE_REQ_MAX_BLOCK) ||
-       (servBlock->numServ == 0U) || (servBlock->numServ > RFAL_NFCF_UPDATE_REQ_MAX_SERV) ||
-       (rxBufLen < (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_UPDATE_RES_MIN_LEN))) {
-        return ERR_PARAM;
-    }
-
-    /* Calculate required txBuffer lenth */
-    auxLen = (uint16_t)(RFAL_NFCF_CMD_LEN + RFAL_NFCF_NFCID2_LEN +
-                        (servBlock->numServ * sizeof(rfalNfcfServ)) +
-                        (servBlock->numBlock * sizeof(rfalNfcfBlockListElem)) +
-                        (uint16_t)((uint16_t)servBlock->numBlock * RFAL_NFCF_BLOCK_LEN));
-
-    /* Check whether the provided buffer is sufficient for this request */
-    if(txBufLen < auxLen) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-
-    /*******************************************************************************/
-    /* Compose UPDATE command/request                                              */
-
-    txBuf[msgIt++] = RFAL_NFCF_CMD_WRITE_WITHOUT_ENCRYPTION; /* Command Code    */
-
-    ST_MEMCPY(&txBuf[msgIt], nfcid2, RFAL_NFCF_NFCID2_LEN); /* NFCID2          */
-    msgIt += RFAL_NFCF_NFCID2_LEN;
-
-    txBuf[msgIt++] = servBlock->numServ; /* NoS             */
-    for(i = 0; i < servBlock->numServ; i++) {
-        txBuf[msgIt++] = (uint8_t)((servBlock->servList[i] >> 0U) & 0xFFU); /* Service Code    */
-        txBuf[msgIt++] = (uint8_t)((servBlock->servList[i] >> 8U) & 0xFFU);
-    }
-
-    txBuf[msgIt++] = servBlock->numBlock; /* NoB             */
-    for(i = 0; i < servBlock->numBlock; i++) {
-        txBuf[msgIt++] =
-            servBlock->blockList[i].conf; /* Block list element conf (Flag|Access|Service) */
-        if((servBlock->blockList[i].conf & 0x80U) !=
-           0U) /* Check if 2 or 3 byte block list element       */
-        {
-            txBuf[msgIt++] =
-                (uint8_t)(servBlock->blockList[i].blockNum & 0xFFU); /* 1byte Block Num */
-        } else {
-            txBuf[msgIt++] =
-                (uint8_t)((servBlock->blockList[i].blockNum >> 0U) & 0xFFU); /* 2byte Block Num */
-            txBuf[msgIt++] = (uint8_t)((servBlock->blockList[i].blockNum >> 8U) & 0xFFU);
-        }
-    }
-
-    auxLen = ((uint16_t)servBlock->numBlock * RFAL_NFCF_BLOCK_LEN);
-    ST_MEMCPY(&txBuf[msgIt], blockData, auxLen); /* Block Data      */
-    msgIt += auxLen;
-
-    /*******************************************************************************/
-    /* Transceive UPDATE command/request                                           */
-    ret = rfalTransceiveBlockingTxRx(
-        txBuf,
-        msgIt,
-        rxBuf,
-        rxBufLen,
-        &rcvdLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCF_MRT_CHECK_UPDATE);
-
-    if(ret == ERR_NONE) {
-        /* Skip LEN byte */
-        updateRes = (rxBuf + RFAL_NFCF_LENGTH_LEN);
-
-        /* Check response length */
-        if(rcvdLen < (RFAL_NFCF_LENGTH_LEN + RFAL_NFCF_CHECKUPDATE_RES_ST2_POS)) {
-            ret = ERR_PROTO;
-        }
-        /* Check for a valid response */
-        else if(
-            (updateRes[RFAL_NFCF_CMD_POS] !=
-             (uint8_t)RFAL_NFCF_CMD_WRITE_WITHOUT_ENCRYPTION_RES) ||
-            (updateRes[RFAL_NFCF_CHECKUPDATE_RES_ST1_POS] != RFAL_NFCF_STATUS_FLAG_SUCCESS) ||
-            (updateRes[RFAL_NFCF_CHECKUPDATE_RES_ST2_POS] != RFAL_NFCF_STATUS_FLAG_SUCCESS)) {
-            ret = ERR_REQUEST;
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-bool rfalNfcfListenerIsT3TReq(const uint8_t* buf, uint16_t bufLen, uint8_t* nfcid2) {
-    /* Check cmd byte */
-    switch(*buf) {
-    case RFAL_NFCF_CMD_READ_WITHOUT_ENCRYPTION:
-        if(bufLen < RFAL_NFCF_READ_WO_ENCRYPTION_MIN_LEN) {
-            return false;
-        }
-        break;
-
-    case RFAL_NFCF_CMD_WRITE_WITHOUT_ENCRYPTION:
-        if(bufLen < RFAL_NFCF_WRITE_WO_ENCRYPTION_MIN_LEN) {
-            return false;
-        }
-        break;
-
-    default:
-        return false;
-    }
-
-    /* Output NFID2 if requested */
-    if(nfcid2 != NULL) {
-        ST_MEMCPY(nfcid2, &buf[RFAL_NFCF_CMD_LEN], RFAL_NFCF_NFCID2_LEN);
-    }
-
-    return true;
-}
-
-#endif /* RFAL_FEATURE_NFCF */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_nfcv.c

@@ -1,1059 +0,0 @@
-
-/******************************************************************************
-  * \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_nfcv.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of NFC-V Poller (ISO15693) device
- *
- *  The definitions and helpers methods provided by this module are 
- *  aligned with NFC-V (ISO15693)
- *
- *  The definitions and helpers methods provided by this module 
- *  are aligned with NFC-V Digital 2.1
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_nfcv.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_NFCV
-#define RFAL_FEATURE_NFCV false /* NFC-V module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_NFCV
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_NFCV_INV_REQ_FLAG \
-    0x06U /*!< INVENTORY_REQ  INV_FLAG  Digital  2.1  9.6.1                      */
-#define RFAL_NFCV_MASKVAL_MAX_LEN \
-    8U /*!< Mask value max length: 64 bits  (UID length)                      */
-#define RFAL_NFCV_MASKVAL_MAX_1SLOT_LEN \
-    64U /*!< Mask value max length in 1 Slot mode in bits  Digital 2.1 9.6.1.6 */
-#define RFAL_NFCV_MASKVAL_MAX_16SLOT_LEN \
-    60U /*!< Mask value max length in 16 Slot mode in bits Digital 2.1 9.6.1.6 */
-#define RFAL_NFCV_MAX_SLOTS \
-    16U /*!< NFC-V max number of Slots                                         */
-#define RFAL_NFCV_INV_REQ_HEADER_LEN \
-    3U /*!< INVENTORY_REQ header length (INV_FLAG, CMD, MASK_LEN)             */
-#define RFAL_NFCV_INV_RES_LEN \
-    10U /*!< INVENTORY_RES length                                              */
-#define RFAL_NFCV_WR_MUL_REQ_HEADER_LEN \
-    4U /*!< Write Multiple header length (INV_FLAG, CMD, [UID], BNo, Bno)     */
-
-#define RFAL_NFCV_CMD_LEN \
-    1U /*!< Commandbyte length                                                */
-#define RFAL_NFCV_FLAG_POS \
-    0U /*!< Flag byte position                                                */
-#define RFAL_NFCV_FLAG_LEN \
-    1U /*!< Flag byte length                                                  */
-#define RFAL_NFCV_DATASTART_POS \
-    1U /*!< Position of start of data                                         */
-#define RFAL_NFCV_DSFI_LEN \
-    1U /*!< DSFID length                                                      */
-#define RFAL_NFCV_SLPREQ_REQ_FLAG \
-    0x22U /*!< SLPV_REQ request flags Digital 2.0 (Candidate) 9.7.1.1            */
-#define RFAL_NFCV_RES_FLAG_NOERROR \
-    0x00U /*!< RES_FLAG indicating no error (checked during activation)          */
-
-#define RFAL_NFCV_MAX_COLL_SUPPORTED \
-    16U /*!< Maximum number of collisions supported by the Anticollision loop  */
-
-#define RFAL_NFCV_FDT_MAX \
-    rfalConvMsTo1fc(20) /*!< Maximum Wait time FDTV,EOF and MAX2   Digital 2.1 B.5*/
-#define RFAL_NFCV_FDT_MAX1 \
-    4394U /*!< Read alike command FWT FDTV,LISTEN,MAX1  Digital 2.0 B.5          */
-
-/*! Time from special frame to EOF 
- *                    ISO15693 2009 10.4.2                 : 20ms
- *                    NFC Forum defines Digital 2.0  9.7.4 : FDTV,EOF = [10 ; 20]ms 
- */
-#define RFAL_NFCV_FDT_EOF 20U
-
-/*! Time between slots - ISO 15693 defines t3min depending on modulation depth and data rate.
- *  With only high-bitrate supported, AM modulation and a length of 12 bytes (96bits) for INV_RES we get:
- *                    - ISO t3min = 96/26 ms + 300us = 4 ms
- *                    - NFC Forum defines FDTV,INVENT_NORES = (4394 + 2048)/fc. Digital 2.0  B.5*/
-#define RFAL_NFCV_FDT_V_INVENT_NORES 4U
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*! Checks if a valid INVENTORY_RES is valid    Digital 2.2  9.6.2.1 & 9.6.2.3  */
-#define rfalNfcvCheckInvRes(f, l)                                               \
-    (((l) == rfalConvBytesToBits(RFAL_NFCV_INV_RES_LEN + RFAL_NFCV_CRC_LEN)) && \
-     ((f) == RFAL_NFCV_RES_FLAG_NOERROR))
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-V INVENTORY_REQ format   Digital 2.0 9.6.1 */
-typedef struct {
-    uint8_t INV_FLAG; /*!< Inventory Flags    */
-    uint8_t CMD; /*!< Command code: 01h  */
-    uint8_t MASK_LEN; /*!< Mask Value Length  */
-    uint8_t MASK_VALUE[RFAL_NFCV_MASKVAL_MAX_LEN]; /*!< Mask Value         */
-} rfalNfcvInventoryReq;
-
-/*! NFC-V SLP_REQ format   Digital 2.0 (Candidate) 9.7.1 */
-typedef struct {
-    uint8_t REQ_FLAG; /*!< Request Flags      */
-    uint8_t CMD; /*!< Command code: 02h  */
-    uint8_t UID[RFAL_NFCV_UID_LEN]; /*!< Mask Value         */
-} rfalNfcvSlpvReq;
-
-/*! Container for a collision found during Anticollision loop */
-typedef struct {
-    uint8_t maskLen;
-    uint8_t maskVal[RFAL_NFCV_MASKVAL_MAX_LEN];
-} rfalNfcvCollision;
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static ReturnCode rfalNfcvParseError(uint8_t err);
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* LOCAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-static ReturnCode rfalNfcvParseError(uint8_t err) {
-    switch(err) {
-    case RFAL_NFCV_ERROR_CMD_NOT_SUPPORTED:
-    case RFAL_NFCV_ERROR_OPTION_NOT_SUPPORTED:
-        return ERR_NOTSUPP;
-
-    case RFAL_NFCV_ERROR_CMD_NOT_RECOGNIZED:
-        return ERR_PROTO;
-
-    case RFAL_NFCV_ERROR_WRITE_FAILED:
-        return ERR_WRITE;
-
-    default:
-        return ERR_REQUEST;
-    }
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerInitialize(void) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(ret, rfalSetMode(RFAL_MODE_POLL_NFCV, RFAL_BR_26p48, RFAL_BR_26p48));
-    rfalSetErrorHandling(RFAL_ERRORHANDLING_NFC);
-
-    rfalSetGT(RFAL_GT_NFCV);
-    rfalSetFDTListen(RFAL_FDT_LISTEN_NFCV_POLLER);
-    rfalSetFDTPoll(RFAL_FDT_POLL_NFCV_POLLER);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerCheckPresence(rfalNfcvInventoryRes* invRes) {
-    ReturnCode ret;
-
-    /* INVENTORY_REQ with 1 slot and no Mask   Activity 2.0 (Candidate) 9.2.3.32 */
-    ret = rfalNfcvPollerInventory(RFAL_NFCV_NUM_SLOTS_1, 0, NULL, invRes, NULL);
-
-    if((ret == ERR_RF_COLLISION) || (ret == ERR_CRC) || (ret == ERR_FRAMING) ||
-       (ret == ERR_PROTO)) {
-        ret = ERR_NONE;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerInventory(
-    rfalNfcvNumSlots nSlots,
-    uint8_t maskLen,
-    const uint8_t* maskVal,
-    rfalNfcvInventoryRes* invRes,
-    uint16_t* rcvdLen) {
-    ReturnCode ret;
-    rfalNfcvInventoryReq invReq;
-    uint16_t rxLen;
-
-    if(((maskVal == NULL) && (maskLen != 0U)) || (invRes == NULL)) {
-        return ERR_PARAM;
-    }
-
-    invReq.INV_FLAG = (RFAL_NFCV_INV_REQ_FLAG | (uint8_t)nSlots);
-    invReq.CMD = RFAL_NFCV_CMD_INVENTORY;
-    invReq.MASK_LEN = (uint8_t)MIN(
-        maskLen,
-        ((nSlots == RFAL_NFCV_NUM_SLOTS_1) ?
-             RFAL_NFCV_MASKVAL_MAX_1SLOT_LEN :
-             RFAL_NFCV_MASKVAL_MAX_16SLOT_LEN)); /* Digital 2.0  9.6.1.6 */
-
-    if((rfalConvBitsToBytes(invReq.MASK_LEN) > 0U) && (maskVal != NULL)) /* MISRA 21.18 & 1.3 */
-    {
-        ST_MEMCPY(invReq.MASK_VALUE, maskVal, rfalConvBitsToBytes(invReq.MASK_LEN));
-    }
-
-    ret = rfalISO15693TransceiveAnticollisionFrame(
-        (uint8_t*)&invReq,
-        (uint8_t)(RFAL_NFCV_INV_REQ_HEADER_LEN + rfalConvBitsToBytes(invReq.MASK_LEN)),
-        (uint8_t*)invRes,
-        sizeof(rfalNfcvInventoryRes),
-        &rxLen);
-
-    /* Check for optional output parameter */
-    if(rcvdLen != NULL) {
-        *rcvdLen = rxLen;
-    }
-
-    if(ret == ERR_NONE) {
-        /* Check for valid INVENTORY_RES   Digital 2.2  9.6.2.1 & 9.6.2.3 */
-        if(!rfalNfcvCheckInvRes(invRes->RES_FLAG, rxLen)) {
-            return ERR_PROTO;
-        }
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerCollisionResolution(
-    rfalComplianceMode compMode,
-    uint8_t devLimit,
-    rfalNfcvListenDevice* nfcvDevList,
-    uint8_t* devCnt) {
-    ReturnCode ret;
-    uint8_t slotNum;
-    uint16_t rcvdLen;
-    uint8_t colIt;
-    uint8_t colCnt;
-    uint8_t colPos;
-    bool colPending;
-    rfalNfcvCollision colFound[RFAL_NFCV_MAX_COLL_SUPPORTED];
-
-    if((nfcvDevList == NULL) || (devCnt == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /* Initialize parameters */
-    *devCnt = 0;
-    colIt = 0;
-    colCnt = 0;
-    colPending = false;
-    ST_MEMSET(colFound, 0x00, (sizeof(rfalNfcvCollision) * RFAL_NFCV_MAX_COLL_SUPPORTED));
-
-    if(devLimit > 0U) /* MISRA 21.18 */
-    {
-        ST_MEMSET(nfcvDevList, 0x00, (sizeof(rfalNfcvListenDevice) * devLimit));
-    }
-
-    NO_WARNING(
-        colPending); /* colPending is not exposed externally, in future it might become exposed/ouput parameter */
-
-    if(compMode == RFAL_COMPLIANCE_MODE_NFC) {
-        /* Send INVENTORY_REQ with one slot   Activity 2.1  9.3.7.1  (Symbol 0)  */
-        ret = rfalNfcvPollerInventory(RFAL_NFCV_NUM_SLOTS_1, 0, NULL, &nfcvDevList->InvRes, NULL);
-
-        if(ret == ERR_TIMEOUT) /* Exit if no device found     Activity 2.1  9.3.7.2 (Symbol 1)  */
-        {
-            return ERR_NONE;
-        }
-        if(ret ==
-           ERR_NONE) /* Device found without transmission error/collision    Activity 2.1  9.3.7.3 (Symbol 2)  */
-        {
-            (*devCnt)++;
-            return ERR_NONE;
-        }
-
-        /* A Collision has been identified  Activity 2.1  9.3.7.4  (Symbol 3) */
-        colPending = true;
-        colCnt = 1;
-
-        /* Check if the Collision Resolution is set to perform only Collision detection   Activity 2.1  9.3.7.5 (Symbol 4)*/
-        if(devLimit == 0U) {
-            return ERR_RF_COLLISION;
-        }
-
-        platformDelay(RFAL_NFCV_FDT_V_INVENT_NORES);
-
-        /*******************************************************************************/
-        /* Collisions pending, Anticollision loop must be executed                     */
-        /*******************************************************************************/
-    } else {
-        /* Advance to 16 slots below without mask. Will give a good chance to identify multiple cards */
-        colPending = true;
-        colCnt = 1;
-    }
-
-    /* Execute until all collisions are resolved Activity 2.1 9.3.7.18  (Symbol 17) */
-    do {
-        /* Activity 2.1  9.3.7.7  (Symbol 6 / 7) */
-        colPending = false;
-        slotNum = 0;
-
-        do {
-            if(slotNum == 0U) {
-                /* Send INVENTORY_REQ with 16 slots   Activity 2.1  9.3.7.9  (Symbol 8) */
-                ret = rfalNfcvPollerInventory(
-                    RFAL_NFCV_NUM_SLOTS_16,
-                    colFound[colIt].maskLen,
-                    colFound[colIt].maskVal,
-                    &nfcvDevList[(*devCnt)].InvRes,
-                    &rcvdLen);
-            } else {
-                ret = rfalISO15693TransceiveEOFAnticollision(
-                    (uint8_t*)&nfcvDevList[(*devCnt)].InvRes,
-                    sizeof(rfalNfcvInventoryRes),
-                    &rcvdLen);
-            }
-            slotNum++;
-
-            /*******************************************************************************/
-            if(ret != ERR_TIMEOUT) {
-                if(rcvdLen <
-                   rfalConvBytesToBits(
-                       RFAL_NFCV_INV_RES_LEN +
-                       RFAL_NFCV_CRC_LEN)) { /* If only a partial frame was received make sure the FDT_V_INVENT_NORES is fulfilled */
-                    platformDelay(RFAL_NFCV_FDT_V_INVENT_NORES);
-                }
-
-                /* Check if response is a correct frame (no TxRx error)  Activity 2.1  9.3.7.11  (Symbol 10)*/
-                if((ret == ERR_NONE) || (ret == ERR_PROTO)) {
-                    /* Check if the device found is already on the list and its response is a valid INVENTORY_RES */
-                    if(rfalNfcvCheckInvRes(nfcvDevList[(*devCnt)].InvRes.RES_FLAG, rcvdLen)) {
-                        /* Activity 2.1  9.3.7.12  (Symbol 11) */
-                        (*devCnt)++;
-                    }
-                } else /* Treat everything else as collision */
-                {
-                    /* Activity 2.1  9.3.7.17  (Symbol 16) */
-                    colPending = true;
-
-                    /*******************************************************************************/
-                    /* Ensure that this collision still fits on the container */
-                    if(colCnt < RFAL_NFCV_MAX_COLL_SUPPORTED) {
-                        /* Store this collision on the container to be resolved later */
-                        /* Activity 2.1  9.3.7.17  (Symbol 16): add the collision information
-                         * (MASK_VAL + SN) to the list containing the collision information */
-                        ST_MEMCPY(
-                            colFound[colCnt].maskVal, colFound[colIt].maskVal, RFAL_NFCV_UID_LEN);
-                        colPos = colFound[colIt].maskLen;
-                        colFound[colCnt].maskVal[(colPos / RFAL_BITS_IN_BYTE)] &=
-                            (uint8_t)((1U << (colPos % RFAL_BITS_IN_BYTE)) - 1U);
-                        colFound[colCnt].maskVal[(colPos / RFAL_BITS_IN_BYTE)] |=
-                            (uint8_t)((slotNum - 1U) << (colPos % RFAL_BITS_IN_BYTE));
-                        colFound[colCnt].maskVal[((colPos / RFAL_BITS_IN_BYTE) + 1U)] =
-                            (uint8_t)((slotNum - 1U) >>
-                                      (RFAL_BITS_IN_BYTE - (colPos % RFAL_BITS_IN_BYTE)));
-
-                        colFound[colCnt].maskLen = (colFound[colIt].maskLen + 4U);
-
-                        colCnt++;
-                    }
-                }
-            } else {
-                /* Timeout */
-                platformDelay(RFAL_NFCV_FDT_V_INVENT_NORES);
-            }
-
-            /* Check if devices found have reached device limit   Activity 2.1  9.3.7.13  (Symbol 12) */
-            if(*devCnt >= devLimit) {
-                return ERR_NONE;
-            }
-
-        } while(slotNum < RFAL_NFCV_MAX_SLOTS); /* Slot loop             */
-        colIt++;
-    } while(colIt < colCnt); /* Collisions found loop */
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerSleepCollisionResolution(
-    uint8_t devLimit,
-    rfalNfcvListenDevice* nfcvDevList,
-    uint8_t* devCnt) {
-    uint8_t tmpDevCnt;
-    ReturnCode ret;
-    uint8_t i;
-
-    if((nfcvDevList == NULL) || (devCnt == NULL)) {
-        return ERR_PARAM;
-    }
-
-    *devCnt = 0;
-
-    do {
-        tmpDevCnt = 0;
-        ret = rfalNfcvPollerCollisionResolution(
-            RFAL_COMPLIANCE_MODE_ISO, (devLimit - *devCnt), &nfcvDevList[*devCnt], &tmpDevCnt);
-
-        for(i = *devCnt; i < (*devCnt + tmpDevCnt); i++) {
-            rfalNfcvPollerSleep(0x00, nfcvDevList[i].InvRes.UID);
-            nfcvDevList[i].isSleep = true;
-        }
-        *devCnt += tmpDevCnt;
-    } while((ret == ERR_NONE) && (tmpDevCnt > 0U) && (*devCnt < devLimit));
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerSleep(uint8_t flags, const uint8_t* uid) {
-    ReturnCode ret;
-    rfalNfcvSlpvReq slpReq;
-    uint8_t rxBuf; /* dummy buffer, just to perform Rx */
-
-    if(uid == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Compute SLPV_REQ */
-    slpReq.REQ_FLAG =
-        (flags |
-         (uint8_t)
-             RFAL_NFCV_REQ_FLAG_ADDRESS); /* Should be with UID according Digital 2.0 (Candidate) 9.7.1.1 */
-    slpReq.CMD = RFAL_NFCV_CMD_SLPV;
-    ST_MEMCPY(slpReq.UID, uid, RFAL_NFCV_UID_LEN);
-
-    /* NFC Forum device SHALL wait at least FDTVpp to consider the SLPV acknowledged (FDTVpp = FDTVpoll)  Digital 2.0 (Candidate)  9.7  9.8.2  */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&slpReq,
-        sizeof(rfalNfcvSlpvReq),
-        &rxBuf,
-        sizeof(rxBuf),
-        NULL,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCV_FDT_MAX1);
-    if(ret != ERR_TIMEOUT) {
-        return ret;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerSelect(uint8_t flags, const uint8_t* uid) {
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    if(uid == NULL) {
-        return ERR_PARAM;
-    }
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_SELECT,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        NULL,
-        0U,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t bn;
-
-    bn = blockNum;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_READ_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        &bn,
-        sizeof(uint8_t),
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_LEN + RFAL_NFCV_MAX_BLOCK_LEN)];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    /* Check for valid parameters */
-    if((blockLen == 0U) || (blockLen > (uint8_t)RFAL_NFCV_MAX_BLOCK_LEN) || (wrData == NULL)) {
-        return ERR_PARAM;
-    }
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = blockNum; /* Set Block Number (8 bits)  */
-    ST_MEMCPY(&data[dataLen], wrData, blockLen); /* Append Block data to write */
-    dataLen += blockLen;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_WRITE_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerLockBlock(uint8_t flags, const uint8_t* uid, uint8_t blockNum) {
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-    uint8_t bn;
-
-    bn = blockNum;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_LOCK_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        &bn,
-        sizeof(uint8_t),
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_LEN + RFAL_NFCV_BLOCKNUM_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = firstBlockNum; /* Set first Block Number       */
-    data[dataLen++] = numOfBlocks; /* Set number of blocks to read */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_READ_MULTIPLE_BLOCKS,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerWriteMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t blockLen,
-    const uint8_t* wrData,
-    uint16_t wrDataLen) {
-    ReturnCode ret;
-    uint16_t rcvLen;
-    uint16_t reqLen;
-    rfalNfcvGenericRes res;
-    uint16_t msgIt;
-
-    /* Calculate required buffer length */
-    reqLen = (uint16_t)((uid != NULL) ?
-                            (RFAL_NFCV_WR_MUL_REQ_HEADER_LEN + RFAL_NFCV_UID_LEN + wrDataLen) :
-                            (RFAL_NFCV_WR_MUL_REQ_HEADER_LEN + wrDataLen));
-
-    if((reqLen > txBufLen) || (blockLen > (uint8_t)RFAL_NFCV_MAX_BLOCK_LEN) ||
-       ((((uint16_t)numOfBlocks) * (uint16_t)blockLen) != wrDataLen) || (numOfBlocks == 0U) ||
-       (wrData == NULL)) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-
-    /* Compute Request Command */
-    txBuf[msgIt++] = (uint8_t)(flags & (~((uint32_t)RFAL_NFCV_REQ_FLAG_ADDRESS)));
-    txBuf[msgIt++] = RFAL_NFCV_CMD_WRITE_MULTIPLE_BLOCKS;
-
-    /* Check if Request is to be sent in Addressed mode. Select mode flag shall be set by user */
-    if(uid != NULL) {
-        txBuf[RFAL_NFCV_FLAG_POS] |= (uint8_t)RFAL_NFCV_REQ_FLAG_ADDRESS;
-        ST_MEMCPY(&txBuf[msgIt], uid, RFAL_NFCV_UID_LEN);
-        msgIt += (uint8_t)RFAL_NFCV_UID_LEN;
-    }
-
-    txBuf[msgIt++] = firstBlockNum;
-    txBuf[msgIt++] = (numOfBlocks - 1U);
-
-    if(wrDataLen > 0U) /* MISRA 21.18 */
-    {
-        ST_MEMCPY(&txBuf[msgIt], wrData, wrDataLen);
-        msgIt += wrDataLen;
-    }
-
-    /* Transceive Command */
-    ret = rfalTransceiveBlockingTxRx(
-        txBuf,
-        msgIt,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCV_FDT_MAX);
-
-    if(ret != ERR_NONE) {
-        return ret;
-    }
-
-    /* Check if the response minimum length has been received */
-    if(rcvLen < (uint8_t)RFAL_NFCV_FLAG_LEN) {
-        return ERR_PROTO;
-    }
-
-    /* Check if an error has been signalled */
-    if((res.RES_FLAG & (uint8_t)RFAL_NFCV_RES_FLAG_ERROR) != 0U) {
-        return rfalNfcvParseError(*res.data);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerExtendedReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[RFAL_NFCV_BLOCKNUM_EXTENDED_LEN];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)
-        blockNum; /* TS T5T 1.0 BNo is considered as a multi-byte field. TS T5T 1.0 5.1.1.13 multi-byte field follows [DIGITAL]. [DIGITAL] 9.3.1 A multiple byte field is transmitted LSB first. */
-    data[dataLen++] = (uint8_t)((blockNum >> 8U) & 0xFFU);
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_EXTENDED_READ_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerExtendedWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_EXTENDED_LEN + RFAL_NFCV_MAX_BLOCK_LEN)];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    /* Check for valid parameters */
-    if((blockLen == 0U) || (blockLen > (uint8_t)RFAL_NFCV_MAX_BLOCK_LEN)) {
-        return ERR_PARAM;
-    }
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)
-        blockNum; /* TS T5T 1.0 BNo is considered as a multi-byte field. TS T5T 1.0 5.1.1.13 multi-byte field follows [DIGITAL]. [DIGITAL] 9.3.1 A multiple byte field is transmitted LSB first. */
-    data[dataLen++] = (uint8_t)((blockNum >> 8U) & 0xFFU);
-    ST_MEMCPY(&data[dataLen], wrData, blockLen); /* Append Block data to write */
-    dataLen += blockLen;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_EXTENDED_WRITE_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode
-    rfalNfcvPollerExtendedLockSingleBlock(uint8_t flags, const uint8_t* uid, uint16_t blockNum) {
-    uint8_t data[RFAL_NFCV_BLOCKNUM_EXTENDED_LEN];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)
-        blockNum; /* TS T5T 1.0 BNo is considered as a multi-byte field. TS T5T 1.0 5.1.1.13 multi-byte field follows [DIGITAL]. [DIGITAL] 9.3.1 A multiple byte field is transmitted LSB first. */
-    data[dataLen++] = (uint8_t)((blockNum >> 8U) & 0xFFU);
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_EXTENDED_LOCK_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerExtendedReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_EXTENDED_LEN + RFAL_NFCV_BLOCKNUM_EXTENDED_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)((firstBlockNum >> 0U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((firstBlockNum >> 8U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((numOfBlocks >> 0U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((numOfBlocks >> 8U) & 0xFFU);
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_EXTENDED_READ_MULTIPLE_BLOCK,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerExtendedWriteMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t blockLen,
-    const uint8_t* wrData,
-    uint16_t wrDataLen) {
-    ReturnCode ret;
-    uint16_t rcvLen;
-    uint16_t reqLen;
-    rfalNfcvGenericRes res;
-    uint16_t msgIt;
-    uint16_t nBlocks;
-
-    /* Calculate required buffer length */
-    reqLen =
-        ((uid != NULL) ? (RFAL_NFCV_WR_MUL_REQ_HEADER_LEN + RFAL_NFCV_UID_LEN + wrDataLen) :
-                         (RFAL_NFCV_WR_MUL_REQ_HEADER_LEN + wrDataLen));
-
-    if((reqLen > txBufLen) || (blockLen > (uint8_t)RFAL_NFCV_MAX_BLOCK_LEN) ||
-       (((uint16_t)numOfBlocks * (uint16_t)blockLen) != wrDataLen) || (numOfBlocks == 0U)) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-    nBlocks = (numOfBlocks - 1U);
-
-    /* Compute Request Command */
-    txBuf[msgIt++] = (uint8_t)(flags & (~((uint32_t)RFAL_NFCV_REQ_FLAG_ADDRESS)));
-    txBuf[msgIt++] = RFAL_NFCV_CMD_EXTENDED_WRITE_MULTIPLE_BLOCK;
-
-    /* Check if Request is to be sent in Addressed mode. Select mode flag shall be set by user */
-    if(uid != NULL) {
-        txBuf[RFAL_NFCV_FLAG_POS] |= (uint8_t)RFAL_NFCV_REQ_FLAG_ADDRESS;
-        ST_MEMCPY(&txBuf[msgIt], uid, RFAL_NFCV_UID_LEN);
-        msgIt += (uint8_t)RFAL_NFCV_UID_LEN;
-    }
-
-    txBuf[msgIt++] = (uint8_t)((firstBlockNum >> 0) & 0xFFU);
-    txBuf[msgIt++] = (uint8_t)((firstBlockNum >> 8) & 0xFFU);
-    txBuf[msgIt++] = (uint8_t)((nBlocks >> 0) & 0xFFU);
-    txBuf[msgIt++] = (uint8_t)((nBlocks >> 8) & 0xFFU);
-
-    if(wrDataLen > 0U) /* MISRA 21.18 */
-    {
-        ST_MEMCPY(&txBuf[msgIt], wrData, wrDataLen);
-        msgIt += wrDataLen;
-    }
-
-    /* Transceive Command */
-    ret = rfalTransceiveBlockingTxRx(
-        txBuf,
-        msgIt,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCV_FDT_MAX);
-
-    if(ret != ERR_NONE) {
-        return ret;
-    }
-
-    /* Check if the response minimum length has been received */
-    if(rcvLen < (uint8_t)RFAL_NFCV_FLAG_LEN) {
-        return ERR_PROTO;
-    }
-
-    /* Check if an error has been signalled */
-    if((res.RES_FLAG & (uint8_t)RFAL_NFCV_RES_FLAG_ERROR) != 0U) {
-        return rfalNfcvParseError(*res.data);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerGetSystemInformation(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_GET_SYS_INFO,
-        flags,
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        NULL,
-        0U,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerExtendedGetSystemInformation(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t requestField,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_EXTENDED_GET_SYS_INFO,
-        flags,
-        requestField,
-        uid,
-        NULL,
-        0U,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalNfcvPollerTransceiveReq(
-    uint8_t cmd,
-    uint8_t flags,
-    uint8_t param,
-    const uint8_t* uid,
-    const uint8_t* data,
-    uint16_t dataLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    ReturnCode ret;
-    rfalNfcvGenericReq req;
-    uint8_t msgIt;
-    rfalBitRate rxBR;
-    bool fastMode;
-
-    msgIt = 0;
-    fastMode = false;
-
-    /* Check for valid parameters */
-    if((rxBuf == NULL) || (rcvLen == NULL) || ((dataLen > 0U) && (data == NULL)) ||
-       (dataLen > ((uid != NULL) ? RFAL_NFCV_MAX_GEN_DATA_LEN :
-                                   (RFAL_NFCV_MAX_GEN_DATA_LEN - RFAL_NFCV_UID_LEN)))) {
-        return ERR_PARAM;
-    }
-
-    /* Check if the command is an ST's Fast command */
-    if((cmd == (uint8_t)RFAL_NFCV_CMD_FAST_READ_SINGLE_BLOCK) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_EXTENDED_READ_SINGLE_BLOCK) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_READ_MULTIPLE_BLOCKS) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_EXTENDED_READ_MULTIPLE_BLOCKS) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_WRITE_MESSAGE) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_READ_MESSAGE_LENGTH) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_READ_MESSAGE) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_READ_DYN_CONFIGURATION) ||
-       (cmd == (uint8_t)RFAL_NFCV_CMD_FAST_WRITE_DYN_CONFIGURATION)) {
-        /* Store current Rx bit rate and move to fast mode */
-        rfalGetBitRate(NULL, &rxBR);
-        rfalSetBitRate(RFAL_BR_KEEP, RFAL_BR_52p97);
-
-        fastMode = true;
-    }
-
-    /* Compute Request Command */
-    req.REQ_FLAG = (uint8_t)(flags & (~((uint32_t)RFAL_NFCV_REQ_FLAG_ADDRESS)));
-    req.CMD = cmd;
-
-    /* Prepend parameter on ceratin proprietary requests: IC Manuf, Parameters */
-    if(param != RFAL_NFCV_PARAM_SKIP) {
-        req.payload.data[msgIt++] = param;
-    }
-
-    /* Check if Request is to be sent in Addressed mode. Select mode flag shall be set by user */
-    if(uid != NULL) {
-        req.REQ_FLAG |= (uint8_t)RFAL_NFCV_REQ_FLAG_ADDRESS;
-        ST_MEMCPY(&req.payload.data[msgIt], uid, RFAL_NFCV_UID_LEN);
-        msgIt += RFAL_NFCV_UID_LEN;
-    }
-
-    if(dataLen > 0U) {
-        ST_MEMCPY(&req.payload.data[msgIt], data, dataLen);
-        msgIt += (uint8_t)dataLen;
-    }
-
-    /* Transceive Command */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&req,
-        (RFAL_NFCV_CMD_LEN + RFAL_NFCV_FLAG_LEN + (uint16_t)msgIt),
-        rxBuf,
-        rxBufLen,
-        rcvLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_NFCV_FDT_MAX);
-
-    /* If the Option Flag is set in certain commands an EOF needs to be sent after 20ms to retrieve the VICC response      ISO15693-3 2009  10.4.2 & 10.4.3 & 10.4.5 */
-    if(((flags & (uint8_t)RFAL_NFCV_REQ_FLAG_OPTION) != 0U) &&
-       ((cmd == (uint8_t)RFAL_NFCV_CMD_WRITE_SINGLE_BLOCK) ||
-        (cmd == (uint8_t)RFAL_NFCV_CMD_WRITE_MULTIPLE_BLOCKS) ||
-        (cmd == (uint8_t)RFAL_NFCV_CMD_LOCK_BLOCK) ||
-        (cmd == (uint8_t)RFAL_NFCV_CMD_EXTENDED_WRITE_SINGLE_BLOCK) ||
-        (cmd == (uint8_t)RFAL_NFCV_CMD_EXTENDED_LOCK_SINGLE_BLOCK) ||
-        (cmd == (uint8_t)RFAL_NFCV_CMD_EXTENDED_WRITE_MULTIPLE_BLOCK))) {
-        ret = rfalISO15693TransceiveEOF(rxBuf, (uint8_t)rxBufLen, rcvLen);
-    }
-
-    /* Restore Rx BitRate */
-    if(fastMode) {
-        rfalSetBitRate(RFAL_BR_KEEP, rxBR);
-    }
-
-    if(ret != ERR_NONE) {
-        return ret;
-    }
-
-    /* Check if the response minimum length has been received */
-    if((*rcvLen) < (uint8_t)RFAL_NFCV_FLAG_LEN) {
-        return ERR_PROTO;
-    }
-
-    /* Check if an error has been signalled */
-    if((rxBuf[RFAL_NFCV_FLAG_POS] & (uint8_t)RFAL_NFCV_RES_FLAG_ERROR) != 0U) {
-        return rfalNfcvParseError(rxBuf[RFAL_NFCV_DATASTART_POS]);
-    }
-
-    return ERR_NONE;
-}
-
-#endif /* RFAL_FEATURE_NFCV */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_st25tb.c

@@ -1,563 +0,0 @@
-
-/******************************************************************************
-  * \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_st25tb.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of ST25TB interface 
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_st25tb.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-#ifndef RFAL_FEATURE_ST25TB
-#define RFAL_FEATURE_ST25TB false /* ST25TB module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_ST25TB
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_ST25TB_CMD_LEN 1U /*!< ST25TB length of a command                       */
-#define RFAL_ST25TB_SLOTS 16U /*!< ST25TB number of slots                           */
-#define RFAL_ST25TB_SLOTNUM_MASK 0x0FU /*!< ST25TB Slot Number bit mask on SlotMarker        */
-#define RFAL_ST25TB_SLOTNUM_SHIFT 4U /*!< ST25TB Slot Number shift on SlotMarker           */
-
-#define RFAL_ST25TB_INITIATE_CMD1 0x06U /*!< ST25TB Initiate command byte1                    */
-#define RFAL_ST25TB_INITIATE_CMD2 0x00U /*!< ST25TB Initiate command byte2                    */
-#define RFAL_ST25TB_PCALL_CMD1 0x06U /*!< ST25TB Pcall16 command byte1                     */
-#define RFAL_ST25TB_PCALL_CMD2 0x04U /*!< ST25TB Pcall16 command byte2                     */
-#define RFAL_ST25TB_SELECT_CMD 0x0EU /*!< ST25TB Select command                            */
-#define RFAL_ST25TB_GET_UID_CMD 0x0BU /*!< ST25TB Get UID command                           */
-#define RFAL_ST25TB_COMPLETION_CMD 0x0FU /*!< ST25TB Completion command                        */
-#define RFAL_ST25TB_RESET_INV_CMD 0x0CU /*!< ST25TB Reset to Inventory command                */
-#define RFAL_ST25TB_READ_BLOCK_CMD 0x08U /*!< ST25TB Read Block command                        */
-#define RFAL_ST25TB_WRITE_BLOCK_CMD 0x09U /*!< ST25TB Write Block command                       */
-
-#define RFAL_ST25TB_T0 2157U /*!< ST25TB t0  159 us   ST25TB RF characteristics    */
-#define RFAL_ST25TB_T1 2048U /*!< ST25TB t1  151 us   ST25TB RF characteristics    */
-
-#define RFAL_ST25TB_FWT \
-    (RFAL_ST25TB_T0 + RFAL_ST25TB_T1) /*!< ST25TB FWT  = T0 + T1                            */
-#define RFAL_ST25TB_TW rfalConvMsTo1fc(7U) /*!< ST25TB TW : Programming time for write max 7ms   */
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! Initiate Request */
-typedef struct {
-    uint8_t cmd1; /*!< Initiate Request cmd1: 0x06 */
-    uint8_t cmd2; /*!< Initiate Request cmd2: 0x00 */
-} rfalSt25tbInitiateReq;
-
-/*! Pcall16 Request */
-typedef struct {
-    uint8_t cmd1; /*!< Pcal16 Request cmd1: 0x06   */
-    uint8_t cmd2; /*!< Pcal16 Request cmd2: 0x04   */
-} rfalSt25tbPcallReq;
-
-/*! Select Request */
-typedef struct {
-    uint8_t cmd; /*!< Select Request cmd: 0x0E     */
-    uint8_t chipId; /*!< Chip ID                      */
-} rfalSt25tbSelectReq;
-
-/*! Read Block Request */
-typedef struct {
-    uint8_t cmd; /*!< Select Request cmd: 0x08     */
-    uint8_t address; /*!< Block address                */
-} rfalSt25tbReadBlockReq;
-
-/*! Write Block Request */
-typedef struct {
-    uint8_t cmd; /*!< Select Request cmd: 0x09     */
-    uint8_t address; /*!< Block address                */
-    rfalSt25tbBlock data; /*!< Block Data                   */
-} rfalSt25tbWriteBlockReq;
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-/*! 
- *****************************************************************************
- * \brief  ST25TB Poller Do Collision Resolution
- *  
- * This method performs ST25TB Collision resolution loop for each slot
- *   
- * \param[in]  devLimit      : device limit value, and size st25tbDevList
- * \param[out] st25tbDevList : ST35TB listener device info
- * \param[out] devCnt        : Devices found counter
- * 
- * \return colPending         : true if a collision was detected
- *****************************************************************************
- */
-static bool rfalSt25tbPollerDoCollisionResolution(
-    uint8_t devLimit,
-    rfalSt25tbListenDevice* st25tbDevList,
-    uint8_t* devCnt);
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-static bool rfalSt25tbPollerDoCollisionResolution(
-    uint8_t devLimit,
-    rfalSt25tbListenDevice* st25tbDevList,
-    uint8_t* devCnt) {
-    uint8_t i;
-    uint8_t chipId;
-    ReturnCode ret;
-    bool col;
-
-    col = false;
-
-    for(i = 0; i < RFAL_ST25TB_SLOTS; i++) {
-        platformDelay(1); /* Wait t2: Answer to new request delay  */
-
-        if(i == 0U) {
-            /* Step 2: Send Pcall16 */
-            ret = rfalSt25tbPollerPcall(&chipId);
-        } else {
-            /* Step 3-17: Send Pcall16 */
-            ret = rfalSt25tbPollerSlotMarker(i, &chipId);
-        }
-
-        if(ret == ERR_NONE) {
-            /* Found another device */
-            st25tbDevList[*devCnt].chipID = chipId;
-            st25tbDevList[*devCnt].isDeselected = false;
-
-            /* Select Device, retrieve its UID  */
-            ret = rfalSt25tbPollerSelect(chipId);
-
-            /* By Selecting this device, the previous gets Deselected */
-            if((*devCnt) > 0U) {
-                st25tbDevList[(*devCnt) - 1U].isDeselected = true;
-            }
-
-            if(ERR_NONE == ret) {
-                rfalSt25tbPollerGetUID(&st25tbDevList[*devCnt].UID);
-            }
-
-            if(ERR_NONE == ret) {
-                (*devCnt)++;
-            }
-        } else if((ret == ERR_CRC) || (ret == ERR_FRAMING)) {
-            col = true;
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-
-        if(*devCnt >= devLimit) {
-            break;
-        }
-    }
-    return col;
-}
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerInitialize(void) {
-    return rfalNfcbPollerInitialize();
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerCheckPresence(uint8_t* chipId) {
-    ReturnCode ret;
-    uint8_t chipIdRes;
-
-    chipIdRes = 0x00;
-
-    /* Send Initiate Request */
-    ret = rfalSt25tbPollerInitiate(&chipIdRes);
-
-    /*  Check if a transmission error was detected */
-    if((ret == ERR_CRC) || (ret == ERR_FRAMING)) {
-        return ERR_NONE;
-    }
-
-    /* Copy chip ID if requested */
-    if(chipId != NULL) {
-        *chipId = chipIdRes;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerInitiate(uint8_t* chipId) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    rfalSt25tbInitiateReq initiateReq;
-    uint8_t rxBuf
-        [RFAL_ST25TB_CHIP_ID_LEN +
-         RFAL_ST25TB_CRC_LEN]; /* In case we receive less data that CRC, RF layer will not remove the CRC from buffer */
-
-    /* Compute Initiate Request */
-    initiateReq.cmd1 = RFAL_ST25TB_INITIATE_CMD1;
-    initiateReq.cmd2 = RFAL_ST25TB_INITIATE_CMD2;
-
-    /* Send Initiate Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&initiateReq,
-        sizeof(rfalSt25tbInitiateReq),
-        (uint8_t*)rxBuf,
-        sizeof(rxBuf),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid Select Response   */
-    if((ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN)) {
-        return ERR_PROTO;
-    }
-
-    /* Copy chip ID if requested */
-    if(chipId != NULL) {
-        *chipId = *rxBuf;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerPcall(uint8_t* chipId) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    rfalSt25tbPcallReq pcallReq;
-
-    /* Compute Pcal16 Request */
-    pcallReq.cmd1 = RFAL_ST25TB_PCALL_CMD1;
-    pcallReq.cmd2 = RFAL_ST25TB_PCALL_CMD2;
-
-    /* Send Pcal16 Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&pcallReq,
-        sizeof(rfalSt25tbPcallReq),
-        (uint8_t*)chipId,
-        RFAL_ST25TB_CHIP_ID_LEN,
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid Select Response   */
-    if((ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN)) {
-        return ERR_PROTO;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerSlotMarker(uint8_t slotNum, uint8_t* chipIdRes) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    uint8_t slotMarker;
-
-    if((slotNum == 0U) || (slotNum > 15U)) {
-        return ERR_PARAM;
-    }
-
-    /* Compute SlotMarker */
-    slotMarker =
-        (((slotNum & RFAL_ST25TB_SLOTNUM_MASK) << RFAL_ST25TB_SLOTNUM_SHIFT) |
-         RFAL_ST25TB_PCALL_CMD1);
-
-    /* Send SlotMarker */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&slotMarker,
-        RFAL_ST25TB_CMD_LEN,
-        (uint8_t*)chipIdRes,
-        RFAL_ST25TB_CHIP_ID_LEN,
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid ChipID Response   */
-    if((ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN)) {
-        return ERR_PROTO;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerSelect(uint8_t chipId) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    rfalSt25tbSelectReq selectReq;
-    uint8_t chipIdRes;
-
-    /* Compute Select Request */
-    selectReq.cmd = RFAL_ST25TB_SELECT_CMD;
-    selectReq.chipId = chipId;
-
-    /* Send Select Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&selectReq,
-        sizeof(rfalSt25tbSelectReq),
-        (uint8_t*)&chipIdRes,
-        RFAL_ST25TB_CHIP_ID_LEN,
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid Select Response   */
-    if((ret == ERR_NONE) && ((rxLen != RFAL_ST25TB_CHIP_ID_LEN) || (chipIdRes != chipId))) {
-        return ERR_PROTO;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerGetUID(rfalSt25tbUID* UID) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    uint8_t getUidReq;
-
-    /* Compute Get UID Request */
-    getUidReq = RFAL_ST25TB_GET_UID_CMD;
-
-    /* Send Select Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&getUidReq,
-        RFAL_ST25TB_CMD_LEN,
-        (uint8_t*)UID,
-        sizeof(rfalSt25tbUID),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid UID Response */
-    if((ret == ERR_NONE) && (rxLen != RFAL_ST25TB_UID_LEN)) {
-        return ERR_PROTO;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerCollisionResolution(
-    uint8_t devLimit,
-    rfalSt25tbListenDevice* st25tbDevList,
-    uint8_t* devCnt) {
-    uint8_t chipId;
-    ReturnCode ret;
-    bool detected; /* collision or device was detected */
-
-    if((st25tbDevList == NULL) || (devCnt == NULL) || (devLimit == 0U)) {
-        return ERR_PARAM;
-    }
-
-    *devCnt = 0;
-
-    /* Step 1: Send Initiate */
-    ret = rfalSt25tbPollerInitiate(&chipId);
-    if(ret == ERR_NONE) {
-        /* If only 1 answer is detected */
-        st25tbDevList[*devCnt].chipID = chipId;
-        st25tbDevList[*devCnt].isDeselected = false;
-
-        /* Retrieve its UID and keep it Selected*/
-        ret = rfalSt25tbPollerSelect(chipId);
-
-        if(ERR_NONE == ret) {
-            ret = rfalSt25tbPollerGetUID(&st25tbDevList[*devCnt].UID);
-        }
-
-        if(ERR_NONE == ret) {
-            (*devCnt)++;
-        }
-    }
-    /* Always proceed to Pcall16 anticollision as phase differences of tags can lead to no tag recognized, even if there is one */
-    if(*devCnt < devLimit) {
-        /* Multiple device responses */
-        do {
-            detected = rfalSt25tbPollerDoCollisionResolution(devLimit, st25tbDevList, devCnt);
-        } while((detected == true) && (*devCnt < devLimit));
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerReadBlock(uint8_t blockAddress, rfalSt25tbBlock* blockData) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    rfalSt25tbReadBlockReq readBlockReq;
-
-    /* Compute Read Block Request */
-    readBlockReq.cmd = RFAL_ST25TB_READ_BLOCK_CMD;
-    readBlockReq.address = blockAddress;
-
-    /* Send Read Block Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&readBlockReq,
-        sizeof(rfalSt25tbReadBlockReq),
-        (uint8_t*)blockData,
-        sizeof(rfalSt25tbBlock),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-
-    /* Check for valid UID Response */
-    if((ret == ERR_NONE) && (rxLen != RFAL_ST25TB_BLOCK_LEN)) {
-        return ERR_PROTO;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerWriteBlock(uint8_t blockAddress, const rfalSt25tbBlock* blockData) {
-    ReturnCode ret;
-    uint16_t rxLen;
-    rfalSt25tbWriteBlockReq writeBlockReq;
-    rfalSt25tbBlock tmpBlockData;
-
-    /* Compute Write Block Request */
-    writeBlockReq.cmd = RFAL_ST25TB_WRITE_BLOCK_CMD;
-    writeBlockReq.address = blockAddress;
-    ST_MEMCPY(&writeBlockReq.data, blockData, RFAL_ST25TB_BLOCK_LEN);
-
-    /* Send Write Block Request */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&writeBlockReq,
-        sizeof(rfalSt25tbWriteBlockReq),
-        tmpBlockData,
-        RFAL_ST25TB_BLOCK_LEN,
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        (RFAL_ST25TB_FWT + RFAL_ST25TB_TW));
-
-    /* Check if there was any error besides timeout */
-    if(ret != ERR_TIMEOUT) {
-        /* Check if an unexpected answer was received */
-        if(ret == ERR_NONE) {
-            return ERR_PROTO;
-        }
-
-        /* Check whether a transmission error occurred */
-        if((ret != ERR_CRC) && (ret != ERR_FRAMING) && (ret != ERR_NOMEM) &&
-           (ret != ERR_RF_COLLISION)) {
-            return ret;
-        }
-
-        /* If a transmission error occurred (maybe noise while committing data) wait maximum programming time and verify data afterwards */
-        rfalSetGT((RFAL_ST25TB_FWT + RFAL_ST25TB_TW));
-        rfalFieldOnAndStartGT();
-    }
-
-    ret = rfalSt25tbPollerReadBlock(blockAddress, &tmpBlockData);
-    if(ret == ERR_NONE) {
-        if(ST_BYTECMP(&tmpBlockData, blockData, RFAL_ST25TB_BLOCK_LEN) == 0) {
-            return ERR_NONE;
-        }
-        return ERR_PROTO;
-    }
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerCompletion(void) {
-    uint8_t completionReq;
-
-    /* Compute Completion Request */
-    completionReq = RFAL_ST25TB_COMPLETION_CMD;
-
-    /* Send Completion Request, no response is expected */
-    return rfalTransceiveBlockingTxRx(
-        (uint8_t*)&completionReq,
-        RFAL_ST25TB_CMD_LEN,
-        NULL,
-        0,
-        NULL,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-}
-
-/*******************************************************************************/
-ReturnCode rfalSt25tbPollerResetToInventory(void) {
-    uint8_t resetInvReq;
-
-    /* Compute Completion Request */
-    resetInvReq = RFAL_ST25TB_RESET_INV_CMD;
-
-    /* Send Completion Request, no response is expected */
-    return rfalTransceiveBlockingTxRx(
-        (uint8_t*)&resetInvReq,
-        RFAL_ST25TB_CMD_LEN,
-        NULL,
-        0,
-        NULL,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25TB_FWT);
-}
-
-#endif /* RFAL_FEATURE_ST25TB */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_st25xv.c

@@ -1,818 +0,0 @@
-
-/******************************************************************************
-  * \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_st25xv.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief NFC-V ST25 NFC-V Tag specific features
- *
- *  This module provides support for ST's specific features available on
- *  NFC-V (ISO15693) tag families: ST25D, ST25TV, M24LR
- *
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_st25xv.h"
-#include "../include/rfal_nfcv.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_ST25xV
-#define RFAL_FEATURE_ST25xV false /* ST25xV module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_ST25xV
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_ST25xV_READ_CONFIG_LEN \
-    2U /*!< READ CONFIGURATION length                                         */
-#define RFAL_ST25xV_READ_MSG_LEN_LEN \
-    2U /*!< READ MESSAGE LENGTH length                                        */
-#define RFAL_ST25xV_CONF_POINTER_LEN \
-    1U /*!< READ/WRITE CONFIGURATION Pointer length                           */
-#define RFAL_ST25xV_CONF_REGISTER_LEN \
-    1U /*!< READ/WRITE CONFIGURATION Register length                          */
-#define RFAL_ST25xV_PWDNUM_LEN \
-    1U /*!< Password Number length                                            */
-#define RFAL_ST25xV_PWD_LEN \
-    8U /*!< Password length                                                   */
-#define RFAL_ST25xV_MBPOINTER_LEN \
-    1U /*!< Read Message MBPointer length                                     */
-#define RFAL_ST25xV_NUMBYTES_LEN \
-    1U /*!< Read Message Number of Bytes length                               */
-
-#define RFAL_ST25TV02K_TBOOT_RF \
-    1U /*!< RF Boot time (Minimum time from carrier generation to first data) */
-#define RFAL_ST25TV02K_TRF_OFF \
-    2U /*!< RF OFF time                                                       */
-
-#define RFAL_ST25xV_FDT_POLL_MAX \
-    rfalConvMsTo1fc(20) /*!< Maximum Wait time FDTV,EOF 20 ms    Digital 2.1  B.5 */
-#define RFAL_NFCV_FLAG_POS \
-    0U /*!< Flag byte position                                                */
-#define RFAL_NFCV_FLAG_LEN \
-    1U /*!< Flag byte length                                                  */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-static ReturnCode rfalST25xVPollerGenericReadConfiguration(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue);
-static ReturnCode rfalST25xVPollerGenericWriteConfiguration(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue);
-static ReturnCode rfalST25xVPollerGenericReadMessageLength(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* msgLen);
-static ReturnCode rfalST25xVPollerGenericReadMessage(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen);
-static ReturnCode rfalST25xVPollerGenericWriteMessage(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen);
-/*
-******************************************************************************
-* LOCAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-static ReturnCode rfalST25xVPollerGenericReadConfiguration(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue) {
-    ReturnCode ret;
-    uint8_t p;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    if(regValue == NULL) {
-        return ERR_PARAM;
-    }
-
-    p = pointer;
-
-    ret = rfalNfcvPollerTransceiveReq(
-        cmd,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        &p,
-        sizeof(uint8_t),
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-    if(ret == ERR_NONE) {
-        if(rcvLen < RFAL_ST25xV_READ_CONFIG_LEN) {
-            ret = ERR_PROTO;
-        } else {
-            *regValue = res.data[0];
-        }
-    }
-    return ret;
-}
-
-/*******************************************************************************/
-static ReturnCode rfalST25xVPollerGenericWriteConfiguration(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue) {
-    uint8_t data[RFAL_ST25xV_CONF_POINTER_LEN + RFAL_ST25xV_CONF_REGISTER_LEN];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    dataLen = 0U;
-
-    data[dataLen++] = pointer;
-    data[dataLen++] = regValue;
-
-    return rfalNfcvPollerTransceiveReq(
-        cmd,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-static ReturnCode rfalST25xVPollerGenericReadMessageLength(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* msgLen) {
-    ReturnCode ret;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    if(msgLen == NULL) {
-        return ERR_PARAM;
-    }
-
-    ret = rfalNfcvPollerTransceiveReq(
-        cmd,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        NULL,
-        0,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-    if(ret == ERR_NONE) {
-        if(rcvLen < RFAL_ST25xV_READ_MSG_LEN_LEN) {
-            ret = ERR_PROTO;
-        } else {
-            *msgLen = res.data[0];
-        }
-    }
-    return ret;
-}
-
-/*******************************************************************************/
-static ReturnCode rfalST25xVPollerGenericReadMessage(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[RFAL_ST25xV_MBPOINTER_LEN + RFAL_ST25xV_NUMBYTES_LEN];
-    uint8_t dataLen;
-
-    dataLen = 0;
-
-    /* Compute Request Data */
-    data[dataLen++] = mbPointer;
-    data[dataLen++] = numBytes;
-
-    return rfalNfcvPollerTransceiveReq(
-        cmd, flags, RFAL_NFCV_ST_IC_MFG_CODE, uid, data, dataLen, rxBuf, rxBufLen, rcvLen);
-}
-
-/*******************************************************************************/
-static ReturnCode rfalST25xVPollerGenericWriteMessage(
-    uint8_t cmd,
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen) {
-    ReturnCode ret;
-    uint8_t reqFlag;
-    uint16_t msgIt;
-    rfalBitRate rxBR;
-    bool fastMode;
-    rfalNfcvGenericRes res;
-    uint16_t rcvLen;
-
-    /* Calculate required Tx buf length:                    Mfg Code               UID                      MSGLen  MSGLen+1 */
-    msgIt = (uint16_t)(msgLen + sizeof(flags) + sizeof(cmd) + 1U +
-                       ((uid != NULL) ? RFAL_NFCV_UID_LEN : 0U) + 1U + 1U);
-    /* Note:  MSGlength parameter of the command is the number of Data bytes minus - 1 (00 for 1 byte of data, FFh for 256 bytes of data) */
-
-    /* Check for valid parameters */
-    if((txBuf == NULL) || (msgData == NULL) || (txBufLen < msgIt)) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-    fastMode = false;
-
-    /* Check if the command is an ST's Fast command */
-    if(cmd == (uint8_t)RFAL_NFCV_CMD_FAST_WRITE_MESSAGE) {
-        /* Store current Rx bit rate and move to fast mode */
-        rfalGetBitRate(NULL, &rxBR);
-        rfalSetBitRate(RFAL_BR_KEEP, RFAL_BR_52p97);
-
-        fastMode = true;
-    }
-
-    /* Compute Request Command */
-    reqFlag = (uint8_t)(flags & (~((uint32_t)RFAL_NFCV_REQ_FLAG_ADDRESS) &
-                                 ~((uint32_t)RFAL_NFCV_REQ_FLAG_SELECT)));
-    reqFlag |=
-        ((uid != NULL) ? (uint8_t)RFAL_NFCV_REQ_FLAG_ADDRESS : (uint8_t)RFAL_NFCV_REQ_FLAG_SELECT);
-
-    txBuf[msgIt++] = reqFlag;
-    txBuf[msgIt++] = cmd;
-    txBuf[msgIt++] = RFAL_NFCV_ST_IC_MFG_CODE;
-
-    if(uid != NULL) {
-        ST_MEMCPY(&txBuf[msgIt], uid, RFAL_NFCV_UID_LEN);
-        msgIt += RFAL_NFCV_UID_LEN;
-    }
-    txBuf[msgIt++] = msgLen;
-    ST_MEMCPY(
-        &txBuf[msgIt],
-        msgData,
-        (uint16_t)(msgLen + (uint16_t)1U)); /* Message Data contains (MSGLength + 1) bytes */
-    msgIt += (uint16_t)(msgLen + (uint16_t)1U);
-
-    /* Transceive Command */
-    ret = rfalTransceiveBlockingTxRx(
-        txBuf,
-        msgIt,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_ST25xV_FDT_POLL_MAX);
-
-    /* Restore Rx BitRate */
-    if(fastMode) {
-        rfalSetBitRate(RFAL_BR_KEEP, rxBR);
-    }
-
-    if(ret != ERR_NONE) {
-        return ret;
-    }
-
-    /* Check if the response minimum length has been received */
-    if(rcvLen < (uint8_t)RFAL_NFCV_FLAG_LEN) {
-        return ERR_PROTO;
-    }
-
-    /* Check if an error has been signalled */
-    if((res.RES_FLAG & (uint8_t)RFAL_NFCV_RES_FLAG_ERROR) != 0U) {
-        return ERR_PROTO;
-    }
-
-    return ERR_NONE;
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerM24LRReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[RFAL_NFCV_BLOCKNUM_M24LR_LEN];
-    uint8_t dataLen;
-
-    dataLen = 0;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)blockNum; /* Set M24LR Block Number (16 bits) LSB */
-    data[dataLen++] = (uint8_t)(blockNum >> 8U); /* Set M24LR Block Number (16 bits) MSB */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_READ_SINGLE_BLOCK,
-        (flags | (uint8_t)RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT),
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerM24LRWriteSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    const uint8_t* wrData,
-    uint8_t blockLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_M24LR_LEN + RFAL_NFCV_MAX_BLOCK_LEN)];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    /* Check for valid parameters */
-    if((blockLen == 0U) || (blockLen > (uint8_t)RFAL_NFCV_MAX_BLOCK_LEN) || (wrData == NULL)) {
-        return ERR_PARAM;
-    }
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)blockNum; /* Set M24LR Block Number (16 bits) LSB */
-    data[dataLen++] = (uint8_t)(blockNum >> 8U); /* Set M24LR Block Number (16 bits) MSB */
-    ST_MEMCPY(&data[dataLen], wrData, blockLen); /* Append Block data to write       */
-    dataLen += blockLen;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_WRITE_SINGLE_BLOCK,
-        (flags | (uint8_t)RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT),
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerM24LRReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_M24LR_LEN + RFAL_NFCV_BLOCKNUM_M24LR_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)firstBlockNum; /* Set M24LR Block Number (16 bits) LSB */
-    data[dataLen++] = (uint8_t)(firstBlockNum >> 8U); /* Set M24LR Block Number (16 bits) MSB */
-    data[dataLen++] = numOfBlocks; /* Set number of blocks to read         */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_READ_MULTIPLE_BLOCKS,
-        (flags | (uint8_t)RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT),
-        RFAL_NFCV_PARAM_SKIP,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t bn;
-
-    bn = blockNum;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_READ_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        &bn,
-        sizeof(uint8_t),
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerM24LRFastReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[RFAL_NFCV_BLOCKNUM_M24LR_LEN];
-    uint8_t dataLen;
-
-    dataLen = 0;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)blockNum; /* Set M24LR Block Number (16 bits) LSB */
-    data[dataLen++] = (uint8_t)(blockNum >> 8U); /* Set M24LR Block Number (16 bits) MSB */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_READ_SINGLE_BLOCK,
-        (flags | (uint8_t)RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT),
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerM24LRFastReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_M24LR_LEN + RFAL_NFCV_BLOCKNUM_M24LR_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)firstBlockNum; /* Set M24LR Block Number (16 bits) LSB */
-    data[dataLen++] = (uint8_t)(firstBlockNum >> 8U); /* Set M24LR Block Number (16 bits) MSB */
-    data[dataLen++] = numOfBlocks; /* Set number of blocks to read         */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_READ_MULTIPLE_BLOCKS,
-        (flags | (uint8_t)RFAL_NFCV_REQ_FLAG_PROTOCOL_EXT),
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t firstBlockNum,
-    uint8_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_LEN + RFAL_NFCV_BLOCKNUM_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = firstBlockNum; /* Set first Block Number       */
-    data[dataLen++] = numOfBlocks; /* Set number of blocks to read */
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_READ_MULTIPLE_BLOCKS,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastExtendedReadSingleBlock(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t blockNum,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[RFAL_NFCV_BLOCKNUM_EXTENDED_LEN];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)
-        blockNum; /* TS T5T 1.0 BNo is considered as a multi-byte field. TS T5T 1.0 5.1.1.13 multi-byte field follows [DIGITAL]. [DIGITAL] 9.3.1 A multiple byte field is transmitted LSB first. */
-    data[dataLen++] = (uint8_t)((blockNum >> 8U) & 0xFFU);
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_EXTENDED_READ_SINGLE_BLOCK,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastExtReadMultipleBlocks(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint16_t firstBlockNum,
-    uint16_t numOfBlocks,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    uint8_t data[(RFAL_NFCV_BLOCKNUM_EXTENDED_LEN + RFAL_NFCV_BLOCKNUM_EXTENDED_LEN)];
-    uint8_t dataLen;
-
-    dataLen = 0U;
-
-    /* Compute Request Data */
-    data[dataLen++] = (uint8_t)((firstBlockNum >> 0U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((firstBlockNum >> 8U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((numOfBlocks >> 0U) & 0xFFU);
-    data[dataLen++] = (uint8_t)((numOfBlocks >> 8U) & 0xFFU);
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_FAST_EXTENDED_READ_MULTIPLE_BLOCKS,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerReadConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue) {
-    return rfalST25xVPollerGenericReadConfiguration(
-        RFAL_NFCV_CMD_READ_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerWriteConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue) {
-    return rfalST25xVPollerGenericWriteConfiguration(
-        RFAL_NFCV_CMD_WRITE_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerReadDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue) {
-    return rfalST25xVPollerGenericReadConfiguration(
-        RFAL_NFCV_CMD_READ_DYN_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerWriteDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue) {
-    return rfalST25xVPollerGenericWriteConfiguration(
-        RFAL_NFCV_CMD_WRITE_DYN_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastReadDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t* regValue) {
-    return rfalST25xVPollerGenericReadConfiguration(
-        RFAL_NFCV_CMD_FAST_READ_DYN_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastWriteDynamicConfiguration(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pointer,
-    uint8_t regValue) {
-    return rfalST25xVPollerGenericWriteConfiguration(
-        RFAL_NFCV_CMD_FAST_WRITE_DYN_CONFIGURATION, flags, uid, pointer, regValue);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerPresentPassword(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t pwdNum,
-    const uint8_t* pwd,
-    uint8_t pwdLen) {
-    uint8_t data[RFAL_ST25xV_PWDNUM_LEN + RFAL_ST25xV_PWD_LEN];
-    uint8_t dataLen;
-    uint16_t rcvLen;
-    rfalNfcvGenericRes res;
-
-    if((pwdLen > RFAL_ST25xV_PWD_LEN) || (pwd == NULL)) {
-        return ERR_PARAM;
-    }
-
-    dataLen = 0U;
-    data[dataLen++] = pwdNum;
-    if(pwdLen > 0U) {
-        ST_MEMCPY(&data[dataLen], pwd, pwdLen);
-    }
-    dataLen += pwdLen;
-
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_PRESENT_PASSWORD,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        data,
-        dataLen,
-        (uint8_t*)&res,
-        sizeof(rfalNfcvGenericRes),
-        &rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerGetRandomNumber(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    rfalFieldOff();
-    platformDelay(RFAL_ST25TV02K_TRF_OFF);
-    rfalNfcvPollerInitialize();
-    rfalFieldOnAndStartGT();
-    platformDelay(RFAL_ST25TV02K_TBOOT_RF);
-    return rfalNfcvPollerTransceiveReq(
-        RFAL_NFCV_CMD_GET_RANDOM_NUMBER,
-        flags,
-        RFAL_NFCV_ST_IC_MFG_CODE,
-        uid,
-        NULL,
-        0U,
-        rxBuf,
-        rxBufLen,
-        rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerWriteMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen) {
-    return rfalST25xVPollerGenericWriteMessage(
-        RFAL_NFCV_CMD_WRITE_MESSAGE, flags, uid, msgLen, msgData, txBuf, txBufLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastWriteMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t msgLen,
-    const uint8_t* msgData,
-    uint8_t* txBuf,
-    uint16_t txBufLen) {
-    return rfalST25xVPollerGenericWriteMessage(
-        RFAL_NFCV_CMD_FAST_WRITE_MESSAGE, flags, uid, msgLen, msgData, txBuf, txBufLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerReadMessageLength(uint8_t flags, const uint8_t* uid, uint8_t* msgLen) {
-    return rfalST25xVPollerGenericReadMessageLength(
-        RFAL_NFCV_CMD_READ_MESSAGE_LENGTH, flags, uid, msgLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastReadMsgLength(uint8_t flags, const uint8_t* uid, uint8_t* msgLen) {
-    return rfalST25xVPollerGenericReadMessageLength(
-        RFAL_NFCV_CMD_FAST_READ_MESSAGE_LENGTH, flags, uid, msgLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerReadMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    return rfalST25xVPollerGenericReadMessage(
-        RFAL_NFCV_CMD_READ_MESSAGE, flags, uid, mbPointer, numBytes, rxBuf, rxBufLen, rcvLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalST25xVPollerFastReadMessage(
-    uint8_t flags,
-    const uint8_t* uid,
-    uint8_t mbPointer,
-    uint8_t numBytes,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rcvLen) {
-    return rfalST25xVPollerGenericReadMessage(
-        RFAL_NFCV_CMD_FAST_READ_MESSAGE, flags, uid, mbPointer, numBytes, rxBuf, rxBufLen, rcvLen);
-}
-
-#endif /* RFAL_FEATURE_ST25xV */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_t1t.c

@@ -1,233 +0,0 @@
-
-/******************************************************************************
-  * \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_t1t.c
- *
- *  \author Gustavo Patricio
- *
- *  \brief Provides NFC-A T1T convenience methods and definitions
- *  
- *  This module provides an interface to perform as a NFC-A Reader/Writer
- *  to handle a Type 1 Tag T1T (Topaz) 
- *  
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_t1t.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_T1T
-#define RFAL_FEATURE_T1T false /* T1T module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_T1T
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-
-#define RFAL_T1T_DRD_READ \
-    (1236U * 2U) /*!< DRD for Reads with n=9         => 1236/fc  ~= 91 us   T1T 1.2  4.4.2 */
-#define RFAL_T1T_DRD_WRITE \
-    36052U /*!< DRD for Write with n=281       => 36052/fc ~= 2659 us T1T 1.2  4.4.2 */
-#define RFAL_T1T_DRD_WRITE_E \
-    70996U /*!< DRD for Write/Erase with n=554 => 70996/fc ~= 5236 us T1T 1.2  4.4.2 */
-
-#define RFAL_T1T_RID_RES_HR0_VAL \
-    0x10U /*!< HR0 indicating NDEF support  Digital 2.0 (Candidate) 11.6.2.1        */
-#define RFAL_T1T_RID_RES_HR0_MASK \
-    0xF0U /*!< HR0 most significant nibble mask                                     */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-A T1T (Topaz) RID_REQ  Digital 1.1  10.6.1 & Table 49 */
-typedef struct {
-    uint8_t cmd; /*!< T1T cmd: RID              */
-    uint8_t add; /*!< ADD: undefined value      */
-    uint8_t data; /*!< DATA: undefined value     */
-    uint8_t uid[RFAL_T1T_UID_LEN]; /*!< UID-echo: undefined value */
-} rfalT1TRidReq;
-
-/*! NFC-A T1T (Topaz) RALL_REQ   T1T 1.2  Table 4 */
-typedef struct {
-    uint8_t cmd; /*!< T1T cmd: RALL             */
-    uint8_t add1; /*!< ADD: 0x00                 */
-    uint8_t add0; /*!< ADD: 0x00                 */
-    uint8_t uid[RFAL_T1T_UID_LEN]; /*!< UID                       */
-} rfalT1TRallReq;
-
-/*! NFC-A T1T (Topaz) WRITE_REQ   T1T 1.2  Table 4 */
-typedef struct {
-    uint8_t cmd; /*!< T1T cmd: RALL             */
-    uint8_t add; /*!< ADD                       */
-    uint8_t data; /*!< DAT                       */
-    uint8_t uid[RFAL_T1T_UID_LEN]; /*!< UID                       */
-} rfalT1TWriteReq;
-
-/*! NFC-A T1T (Topaz) WRITE_RES   T1T 1.2  Table 4 */
-typedef struct {
-    uint8_t add; /*!< ADD                       */
-    uint8_t data; /*!< DAT                       */
-} rfalT1TWriteRes;
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-ReturnCode rfalT1TPollerInitialize(void) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(ret, rfalSetMode(RFAL_MODE_POLL_NFCA_T1T, RFAL_BR_106, RFAL_BR_106));
-    rfalSetErrorHandling(RFAL_ERRORHANDLING_NFC);
-
-    rfalSetGT(
-        RFAL_GT_NONE); /* T1T should only be initialized after NFC-A mode, therefore the GT has been fulfilled */
-    rfalSetFDTListen(
-        RFAL_FDT_LISTEN_NFCA_POLLER); /* T1T uses NFC-A FDT Listen with n=9   Digital 1.1  10.7.2                             */
-    rfalSetFDTPoll(RFAL_FDT_POLL_NFCA_T1T_POLLER);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalT1TPollerRid(rfalT1TRidRes* ridRes) {
-    ReturnCode ret;
-    rfalT1TRidReq ridReq;
-    uint16_t rcvdLen;
-
-    if(ridRes == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Compute RID command and set Undefined Values to 0x00    Digital 1.1 10.6.1 */
-    ST_MEMSET(&ridReq, 0x00, sizeof(rfalT1TRidReq));
-    ridReq.cmd = (uint8_t)RFAL_T1T_CMD_RID;
-
-    EXIT_ON_ERR(
-        ret,
-        rfalTransceiveBlockingTxRx(
-            (uint8_t*)&ridReq,
-            sizeof(rfalT1TRidReq),
-            (uint8_t*)ridRes,
-            sizeof(rfalT1TRidRes),
-            &rcvdLen,
-            RFAL_TXRX_FLAGS_DEFAULT,
-            RFAL_T1T_DRD_READ));
-
-    /* Check expected RID response length and the HR0   Digital 2.0 (Candidate) 11.6.2.1 */
-    if((rcvdLen != sizeof(rfalT1TRidRes)) ||
-       ((ridRes->hr0 & RFAL_T1T_RID_RES_HR0_MASK) != RFAL_T1T_RID_RES_HR0_VAL)) {
-        return ERR_PROTO;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode
-    rfalT1TPollerRall(const uint8_t* uid, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rxRcvdLen) {
-    rfalT1TRallReq rallReq;
-
-    if((rxBuf == NULL) || (uid == NULL) || (rxRcvdLen == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /* Compute RALL command and set Add to 0x00 */
-    ST_MEMSET(&rallReq, 0x00, sizeof(rfalT1TRallReq));
-    rallReq.cmd = (uint8_t)RFAL_T1T_CMD_RALL;
-    ST_MEMCPY(rallReq.uid, uid, RFAL_T1T_UID_LEN);
-
-    return rfalTransceiveBlockingTxRx(
-        (uint8_t*)&rallReq,
-        sizeof(rfalT1TRallReq),
-        (uint8_t*)rxBuf,
-        rxBufLen,
-        rxRcvdLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_T1T_DRD_READ);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT1TPollerWrite(const uint8_t* uid, uint8_t address, uint8_t data) {
-    rfalT1TWriteReq writeReq;
-    rfalT1TWriteRes writeRes;
-    uint16_t rxRcvdLen;
-    ReturnCode err;
-
-    if(uid == NULL) {
-        return ERR_PARAM;
-    }
-
-    writeReq.cmd = (uint8_t)RFAL_T1T_CMD_WRITE_E;
-    writeReq.add = address;
-    writeReq.data = data;
-    ST_MEMCPY(writeReq.uid, uid, RFAL_T1T_UID_LEN);
-
-    err = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&writeReq,
-        sizeof(rfalT1TWriteReq),
-        (uint8_t*)&writeRes,
-        sizeof(rfalT1TWriteRes),
-        &rxRcvdLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_T1T_DRD_WRITE_E);
-
-    if(err == ERR_NONE) {
-        if((writeReq.add != writeRes.add) || (writeReq.data != writeRes.data) ||
-           (rxRcvdLen != sizeof(rfalT1TWriteRes))) {
-            return ERR_PROTO;
-        }
-    }
-    return err;
-}
-
-#endif /* RFAL_FEATURE_T1T */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_t2t.c

@@ -1,253 +0,0 @@
-
-/******************************************************************************
-  * \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_t2t.c
- *
- *  \author 
- *
- *  \brief Provides NFC-A T2T convenience methods and definitions
- *  
- *  This module provides an interface to perform as a NFC-A Reader/Writer
- *  to handle a Type 2 Tag T2T 
- *  
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_t2t.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_T2T
-#define RFAL_FEATURE_T2T false /* T2T module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_T2T
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-#define RFAL_FDT_POLL_READ_MAX \
-    rfalConvMsTo1fc(           \
-        5U) /*!< Maximum Wait time for Read command as defined in TS T2T 1.0 table 18   */
-#define RFAL_FDT_POLL_WRITE_MAX \
-    rfalConvMsTo1fc(            \
-        10U) /*!< Maximum Wait time for Write command as defined in TS T2T 1.0 table 18  */
-#define RFAL_FDT_POLL_SL_MAX \
-    rfalConvMsTo1fc(         \
-        1U) /*!< Maximum Wait time for Sector Select as defined in TS T2T 1.0 table 18  */
-#define RFAL_T2T_ACK_NACK_LEN \
-    1U /*!< Len of NACK in bytes (4 bits)                                          */
-#define RFAL_T2T_ACK \
-    0x0AU /*!< ACK value                                                              */
-#define RFAL_T2T_ACK_MASK \
-    0x0FU /*!< ACK value                                                              */
-
-#define RFAL_T2T_SECTOR_SELECT_P1_BYTE2 \
-    0xFFU /*!< Sector Select Packet 1 byte 2                                          */
-#define RFAL_T2T_SECTOR_SELECT_P2_RFU_LEN \
-    3U /*!< Sector Select RFU length                                               */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! NFC-A T2T command set    T2T 1.0 5.1 */
-typedef enum {
-    RFAL_T2T_CMD_READ = 0x30, /*!< T2T Read                                */
-    RFAL_T2T_CMD_WRITE = 0xA2, /*!< T2T Write                               */
-    RFAL_T2T_CMD_SECTOR_SELECT = 0xC2 /*!< T2T Sector Select                       */
-} rfalT2Tcmds;
-
-/*! NFC-A T2T READ     T2T 1.0 5.2 and table 11 */
-typedef struct {
-    uint8_t code; /*!< Command code                            */
-    uint8_t blNo; /*!< Block number                            */
-} rfalT2TReadReq;
-
-/*! NFC-A T2T WRITE    T2T 1.0 5.3 and table 12 */
-typedef struct {
-    uint8_t code; /*!< Command code                            */
-    uint8_t blNo; /*!< Block number                            */
-    uint8_t data[RFAL_T2T_WRITE_DATA_LEN]; /*!< Data                                    */
-} rfalT2TWriteReq;
-
-/*! NFC-A T2T SECTOR SELECT Packet 1   T2T 1.0 5.4 and table 13 */
-typedef struct {
-    uint8_t code; /*!< Command code                            */
-    uint8_t byte2; /*!< Sector Select Packet 1 byte 2           */
-} rfalT2TSectorSelectP1Req;
-
-/*! NFC-A T2T SECTOR SELECT Packet 2   T2T 1.0 5.4 and table 13 */
-typedef struct {
-    uint8_t secNo; /*!< Block number                   */
-    uint8_t rfu[RFAL_T2T_SECTOR_SELECT_P2_RFU_LEN]; /*!< Sector Select Packet RFU       */
-} rfalT2TSectorSelectP2Req;
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTIONS
- ******************************************************************************
- */
-
-ReturnCode
-    rfalT2TPollerRead(uint8_t blockNum, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rcvLen) {
-    ReturnCode ret;
-    rfalT2TReadReq req;
-
-    if((rxBuf == NULL) || (rcvLen == NULL)) {
-        return ERR_PARAM;
-    }
-
-    req.code = (uint8_t)RFAL_T2T_CMD_READ;
-    req.blNo = blockNum;
-
-    /* Transceive Command */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&req,
-        sizeof(rfalT2TReadReq),
-        rxBuf,
-        rxBufLen,
-        rcvLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_FDT_POLL_READ_MAX);
-
-    /* T2T 1.0 5.2.1.7 The Reader/Writer SHALL treat a NACK in response to a READ Command as a Protocol Error */
-    if((ret == ERR_INCOMPLETE_BYTE) && (*rcvLen == RFAL_T2T_ACK_NACK_LEN) &&
-       ((*rxBuf & RFAL_T2T_ACK_MASK) != RFAL_T2T_ACK)) {
-        return ERR_PROTO;
-    }
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalT2TPollerWrite(uint8_t blockNum, const uint8_t* wrData) {
-    ReturnCode ret;
-    rfalT2TWriteReq req;
-    uint8_t res;
-    uint16_t rxLen;
-
-    req.code = (uint8_t)RFAL_T2T_CMD_WRITE;
-    req.blNo = blockNum;
-    ST_MEMCPY(req.data, wrData, RFAL_T2T_WRITE_DATA_LEN);
-
-    /* Transceive WRITE Command */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&req,
-        sizeof(rfalT2TWriteReq),
-        &res,
-        sizeof(uint8_t),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_FDT_POLL_READ_MAX);
-
-    /* Check for a valid ACK */
-    if((ret == ERR_INCOMPLETE_BYTE) || (ret == ERR_NONE)) {
-        ret = ERR_PROTO;
-
-        if((rxLen == RFAL_T2T_ACK_NACK_LEN) && ((res & RFAL_T2T_ACK_MASK) == RFAL_T2T_ACK)) {
-            ret = ERR_NONE;
-        }
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalT2TPollerSectorSelect(uint8_t sectorNum) {
-    rfalT2TSectorSelectP1Req p1Req;
-    rfalT2TSectorSelectP2Req p2Req;
-    ReturnCode ret;
-    uint8_t res;
-    uint16_t rxLen;
-
-    /* Compute SECTOR SELECT Packet 1  */
-    p1Req.code = (uint8_t)RFAL_T2T_CMD_SECTOR_SELECT;
-    p1Req.byte2 = RFAL_T2T_SECTOR_SELECT_P1_BYTE2;
-
-    /* Transceive SECTOR SELECT Packet 1 */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&p1Req,
-        sizeof(rfalT2TSectorSelectP1Req),
-        &res,
-        sizeof(uint8_t),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_FDT_POLL_SL_MAX);
-
-    /* Check and report any transmission error */
-    if((ret != ERR_INCOMPLETE_BYTE) && (ret != ERR_NONE)) {
-        return ret;
-    }
-
-    /* Ensure that an ACK was received */
-    if((ret != ERR_INCOMPLETE_BYTE) || (rxLen != RFAL_T2T_ACK_NACK_LEN) ||
-       ((res & RFAL_T2T_ACK_MASK) != RFAL_T2T_ACK)) {
-        return ERR_PROTO;
-    }
-
-    /* Compute SECTOR SELECT Packet 2  */
-    p2Req.secNo = sectorNum;
-    ST_MEMSET(&p2Req.rfu, 0x00, RFAL_T2T_SECTOR_SELECT_P2_RFU_LEN);
-
-    /* Transceive SECTOR SELECT Packet 2 */
-    ret = rfalTransceiveBlockingTxRx(
-        (uint8_t*)&p2Req,
-        sizeof(rfalT2TSectorSelectP2Req),
-        &res,
-        sizeof(uint8_t),
-        &rxLen,
-        RFAL_TXRX_FLAGS_DEFAULT,
-        RFAL_FDT_POLL_SL_MAX);
-
-    /* T2T 1.0 5.4.1.14 The Reader/Writer SHALL treat any response received before the end of PATT2T,SL,MAX as a Protocol Error */
-    if((ret == ERR_NONE) || (ret == ERR_INCOMPLETE_BYTE)) {
-        return ERR_PROTO;
-    }
-
-    /* T2T 1.0 5.4.1.13 The Reader/Writer SHALL treat the transmission of the SECTOR SELECT Command Packet 2 as being successful when it receives no response until PATT2T,SL,MAX. */
-    if(ret == ERR_TIMEOUT) {
-        return ERR_NONE;
-    }
-
-    return ret;
-}
-
-#endif /* RFAL_FEATURE_T2T */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/rfal_t4t.c

@@ -1,397 +0,0 @@
-
-/******************************************************************************
-  * \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_t4t.h
- *
- *  \author Gustavo Patricio
- *
- *  \brief Provides convenience methods and definitions for T4T (ISO7816-4)
- *  
- *  This module provides an interface to exchange T4T APDUs according to 
- *  NFC Forum T4T and ISO7816-4
- *  
- *  This implementation was based on the following specs:
- *    - ISO/IEC 7816-4  3rd Edition 2013-04-15
- *    - NFC Forum T4T Technical Specification 1.0 2017-08-28
- *  
- */
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../include/rfal_t4t.h"
-#include "../utils.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCH
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_T4T
-#define RFAL_FEATURE_T4T false /* T4T module configuration missing. Disabled by default */
-#endif
-
-#if RFAL_FEATURE_T4T
-
-/*
- ******************************************************************************
- * GLOBAL DEFINES
- ******************************************************************************
- */
-#define RFAL_T4T_OFFSET_DO 0x54U /*!< Tag value for offset BER-TLV data object          */
-#define RFAL_T4T_LENGTH_DO 0x03U /*!< Len value for offset BER-TLV data object          */
-#define RFAL_T4T_DATA_DO 0x53U /*!< Tag value for data BER-TLV data object            */
-
-#define RFAL_T4T_MAX_LC 255U /*!< Maximum Lc value for short Lc coding              */
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*
- ******************************************************************************
- * LOCAL VARIABLES
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * GLOBAL FUNCTIONS
- ******************************************************************************
- */
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeCAPDU(const rfalT4tCApduParam* apduParam) {
-    uint8_t hdrLen;
-    uint16_t msgIt;
-
-    if((apduParam == NULL) || (apduParam->cApduBuf == NULL) || (apduParam->cApduLen == NULL)) {
-        return ERR_PARAM;
-    }
-
-    msgIt = 0;
-    *(apduParam->cApduLen) = 0;
-
-    /*******************************************************************************/
-    /* Compute Command-APDU  according to the format   T4T 1.0 5.1.2 & ISO7816-4 2013 Table 1 */
-
-    /* Check if Data is present */
-    if(apduParam->LcFlag) {
-        if(apduParam->Lc == 0U) {
-            /* Extended field coding not supported */
-            return ERR_PARAM;
-        }
-
-        /* Check whether requested Lc fits */
-#pragma GCC diagnostic ignored "-Wtype-limits"
-        if((uint16_t)apduParam->Lc >
-           (uint16_t)(RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN - RFAL_T4T_LE_LEN)) {
-            return ERR_PARAM; /*  PRQA S  2880 # MISRA 2.1 - Unreachable code due to configuration option being set/unset  */
-        }
-
-        /* Calculate the header length a place the data/body where it should be */
-        hdrLen = RFAL_T4T_MAX_CAPDU_PROLOGUE_LEN + RFAL_T4T_LC_LEN;
-
-        /* make sure not to exceed buffer size */
-        if(((uint16_t)hdrLen + (uint16_t)apduParam->Lc +
-            (apduParam->LeFlag ? RFAL_T4T_LC_LEN : 0U)) > RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN) {
-            return ERR_NOMEM; /*  PRQA S  2880 # MISRA 2.1 - Unreachable code due to configuration option being set/unset */
-        }
-        ST_MEMMOVE(&apduParam->cApduBuf->apdu[hdrLen], apduParam->cApduBuf->apdu, apduParam->Lc);
-    }
-
-    /* Prepend the ADPDU's header */
-    apduParam->cApduBuf->apdu[msgIt++] = apduParam->CLA;
-    apduParam->cApduBuf->apdu[msgIt++] = apduParam->INS;
-    apduParam->cApduBuf->apdu[msgIt++] = apduParam->P1;
-    apduParam->cApduBuf->apdu[msgIt++] = apduParam->P2;
-
-    /* Check if Data field length is to be added */
-    if(apduParam->LcFlag) {
-        apduParam->cApduBuf->apdu[msgIt++] = apduParam->Lc;
-        msgIt += apduParam->Lc;
-    }
-
-    /* Check if Expected Response Length is to be added */
-    if(apduParam->LeFlag) {
-        apduParam->cApduBuf->apdu[msgIt++] = apduParam->Le;
-    }
-
-    *(apduParam->cApduLen) = msgIt;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerParseRAPDU(rfalT4tRApduParam* apduParam) {
-    if((apduParam == NULL) || (apduParam->rApduBuf == NULL)) {
-        return ERR_PARAM;
-    }
-
-    if(apduParam->rcvdLen < RFAL_T4T_MAX_RAPDU_SW1SW2_LEN) {
-        return ERR_PROTO;
-    }
-
-    apduParam->rApduBodyLen = (apduParam->rcvdLen - (uint16_t)RFAL_T4T_MAX_RAPDU_SW1SW2_LEN);
-    apduParam->statusWord = GETU16((&apduParam->rApduBuf->apdu[apduParam->rApduBodyLen]));
-
-    /* Check SW1 SW2    T4T 1.0 5.1.3 NOTE */
-    if(apduParam->statusWord == RFAL_T4T_ISO7816_STATUS_COMPLETE) {
-        return ERR_NONE;
-    }
-
-    return ERR_REQUEST;
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeSelectAppl(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* aid,
-    uint8_t aidLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-
-    /* CLA INS P1  P2   Lc  Data   Le  */
-    /* 00h A4h 00h 00h  07h AID    00h */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_SELECT;
-    cAPDU.P1 = RFAL_T4T_ISO7816_P1_SELECT_BY_DF_NAME;
-    cAPDU.P2 = RFAL_T4T_ISO7816_P2_SELECT_FIRST_OR_ONLY_OCCURENCE |
-               RFAL_T4T_ISO7816_P2_SELECT_RETURN_FCI_TEMPLATE;
-    cAPDU.Lc = aidLen;
-    cAPDU.Le = 0x00;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = true;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    if(aidLen > 0U) {
-        ST_MEMCPY(cAPDU.cApduBuf->apdu, aid, aidLen);
-    }
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeSelectFile(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* fid,
-    uint8_t fidLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-
-    /* CLA INS P1  P2   Lc  Data   Le  */
-    /* 00h A4h 00h 0Ch  02h FID    -   */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_SELECT;
-    cAPDU.P1 = RFAL_T4T_ISO7816_P1_SELECT_BY_FILEID;
-    cAPDU.P2 = RFAL_T4T_ISO7816_P2_SELECT_FIRST_OR_ONLY_OCCURENCE |
-               RFAL_T4T_ISO7816_P2_SELECT_NO_RESPONSE_DATA;
-    cAPDU.Lc = fidLen;
-    cAPDU.Le = 0x00;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = false;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    if(fidLen > 0U) {
-        ST_MEMCPY(cAPDU.cApduBuf->apdu, fid, fidLen);
-    }
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeSelectFileV1Mapping(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    const uint8_t* fid,
-    uint8_t fidLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-
-    /* CLA INS P1  P2   Lc  Data   Le  */
-    /* 00h A4h 00h 00h  02h FID    -   */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_SELECT;
-    cAPDU.P1 = RFAL_T4T_ISO7816_P1_SELECT_BY_FILEID;
-    cAPDU.P2 = RFAL_T4T_ISO7816_P2_SELECT_FIRST_OR_ONLY_OCCURENCE |
-               RFAL_T4T_ISO7816_P2_SELECT_RETURN_FCI_TEMPLATE;
-    cAPDU.Lc = fidLen;
-    cAPDU.Le = 0x00;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = false;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    if(fidLen > 0U) {
-        ST_MEMCPY(cAPDU.cApduBuf->apdu, fid, fidLen);
-    }
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeReadData(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint16_t offset,
-    uint8_t expLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-
-    /* CLA INS P1  P2   Lc  Data   Le  */
-    /* 00h B0h [Offset] -   -      len */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_READBINARY;
-    cAPDU.P1 = (uint8_t)((offset >> 8U) & 0xFFU);
-    cAPDU.P2 = (uint8_t)((offset >> 0U) & 0xFFU);
-    cAPDU.Le = expLen;
-    cAPDU.LcFlag = false;
-    cAPDU.LeFlag = true;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeReadDataODO(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint32_t offset,
-    uint8_t expLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-    uint8_t dataIt;
-
-    /* CLA INS P1  P2  Lc  Data         Le */
-    /* 00h B1h 00h 00h Lc  54 03 xxyyzz len */
-    /*                          [Offset]    */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_READBINARY_ODO;
-    cAPDU.P1 = 0x00U;
-    cAPDU.P2 = 0x00U;
-    cAPDU.Le = expLen;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = true;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    dataIt = 0U;
-    cApduBuf->apdu[dataIt++] = RFAL_T4T_OFFSET_DO;
-    cApduBuf->apdu[dataIt++] = RFAL_T4T_LENGTH_DO;
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset >> 16U);
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset >> 8U);
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset);
-    cAPDU.Lc = dataIt;
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeWriteData(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint16_t offset,
-    const uint8_t* data,
-    uint8_t dataLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-
-    /* CLA INS P1  P2   Lc  Data   Le  */
-    /* 00h D6h [Offset] len Data   -   */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_UPDATEBINARY;
-    cAPDU.P1 = (uint8_t)((offset >> 8U) & 0xFFU);
-    cAPDU.P2 = (uint8_t)((offset >> 0U) & 0xFFU);
-    cAPDU.Lc = dataLen;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = false;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    if(dataLen > 0U) {
-        ST_MEMCPY(cAPDU.cApduBuf->apdu, data, dataLen);
-    }
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-/*******************************************************************************/
-ReturnCode rfalT4TPollerComposeWriteDataODO(
-    rfalIsoDepApduBufFormat* cApduBuf,
-    uint32_t offset,
-    const uint8_t* data,
-    uint8_t dataLen,
-    uint16_t* cApduLen) {
-    rfalT4tCApduParam cAPDU;
-    uint8_t dataIt;
-
-    /* CLA INS P1  P2   Lc  Data                     Le  */
-    /* 00h D7h 00h 00h  len 54 03 xxyyzz 53 Ld data  -   */
-    /*                           [offset]     [data]     */
-    cAPDU.CLA = RFAL_T4T_CLA;
-    cAPDU.INS = (uint8_t)RFAL_T4T_INS_UPDATEBINARY_ODO;
-    cAPDU.P1 = 0x00U;
-    cAPDU.P2 = 0x00U;
-    cAPDU.LcFlag = true;
-    cAPDU.LeFlag = false;
-    cAPDU.cApduBuf = cApduBuf;
-    cAPDU.cApduLen = cApduLen;
-
-    dataIt = 0U;
-    cApduBuf->apdu[dataIt++] = RFAL_T4T_OFFSET_DO;
-    cApduBuf->apdu[dataIt++] = RFAL_T4T_LENGTH_DO;
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset >> 16U);
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset >> 8U);
-    cApduBuf->apdu[dataIt++] = (uint8_t)(offset);
-    cApduBuf->apdu[dataIt++] = RFAL_T4T_DATA_DO;
-    cApduBuf->apdu[dataIt++] = dataLen;
-
-    if((((uint32_t)dataLen + (uint32_t)dataIt) >= RFAL_T4T_MAX_LC) ||
-       (((uint32_t)dataLen + (uint32_t)dataIt) >= RFAL_FEATURE_ISO_DEP_APDU_MAX_LEN)) {
-        return (ERR_NOMEM);
-    }
-
-    if(dataLen > 0U) {
-        ST_MEMCPY(&cAPDU.cApduBuf->apdu[dataIt], data, dataLen);
-    }
-    dataIt += dataLen;
-    cAPDU.Lc = dataIt;
-
-    return rfalT4TPollerComposeCAPDU(&cAPDU);
-}
-
-#endif /* RFAL_FEATURE_T4T */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/rfal_analogConfigTbl.h

@@ -1,1487 +0,0 @@
-
-/******************************************************************************
-  * \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_analogConfig.h
- *
- *  \author bkam
- *
- *  \brief ST25R3916 Analog Configuration Settings
- *  
- */
-
-#ifndef ST25R3916_ANALOGCONFIG_H
-#define ST25R3916_ANALOGCONFIG_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../../include/rfal_analogConfig.h"
-#include "st25r3916_com.h"
-
-/*
- ******************************************************************************
- * DEFINES
- ******************************************************************************
- */
-
-/*
- ******************************************************************************
- * GLOBAL MACROS
- ******************************************************************************
- */
-
-/*! Macro for Configuration Setting with only one register-mask-value set: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1] */
-#define MODE_ENTRY_1_REG(MODE, R0, M0, V0)                           \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 1, \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0)
-
-/*! Macro for Configuration Setting with only two register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1] */
-#define MODE_ENTRY_2_REG(MODE, R0, M0, V0, R1, M1, V1)                                          \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 2,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1)
-
-/*! Macro for Configuration Setting with only three register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_3_REG(MODE, R0, M0, V0, R1, M1, V1, R2, M2, V2)                              \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 3,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2)
-
-/*! Macro for Configuration Setting with only four register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_4_REG(MODE, R0, M0, V0, R1, M1, V1, R2, M2, V2, R3, M3, V3)                  \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 4,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3)
-
-/*! Macro for Configuration Setting with only five register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_5_REG(MODE, R0, M0, V0, R1, M1, V1, R2, M2, V2, R3, M3, V3, R4, M4, V4)      \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 5,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4)
-
-/*! Macro for Configuration Setting with only six register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_6_REG(                                                                       \
-    MODE, R0, M0, V0, R1, M1, V1, R2, M2, V2, R3, M3, V3, R4, M4, V4, R5, M5, V5)               \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 6,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5)
-
-/*! Macro for Configuration Setting with only seven register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_7_REG(                                                                       \
-    MODE, R0, M0, V0, R1, M1, V1, R2, M2, V2, R3, M3, V3, R4, M4, V4, R5, M5, V5, R6, M6, V6)   \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 7,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6)
-
-/*! Macro for Configuration Setting with only eight register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_8_REG(                                                                       \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7)                                                                                         \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 8,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7)
-
-/*! Macro for Configuration Setting with only nine register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_9_REG(                                                                       \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7,                                                                                         \
-    R8,                                                                                         \
-    M8,                                                                                         \
-    V8)                                                                                         \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 9,                            \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8U), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8)
-
-/*! Macro for Configuration Setting with only ten register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_10_REG(                                                                      \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7,                                                                                         \
-    R8,                                                                                         \
-    M8,                                                                                         \
-    V8,                                                                                         \
-    R9,                                                                                         \
-    M9,                                                                                         \
-    V9)                                                                                         \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 10,                           \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8U), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8U), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9)
-
-/*! Macro for Configuration Setting with eleven register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_11_REG(                                                                      \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7,                                                                                         \
-    R8,                                                                                         \
-    M8,                                                                                         \
-    V8,                                                                                         \
-    R9,                                                                                         \
-    M9,                                                                                         \
-    V9,                                                                                         \
-    R10,                                                                                        \
-    M10,                                                                                        \
-    V10)                                                                                        \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 11,                           \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8U), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8U), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8U), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10)
-
-/*! Macro for Configuration Setting with twelve register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_12_REG(                                                                      \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7,                                                                                         \
-    R8,                                                                                         \
-    M8,                                                                                         \
-    V8,                                                                                         \
-    R9,                                                                                         \
-    M9,                                                                                         \
-    V9,                                                                                         \
-    R10,                                                                                        \
-    M10,                                                                                        \
-    V10,                                                                                        \
-    R11,                                                                                        \
-    M11,                                                                                        \
-    V11)                                                                                        \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 12,                           \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8U), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8U), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8U), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8U), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11)
-
-/*! Macro for Configuration Setting with thirteen register-mask-value sets: 
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_13_REG(                                                                      \
-    MODE,                                                                                       \
-    R0,                                                                                         \
-    M0,                                                                                         \
-    V0,                                                                                         \
-    R1,                                                                                         \
-    M1,                                                                                         \
-    V1,                                                                                         \
-    R2,                                                                                         \
-    M2,                                                                                         \
-    V2,                                                                                         \
-    R3,                                                                                         \
-    M3,                                                                                         \
-    V3,                                                                                         \
-    R4,                                                                                         \
-    M4,                                                                                         \
-    V4,                                                                                         \
-    R5,                                                                                         \
-    M5,                                                                                         \
-    V5,                                                                                         \
-    R6,                                                                                         \
-    M6,                                                                                         \
-    V6,                                                                                         \
-    R7,                                                                                         \
-    M7,                                                                                         \
-    V7,                                                                                         \
-    R8,                                                                                         \
-    M8,                                                                                         \
-    V8,                                                                                         \
-    R9,                                                                                         \
-    M9,                                                                                         \
-    V9,                                                                                         \
-    R10,                                                                                        \
-    M10,                                                                                        \
-    V10,                                                                                        \
-    R11,                                                                                        \
-    M11,                                                                                        \
-    V11,                                                                                        \
-    R12,                                                                                        \
-    M12,                                                                                        \
-    V12)                                                                                        \
-    (uint8_t)((uint16_t)(MODE) >> 8U), (uint8_t)((MODE) & 0xFFU), 13,                           \
-        (uint8_t)((uint16_t)(R0) >> 8U), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8U), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8U), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8U), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8U), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8U), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8U), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8U), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8U), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8U), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8U), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8U), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11), (uint8_t)((uint16_t)(R12) >> 8U),                       \
-        (uint8_t)((R12) & 0xFFU), (uint8_t)(M12), (uint8_t)(V12)
-
-/*! Macro for Configuration Setting with fourteen register-mask-value sets:
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_14_REG(                                                                     \
-    MODE,                                                                                      \
-    R0,                                                                                        \
-    M0,                                                                                        \
-    V0,                                                                                        \
-    R1,                                                                                        \
-    M1,                                                                                        \
-    V1,                                                                                        \
-    R2,                                                                                        \
-    M2,                                                                                        \
-    V2,                                                                                        \
-    R3,                                                                                        \
-    M3,                                                                                        \
-    V3,                                                                                        \
-    R4,                                                                                        \
-    M4,                                                                                        \
-    V4,                                                                                        \
-    R5,                                                                                        \
-    M5,                                                                                        \
-    V5,                                                                                        \
-    R6,                                                                                        \
-    M6,                                                                                        \
-    V6,                                                                                        \
-    R7,                                                                                        \
-    M7,                                                                                        \
-    V7,                                                                                        \
-    R8,                                                                                        \
-    M8,                                                                                        \
-    V8,                                                                                        \
-    R9,                                                                                        \
-    M9,                                                                                        \
-    V9,                                                                                        \
-    R10,                                                                                       \
-    M10,                                                                                       \
-    V10,                                                                                       \
-    R11,                                                                                       \
-    M11,                                                                                       \
-    V11,                                                                                       \
-    R12,                                                                                       \
-    M12,                                                                                       \
-    V12,                                                                                       \
-    R13,                                                                                       \
-    M13,                                                                                       \
-    V13,                                                                                       \
-    R14,                                                                                       \
-    M14,                                                                                       \
-    V14,                                                                                       \
-    R15,                                                                                       \
-    M15,                                                                                       \
-    V15)                                                                                       \
-    (uint8_t)((uint16_t)(MODE) >> 8), (uint8_t)((MODE) & 0xFFU), 14,                           \
-        (uint8_t)((uint16_t)(R0) >> 8), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11), (uint8_t)((uint16_t)(R12) >> 8),                       \
-        (uint8_t)((R12) & 0xFFU), (uint8_t)(M12), (uint8_t)(V12),                              \
-        (uint8_t)((uint16_t)(R13) >> 8), (uint8_t)((R13) & 0xFFU), (uint8_t)(M13), (uint8_t)(V13)
-
-/*! Macro for Configuration Setting with fifteen register-mask-value sets:
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_15_REG(                                                                     \
-    MODE,                                                                                      \
-    R0,                                                                                        \
-    M0,                                                                                        \
-    V0,                                                                                        \
-    R1,                                                                                        \
-    M1,                                                                                        \
-    V1,                                                                                        \
-    R2,                                                                                        \
-    M2,                                                                                        \
-    V2,                                                                                        \
-    R3,                                                                                        \
-    M3,                                                                                        \
-    V3,                                                                                        \
-    R4,                                                                                        \
-    M4,                                                                                        \
-    V4,                                                                                        \
-    R5,                                                                                        \
-    M5,                                                                                        \
-    V5,                                                                                        \
-    R6,                                                                                        \
-    M6,                                                                                        \
-    V6,                                                                                        \
-    R7,                                                                                        \
-    M7,                                                                                        \
-    V7,                                                                                        \
-    R8,                                                                                        \
-    M8,                                                                                        \
-    V8,                                                                                        \
-    R9,                                                                                        \
-    M9,                                                                                        \
-    V9,                                                                                        \
-    R10,                                                                                       \
-    M10,                                                                                       \
-    V10,                                                                                       \
-    R11,                                                                                       \
-    M11,                                                                                       \
-    V11,                                                                                       \
-    R12,                                                                                       \
-    M12,                                                                                       \
-    V12,                                                                                       \
-    R13,                                                                                       \
-    M13,                                                                                       \
-    V13,                                                                                       \
-    R14,                                                                                       \
-    M14,                                                                                       \
-    V14,                                                                                       \
-    R15,                                                                                       \
-    M15,                                                                                       \
-    V15)                                                                                       \
-    (uint8_t)((uint16_t)(MODE) >> 8), (uint8_t)((MODE) & 0xFFU), 15,                           \
-        (uint8_t)((uint16_t)(R0) >> 8), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11), (uint8_t)((uint16_t)(R12) >> 8),                       \
-        (uint8_t)((R12) & 0xFFU), (uint8_t)(M12), (uint8_t)(V12),                              \
-        (uint8_t)((uint16_t)(R13) >> 8), (uint8_t)((R13) & 0xFFU), (uint8_t)(M13),             \
-        (uint8_t)(V13), (uint8_t)((uint16_t)(R14) >> 8), (uint8_t)((R14) & 0xFFU),             \
-        (uint8_t)(M14), (uint8_t)(V14)
-
-/*! Macro for Configuration Setting with sixteen register-mask-value sets:
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_16_REG(                                                                     \
-    MODE,                                                                                      \
-    R0,                                                                                        \
-    M0,                                                                                        \
-    V0,                                                                                        \
-    R1,                                                                                        \
-    M1,                                                                                        \
-    V1,                                                                                        \
-    R2,                                                                                        \
-    M2,                                                                                        \
-    V2,                                                                                        \
-    R3,                                                                                        \
-    M3,                                                                                        \
-    V3,                                                                                        \
-    R4,                                                                                        \
-    M4,                                                                                        \
-    V4,                                                                                        \
-    R5,                                                                                        \
-    M5,                                                                                        \
-    V5,                                                                                        \
-    R6,                                                                                        \
-    M6,                                                                                        \
-    V6,                                                                                        \
-    R7,                                                                                        \
-    M7,                                                                                        \
-    V7,                                                                                        \
-    R8,                                                                                        \
-    M8,                                                                                        \
-    V8,                                                                                        \
-    R9,                                                                                        \
-    M9,                                                                                        \
-    V9,                                                                                        \
-    R10,                                                                                       \
-    M10,                                                                                       \
-    V10,                                                                                       \
-    R11,                                                                                       \
-    M11,                                                                                       \
-    V11,                                                                                       \
-    R12,                                                                                       \
-    M12,                                                                                       \
-    V12,                                                                                       \
-    R13,                                                                                       \
-    M13,                                                                                       \
-    V13,                                                                                       \
-    R14,                                                                                       \
-    M14,                                                                                       \
-    V14,                                                                                       \
-    R15,                                                                                       \
-    M15,                                                                                       \
-    V15)                                                                                       \
-    (uint8_t)((uint16_t)(MODE) >> 8), (uint8_t)((MODE) & 0xFFU), 16,                           \
-        (uint8_t)((uint16_t)(R0) >> 8), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11), (uint8_t)((uint16_t)(R12) >> 8),                       \
-        (uint8_t)((R12) & 0xFFU), (uint8_t)(M12), (uint8_t)(V12),                              \
-        (uint8_t)((uint16_t)(R13) >> 8), (uint8_t)((R13) & 0xFFU), (uint8_t)(M13),             \
-        (uint8_t)(V13), (uint8_t)((uint16_t)(R14) >> 8), (uint8_t)((R14) & 0xFFU),             \
-        (uint8_t)(M14), (uint8_t)(V14), (uint8_t)((uint16_t)(R15) >> 8),                       \
-        (uint8_t)((R15) & 0xFFU), (uint8_t)(M15), (uint8_t)(V15)
-
-/*! Macro for Configuration Setting with seventeen register-mask-value sets:
- *  - Configuration ID[2], Number of Register sets to follow[1], Register[2], Mask[1], Value[1], Register[2], Mask[1], Value[1], Register[2]... */
-#define MODE_ENTRY_17_REG(                                                                     \
-    MODE,                                                                                      \
-    R0,                                                                                        \
-    M0,                                                                                        \
-    V0,                                                                                        \
-    R1,                                                                                        \
-    M1,                                                                                        \
-    V1,                                                                                        \
-    R2,                                                                                        \
-    M2,                                                                                        \
-    V2,                                                                                        \
-    R3,                                                                                        \
-    M3,                                                                                        \
-    V3,                                                                                        \
-    R4,                                                                                        \
-    M4,                                                                                        \
-    V4,                                                                                        \
-    R5,                                                                                        \
-    M5,                                                                                        \
-    V5,                                                                                        \
-    R6,                                                                                        \
-    M6,                                                                                        \
-    V6,                                                                                        \
-    R7,                                                                                        \
-    M7,                                                                                        \
-    V7,                                                                                        \
-    R8,                                                                                        \
-    M8,                                                                                        \
-    V8,                                                                                        \
-    R9,                                                                                        \
-    M9,                                                                                        \
-    V9,                                                                                        \
-    R10,                                                                                       \
-    M10,                                                                                       \
-    V10,                                                                                       \
-    R11,                                                                                       \
-    M11,                                                                                       \
-    V11,                                                                                       \
-    R12,                                                                                       \
-    M12,                                                                                       \
-    V12,                                                                                       \
-    R13,                                                                                       \
-    M13,                                                                                       \
-    V13,                                                                                       \
-    R14,                                                                                       \
-    M14,                                                                                       \
-    V14,                                                                                       \
-    R15,                                                                                       \
-    M15,                                                                                       \
-    V15,                                                                                       \
-    R16,                                                                                       \
-    M16,                                                                                       \
-    V16)                                                                                       \
-    (uint8_t)((uint16_t)(MODE) >> 8), (uint8_t)((MODE) & 0xFFU), 17,                           \
-        (uint8_t)((uint16_t)(R0) >> 8), (uint8_t)((R0) & 0xFFU), (uint8_t)(M0), (uint8_t)(V0), \
-        (uint8_t)((uint16_t)(R1) >> 8), (uint8_t)((R1) & 0xFFU), (uint8_t)(M1), (uint8_t)(V1), \
-        (uint8_t)((uint16_t)(R2) >> 8), (uint8_t)((R2) & 0xFFU), (uint8_t)(M2), (uint8_t)(V2), \
-        (uint8_t)((uint16_t)(R3) >> 8), (uint8_t)((R3) & 0xFFU), (uint8_t)(M3), (uint8_t)(V3), \
-        (uint8_t)((uint16_t)(R4) >> 8), (uint8_t)((R4) & 0xFFU), (uint8_t)(M4), (uint8_t)(V4), \
-        (uint8_t)((uint16_t)(R5) >> 8), (uint8_t)((R5) & 0xFFU), (uint8_t)(M5), (uint8_t)(V5), \
-        (uint8_t)((uint16_t)(R6) >> 8), (uint8_t)((R6) & 0xFFU), (uint8_t)(M6), (uint8_t)(V6), \
-        (uint8_t)((uint16_t)(R7) >> 8), (uint8_t)((R7) & 0xFFU), (uint8_t)(M7), (uint8_t)(V7), \
-        (uint8_t)((uint16_t)(R8) >> 8), (uint8_t)((R8) & 0xFFU), (uint8_t)(M8), (uint8_t)(V8), \
-        (uint8_t)((uint16_t)(R9) >> 8), (uint8_t)((R9) & 0xFFU), (uint8_t)(M9), (uint8_t)(V9), \
-        (uint8_t)((uint16_t)(R10) >> 8), (uint8_t)((R10) & 0xFFU), (uint8_t)(M10),             \
-        (uint8_t)(V10), (uint8_t)((uint16_t)(R11) >> 8), (uint8_t)((R11) & 0xFFU),             \
-        (uint8_t)(M11), (uint8_t)(V11), (uint8_t)((uint16_t)(R12) >> 8),                       \
-        (uint8_t)((R12) & 0xFFU), (uint8_t)(M12), (uint8_t)(V12),                              \
-        (uint8_t)((uint16_t)(R13) >> 8), (uint8_t)((R13) & 0xFFU), (uint8_t)(M13),             \
-        (uint8_t)(V13), (uint8_t)((uint16_t)(R14) >> 8), (uint8_t)((R14) & 0xFFU),             \
-        (uint8_t)(M14), (uint8_t)(V14), (uint8_t)((uint16_t)(R15) >> 8),                       \
-        (uint8_t)((R15) & 0xFFU), (uint8_t)(M15), (uint8_t)(V15),                              \
-        (uint8_t)((uint16_t)(R16) >> 8), (uint8_t)((R16) & 0xFFU), (uint8_t)(M16), (uint8_t)(V16)
-/*
- ******************************************************************************
- * GLOBAL DATA TYPES
- ******************************************************************************
- */
-/*  PRQA S 3406 1 # MISRA 8.6 - Externally generated table included by the library */ /*  PRQA S 1514 1 # MISRA 8.9 - Externally generated table included by the library */
-const uint8_t rfalAnalogConfigDefaultSettings[] = {
-
-    /****** Default Analog Configuration for Chip-Specific Reset ******/
-    MODE_ENTRY_17_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_INIT),
-        ST25R3916_REG_IO_CONF1,
-        (ST25R3916_REG_IO_CONF1_out_cl_mask | ST25R3916_REG_IO_CONF1_lf_clk_off),
-        0x07 /* Disable MCU_CLK */
-        ,
-        ST25R3916_REG_IO_CONF2,
-        (ST25R3916_REG_IO_CONF2_miso_pd1 | ST25R3916_REG_IO_CONF2_miso_pd2),
-        0x18 /* SPI Pull downs */
-        ,
-        ST25R3916_REG_IO_CONF2,
-        ST25R3916_REG_IO_CONF2_aat_en,
-        ST25R3916_REG_IO_CONF2_aat_en /* Enable AAT */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_d_res_mask,
-        0x00 /* Set RFO resistance Active Tx */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        0xFF,
-        0x80 /* Use minimum non-overlap */
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_105mV /* Lower activation threshold (higher than deactivation)*/
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_105mV /* Lower activation threshold (higher than deactivation)*/
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_75mV /* Lower deactivation threshold */
-        ,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_mask,
-        ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_75mV /* Lower deactivation threshold */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        ST25R3916_REG_AUX_MOD_lm_ext,
-        0x00 /* Disable External Load Modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        ST25R3916_REG_AUX_MOD_lm_dri,
-        ST25R3916_REG_AUX_MOD_lm_dri /* Use internal Load Modulation */
-        ,
-        ST25R3916_REG_PASSIVE_TARGET,
-        ST25R3916_REG_PASSIVE_TARGET_fdel_mask,
-        (5U
-         << ST25R3916_REG_PASSIVE_TARGET_fdel_shift) /* Adjust the FDT to be aligned with the bitgrid  */
-        ,
-        ST25R3916_REG_PT_MOD,
-        (ST25R3916_REG_PT_MOD_ptm_res_mask | ST25R3916_REG_PT_MOD_pt_res_mask),
-        0x5f /* Reduce RFO resistance in Modulated state */
-        ,
-        ST25R3916_REG_EMD_SUP_CONF,
-        ST25R3916_REG_EMD_SUP_CONF_rx_start_emv,
-        ST25R3916_REG_EMD_SUP_CONF_rx_start_emv_on /* Enable start on first 4 bits */
-        ,
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        0x84U,
-        0x10,
-        0x10 /* Avoid chip internal overheat protection */
-        )
-
-    /****** Default Analog Configuration for Chip-Specific Poll Common ******/
-    ,
-    MODE_ENTRY_9_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_12percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x00 /* Use AM via regulator */
-        ,
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 106 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x08,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x51,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 212 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x88 /* Use Resistive AM */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        ST25R3916_REG_RES_AM_MOD_md_res_mask,
-        0x7F /* Set Resistive modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 212 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x02,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x14,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 424 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x88 /* Use Resistive AM */
-        ,
-        ST25R3916_REG_RES_AM_MOD,
-        ST25R3916_REG_RES_AM_MOD_md_res_mask,
-        0x7F /* Set Resistive modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 424 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Tx 848 ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_40percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_AUX_MOD,
-        (ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am),
-        0x00 /* Use AM via regulator */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll NFC-A Rx 848 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x44,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-A Anticolision setting ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_ANTICOL),
-        ST25R3916_REG_CORR_CONF1,
-        ST25R3916_REG_CORR_CONF1_corr_s6,
-        0x00 /* Set collision detection level different from data */
-        )
-
-#ifdef RFAL_USE_COHE
-    /****** Default Analog Configuration for Poll NFC-B Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Coherent Receiver */
-        )
-#else
-    /****** Default Analog Configuration for Poll NFC-B Rx Common ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        )
-#endif /*RFAL_USE_COHE*/
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 106 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x04,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x1B,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 212 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x02,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x14,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 424 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-
-    /****** Default Analog Configuration for Poll NFC-B Rx 848 ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB | RFAL_ANALOG_CONFIG_BITRATE_848 |
-         RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x42,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x44,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#ifdef RFAL_USE_COHE
-
-    /****** Default Analog Configuration for Poll NFC-F Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Pulse Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#else
-    /****** Default Analog Configuration for Poll NFC-F Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x3D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x54,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x00)
-#endif /*RFAL_USE_COHE*/
-
-        ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV | RFAL_ANALOG_CONFIG_BITRATE_1OF4 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK */
-        )
-
-#ifdef RFAL_USE_COHE
-    /****** Default Analog Configuration for Poll NFC-V Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_coherent /* Use Pulse Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x01)
-#else
-    /****** Default Analog Configuration for Poll NFC-V Rx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_AUX,
-        ST25R3916_REG_AUX_dis_corr,
-        ST25R3916_REG_AUX_dis_corr_correlator /* Use Correlator Receiver */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_RX_CONF2,
-        0xFF,
-        0x2D,
-        ST25R3916_REG_RX_CONF3,
-        0xFF,
-        0x00,
-        ST25R3916_REG_RX_CONF4,
-        0xFF,
-        0x00,
-        ST25R3916_REG_CORR_CONF1,
-        0xFF,
-        0x13,
-        ST25R3916_REG_CORR_CONF2,
-        0xFF,
-        0x01)
-#endif /*RFAL_USE_COHE*/
-
-    /****** Default Analog Configuration for Poll AP2P Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_106 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Poll AP2P Tx 212 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_212 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Poll AP2P Tx 424 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P | RFAL_ANALOG_CONFIG_BITRATE_424 |
-         RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Chip-Specific Listen On ******/
-    ,
-    MODE_ENTRY_6_REG(
-        (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_ON),
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x00 /* Set Antenna Tuning (Listener): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0xff /* Set Antenna Tuning (Listener): ANTL */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx Common ******/
-    ,
-    MODE_ENTRY_7_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_ANT_TUNE_A,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_ANT_TUNE_B,
-        0xFF,
-        0x82 /* Set Antenna Tuning (Poller): ANTL */
-        ,
-        ST25R3916_REG_TX_DRIVER,
-        ST25R3916_REG_TX_DRIVER_am_mod_mask,
-        ST25R3916_REG_TX_DRIVER_am_mod_12percent /* Set Modulation index */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x00 /* Disable Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Rx Common ******/
-    ,
-    MODE_ENTRY_3_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX),
-        ST25R3916_REG_RX_CONF1,
-        ST25R3916_REG_RX_CONF1_lp_mask,
-        ST25R3916_REG_RX_CONF1_lp_1200khz /* Set Rx filter configuration */
-        ,
-        ST25R3916_REG_RX_CONF1,
-        ST25R3916_REG_RX_CONF1_hz_mask,
-        ST25R3916_REG_RX_CONF1_hz_12_200khz /* Set Rx filter configuration */
-        ,
-        ST25R3916_REG_RX_CONF2,
-        ST25R3916_REG_RX_CONF2_amd_sel,
-        ST25R3916_REG_RX_CONF2_amd_sel_mixer /* AM demodulator: mixer */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 106 ******/
-    ,
-    MODE_ENTRY_5_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_106 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_ook /* Use OOK modulation */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_OVERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Overshoot Protection  */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF1,
-        0xFF,
-        0x40 /* Set default Undershoot Protection */
-        ,
-        ST25R3916_REG_UNDERSHOOT_CONF2,
-        0xFF,
-        0x03 /* Set default Undershoot Protection */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 212 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_212 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-    /****** Default Analog Configuration for Listen AP2P Tx 424 ******/
-    ,
-    MODE_ENTRY_1_REG(
-        (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-         RFAL_ANALOG_CONFIG_BITRATE_424 | RFAL_ANALOG_CONFIG_TX),
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_tr_am,
-        ST25R3916_REG_MODE_tr_am_am /* Use AM modulation */
-        )
-
-};
-
-#endif /* ST25R3916_ANALOGCONFIG_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/rfal_dpoTbl.h

@@ -1,68 +0,0 @@
-
-/******************************************************************************
-  * @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:
-  *
-  *        http://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
- *
- *  \author Martin Zechleitner 
- *
- *  \brief RF Dynamic Power Table default values
- */
-
-#ifndef ST25R3916_DPO_H
-#define ST25R3916_DPO_H
-
-/*
- ******************************************************************************
- * INCLUDES
- ******************************************************************************
- */
-#include "../../include/rfal_dpo.h"
-
-/*
- ******************************************************************************
- * GLOBAL DATA TYPES
- ******************************************************************************
- */
-
-/*! Default DPO table */
-const uint8_t rfalDpoDefaultSettings[] = {
-    0x00,
-    255,
-    200,
-    0x01,
-    210,
-    150,
-    0x02,
-    160,
-    100,
-    0x03,
-    110,
-    50,
-};
-
-#endif /* ST25R3916_DPO_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/rfal_features.h

@@ -1,109 +0,0 @@
-
-/******************************************************************************
-  * \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
- *
- *  \author Gustavo Patricio 
- *
- *  \brief RFAL Features/Capabilities Definition for ST25R3916
- */
-
-#ifndef RFAL_FEATURES_H
-#define RFAL_FEATURES_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../../platform.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-#define RFAL_SUPPORT_MODE_POLL_NFCA true /*!< RFAL Poll NFCA mode support switch    */
-#define RFAL_SUPPORT_MODE_POLL_NFCB true /*!< RFAL Poll NFCB mode support switch    */
-#define RFAL_SUPPORT_MODE_POLL_NFCF true /*!< RFAL Poll NFCF mode support switch    */
-#define RFAL_SUPPORT_MODE_POLL_NFCV true /*!< RFAL Poll NFCV mode support switch    */
-#define RFAL_SUPPORT_MODE_POLL_ACTIVE_P2P true /*!< RFAL Poll AP2P mode support switch    */
-#define RFAL_SUPPORT_MODE_LISTEN_NFCA true /*!< RFAL Listen NFCA mode support switch  */
-#define RFAL_SUPPORT_MODE_LISTEN_NFCB false /*!< RFAL Listen NFCB mode support switch  */
-#define RFAL_SUPPORT_MODE_LISTEN_NFCF true /*!< RFAL Listen NFCF mode support switch  */
-#define RFAL_SUPPORT_MODE_LISTEN_ACTIVE_P2P true /*!< RFAL Listen AP2P mode support switch  */
-
-/*******************************************************************************/
-/*! RFAL supported Card Emulation (CE)        */
-#define RFAL_SUPPORT_CE                                                \
-    (RFAL_SUPPORT_MODE_LISTEN_NFCA || RFAL_SUPPORT_MODE_LISTEN_NFCB || \
-     RFAL_SUPPORT_MODE_LISTEN_NFCF)
-
-/*! RFAL supported Reader/Writer (RW)         */
-#define RFAL_SUPPORT_RW                                                                           \
-    (RFAL_SUPPORT_MODE_POLL_NFCA || RFAL_SUPPORT_MODE_POLL_NFCB || RFAL_SUPPORT_MODE_POLL_NFCF || \
-     RFAL_SUPPORT_MODE_POLL_NFCV)
-
-/*! RFAL support for Active P2P (AP2P)        */
-#define RFAL_SUPPORT_AP2P \
-    (RFAL_SUPPORT_MODE_POLL_ACTIVE_P2P || RFAL_SUPPORT_MODE_LISTEN_ACTIVE_P2P)
-
-/*******************************************************************************/
-#define RFAL_SUPPORT_BR_RW_106 true /*!< RFAL RW  106 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_212 true /*!< RFAL RW  212 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_424 true /*!< RFAL RW  424 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_848 true /*!< RFAL RW  848 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_1695 false /*!< RFAL RW 1695 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_3390 false /*!< RFAL RW 3390 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_6780 false /*!< RFAL RW 6780 Bit Rate support switch   */
-#define RFAL_SUPPORT_BR_RW_13560 false /*!< RFAL RW 6780 Bit Rate support switch   */
-
-/*******************************************************************************/
-#define RFAL_SUPPORT_BR_AP2P_106 true /*!< RFAL AP2P  106 Bit Rate support switch */
-#define RFAL_SUPPORT_BR_AP2P_212 true /*!< RFAL AP2P  212 Bit Rate support switch */
-#define RFAL_SUPPORT_BR_AP2P_424 true /*!< RFAL AP2P  424 Bit Rate support switch */
-#define RFAL_SUPPORT_BR_AP2P_848 false /*!< RFAL AP2P  848 Bit Rate support switch */
-
-/*******************************************************************************/
-#define RFAL_SUPPORT_BR_CE_A_106 true /*!< RFAL CE A 106 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_A_212 false /*!< RFAL CE A 212 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_A_424 false /*!< RFAL CE A 424 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_A_848 false /*!< RFAL CE A 848 Bit Rate support switch  */
-
-/*******************************************************************************/
-#define RFAL_SUPPORT_BR_CE_B_106 false /*!< RFAL CE B 106 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_B_212 false /*!< RFAL CE B 212 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_B_424 false /*!< RFAL CE B 424 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_B_848 false /*!< RFAL CE B 848 Bit Rate support switch  */
-
-/*******************************************************************************/
-#define RFAL_SUPPORT_BR_CE_F_212 true /*!< RFAL CE F 212 Bit Rate support switch  */
-#define RFAL_SUPPORT_BR_CE_F_424 true /*!< RFAL CE F 424 Bit Rate support switch  */
-
-#endif /* RFAL_FEATURES_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/rfal_rfst25r3916.c

@@ -1,4857 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio 
- *
- *  \brief RF Abstraction Layer (RFAL)
- *  
- *  RFAL implementation for ST25R3916
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "../../include/rfal_chip.h"
-#include "../../utils.h"
-#include "st25r3916.h"
-#include "st25r3916_com.h"
-#include "st25r3916_irq.h"
-#include "../../include/rfal_analogConfig.h"
-#include "../../include/rfal_iso15693_2.h"
-#include "../../include/rfal_crc.h"
-
-/*
- ******************************************************************************
- * ENABLE SWITCHES
- ******************************************************************************
- */
-
-#ifndef RFAL_FEATURE_LISTEN_MODE
-#define RFAL_FEATURE_LISTEN_MODE false /* Listen Mode configuration missing. Disabled by default */
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-#ifndef RFAL_FEATURE_WAKEUP_MODE
-#define RFAL_FEATURE_WAKEUP_MODE \
-    false /* Wake-Up mode configuration missing. Disabled by default */
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-#ifndef RFAL_FEATURE_LOWPOWER_MODE
-#define RFAL_FEATURE_LOWPOWER_MODE \
-    false /* Low Power mode configuration missing. Disabled by default */
-#endif /* RFAL_FEATURE_LOWPOWER_MODE */
-
-/*
-******************************************************************************
-* GLOBAL TYPES
-******************************************************************************
-*/
-
-/*! Struct that holds all involved on a Transceive including the context passed by the caller     */
-typedef struct {
-    rfalTransceiveState state; /*!< Current transceive state                            */
-    rfalTransceiveState lastState; /*!< Last transceive state (debug purposes)              */
-    ReturnCode status; /*!< Current status/error of the transceive              */
-
-    rfalTransceiveContext ctx; /*!< The transceive context given by the caller          */
-} rfalTxRx;
-
-/*! Struct that holds all context for the Listen Mode                                             */
-typedef struct {
-    rfalLmState state; /*!< Current Listen Mode state                           */
-    uint32_t mdMask; /*!< Listen Mode mask used                               */
-    uint32_t mdReg; /*!< Listen Mode register value used                     */
-    uint32_t mdIrqs; /*!< Listen Mode IRQs used                               */
-    rfalBitRate brDetected; /*!< Last bit rate detected                              */
-
-    uint8_t* rxBuf; /*!< Location to store incoming data in Listen Mode      */
-    uint16_t rxBufLen; /*!< Length of rxBuf                                     */
-    uint16_t* rxLen; /*!< Pointer to write the data length placed into rxBuf  */
-    bool dataFlag; /*!< Listen Mode current Data Flag                       */
-    bool iniFlag; /*!< Listen Mode initialized Flag  (FeliCa slots)        */
-} rfalLm;
-
-/*! Struct that holds all context for the Wake-Up Mode                                             */
-typedef struct {
-    rfalWumState state; /*!< Current Wake-Up Mode state                           */
-    rfalWakeUpConfig cfg; /*!< Current Wake-Up Mode context                         */
-} rfalWum;
-
-/*! Struct that holds all context for the Low Power Mode                                             */
-typedef struct {
-    bool isRunning;
-} rfalLpm;
-
-/*! Struct that holds the timings GT and FDTs                           */
-typedef struct {
-    uint32_t GT; /*!< GT in 1/fc                */
-    uint32_t FDTListen; /*!< FDTListen in 1/fc         */
-    uint32_t FDTPoll; /*!< FDTPoll in 1/fc           */
-    uint8_t nTRFW; /*!< n*TRFW used during RF CA  */
-} rfalTimings;
-
-/*! Struct that holds the software timers                               */
-typedef struct {
-    uint32_t GT; /*!< RFAL's GT timer           */
-    uint32_t RXE; /*!< Timer between RXS and RXE */
-    uint32_t txRx; /*!< Transceive sanity timer   */
-} rfalTimers;
-
-/*! Struct that holds the RFAL's callbacks                              */
-typedef struct {
-    rfalPreTxRxCallback preTxRx; /*!< RFAL's Pre TxRx callback  */
-    rfalPostTxRxCallback postTxRx; /*!< RFAL's Post TxRx callback */
-    RfalStateChangedCallback state_changed_cb;
-    void* ctx;
-} rfalCallbacks;
-
-/*! Struct that holds counters to control the FIFO on Tx and Rx                                                                          */
-typedef struct {
-    uint16_t
-        expWL; /*!< The amount of bytes expected to be Tx when a WL interrupt occurs                          */
-    uint16_t
-        bytesTotal; /*!< Total bytes to be transmitted OR the total bytes received                                  */
-    uint16_t
-        bytesWritten; /*!< Amount of bytes already written on FIFO (Tx) OR read (RX) from FIFO and written on rxBuffer*/
-    uint8_t status
-        [ST25R3916_FIFO_STATUS_LEN]; /*!< FIFO Status Registers                                              */
-} rfalFIFO;
-
-/*! Struct that holds RFAL's configuration settings                                                      */
-typedef struct {
-    uint8_t obsvModeTx; /*!< RFAL's config of the ST25R3916's observation mode while Tx */
-    uint8_t obsvModeRx; /*!< RFAL's config of the ST25R3916's observation mode while Rx */
-    rfalEHandling eHandling; /*!< RFAL's error handling config/mode                          */
-} rfalConfigs;
-
-/*! Struct that holds NFC-F data - Used only inside rfalFelicaPoll() (static to avoid adding it into stack) */
-typedef struct {
-    rfalFeliCaPollRes
-        pollResponses[RFAL_FELICA_POLL_MAX_SLOTS]; /* FeliCa Poll response container for 16 slots */
-} rfalNfcfWorkingData;
-
-/*! Struct that holds NFC-V current context
- *
- * This buffer has to be big enough for coping with maximum response size (hamming coded)
- *    - inventory requests responses: 14*2+2 bytes 
- *    - read single block responses: (32+4)*2+2 bytes
- *    - read multiple block could be very long... -> not supported
- *    - current implementation expects it be written in one bulk into FIFO
- *    - needs to be above FIFO water level of ST25R3916 (200)
- *    - the coding function needs to be able to 
- *      put more than FIFO water level bytes into it (n*64+1)>200                                                          */
-typedef struct {
-    uint8_t codingBuffer[(
-        (2 + 255 + 3) * 2)]; /*!< Coding buffer,   length MUST be above 257: [257; ...]    */
-    uint16_t
-        nfcvOffset; /*!< Offset needed for ISO15693 coding function                             */
-    rfalTransceiveContext
-        origCtx; /*!< context provided by user                                               */
-    uint16_t
-        ignoreBits; /*!< Number of bits at the beginning of a frame to be ignored when decoding */
-} rfalNfcvWorkingData;
-
-/*! RFAL instance  */
-typedef struct {
-    rfalState state; /*!< RFAL's current state                          */
-    rfalMode mode; /*!< RFAL's current mode                           */
-    rfalBitRate txBR; /*!< RFAL's current Tx Bit Rate                    */
-    rfalBitRate rxBR; /*!< RFAL's current Rx Bit Rate                    */
-    bool field; /*!< Current field state (On / Off)                */
-
-    rfalConfigs conf; /*!< RFAL's configuration settings                 */
-    rfalTimings timings; /*!< RFAL's timing setting                         */
-    rfalTxRx TxRx; /*!< RFAL's transceive management                  */
-    rfalFIFO fifo; /*!< RFAL's FIFO management                        */
-    rfalTimers tmr; /*!< RFAL's Software timers                        */
-    rfalCallbacks callbacks; /*!< RFAL's callbacks                              */
-
-#if RFAL_FEATURE_LISTEN_MODE
-    rfalLm Lm; /*!< RFAL's listen mode management                 */
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-#if RFAL_FEATURE_WAKEUP_MODE
-    rfalWum wum; /*!< RFAL's Wake-up mode management                */
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-#if RFAL_FEATURE_LOWPOWER_MODE
-    rfalLpm lpm; /*!< RFAL's Low power mode management              */
-#endif /* RFAL_FEATURE_LOWPOWER_MODE */
-
-#if RFAL_FEATURE_NFCF
-    rfalNfcfWorkingData nfcfData; /*!< RFAL's working data when supporting NFC-F     */
-#endif /* RFAL_FEATURE_NFCF */
-
-#if RFAL_FEATURE_NFCV
-    rfalNfcvWorkingData nfcvData; /*!< RFAL's working data when performing NFC-V     */
-#endif /* RFAL_FEATURE_NFCV */
-
-} rfal;
-
-/*! Felica's command set */
-typedef enum {
-    FELICA_CMD_POLLING =
-        0x00, /*!< Felica Poll/REQC command (aka SENSF_REQ) to identify a card    */
-    FELICA_CMD_POLLING_RES =
-        0x01, /*!< Felica Poll/REQC command (aka SENSF_RES) response              */
-    FELICA_CMD_REQUEST_SERVICE =
-        0x02, /*!< verify the existence of Area and Service                       */
-    FELICA_CMD_REQUEST_RESPONSE =
-        0x04, /*!< verify the existence of a card                                 */
-    FELICA_CMD_READ_WITHOUT_ENCRYPTION =
-        0x06, /*!< read Block Data from a Service that requires no authentication */
-    FELICA_CMD_WRITE_WITHOUT_ENCRYPTION =
-        0x08, /*!< write Block Data to a Service that requires no authentication  */
-    FELICA_CMD_REQUEST_SYSTEM_CODE =
-        0x0C, /*!< acquire the System Code registered to a card                   */
-    FELICA_CMD_AUTHENTICATION1 =
-        0x10, /*!< authenticate a card                                            */
-    FELICA_CMD_AUTHENTICATION2 =
-        0x12, /*!< allow a card to authenticate a Reader/Writer                   */
-    FELICA_CMD_READ = 0x14, /*!< read Block Data from a Service that requires authentication    */
-    FELICA_CMD_WRITE = 0x16, /*!< write Block Data to a Service that requires authentication     */
-} t_rfalFeliCaCmd;
-
-/*! Union representing all PTMem sections */
-typedef union { /*  PRQA S 0750 # MISRA 19.2 - Both members are of the same type, just different names.  Thus no problem can occur. */
-    uint8_t PTMem_A
-        [ST25R3916_PTM_A_LEN]; /*!< PT_Memory area allocated for NFC-A configuration               */
-    uint8_t PTMem_F
-        [ST25R3916_PTM_F_LEN]; /*!< PT_Memory area allocated for NFC-F configuration               */
-    uint8_t
-        TSN[ST25R3916_PTM_TSN_LEN]; /*!< PT_Memory area allocated for TSN - Random numbers              */
-} t_rfalPTMem;
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-#define RFAL_FIFO_IN_WL \
-    200U /*!< Number of bytes in the FIFO when WL interrupt occurs while Tx                   */
-#define RFAL_FIFO_OUT_WL    \
-    (ST25R3916_FIFO_DEPTH - \
-     RFAL_FIFO_IN_WL) /*!< Number of bytes sent/out of the FIFO when WL interrupt occurs while Tx          */
-
-#define RFAL_FIFO_STATUS_REG1 \
-    0U /*!< Location of FIFO status register 1 in local copy                                */
-#define RFAL_FIFO_STATUS_REG2 \
-    1U /*!< Location of FIFO status register 2 in local copy                                */
-#define RFAL_FIFO_STATUS_INVALID \
-    0xFFU /*!< Value indicating that the local FIFO status in invalid|cleared                  */
-
-#define RFAL_ST25R3916_GPT_MAX_1FC \
-    rfalConv8fcTo1fc(              \
-        0xFFFFU) /*!< Max GPT steps in 1fc (0xFFFF steps of 8/fc    => 0xFFFF * 590ns  = 38,7ms)      */
-#define RFAL_ST25R3916_NRT_MAX_1FC \
-    rfalConv4096fcTo1fc(           \
-        0xFFFFU) /*!< Max NRT steps in 1fc (0xFFFF steps of 4096/fc => 0xFFFF * 302us  = 19.8s )      */
-#define RFAL_ST25R3916_NRT_DISABLED \
-    0U /*!< NRT Disabled: All 0 No-response timer is not started, wait forever              */
-#define RFAL_ST25R3916_MRT_MAX_1FC \
-    rfalConv64fcTo1fc(             \
-        0x00FFU) /*!< Max MRT steps in 1fc (0x00FF steps of 64/fc   => 0x00FF * 4.72us = 1.2ms )      */
-#define RFAL_ST25R3916_MRT_MIN_1FC \
-    rfalConv64fcTo1fc(             \
-        0x0004U) /*!< Min MRT steps in 1fc ( 0<=mrt<=4 ; 4 (64/fc)  => 0x0004 * 4.72us = 18.88us )    */
-#define RFAL_ST25R3916_GT_MAX_1FC \
-    rfalConvMsTo1fc(              \
-        6000U) /*!< Max GT value allowed in 1/fc (SFGI=14 => SFGT + dSFGT = 5.4s)                   */
-#define RFAL_ST25R3916_GT_MIN_1FC \
-    rfalConvMsTo1fc(              \
-        RFAL_ST25R3916_SW_TMR_MIN_1MS) /*!< Min GT value allowed in 1/fc                                                    */
-#define RFAL_ST25R3916_SW_TMR_MIN_1MS \
-    1U /*!< Min value of a SW timer in ms                                                   */
-
-#define RFAL_OBSMODE_DISABLE \
-    0x00U /*!< Observation Mode disabled                                                       */
-
-#define RFAL_RX_INCOMPLETE_MAXLEN \
-    (uint8_t)1U /*!< Threshold value where incoming rx may be considered as incomplete               */
-#define RFAL_EMVCO_RX_MAXLEN \
-    (uint8_t)4U /*!< Maximum value where EMVCo to apply special error handling                       */
-
-#define RFAL_NORXE_TOUT \
-    50U /*!< Timeout to be used on a potential missing RXE - Silicon ST25R3916 Errata #TBD   */
-
-#define RFAL_ISO14443A_SDD_RES_LEN \
-    5U /*!< SDD_RES | Anticollision (UID CLn) length  -  rfalNfcaSddRes                     */
-#define RFAL_ISO14443A_CRC_INTVAL \
-    0x6363 /*!< ISO14443 CRC Initial Value|Register                                             */
-
-#define RFAL_FELICA_POLL_DELAY_TIME \
-    512U /*!<  FeliCa Poll Processing time is 2.417 ms ~512*64/fc Digital 1.1 A4              */
-#define RFAL_FELICA_POLL_SLOT_TIME \
-    256U /*!<  FeliCa Poll Time Slot duration is 1.208 ms ~256*64/fc Digital 1.1 A4           */
-
-#define RFAL_LM_SENSF_RD0_POS \
-    17U /*!<  FeliCa SENSF_RES Request Data RD0 position                                     */
-#define RFAL_LM_SENSF_RD1_POS \
-    18U /*!<  FeliCa SENSF_RES Request Data RD1 position                                     */
-
-#define RFAL_LM_NFCID_INCOMPLETE \
-    0x04U /*!<  NFCA NFCID not complete bit in SEL_RES (SAK)                                   */
-
-#define RFAL_ISO15693_IGNORE_BITS \
-    rfalConvBytesToBits(          \
-        2U) /*!< Ignore collisions before the UID (RES_FLAG + DSFID)                             */
-#define RFAL_ISO15693_INV_RES_LEN \
-    12U /*!< ISO15693 Inventory response length with CRC (bytes)                             */
-#define RFAL_ISO15693_INV_RES_DUR \
-    4U /*!< ISO15693 Inventory response duration @ 26 kbps (ms)                             */
-
-#define RFAL_WU_MIN_WEIGHT_VAL \
-    4U /*!< ST25R3916 minimum Wake-up weight value                                         */
-
-/*******************************************************************************/
-
-#define RFAL_LM_GT   \
-    rfalConvUsTo1fc( \
-        100U) /*!< Listen Mode Guard Time enforced (GT - Passive; TIRFG - Active)                  */
-#define RFAL_FDT_POLL_ADJUSTMENT \
-    rfalConvUsTo1fc(             \
-        80U) /*!< FDT Poll adjustment: Time between the expiration of GPT to the actual Tx        */
-#define RFAL_FDT_LISTEN_MRT_ADJUSTMENT \
-    64U /*!< MRT jitter adjustment: timeout will be between [ tout ; tout + 64 cycles ]      */
-#define RFAL_AP2P_FIELDOFF_TRFW \
-    rfalConv8fcTo1fc(           \
-        64U) /*!< Time after TXE and Field Off in AP2P Trfw: 37.76us -> 64  (8/fc)                */
-
-#ifndef RFAL_ST25R3916_AAT_SETTLE
-#define RFAL_ST25R3916_AAT_SETTLE \
-    5U /*!< Time in ms required for AAT pins and Osc to settle after en bit set */
-#endif /* RFAL_ST25R3916_AAT_SETTLE */
-
-/*! FWT adjustment: 
- *    64 : NRT jitter between TXE and NRT start      */
-#define RFAL_FWT_ADJUSTMENT 64U
-
-/*! FWT ISO14443A adjustment:  
- *   512  : 4bit length
- *    64  : Half a bit duration due to ST25R3916 Coherent receiver (1/fc)         */
-#define RFAL_FWT_A_ADJUSTMENT (512U + 64U)
-
-/*! FWT ISO14443B adjustment:  
- *    SOF (14etu) + 1Byte (10etu) + 1etu (IRQ comes 1etu after first byte) - 3etu (ST25R3916 sends TXE 3etu after) */
-#define RFAL_FWT_B_ADJUSTMENT ((14U + 10U + 1U - 3U) * 128U)
-
-/*! FWT FeliCa 212 adjustment:  
- *    1024 : Length of the two Sync bytes at 212kbps */
-#define RFAL_FWT_F_212_ADJUSTMENT 1024U
-
-/*! FWT FeliCa 424 adjustment:  
- *    512 : Length of the two Sync bytes at 424kbps  */
-#define RFAL_FWT_F_424_ADJUSTMENT 512U
-
-/*! Time between our field Off and other peer field On : Tadt + (n x Trfw)
- * Ecma 340 11.1.2 - Tadt: [56.64 , 188.72] us ;  n: [0 , 3]  ; Trfw = 37.76 us        
- * Should be: 189 + (3*38) = 303us ; we'll use a more relaxed setting: 605 us    */
-#define RFAL_AP2P_FIELDON_TADTTRFW rfalConvUsTo1fc(605U)
-
-/*! FDT Listen adjustment for ISO14443A   EMVCo 2.6  4.8.1.3  ;  Digital 1.1  6.10
- *
- *  276: Time from the rising pulse of the pause of the logic '1' (i.e. the time point to measure the deaftime from), 
- *       to the actual end of the EOF sequence (the point where the MRT starts). Please note that the ST25R391x uses the 
- *       ISO14443-2 definition where the EOF consists of logic '0' followed by sequence Y. 
- *  -64: Further adjustment for receiver to be ready just before first bit
- */
-#define RFAL_FDT_LISTEN_A_ADJUSTMENT (276U - 64U)
-
-/*! FDT Listen adjustment for ISO14443B   EMVCo 2.6  4.8.1.6  ;  Digital 1.1  7.9
- *
- *  340: Time from the rising edge of the EoS to the starting point of the MRT timer (sometime after the final high 
- *       part of the EoS is completed)
- */
-#define RFAL_FDT_LISTEN_B_ADJUSTMENT 340U
-
-/*! FDT Listen adjustment for ISO15693
- * ISO15693 2000  8.4  t1 MIN = 4192/fc
- * ISO15693 2009  9.1  t1 MIN = 4320/fc
- * Digital 2.1 B.5 FDTV,LISTEN,MIN  = 4310/fc
- * Set FDT Listen one step earlier than on the more recent spec versions for greater interoperability
- */
-#define RFAL_FDT_LISTEN_V_ADJUSTMENT 64U
-
-/*! FDT Poll adjustment for ISO14443B Correlator - sst 5 etu */
-#define RFAL_FDT_LISTEN_B_ADJT_CORR 128U
-
-/*! FDT Poll adjustment for ISO14443B Correlator sst window - 5 etu */
-#define RFAL_FDT_LISTEN_B_ADJT_CORR_SST 20U
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*! Calculates Transceive Sanity Timer. It accounts for the slowest bit rate and the longest data format
- *    1s for transmission and reception of a 4K message at 106kpbs (~425ms each direction)
- *       plus TxRx preparation and FIFO load over Serial Interface                                      */
-#define rfalCalcSanityTmr(fwt) (uint16_t)(1000U + rfalConv1fcToMs((fwt)))
-
-#define rfalGennTRFW(n) \
-    (((n) + 1U) &       \
-     ST25R3916_REG_AUX_nfc_n_mask) /*!< Generates the next n*TRRW used for RFCA       */
-
-#define rfalCalcNumBytes(nBits) \
-    (((uint32_t)(nBits) + 7U) / \
-     8U) /*!< Returns the number of bytes required to fit given the number of bits */
-
-#define rfalTimerStart(timer, time_ms)                      \
-    do {                                                    \
-        platformTimerDestroy(timer);                        \
-        (timer) = platformTimerCreate((uint16_t)(time_ms)); \
-    } while(0) /*!< Configures and starts timer         */
-#define rfalTimerisExpired(timer) \
-    platformTimerIsExpired(       \
-        timer) /*!< Checks if timer has expired                                         */
-#define rfalTimerDestroy(timer) \
-    platformTimerDestroy(       \
-        timer) /*!< Destroys timer                                                      */
-
-#define rfalST25R3916ObsModeDisable() \
-    st25r3916WriteTestRegister(       \
-        0x01U,                        \
-        (0x40U)) /*!< Disable ST25R3916 Observation mode                                   */
-#define rfalST25R3916ObsModeTx() \
-    st25r3916WriteTestRegister(  \
-        0x01U,                   \
-        (0x40U |                 \
-         gRFAL.conf              \
-             .obsvModeTx)) /*!< Enable Tx Observation mode                                           */
-#define rfalST25R3916ObsModeRx() \
-    st25r3916WriteTestRegister(  \
-        0x01U,                   \
-        (0x40U |                 \
-         gRFAL.conf              \
-             .obsvModeRx)) /*!< Enable Rx Observation mode                                           */
-
-#define rfalCheckDisableObsMode()      \
-    if(gRFAL.conf.obsvModeRx != 0U) {  \
-        rfalST25R3916ObsModeDisable(); \
-    } /*!< Checks if the observation mode is enabled, and applies on ST25R3916  */
-#define rfalCheckEnableObsModeTx()    \
-    if(gRFAL.conf.obsvModeTx != 0U) { \
-        rfalST25R3916ObsModeTx();     \
-    } /*!< Checks if the observation mode is enabled, and applies on ST25R3916  */
-#define rfalCheckEnableObsModeRx()    \
-    if(gRFAL.conf.obsvModeRx != 0U) { \
-        rfalST25R3916ObsModeRx();     \
-    } /*!< Checks if the observation mode is enabled, and applies on ST25R3916  */
-
-#define rfalGetIncmplBits(FIFOStatus2) \
-    (((FIFOStatus2) >> 1) &            \
-     0x07U) /*!< Returns the number of bits from fifo status                  */
-#define rfalIsIncompleteByteError(error) \
-    (((error) >= ERR_INCOMPLETE_BYTE) && \
-     ((error) <=                         \
-      ERR_INCOMPLETE_BYTE_07)) /*!< Checks if given error is a Incomplete error                  */
-
-#define rfalAdjACBR(b)                            \
-    (((uint16_t)(b) >= (uint16_t)RFAL_BR_52p97) ? \
-         (uint16_t)(b) :                          \
-         ((uint16_t)(b) +                         \
-          1U)) /*!< Adjusts ST25R391x Bit rate to Analog Configuration              */
-#define rfalConvBR2ACBR(b)                                      \
-    (((rfalAdjACBR((b))) << RFAL_ANALOG_CONFIG_BITRATE_SHIFT) & \
-     RFAL_ANALOG_CONFIG_BITRATE_MASK) /*!< Converts ST25R391x Bit rate to Analog Configuration bit rate id */
-
-#define rfalConvTDFormat(v) \
-    ((uint16_t)(v) << 8U) /*!< Converts a uint8_t to the format used in SW Tag Detection */
-
-/*
- ******************************************************************************
- * LOCAL VARIABLES
- ******************************************************************************
- */
-
-static rfal gRFAL; /*!< RFAL module instance               */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-static void rfalTransceiveTx(void);
-static void rfalTransceiveRx(void);
-static ReturnCode rfalTransceiveRunBlockingTx(void);
-static void rfalPrepareTransceive(void);
-static void rfalCleanupTransceive(void);
-static void rfalErrorHandling(void);
-
-static ReturnCode rfalRunTransceiveWorker(void);
-#if RFAL_FEATURE_LISTEN_MODE
-static ReturnCode rfalRunListenModeWorker(void);
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-#if RFAL_FEATURE_WAKEUP_MODE
-static void rfalRunWakeUpModeWorker(void);
-static uint16_t rfalWakeUpModeFilter(uint16_t curRef, uint16_t curVal, uint8_t weight);
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-static void rfalFIFOStatusUpdate(void);
-static void rfalFIFOStatusClear(void);
-static bool rfalFIFOStatusIsMissingPar(void);
-static bool rfalFIFOStatusIsIncompleteByte(void);
-static uint16_t rfalFIFOStatusGetNumBytes(void);
-static uint8_t rfalFIFOGetNumIncompleteBits(void);
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode rfalInitialize(void) {
-    ReturnCode err;
-
-    EXIT_ON_ERR(err, st25r3916Initialize());
-
-    st25r3916ClearInterrupts();
-
-    /* Disable any previous observation mode */
-    rfalST25R3916ObsModeDisable();
-
-    /*******************************************************************************/
-    /* Apply RF Chip generic initialization */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_INIT));
-
-    // TODO:
-    // I don't want to mess with config table ("Default Analog Configuration for Chip-Specific Reset", rfal_analogConfigTbl.h)
-    // so with every rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_CHIP_INIT)) currently we need to clear pulldown bits
-    // luckily for us this is done only here
-
-    // disable pulldowns
-    st25r3916ClrRegisterBits(
-        ST25R3916_REG_IO_CONF2,
-        (ST25R3916_REG_IO_CONF2_miso_pd1 | ST25R3916_REG_IO_CONF2_miso_pd2));
-
-    /*******************************************************************************/
-    /* Enable External Field Detector as: Automatics */
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_OP_CONTROL,
-        ST25R3916_REG_OP_CONTROL_en_fd_mask,
-        ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
-
-    /* Clear FIFO status local copy */
-    rfalFIFOStatusClear();
-
-    /*******************************************************************************/
-    gRFAL.state = RFAL_STATE_INIT;
-    gRFAL.mode = RFAL_MODE_NONE;
-    gRFAL.field = false;
-
-    /* Set RFAL default configs */
-    gRFAL.conf.obsvModeRx = RFAL_OBSMODE_DISABLE;
-    gRFAL.conf.obsvModeTx = RFAL_OBSMODE_DISABLE;
-    gRFAL.conf.eHandling = RFAL_ERRORHANDLING_NONE;
-
-    /* Transceive set to IDLE */
-    gRFAL.TxRx.lastState = RFAL_TXRX_STATE_IDLE;
-    gRFAL.TxRx.state = RFAL_TXRX_STATE_IDLE;
-
-    /* Disable all timings */
-    gRFAL.timings.FDTListen = RFAL_TIMING_NONE;
-    gRFAL.timings.FDTPoll = RFAL_TIMING_NONE;
-    gRFAL.timings.GT = RFAL_TIMING_NONE;
-    gRFAL.timings.nTRFW = 0U;
-
-    /* Destroy any previous pending timers */
-    rfalTimerDestroy(gRFAL.tmr.GT);
-    rfalTimerDestroy(gRFAL.tmr.txRx);
-    rfalTimerDestroy(gRFAL.tmr.RXE);
-    gRFAL.tmr.GT = RFAL_TIMING_NONE;
-    gRFAL.tmr.txRx = RFAL_TIMING_NONE;
-    gRFAL.tmr.RXE = RFAL_TIMING_NONE;
-
-    gRFAL.callbacks.preTxRx = NULL;
-    gRFAL.callbacks.postTxRx = NULL;
-    gRFAL.callbacks.state_changed_cb = NULL;
-    gRFAL.callbacks.ctx = NULL;
-
-#if RFAL_FEATURE_NFCV
-    /* Initialize NFC-V Data */
-    gRFAL.nfcvData.ignoreBits = 0;
-#endif /* RFAL_FEATURE_NFCV */
-
-#if RFAL_FEATURE_LISTEN_MODE
-    /* Initialize Listen Mode */
-    gRFAL.Lm.state = RFAL_LM_STATE_NOT_INIT;
-    gRFAL.Lm.brDetected = RFAL_BR_KEEP;
-    gRFAL.Lm.iniFlag = false;
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-#if RFAL_FEATURE_WAKEUP_MODE
-    /* Initialize Wake-Up Mode */
-    gRFAL.wum.state = RFAL_WUM_STATE_NOT_INIT;
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-#if RFAL_FEATURE_LOWPOWER_MODE
-    /* Initialize Low Power Mode */
-    gRFAL.lpm.isRunning = false;
-#endif /* RFAL_FEATURE_LOWPOWER_MODE */
-
-    /*******************************************************************************/
-    /* Perform Automatic Calibration (if configured to do so).                     *
-     * Registers set by rfalSetAnalogConfig will tell rfalCalibrate what to perform*/
-    rfalCalibrate();
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalCalibrate(void) {
-    uint16_t resValue;
-
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state == RFAL_STATE_IDLE) {
-        return ERR_WRONG_STATE;
-    }
-
-    /*******************************************************************************/
-    /* Perform ST25R3916 regulators and antenna calibration                        */
-    /*******************************************************************************/
-
-    /* Automatic regulator adjustment only performed if not set manually on Analog Configs */
-    if(st25r3916CheckReg(
-           ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_reg_s, 0x00)) {
-        /* Adjust the regulators so that Antenna Calibrate has better Regulator values */
-        st25r3916AdjustRegulators(&resValue);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalAdjustRegulators(uint16_t* result) {
-    return st25r3916AdjustRegulators(result);
-}
-
-/*******************************************************************************/
-void rfalSetUpperLayerCallback(rfalUpperLayerCallback pFunc) {
-    st25r3916IRQCallbackSet(pFunc);
-}
-
-/*******************************************************************************/
-void rfalSetPreTxRxCallback(rfalPreTxRxCallback pFunc) {
-    gRFAL.callbacks.preTxRx = pFunc;
-}
-
-/*******************************************************************************/
-void rfalSetPostTxRxCallback(rfalPostTxRxCallback pFunc) {
-    gRFAL.callbacks.postTxRx = pFunc;
-}
-
-void rfal_set_state_changed_callback(RfalStateChangedCallback callback) {
-    gRFAL.callbacks.state_changed_cb = callback;
-}
-
-void rfal_set_callback_context(void* context) {
-    gRFAL.callbacks.ctx = context;
-}
-
-/*******************************************************************************/
-ReturnCode rfalDeinitialize(void) {
-    /* Deinitialize chip */
-    st25r3916Deinitialize();
-
-    /* Set Analog configurations for deinitialization */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_DEINIT));
-
-    gRFAL.state = RFAL_STATE_IDLE;
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-void rfalSetObsvMode(uint8_t txMode, uint8_t rxMode) {
-    gRFAL.conf.obsvModeTx = txMode;
-    gRFAL.conf.obsvModeRx = rxMode;
-}
-
-/*******************************************************************************/
-void rfalGetObsvMode(uint8_t* txMode, uint8_t* rxMode) {
-    if(txMode != NULL) {
-        *txMode = gRFAL.conf.obsvModeTx;
-    }
-
-    if(rxMode != NULL) {
-        *rxMode = gRFAL.conf.obsvModeRx;
-    }
-}
-
-/*******************************************************************************/
-void rfalDisableObsvMode(void) {
-    gRFAL.conf.obsvModeTx = RFAL_OBSMODE_DISABLE;
-    gRFAL.conf.obsvModeRx = RFAL_OBSMODE_DISABLE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSetMode(rfalMode mode, rfalBitRate txBR, rfalBitRate rxBR) {
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state == RFAL_STATE_IDLE) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check allowed bit rate value */
-    if((txBR == RFAL_BR_KEEP) || (rxBR == RFAL_BR_KEEP)) {
-        return ERR_PARAM;
-    }
-
-    switch(mode) {
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCA:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable ISO14443A mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_iso14443a);
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCA_T1T:
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable Topaz mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_topaz);
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCB:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable ISO14443B mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_iso14443b);
-
-        /* Set the EGT, SOF, EOF and EOF */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_1,
-            (ST25R3916_REG_ISO14443B_1_egt_mask | ST25R3916_REG_ISO14443B_1_sof_mask |
-             ST25R3916_REG_ISO14443B_1_eof),
-            ((0U << ST25R3916_REG_ISO14443B_1_egt_shift) | ST25R3916_REG_ISO14443B_1_sof_0_10etu |
-             ST25R3916_REG_ISO14443B_1_sof_1_2etu | ST25R3916_REG_ISO14443B_1_eof_10etu));
-
-        /* Set the minimum TR1, SOF, EOF and EOF12 */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_2,
-            (ST25R3916_REG_ISO14443B_2_tr1_mask | ST25R3916_REG_ISO14443B_2_no_sof |
-             ST25R3916_REG_ISO14443B_2_no_eof),
-            (ST25R3916_REG_ISO14443B_2_tr1_80fs80fs));
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_B_PRIME:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable ISO14443B mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_iso14443b);
-
-        /* Set the EGT, SOF, EOF and EOF */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_1,
-            (ST25R3916_REG_ISO14443B_1_egt_mask | ST25R3916_REG_ISO14443B_1_sof_mask |
-             ST25R3916_REG_ISO14443B_1_eof),
-            ((0U << ST25R3916_REG_ISO14443B_1_egt_shift) | ST25R3916_REG_ISO14443B_1_sof_0_10etu |
-             ST25R3916_REG_ISO14443B_1_sof_1_2etu | ST25R3916_REG_ISO14443B_1_eof_10etu));
-
-        /* Set the minimum TR1, EOF and EOF12 */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_2,
-            (ST25R3916_REG_ISO14443B_2_tr1_mask | ST25R3916_REG_ISO14443B_2_no_sof |
-             ST25R3916_REG_ISO14443B_2_no_eof),
-            (ST25R3916_REG_ISO14443B_2_tr1_80fs80fs | ST25R3916_REG_ISO14443B_2_no_sof));
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_B_CTS:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable ISO14443B mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_iso14443b);
-
-        /* Set the EGT, SOF, EOF and EOF */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_1,
-            (ST25R3916_REG_ISO14443B_1_egt_mask | ST25R3916_REG_ISO14443B_1_sof_mask |
-             ST25R3916_REG_ISO14443B_1_eof),
-            ((0U << ST25R3916_REG_ISO14443B_1_egt_shift) | ST25R3916_REG_ISO14443B_1_sof_0_10etu |
-             ST25R3916_REG_ISO14443B_1_sof_1_2etu | ST25R3916_REG_ISO14443B_1_eof_10etu));
-
-        /* Set the minimum TR1, clear SOF, EOF and EOF12 */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_ISO14443B_2,
-            (ST25R3916_REG_ISO14443B_2_tr1_mask | ST25R3916_REG_ISO14443B_2_no_sof |
-             ST25R3916_REG_ISO14443B_2_no_eof),
-            (ST25R3916_REG_ISO14443B_2_tr1_80fs80fs | ST25R3916_REG_ISO14443B_2_no_sof |
-             ST25R3916_REG_ISO14443B_2_no_eof));
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCF:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable FeliCa mode */
-        st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_felica);
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCV:
-    case RFAL_MODE_POLL_PICOPASS:
-
-#if !RFAL_FEATURE_NFCV
-        return ERR_DISABLED;
-#else
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-#endif /* RFAL_FEATURE_NFCV */
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_ACTIVE_P2P:
-
-        /* Set NFCIP1 active communication Initiator mode and Automatic Response RF Collision Avoidance to always after EOF */
-        st25r3916WriteRegister(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ_init | ST25R3916_REG_MODE_om_nfc |
-             ST25R3916_REG_MODE_nfc_ar_eof));
-
-        /* External Field Detector enabled as Automatics on rfalInitialize() */
-
-        /* Set NRT to start at end of TX (own) field */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL,
-            ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc,
-            ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc_off);
-
-        /* Set GPT to start after end of TX, as GPT is used in active communication mode to timeout the field switching off */
-        /* The field is turned off 37.76us after the end of the transmission  Trfw                                          */
-        st25r3916SetStartGPTimer(
-            (uint16_t)rfalConv1fcTo8fc(RFAL_AP2P_FIELDOFF_TRFW),
-            ST25R3916_REG_TIMER_EMV_CONTROL_gptc_etx_nfc);
-
-        /* Set PPon2 timer with the max time between our field Off and other peer field On : Tadt + (n x Trfw)    */
-        st25r3916WriteRegister(
-            ST25R3916_REG_PPON2, (uint8_t)rfalConv1fcTo64fc(RFAL_AP2P_FIELDON_TADTTRFW));
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_ACTIVE_P2P:
-
-        /* Set NFCIP1 active communication Target mode and Automatic Response RF Collision Avoidance to always after EOF */
-        st25r3916WriteRegister(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om_targ_nfcip |
-             ST25R3916_REG_MODE_nfc_ar_eof));
-
-        /* Set TARFG: 0 (75us+0ms=75us), as Target no Guard time needed */
-        st25r3916WriteRegister(ST25R3916_REG_FIELD_ON_GT, 0U);
-
-        /* External Field Detector enabled as Automatics on rfalInitialize() */
-
-        /* Set NRT to start at end of TX (own) field */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL,
-            ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc,
-            ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc_off);
-
-        /* Set GPT to start after end of TX, as GPT is used in active communication mode to timeout the field switching off */
-        /* The field is turned off 37.76us after the end of the transmission  Trfw                                          */
-        st25r3916SetStartGPTimer(
-            (uint16_t)rfalConv1fcTo8fc(RFAL_AP2P_FIELDOFF_TRFW),
-            ST25R3916_REG_TIMER_EMV_CONTROL_gptc_etx_nfc);
-
-        /* Set PPon2 timer with the max time between our field Off and other peer field On : Tadt + (n x Trfw)    */
-        st25r3916WriteRegister(
-            ST25R3916_REG_PPON2, (uint8_t)rfalConv1fcTo64fc(RFAL_AP2P_FIELDON_TADTTRFW));
-
-        /* Set Analog configurations for this mode and bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCA:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable Passive Target NFC-A mode, disable any Collision Avoidance */
-        st25r3916WriteRegister(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_targ_nfca |
-             ST25R3916_REG_MODE_nfc_ar_off));
-
-        /* Set Analog configurations for this mode */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCA |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCF:
-
-        /* Disable wake up mode, if set */
-        st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-
-        /* Enable Passive Target NFC-F mode, disable any Collision Avoidance */
-        st25r3916WriteRegister(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_targ_nfcf |
-             ST25R3916_REG_MODE_nfc_ar_off));
-
-        /* Set Analog configurations for this mode */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCF |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCF |
-             RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCB:
-        return ERR_NOTSUPP;
-
-    /*******************************************************************************/
-    default:
-        return ERR_NOT_IMPLEMENTED;
-    }
-
-    /* Set state as STATE_MODE_SET only if not initialized yet (PSL) */
-    gRFAL.state = ((gRFAL.state < RFAL_STATE_MODE_SET) ? RFAL_STATE_MODE_SET : gRFAL.state);
-    gRFAL.mode = mode;
-
-    /* Apply the given bit rate */
-    return rfalSetBitRate(txBR, rxBR);
-}
-
-/*******************************************************************************/
-rfalMode rfalGetMode(void) {
-    return gRFAL.mode;
-}
-
-/*******************************************************************************/
-ReturnCode rfalSetBitRate(rfalBitRate txBR, rfalBitRate rxBR) {
-    ReturnCode ret;
-
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state == RFAL_STATE_IDLE) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Store the new Bit Rates */
-    gRFAL.txBR = ((txBR == RFAL_BR_KEEP) ? gRFAL.txBR : txBR);
-    gRFAL.rxBR = ((rxBR == RFAL_BR_KEEP) ? gRFAL.rxBR : rxBR);
-
-    /* Update the bitrate reg if not in NFCV mode (streaming) */
-    if((RFAL_MODE_POLL_NFCV != gRFAL.mode) && (RFAL_MODE_POLL_PICOPASS != gRFAL.mode)) {
-        /* Set bit rate register */
-        EXIT_ON_ERR(ret, st25r3916SetBitrate((uint8_t)gRFAL.txBR, (uint8_t)gRFAL.rxBR));
-    }
-
-    switch(gRFAL.mode) {
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCA:
-    case RFAL_MODE_POLL_NFCA_T1T:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCB:
-    case RFAL_MODE_POLL_B_PRIME:
-    case RFAL_MODE_POLL_B_CTS:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCB |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCF:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCF |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_NFCV:
-    case RFAL_MODE_POLL_PICOPASS:
-
-#if !RFAL_FEATURE_NFCV
-        return ERR_DISABLED;
-#else
-
-        if(((gRFAL.rxBR != RFAL_BR_26p48) && (gRFAL.rxBR != RFAL_BR_52p97)) ||
-           ((gRFAL.txBR != RFAL_BR_1p66) && (gRFAL.txBR != RFAL_BR_26p48))) {
-            return ERR_PARAM;
-        }
-
-        {
-            const struct iso15693StreamConfig* isoStreamConfig;
-            struct st25r3916StreamConfig streamConf;
-            iso15693PhyConfig_t config;
-
-            config.coding =
-                ((gRFAL.txBR == RFAL_BR_1p66) ? ISO15693_VCD_CODING_1_256 :
-                                                ISO15693_VCD_CODING_1_4);
-            switch(gRFAL.rxBR) {
-            case RFAL_BR_52p97:
-                config.speedMode = 1;
-                break;
-            default:
-                config.speedMode = 0;
-                break;
-            }
-
-            iso15693PhyConfigure(&config, &isoStreamConfig);
-
-            /* MISRA 11.3 - Cannot point directly into different object type, copy to local var */
-            streamConf.din = isoStreamConfig->din;
-            streamConf.dout = isoStreamConfig->dout;
-            streamConf.report_period_length = isoStreamConfig->report_period_length;
-            streamConf.useBPSK = isoStreamConfig->useBPSK;
-            st25r3916StreamConfigure(&streamConf);
-        }
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-#endif /* RFAL_FEATURE_NFCV */
-
-    /*******************************************************************************/
-    case RFAL_MODE_POLL_ACTIVE_P2P:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_POLL_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_AP2P |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_ACTIVE_P2P:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_AP2P |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCA:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCA |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCA |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCF:
-
-        /* Set Analog configurations for this bit rate */
-        rfalSetAnalogConfig(
-            (RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_COMMON));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCF |
-                                 rfalConvBR2ACBR(gRFAL.txBR) | RFAL_ANALOG_CONFIG_TX));
-        rfalSetAnalogConfig(
-            (rfalAnalogConfigId)(RFAL_ANALOG_CONFIG_LISTEN | RFAL_ANALOG_CONFIG_TECH_NFCF |
-                                 rfalConvBR2ACBR(gRFAL.rxBR) | RFAL_ANALOG_CONFIG_RX));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_MODE_LISTEN_NFCB:
-    case RFAL_MODE_NONE:
-        return ERR_WRONG_STATE;
-
-    /*******************************************************************************/
-    default:
-        return ERR_NOT_IMPLEMENTED;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalGetBitRate(rfalBitRate* txBR, rfalBitRate* rxBR) {
-    if((gRFAL.state == RFAL_STATE_IDLE) || (gRFAL.mode == RFAL_MODE_NONE)) {
-        return ERR_WRONG_STATE;
-    }
-
-    if(txBR != NULL) {
-        *txBR = gRFAL.txBR;
-    }
-
-    if(rxBR != NULL) {
-        *rxBR = gRFAL.rxBR;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-void rfalSetErrorHandling(rfalEHandling eHandling) {
-    switch(eHandling) {
-    case RFAL_ERRORHANDLING_NFC:
-    case RFAL_ERRORHANDLING_NONE:
-        st25r3916ClrRegisterBits(ST25R3916_REG_EMD_SUP_CONF, ST25R3916_REG_EMD_SUP_CONF_emd_emv);
-        break;
-
-    case RFAL_ERRORHANDLING_EMVCO:
-        /* MISRA 16.4: no empty default statement (in case RFAL_SW_EMD is defined) */
-#ifndef RFAL_SW_EMD
-        st25r3916ModifyRegister(
-            ST25R3916_REG_EMD_SUP_CONF,
-            (ST25R3916_REG_EMD_SUP_CONF_emd_emv | ST25R3916_REG_EMD_SUP_CONF_emd_thld_mask),
-            (ST25R3916_REG_EMD_SUP_CONF_emd_emv_on | RFAL_EMVCO_RX_MAXLEN));
-#endif /* RFAL_SW_EMD */
-        break;
-    default:
-        /* MISRA 16.4: no empty default statement (a comment being enough) */
-        break;
-    }
-
-    gRFAL.conf.eHandling = eHandling;
-}
-
-/*******************************************************************************/
-rfalEHandling rfalGetErrorHandling(void) {
-    return gRFAL.conf.eHandling;
-}
-
-/*******************************************************************************/
-void rfalSetFDTPoll(uint32_t FDTPoll) {
-    gRFAL.timings.FDTPoll = MIN(FDTPoll, RFAL_ST25R3916_GPT_MAX_1FC);
-}
-
-/*******************************************************************************/
-uint32_t rfalGetFDTPoll(void) {
-    return gRFAL.timings.FDTPoll;
-}
-
-/*******************************************************************************/
-void rfalSetFDTListen(uint32_t FDTListen) {
-    gRFAL.timings.FDTListen = MIN(FDTListen, RFAL_ST25R3916_MRT_MAX_1FC);
-}
-
-/*******************************************************************************/
-uint32_t rfalGetFDTListen(void) {
-    return gRFAL.timings.FDTListen;
-}
-
-/*******************************************************************************/
-void rfalSetGT(uint32_t GT) {
-    gRFAL.timings.GT = MIN(GT, RFAL_ST25R3916_GT_MAX_1FC);
-}
-
-/*******************************************************************************/
-uint32_t rfalGetGT(void) {
-    return gRFAL.timings.GT;
-}
-
-/*******************************************************************************/
-bool rfalIsGTExpired(void) {
-    if(gRFAL.tmr.GT != RFAL_TIMING_NONE) {
-        if(!rfalTimerisExpired(gRFAL.tmr.GT)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/*******************************************************************************/
-ReturnCode rfalFieldOnAndStartGT(void) {
-    ReturnCode ret;
-
-    /* Check if RFAL has been initialized (Oscillator should be running) and also
-     * if a direct register access has been performed and left the Oscillator Off */
-    if(!st25r3916IsOscOn() || (gRFAL.state < RFAL_STATE_INIT)) {
-        return ERR_WRONG_STATE;
-    }
-
-    ret = ERR_NONE;
-
-    /* Set Analog configurations for Field On event */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_FIELD_ON));
-
-    /*******************************************************************************/
-    /* Perform collision avoidance and turn field On if not already On */
-    if(!st25r3916IsTxEnabled() || !gRFAL.field) {
-        /* Set TARFG: 0 (75us+0ms=75us), GT is fulfilled using a SW timer */
-        st25r3916WriteRegister(ST25R3916_REG_FIELD_ON_GT, 0U);
-
-        /* Use Thresholds set by AnalogConfig */
-        ret = st25r3916PerformCollisionAvoidance(
-            ST25R3916_CMD_INITIAL_RF_COLLISION,
-            ST25R3916_THRESHOLD_DO_NOT_SET,
-            ST25R3916_THRESHOLD_DO_NOT_SET,
-            gRFAL.timings.nTRFW);
-
-        /* n * TRFW timing shall vary  Activity 2.1  3.3.1.1 */
-        gRFAL.timings.nTRFW = rfalGennTRFW(gRFAL.timings.nTRFW);
-
-        gRFAL.field = st25r3916IsTxEnabled(); //(ret == ERR_NONE);
-
-        /* Only turn on Receiver and Transmitter if field was successfully turned On */
-        if(gRFAL.field) {
-            st25r3916TxRxOn(); /* Enable Tx and Rx (Tx is already On)*/
-        }
-    }
-
-    /*******************************************************************************/
-    /* Start GT timer in case the GT value is set */
-    if((gRFAL.timings.GT != RFAL_TIMING_NONE)) {
-        /* Ensure that a SW timer doesn't have a lower value then the minimum  */
-        rfalTimerStart(
-            gRFAL.tmr.GT, rfalConv1fcToMs(MAX((gRFAL.timings.GT), RFAL_ST25R3916_GT_MIN_1FC)));
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalFieldOff(void) {
-    /* Check whether a TxRx is not yet finished */
-    if(gRFAL.TxRx.state != RFAL_TXRX_STATE_IDLE) {
-        rfalCleanupTransceive();
-    }
-
-    /* Disable Tx and Rx */
-    st25r3916TxRxOff();
-
-    /* Set Analog configurations for Field Off event */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_FIELD_OFF));
-    gRFAL.field = false;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalStartTransceive(const rfalTransceiveContext* ctx) {
-    uint32_t FxTAdj; /* FWT or FDT adjustment calculation */
-
-    /* Check for valid parameters */
-    if(ctx == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Ensure that RFAL is already Initialized and the mode has been set */
-    if((gRFAL.state >= RFAL_STATE_MODE_SET) /*&& (gRFAL.TxRx.state == RFAL_TXRX_STATE_INIT )*/) {
-        /*******************************************************************************/
-        /* Check whether the field is already On, otherwise no TXE will be received  */
-        if(!st25r3916IsTxEnabled() &&
-           (!rfalIsModePassiveListen(gRFAL.mode) && (ctx->txBuf != NULL))) {
-            return ERR_WRONG_STATE;
-        }
-
-        gRFAL.TxRx.ctx = *ctx;
-
-        /*******************************************************************************/
-        if(gRFAL.timings.FDTListen != RFAL_TIMING_NONE) {
-            /* Calculate MRT adjustment accordingly to the current mode */
-            FxTAdj = RFAL_FDT_LISTEN_MRT_ADJUSTMENT;
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCA) {
-                FxTAdj += (uint32_t)RFAL_FDT_LISTEN_A_ADJUSTMENT;
-            }
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCA_T1T) {
-                FxTAdj += (uint32_t)RFAL_FDT_LISTEN_A_ADJUSTMENT;
-            }
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCB) {
-                FxTAdj += (uint32_t)RFAL_FDT_LISTEN_B_ADJUSTMENT;
-            }
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCV) {
-                FxTAdj += (uint32_t)RFAL_FDT_LISTEN_V_ADJUSTMENT;
-            }
-
-            /* Ensure that MRT is using 64/fc steps */
-            st25r3916ClrRegisterBits(
-                ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step);
-
-            /* If Correlator is being used further adjustment is required for NFCB */
-            if((st25r3916CheckReg(ST25R3916_REG_AUX, ST25R3916_REG_AUX_dis_corr, 0x00U)) &&
-               (gRFAL.mode == RFAL_MODE_POLL_NFCB)) {
-                FxTAdj += (uint32_t)
-                    RFAL_FDT_LISTEN_B_ADJT_CORR; /* Reduce FDT(Listen)                   */
-                st25r3916SetRegisterBits(
-                    ST25R3916_REG_CORR_CONF1,
-                    ST25R3916_REG_CORR_CONF1_corr_s3); /* Ensure BPSK start to 33 pilot pulses */
-                st25r3916ChangeRegisterBits(
-                    ST25R3916_REG_SUBC_START_TIME,
-                    ST25R3916_REG_SUBC_START_TIME_sst_mask,
-                    RFAL_FDT_LISTEN_B_ADJT_CORR_SST); /* Set sst                              */
-            }
-
-            /* Set Minimum FDT(Listen) in which PICC is not allowed to send a response */
-            st25r3916WriteRegister(
-                ST25R3916_REG_MASK_RX_TIMER,
-                (uint8_t)rfalConv1fcTo64fc(
-                    (FxTAdj > gRFAL.timings.FDTListen) ? RFAL_ST25R3916_MRT_MIN_1FC :
-                                                         (gRFAL.timings.FDTListen - FxTAdj)));
-        }
-
-        /*******************************************************************************/
-        /* FDT Poll will be loaded in rfalPrepareTransceive() once the previous was expired */
-
-        /*******************************************************************************/
-        if((gRFAL.TxRx.ctx.fwt != RFAL_FWT_NONE) && (gRFAL.TxRx.ctx.fwt != 0U)) {
-            /* Ensure proper timing configuration */
-            if(gRFAL.timings.FDTListen >= gRFAL.TxRx.ctx.fwt) {
-                return ERR_PARAM;
-            }
-
-            FxTAdj = RFAL_FWT_ADJUSTMENT;
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCA) {
-                FxTAdj += (uint32_t)RFAL_FWT_A_ADJUSTMENT;
-            }
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCA_T1T) {
-                FxTAdj += (uint32_t)RFAL_FWT_A_ADJUSTMENT;
-            }
-            if(gRFAL.mode == RFAL_MODE_POLL_NFCB) {
-                FxTAdj += (uint32_t)RFAL_FWT_B_ADJUSTMENT;
-            }
-            if((gRFAL.mode == RFAL_MODE_POLL_NFCF) || (gRFAL.mode == RFAL_MODE_POLL_ACTIVE_P2P)) {
-                FxTAdj += (uint32_t)((gRFAL.txBR == RFAL_BR_212) ? RFAL_FWT_F_212_ADJUSTMENT :
-                                                                   RFAL_FWT_F_424_ADJUSTMENT);
-            }
-
-            /* Ensure that the given FWT doesn't exceed NRT maximum */
-            gRFAL.TxRx.ctx.fwt = MIN((gRFAL.TxRx.ctx.fwt + FxTAdj), RFAL_ST25R3916_NRT_MAX_1FC);
-
-            /* Set FWT in the NRT */
-            st25r3916SetNoResponseTime(rfalConv1fcTo64fc(gRFAL.TxRx.ctx.fwt));
-        } else {
-            /* Disable NRT, no NRE will be triggered, therefore wait endlessly for Rx */
-            st25r3916SetNoResponseTime(RFAL_ST25R3916_NRT_DISABLED);
-        }
-
-        gRFAL.state = RFAL_STATE_TXRX;
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_IDLE;
-        gRFAL.TxRx.status = ERR_BUSY;
-
-#if RFAL_FEATURE_NFCV
-        /*******************************************************************************/
-        if((RFAL_MODE_POLL_NFCV == gRFAL.mode) ||
-           (RFAL_MODE_POLL_PICOPASS ==
-            gRFAL.mode)) { /* Exchange receive buffer with internal buffer */
-            gRFAL.nfcvData.origCtx = gRFAL.TxRx.ctx;
-
-            gRFAL.TxRx.ctx.rxBuf =
-                ((gRFAL.nfcvData.origCtx.rxBuf != NULL) ? gRFAL.nfcvData.codingBuffer : NULL);
-            gRFAL.TxRx.ctx.rxBufLen =
-                (uint16_t)rfalConvBytesToBits(sizeof(gRFAL.nfcvData.codingBuffer));
-            gRFAL.TxRx.ctx.flags =
-                (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP |
-                (uint32_t)RFAL_TXRX_FLAGS_NFCIP1_OFF |
-                (uint32_t)(gRFAL.nfcvData.origCtx.flags & (uint32_t)RFAL_TXRX_FLAGS_AGC_OFF) |
-                (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_KEEP | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_NONE;
-
-            /* In NFCV a TxRx with a valid txBuf and txBufSize==0 indicates to send an EOF */
-            /* Skip logic below that would go directly into receive                        */
-            if(gRFAL.TxRx.ctx.txBuf != NULL) {
-                return ERR_NONE;
-            }
-        }
-#endif /* RFAL_FEATURE_NFCV */
-
-        /*******************************************************************************/
-        /* Check if the Transceive start performing Tx or goes directly to Rx          */
-        if((gRFAL.TxRx.ctx.txBuf == NULL) || (gRFAL.TxRx.ctx.txBufLen == 0U)) {
-            /* Clear FIFO, Clear and Enable the Interrupts */
-            rfalPrepareTransceive();
-
-            /* In AP2P check the field status */
-            if(rfalIsModeActiveComm(gRFAL.mode)) {
-                /* Disable our field upon a Rx reEnable, and start PPON2 manually */
-                st25r3916TxOff();
-                st25r3916ExecuteCommand(ST25R3916_CMD_START_PPON2_TIMER);
-            }
-
-            /* No Tx done, enable the Receiver */
-            st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-            /* Start NRT manually, if FWT = 0 (wait endlessly for Rx) chip will ignore anyhow */
-            st25r3916ExecuteCommand(ST25R3916_CMD_START_NO_RESPONSE_TIMER);
-
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_IDLE;
-        }
-
-        return ERR_NONE;
-    }
-
-    return ERR_WRONG_STATE;
-}
-
-/*******************************************************************************/
-bool rfalIsTransceiveInTx(void) {
-    return (
-        (gRFAL.TxRx.state >= RFAL_TXRX_STATE_TX_IDLE) &&
-        (gRFAL.TxRx.state < RFAL_TXRX_STATE_RX_IDLE));
-}
-
-/*******************************************************************************/
-bool rfalIsTransceiveInRx(void) {
-    return (gRFAL.TxRx.state >= RFAL_TXRX_STATE_RX_IDLE);
-}
-
-/*******************************************************************************/
-ReturnCode rfalTransceiveBlockingTx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    ReturnCode ret;
-    rfalTransceiveContext ctx;
-
-    rfalCreateByteFlagsTxRxContext(ctx, txBuf, txBufLen, rxBuf, rxBufLen, actLen, flags, fwt);
-    EXIT_ON_ERR(ret, rfalStartTransceive(&ctx));
-
-    return rfalTransceiveRunBlockingTx();
-}
-
-ReturnCode rfalTransceiveBitsBlockingTx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    ReturnCode ret;
-    rfalTransceiveContext ctx = {
-        .rxBuf = rxBuf,
-        .rxBufLen = rxBufLen,
-        .rxRcvdLen = actLen,
-        .txBuf = txBuf,
-        .txBufLen = txBufLen,
-        .flags = flags,
-        .fwt = fwt,
-    };
-
-    EXIT_ON_ERR(ret, rfalStartTransceive(&ctx));
-
-    return rfalTransceiveRunBlockingTx();
-}
-
-/*******************************************************************************/
-static ReturnCode rfalTransceiveRunBlockingTx(void) {
-    ReturnCode ret;
-
-    do {
-        rfalWorker();
-        ret = rfalGetTransceiveStatus();
-    } while(rfalIsTransceiveInTx() && (ret == ERR_BUSY));
-
-    if(rfalIsTransceiveInRx()) {
-        return ERR_NONE;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalTransceiveBlockingRx(void) {
-    ReturnCode ret;
-
-    do {
-        rfalWorker();
-        ret = rfalGetTransceiveStatus();
-    } while(rfalIsTransceiveInRx() && (ret == ERR_BUSY));
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalTransceiveBlockingTxRx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(
-        ret, rfalTransceiveBlockingTx(txBuf, txBufLen, rxBuf, rxBufLen, actLen, flags, fwt));
-    ret = rfalTransceiveBlockingRx();
-
-    /* Convert received bits to bytes */
-    if(actLen != NULL) {
-        *actLen = rfalConvBitsToBytes(*actLen);
-    }
-
-    return ret;
-}
-
-ReturnCode rfalTransceiveBitsBlockingTxRx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    ReturnCode ret;
-
-    EXIT_ON_ERR(
-        ret, rfalTransceiveBitsBlockingTx(txBuf, txBufLen, rxBuf, rxBufLen, actLen, flags, fwt));
-    ret = rfalTransceiveBlockingRx();
-
-    return ret;
-}
-
-/*******************************************************************************/
-static ReturnCode rfalRunTransceiveWorker(void) {
-    if(gRFAL.state == RFAL_STATE_TXRX) {
-        /*******************************************************************************/
-        /* Check Transceive Sanity Timer has expired */
-        if(gRFAL.tmr.txRx != RFAL_TIMING_NONE) {
-            if(rfalTimerisExpired(gRFAL.tmr.txRx)) {
-                /* If sanity timer has expired abort ongoing transceive and signal error */
-                gRFAL.TxRx.status = ERR_IO;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            }
-        }
-
-        /*******************************************************************************/
-        /* Run Tx or Rx state machines */
-        if(rfalIsTransceiveInTx()) {
-            rfalTransceiveTx();
-            return rfalGetTransceiveStatus();
-        }
-        if(rfalIsTransceiveInRx()) {
-            rfalTransceiveRx();
-            return rfalGetTransceiveStatus();
-        }
-    }
-    return ERR_WRONG_STATE;
-}
-
-/*******************************************************************************/
-rfalTransceiveState rfalGetTransceiveState(void) {
-    return gRFAL.TxRx.state;
-}
-
-/*******************************************************************************/
-ReturnCode rfalGetTransceiveStatus(void) {
-    return ((gRFAL.TxRx.state == RFAL_TXRX_STATE_IDLE) ? gRFAL.TxRx.status : ERR_BUSY);
-}
-
-/*******************************************************************************/
-ReturnCode rfalGetTransceiveRSSI(uint16_t* rssi) {
-    uint16_t amRSSI;
-    uint16_t pmRSSI;
-    bool isSumMode;
-
-    if(rssi == NULL) {
-        return ERR_PARAM;
-    }
-
-    st25r3916GetRSSI(&amRSSI, &pmRSSI);
-
-    /* Check if Correlator Summation mode is being used */
-    isSumMode =
-        (st25r3916CheckReg(
-             ST25R3916_REG_CORR_CONF1,
-             ST25R3916_REG_CORR_CONF1_corr_s4,
-             ST25R3916_REG_CORR_CONF1_corr_s4) ?
-             st25r3916CheckReg(ST25R3916_REG_AUX, ST25R3916_REG_AUX_dis_corr, 0x00) :
-             false);
-    if(isSumMode) {
-        /*******************************************************************************/
-        /* Using SQRT from math.h and float. If due to compiler, resources or performance 
-         * issue this cannot be used, other approaches can be foreseen with less accuracy:
-         *    Use a simpler sqrt algorithm 
-         *    *rssi = MAX( amRSSI, pmRSSI );
-         *    *rssi = ( (amRSSI + pmRSSI) / 2);
-         */
-        *rssi = (uint16_t)sqrt(
-            ((double)amRSSI * (double)amRSSI) +
-            ((double)pmRSSI *
-             (double)
-                 pmRSSI)); /*  PRQA S 5209 # MISRA 4.9 - External function (sqrt()) requires double */
-    } else {
-        /* Check which channel was used */
-        *rssi =
-            (st25r3916CheckReg(
-                 ST25R3916_REG_AUX_DISPLAY,
-                 ST25R3916_REG_AUX_DISPLAY_a_cha,
-                 ST25R3916_REG_AUX_DISPLAY_a_cha) ?
-                 pmRSSI :
-                 amRSSI);
-    }
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-void rfalWorker(void) {
-    platformProtectWorker(); /* Protect RFAL Worker/Task/Process */
-
-    switch(gRFAL.state) {
-    case RFAL_STATE_TXRX:
-        rfalRunTransceiveWorker();
-        break;
-
-#if RFAL_FEATURE_LISTEN_MODE
-    case RFAL_STATE_LM:
-        rfalRunListenModeWorker();
-        break;
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-#if RFAL_FEATURE_WAKEUP_MODE
-    case RFAL_STATE_WUM:
-        rfalRunWakeUpModeWorker();
-        break;
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-    /* Nothing to be done */
-    default:
-        /* MISRA 16.4: no empty default statement (a comment being enough) */
-        break;
-    }
-
-    platformUnprotectWorker(); /* Unprotect RFAL Worker/Task/Process */
-}
-
-/*******************************************************************************/
-static void rfalErrorHandling(void) {
-    uint16_t fifoBytesToRead;
-
-    fifoBytesToRead = rfalFIFOStatusGetNumBytes();
-
-#ifdef RFAL_SW_EMD
-    /*******************************************************************************/
-    /* EMVCo                                                                       */
-    /*******************************************************************************/
-    if(gRFAL.conf.eHandling == RFAL_ERRORHANDLING_EMVCO) {
-        bool rxHasIncParError;
-
-        /*******************************************************************************/
-        /* EMD Handling - NFC Forum Digital 1.1  4.1.1.1 ; EMVCo v2.5  4.9.2           */
-        /* ReEnable the receiver on frames with a length < 4 bytes, upon:              */
-        /*   - Collision or Framing error detected                                     */
-        /*   - Residual bits are detected (hard framing error)                         */
-        /*   - Parity error                                                            */
-        /*   - CRC error                                                               */
-        /*******************************************************************************/
-
-        /* Check if reception has incomplete bytes or parity error */
-        rxHasIncParError =
-            (rfalFIFOStatusIsIncompleteByte() ? true :
-                                                rfalFIFOStatusIsMissingPar()); /* MISRA 13.5 */
-
-        /* In case there are residual bits decrement FIFO bytes */
-        /* Ensure FIFO contains some byte as the FIFO might be empty upon Framing errors */
-        if((fifoBytesToRead > 0U) && rxHasIncParError) {
-            fifoBytesToRead--;
-        }
-
-        if(((gRFAL.fifo.bytesTotal + fifoBytesToRead) < RFAL_EMVCO_RX_MAXLEN) &&
-           ((gRFAL.TxRx.status == ERR_RF_COLLISION) || (gRFAL.TxRx.status == ERR_FRAMING) ||
-            (gRFAL.TxRx.status == ERR_PAR) || (gRFAL.TxRx.status == ERR_CRC) ||
-            rxHasIncParError)) {
-            /* Ignore this reception, ReEnable receiver which also clears the FIFO */
-            st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-            /* Ensure that the NRT has not expired meanwhile */
-            if(st25r3916CheckReg(
-                   ST25R3916_REG_NFCIP1_BIT_RATE, ST25R3916_REG_NFCIP1_BIT_RATE_nrt_on, 0x00)) {
-                if(st25r3916CheckReg(
-                       ST25R3916_REG_AUX_DISPLAY, ST25R3916_REG_AUX_DISPLAY_rx_act, 0x00)) {
-                    /* Abort reception */
-                    st25r3916ExecuteCommand(ST25R3916_CMD_MASK_RECEIVE_DATA);
-                    gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-                    return;
-                }
-            }
-
-            rfalFIFOStatusClear();
-            gRFAL.fifo.bytesTotal = 0;
-            gRFAL.TxRx.status = ERR_BUSY;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXS;
-        }
-        return;
-    }
-#endif
-
-    /*******************************************************************************/
-    /* ISO14443A Mode                                                              */
-    /*******************************************************************************/
-    if(gRFAL.mode == RFAL_MODE_POLL_NFCA) {
-        /*******************************************************************************/
-        /* If we received a frame with a incomplete byte we`ll raise a specific error  *
-         * ( support for T2T 4 bit ACK / NAK, MIFARE and Kovio )                       */
-        /*******************************************************************************/
-        if((gRFAL.TxRx.status == ERR_PAR) || (gRFAL.TxRx.status == ERR_CRC)) {
-            if(rfalFIFOStatusIsIncompleteByte()) {
-                st25r3916ReadFifo((uint8_t*)(gRFAL.TxRx.ctx.rxBuf), fifoBytesToRead);
-                if((gRFAL.TxRx.ctx.rxRcvdLen) != NULL) {
-                    *gRFAL.TxRx.ctx.rxRcvdLen = rfalFIFOGetNumIncompleteBits();
-                }
-
-                gRFAL.TxRx.status = ERR_INCOMPLETE_BYTE;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            }
-        }
-    }
-}
-
-/*******************************************************************************/
-static void rfalCleanupTransceive(void) {
-    /*******************************************************************************/
-    /* Transceive flags                                                            */
-    /*******************************************************************************/
-
-    /* Restore default settings on NFCIP1 mode, Receiving parity + CRC bits and manual Tx Parity*/
-    st25r3916ClrRegisterBits(
-        ST25R3916_REG_ISO14443A_NFC,
-        (ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par |
-         ST25R3916_REG_ISO14443A_NFC_nfc_f0));
-
-    /* Restore AGC enabled */
-    st25r3916SetRegisterBits(ST25R3916_REG_RX_CONF2, ST25R3916_REG_RX_CONF2_agc_en);
-
-    /*******************************************************************************/
-
-    /*******************************************************************************/
-    /* Transceive timers                                                           */
-    /*******************************************************************************/
-    rfalTimerDestroy(gRFAL.tmr.txRx);
-    rfalTimerDestroy(gRFAL.tmr.RXE);
-    gRFAL.tmr.txRx = RFAL_TIMING_NONE;
-    gRFAL.tmr.RXE = RFAL_TIMING_NONE;
-    /*******************************************************************************/
-
-    /*******************************************************************************/
-    /* Execute Post Transceive Callback                                            */
-    /*******************************************************************************/
-    if(gRFAL.callbacks.postTxRx != NULL) {
-        gRFAL.callbacks.postTxRx(gRFAL.callbacks.ctx);
-    }
-    /*******************************************************************************/
-}
-
-/*******************************************************************************/
-static void rfalPrepareTransceive(void) {
-    uint32_t maskInterrupts;
-    uint8_t reg;
-
-    /* If we are in RW or AP2P mode */
-    if(!rfalIsModePassiveListen(gRFAL.mode)) {
-        /* Reset receive logic with STOP command */
-        st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-
-        /* Reset Rx Gain */
-        st25r3916ExecuteCommand(ST25R3916_CMD_RESET_RXGAIN);
-    } else {
-        /* In Passive Listen Mode do not use STOP as it stops FDT timer */
-        st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-    }
-
-    /*******************************************************************************/
-    /* FDT Poll                                                                    */
-    /*******************************************************************************/
-    if(rfalIsModePassiveComm(gRFAL.mode)) /* Passive Comms */
-    {
-        /* In Passive communications General Purpose Timer is used to measure FDT Poll */
-        if(gRFAL.timings.FDTPoll != RFAL_TIMING_NONE) {
-            /* Configure GPT to start at RX end */
-            st25r3916SetStartGPTimer(
-                (uint16_t)rfalConv1fcTo8fc(MIN(
-                    gRFAL.timings.FDTPoll, (gRFAL.timings.FDTPoll - RFAL_FDT_POLL_ADJUSTMENT))),
-                ST25R3916_REG_TIMER_EMV_CONTROL_gptc_erx);
-        }
-    }
-
-    /*******************************************************************************/
-    /* Execute Pre Transceive Callback                                             */
-    /*******************************************************************************/
-    if(gRFAL.callbacks.preTxRx != NULL) {
-        gRFAL.callbacks.preTxRx(gRFAL.callbacks.ctx);
-    }
-    /*******************************************************************************/
-
-    maskInterrupts =
-        (ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_RXS |
-         ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC |
-         ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_NRE);
-
-    /*******************************************************************************/
-    /* Transceive flags                                                            */
-    /*******************************************************************************/
-
-    reg =
-        (ST25R3916_REG_ISO14443A_NFC_no_tx_par_off | ST25R3916_REG_ISO14443A_NFC_no_rx_par_off |
-         ST25R3916_REG_ISO14443A_NFC_nfc_f0_off);
-
-    /* Check if NFCIP1 mode is to be enabled */
-    if((gRFAL.TxRx.ctx.flags & (uint8_t)RFAL_TXRX_FLAGS_NFCIP1_ON) != 0U) {
-        reg |= ST25R3916_REG_ISO14443A_NFC_nfc_f0;
-    }
-
-    /* Check if Parity check is to be skipped and to keep the parity + CRC bits in FIFO */
-    if((gRFAL.TxRx.ctx.flags & (uint8_t)RFAL_TXRX_FLAGS_PAR_RX_KEEP) != 0U) {
-        reg |= ST25R3916_REG_ISO14443A_NFC_no_rx_par;
-    }
-
-    /* Check if automatic Parity bits is to be disabled */
-    if((gRFAL.TxRx.ctx.flags & (uint8_t)RFAL_TXRX_FLAGS_PAR_TX_NONE) != 0U) {
-        reg |= ST25R3916_REG_ISO14443A_NFC_no_tx_par;
-    }
-
-    /* Apply current TxRx flags on ISO14443A and NFC 106kb/s Settings Register */
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_ISO14443A_NFC,
-        (ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par |
-         ST25R3916_REG_ISO14443A_NFC_nfc_f0),
-        reg);
-
-    /* Check if AGC is to be disabled */
-    if((gRFAL.TxRx.ctx.flags & (uint8_t)RFAL_TXRX_FLAGS_AGC_OFF) != 0U) {
-        st25r3916ClrRegisterBits(ST25R3916_REG_RX_CONF2, ST25R3916_REG_RX_CONF2_agc_en);
-    } else {
-        st25r3916SetRegisterBits(ST25R3916_REG_RX_CONF2, ST25R3916_REG_RX_CONF2_agc_en);
-    }
-    /*******************************************************************************/
-
-    /*******************************************************************************/
-    /* EMVCo NRT mode                                                              */
-    /*******************************************************************************/
-    if(gRFAL.conf.eHandling == RFAL_ERRORHANDLING_EMVCO) {
-        st25r3916SetRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv);
-        maskInterrupts |= ST25R3916_IRQ_MASK_RX_REST;
-    } else {
-        st25r3916ClrRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv);
-    }
-    /*******************************************************************************/
-
-    /* In Passive Listen mode additionally enable External Field interrupts  */
-    if(rfalIsModePassiveListen(gRFAL.mode)) {
-        maskInterrupts |=
-            (ST25R3916_IRQ_MASK_EOF |
-             ST25R3916_IRQ_MASK_WU_F); /* Enable external Field interrupts to detect Link Loss and SENF_REQ auto responses */
-    }
-
-    /* In Active comms enable also External Field interrupts and set RF Collision Avoindance */
-    if(rfalIsModeActiveComm(gRFAL.mode)) {
-        maskInterrupts |=
-            (ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_EON | ST25R3916_IRQ_MASK_PPON2 |
-             ST25R3916_IRQ_MASK_CAT | ST25R3916_IRQ_MASK_CAC);
-
-        /* Set n=0 for subsequent RF Collision Avoidance */
-        st25r3916ChangeRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_n_mask, 0);
-    }
-
-    /*******************************************************************************/
-    /* Start transceive Sanity Timer if a FWT is used */
-    if((gRFAL.TxRx.ctx.fwt != RFAL_FWT_NONE) && (gRFAL.TxRx.ctx.fwt != 0U)) {
-        rfalTimerStart(gRFAL.tmr.txRx, rfalCalcSanityTmr(gRFAL.TxRx.ctx.fwt));
-    }
-    /*******************************************************************************/
-
-    /*******************************************************************************/
-    /* Clear and enable these interrupts */
-    st25r3916GetInterrupt(maskInterrupts);
-    st25r3916EnableInterrupts(maskInterrupts);
-
-    /* Clear FIFO status local copy */
-    rfalFIFOStatusClear();
-}
-
-/*******************************************************************************/
-static void rfalTransceiveTx(void) {
-    volatile uint32_t irqs;
-    uint16_t tmp;
-    ReturnCode ret;
-
-    /* Suppress warning in case NFC-V feature is disabled */
-    ret = ERR_NONE;
-    NO_WARNING(ret);
-
-    irqs = ST25R3916_IRQ_MASK_NONE;
-
-    if(gRFAL.TxRx.state != gRFAL.TxRx.lastState) {
-        /* rfalLogD( "RFAL: lastSt: %d curSt: %d \r\n", gRFAL.TxRx.lastState, gRFAL.TxRx.state ); */
-        gRFAL.TxRx.lastState = gRFAL.TxRx.state;
-    }
-
-    switch(gRFAL.TxRx.state) {
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_IDLE:
-
-        /* Nothing to do */
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_WAIT_GT;
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_WAIT_GT: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        if(!rfalIsGTExpired()) {
-            break;
-        }
-
-        rfalTimerDestroy(gRFAL.tmr.GT);
-        gRFAL.tmr.GT = RFAL_TIMING_NONE;
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_WAIT_FDT;
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_WAIT_FDT: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        /* Only in Passive communications GPT is used to measure FDT Poll */
-        if(rfalIsModePassiveComm(gRFAL.mode)) {
-            if(st25r3916IsGPTRunning()) {
-                break;
-            }
-        }
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_TRANSMIT;
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_TRANSMIT: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        /* Clear FIFO, Clear and Enable the Interrupts */
-        rfalPrepareTransceive();
-
-        /* ST25R3916 has a fixed FIFO water level */
-        gRFAL.fifo.expWL = RFAL_FIFO_OUT_WL;
-
-#if RFAL_FEATURE_NFCV
-        /*******************************************************************************/
-        /* In NFC-V streaming mode, the FIFO needs to be loaded with the coded bits    */
-        if((RFAL_MODE_POLL_NFCV == gRFAL.mode) || (RFAL_MODE_POLL_PICOPASS == gRFAL.mode)) {
-#if 0
-                /* Debugging code: output the payload bits by writing into the FIFO and subsequent clearing */
-                st25r3916WriteFifo(gRFAL.TxRx.ctx.txBuf, rfalConvBitsToBytes(gRFAL.TxRx.ctx.txBufLen));
-                st25r3916ExecuteCommand( ST25R3916_CMD_CLEAR_FIFO );
-#endif
-            /* Calculate the bytes needed to be Written into FIFO (a incomplete byte will be added as 1byte) */
-            gRFAL.nfcvData.nfcvOffset = 0;
-            ret = iso15693VCDCode(
-                gRFAL.TxRx.ctx.txBuf,
-                rfalConvBitsToBytes(gRFAL.TxRx.ctx.txBufLen),
-                (((gRFAL.nfcvData.origCtx.flags & (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL) != 0U) ?
-                     false :
-                     true),
-                (((gRFAL.nfcvData.origCtx.flags & (uint32_t)RFAL_TXRX_FLAGS_NFCV_FLAG_MANUAL) !=
-                  0U) ?
-                     false :
-                     true),
-                (RFAL_MODE_POLL_PICOPASS == gRFAL.mode),
-                &gRFAL.fifo.bytesTotal,
-                &gRFAL.nfcvData.nfcvOffset,
-                gRFAL.nfcvData.codingBuffer,
-                MIN((uint16_t)ST25R3916_FIFO_DEPTH, (uint16_t)sizeof(gRFAL.nfcvData.codingBuffer)),
-                &gRFAL.fifo.bytesWritten);
-
-            if((ret != ERR_NONE) && (ret != ERR_AGAIN)) {
-                gRFAL.TxRx.status = ret;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-                break;
-            }
-            /* Set the number of full bytes and bits to be transmitted */
-            st25r3916SetNumTxBits((uint16_t)rfalConvBytesToBits(gRFAL.fifo.bytesTotal));
-
-            /* Load FIFO with coded bytes */
-            st25r3916WriteFifo(gRFAL.nfcvData.codingBuffer, gRFAL.fifo.bytesWritten);
-
-        }
-        /*******************************************************************************/
-        else
-#endif /* RFAL_FEATURE_NFCV */
-        {
-            /* Calculate the bytes needed to be Written into FIFO (a incomplete byte will be added as 1byte) */
-            gRFAL.fifo.bytesTotal = (uint16_t)rfalCalcNumBytes(gRFAL.TxRx.ctx.txBufLen);
-
-            /* Set the number of full bytes and bits to be transmitted */
-            st25r3916SetNumTxBits(gRFAL.TxRx.ctx.txBufLen);
-
-            /* Load FIFO with total length or FIFO's maximum */
-            gRFAL.fifo.bytesWritten = MIN(gRFAL.fifo.bytesTotal, ST25R3916_FIFO_DEPTH);
-            st25r3916WriteFifo(gRFAL.TxRx.ctx.txBuf, gRFAL.fifo.bytesWritten);
-        }
-
-        /*Check if Observation Mode is enabled and set it on ST25R391x */
-        rfalCheckEnableObsModeTx();
-
-        /*******************************************************************************/
-        /* If we're in Passive Listen mode ensure that the external field is still On  */
-        if(rfalIsModePassiveListen(gRFAL.mode)) {
-            if(!rfalIsExtFieldOn()) {
-                gRFAL.TxRx.status = ERR_LINK_LOSS;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-                break;
-            }
-        }
-
-        /*******************************************************************************/
-        /* Trigger/Start transmission                                                  */
-        if((gRFAL.TxRx.ctx.flags & (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL) != 0U) {
-            st25r3916ExecuteCommand(ST25R3916_CMD_TRANSMIT_WITHOUT_CRC);
-        } else {
-            st25r3916ExecuteCommand(ST25R3916_CMD_TRANSMIT_WITH_CRC);
-        }
-
-        /* Check if a WL level is expected or TXE should come */
-        gRFAL.TxRx.state =
-            ((gRFAL.fifo.bytesWritten < gRFAL.fifo.bytesTotal) ? RFAL_TXRX_STATE_TX_WAIT_WL :
-                                                                 RFAL_TXRX_STATE_TX_WAIT_TXE);
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_WAIT_WL:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if(((irqs & ST25R3916_IRQ_MASK_FWL) != 0U) && ((irqs & ST25R3916_IRQ_MASK_TXE) == 0U)) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_RELOAD_FIFO;
-        } else {
-            gRFAL.TxRx.status = ERR_IO;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-            break;
-        }
-
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_RELOAD_FIFO: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-#if RFAL_FEATURE_NFCV
-        /*******************************************************************************/
-        /* In NFC-V streaming mode, the FIFO needs to be loaded with the coded bits    */
-        if((RFAL_MODE_POLL_NFCV == gRFAL.mode) || (RFAL_MODE_POLL_PICOPASS == gRFAL.mode)) {
-            uint16_t maxLen;
-
-            /* Load FIFO with the remaining length or maximum available (which fit on the coding buffer) */
-            maxLen =
-                (uint16_t)MIN((gRFAL.fifo.bytesTotal - gRFAL.fifo.bytesWritten), gRFAL.fifo.expWL);
-            maxLen = (uint16_t)MIN(maxLen, sizeof(gRFAL.nfcvData.codingBuffer));
-            tmp = 0;
-
-            /* Calculate the bytes needed to be Written into FIFO (a incomplete byte will be added as 1byte) */
-            ret = iso15693VCDCode(
-                gRFAL.TxRx.ctx.txBuf,
-                rfalConvBitsToBytes(gRFAL.TxRx.ctx.txBufLen),
-                (((gRFAL.nfcvData.origCtx.flags & (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL) != 0U) ?
-                     false :
-                     true),
-                (((gRFAL.nfcvData.origCtx.flags & (uint32_t)RFAL_TXRX_FLAGS_NFCV_FLAG_MANUAL) !=
-                  0U) ?
-                     false :
-                     true),
-                (RFAL_MODE_POLL_PICOPASS == gRFAL.mode),
-                &gRFAL.fifo.bytesTotal,
-                &gRFAL.nfcvData.nfcvOffset,
-                gRFAL.nfcvData.codingBuffer,
-                maxLen,
-                &tmp);
-
-            if((ret != ERR_NONE) && (ret != ERR_AGAIN)) {
-                gRFAL.TxRx.status = ret;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-                break;
-            }
-
-            /* Load FIFO with coded bytes */
-            st25r3916WriteFifo(gRFAL.nfcvData.codingBuffer, tmp);
-        }
-        /*******************************************************************************/
-        else
-#endif /* RFAL_FEATURE_NFCV */
-        {
-            /* Load FIFO with the remaining length or maximum available */
-            tmp = MIN(
-                (gRFAL.fifo.bytesTotal - gRFAL.fifo.bytesWritten),
-                gRFAL.fifo.expWL); /* tmp holds the number of bytes written on this iteration */
-            st25r3916WriteFifo(&gRFAL.TxRx.ctx.txBuf[gRFAL.fifo.bytesWritten], tmp);
-        }
-
-        /* Update total written bytes to FIFO */
-        gRFAL.fifo.bytesWritten += tmp;
-
-        /* Check if a WL level is expected or TXE should come */
-        gRFAL.TxRx.state =
-            ((gRFAL.fifo.bytesWritten < gRFAL.fifo.bytesTotal) ? RFAL_TXRX_STATE_TX_WAIT_WL :
-                                                                 RFAL_TXRX_STATE_TX_WAIT_TXE);
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_WAIT_TXE:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_TXE) != 0U) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_DONE;
-        } else if((irqs & ST25R3916_IRQ_MASK_FWL) != 0U) {
-            break; /* Ignore ST25R3916 FIFO WL if total TxLen is already on the FIFO */
-        } else {
-            gRFAL.TxRx.status = ERR_IO;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-            break;
-        }
-
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_DONE: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        /* If no rxBuf is provided do not wait/expect Rx */
-        if(gRFAL.TxRx.ctx.rxBuf == NULL) {
-            /*Check if Observation Mode was enabled and disable it on ST25R391x */
-            rfalCheckDisableObsMode();
-
-            /* Clean up Transceive */
-            rfalCleanupTransceive();
-
-            gRFAL.TxRx.status = ERR_NONE;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_IDLE;
-            break;
-        }
-
-        rfalCheckEnableObsModeRx();
-
-        /* Goto Rx */
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_IDLE;
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_TX_FAIL:
-
-        /* Error should be assigned by previous state */
-        if(gRFAL.TxRx.status == ERR_BUSY) {
-            gRFAL.TxRx.status = ERR_SYSTEM;
-        }
-
-        /*Check if Observation Mode was enabled and disable it on ST25R391x */
-        rfalCheckDisableObsMode();
-
-        /* Clean up Transceive */
-        rfalCleanupTransceive();
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_IDLE;
-        break;
-
-    /*******************************************************************************/
-    default:
-        gRFAL.TxRx.status = ERR_SYSTEM;
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_TX_FAIL;
-        break;
-    }
-}
-
-/*******************************************************************************/
-static void rfalTransceiveRx(void) {
-    volatile uint32_t irqs;
-    uint16_t tmp;
-    uint16_t aux;
-
-    irqs = ST25R3916_IRQ_MASK_NONE;
-
-    if(gRFAL.TxRx.state != gRFAL.TxRx.lastState) {
-        /* rfalLogD( "RFAL: lastSt: %d curSt: %d \r\n", gRFAL.TxRx.lastState, gRFAL.TxRx.state ); */
-        gRFAL.TxRx.lastState = gRFAL.TxRx.state;
-    }
-
-    switch(gRFAL.TxRx.state) {
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_IDLE:
-
-        /* Clear rx counters */
-        gRFAL.fifo.bytesWritten = 0; /* Total bytes written on RxBuffer         */
-        gRFAL.fifo.bytesTotal = 0; /* Total bytes in FIFO will now be from Rx */
-        if(gRFAL.TxRx.ctx.rxRcvdLen != NULL) {
-            *gRFAL.TxRx.ctx.rxRcvdLen = 0;
-        }
-
-        gRFAL.TxRx.state =
-            (rfalIsModeActiveComm(gRFAL.mode) ? RFAL_TXRX_STATE_RX_WAIT_EON :
-                                                RFAL_TXRX_STATE_RX_WAIT_RXS);
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_WAIT_RXS:
-
-        /*******************************************************************************/
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_RXS | ST25R3916_IRQ_MASK_NRE | ST25R3916_IRQ_MASK_EOF));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        /* Only raise Timeout if NRE is detected with no Rx Start (NRT EMV mode) */
-        if(((irqs & ST25R3916_IRQ_MASK_NRE) != 0U) && ((irqs & ST25R3916_IRQ_MASK_RXS) == 0U)) {
-            gRFAL.TxRx.status = ERR_TIMEOUT;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        }
-
-        /* Only raise Link Loss if EOF is detected with no Rx Start */
-        if(((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) && ((irqs & ST25R3916_IRQ_MASK_RXS) == 0U)) {
-            /* In AP2P a Field On has already occurred - treat this as timeout | mute */
-            gRFAL.TxRx.status = (rfalIsModeActiveComm(gRFAL.mode) ? ERR_TIMEOUT : ERR_LINK_LOSS);
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_RXS) != 0U) {
-            /*******************************************************************************/
-            /* REMARK: Silicon workaround ST25R3916 Errata #TBD                            */
-            /* Rarely on corrupted frames I_rxs gets signaled but I_rxe is not signaled    */
-            /* Use a SW timer to handle an eventual missing RXE                            */
-            rfalTimerStart(gRFAL.tmr.RXE, RFAL_NORXE_TOUT);
-            /*******************************************************************************/
-
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXE;
-        } else {
-            gRFAL.TxRx.status = ERR_IO;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        }
-
-        /* remove NRE that might appear together (NRT EMV mode), and remove RXS, but keep EOF if present for next state */
-        irqs &= ~(ST25R3916_IRQ_MASK_RXS | ST25R3916_IRQ_MASK_NRE);
-
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_WAIT_RXE: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        /*******************************************************************************/
-        /* REMARK: Silicon workaround ST25R3916 Errata #TBD                            */
-        /* ST25R396 may indicate RXS without RXE afterwards, this happens rarely on    */
-        /* corrupted frames.                                                           */
-        /* SW timer is used to timeout upon a missing RXE                              */
-        if(rfalTimerisExpired(gRFAL.tmr.RXE)) {
-            gRFAL.TxRx.status = ERR_FRAMING;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        }
-        /*******************************************************************************/
-
-        irqs |= st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_EOF |
-             ST25R3916_IRQ_MASK_RX_REST | ST25R3916_IRQ_MASK_WU_F));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_RX_REST) != 0U) {
-            /* RX_REST indicates that Receiver has been reset due to EMD, therefore a RXS + RXE should *
-                 * follow if a good reception is followed within the valid initial timeout                   */
-
-            /* Check whether NRT has expired already, if so signal a timeout */
-            if(st25r3916GetInterrupt(ST25R3916_IRQ_MASK_NRE) != 0U) {
-                gRFAL.TxRx.status = ERR_TIMEOUT;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-                break;
-            }
-            if(st25r3916CheckReg(
-                   ST25R3916_REG_NFCIP1_BIT_RATE,
-                   ST25R3916_REG_NFCIP1_BIT_RATE_nrt_on,
-                   0)) /* MISRA 13.5 */
-            {
-                gRFAL.TxRx.status = ERR_TIMEOUT;
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-                break;
-            }
-
-            /* Discard any previous RXS */
-            st25r3916GetInterrupt(ST25R3916_IRQ_MASK_RXS);
-
-            /* Check whether a following reception has already started */
-            if(st25r3916CheckReg(
-                   ST25R3916_REG_AUX_DISPLAY,
-                   ST25R3916_REG_AUX_DISPLAY_rx_act,
-                   ST25R3916_REG_AUX_DISPLAY_rx_act)) {
-                gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXE;
-                break;
-            }
-
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXS;
-            break;
-        }
-
-        if(((irqs & ST25R3916_IRQ_MASK_FWL) != 0U) && ((irqs & ST25R3916_IRQ_MASK_RXE) == 0U)) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_FIFO;
-            break;
-        }
-
-        /* Automatic responses allowed during TxRx only for the SENSF_REQ */
-        if((irqs & ST25R3916_IRQ_MASK_WU_F) != 0U) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXS;
-            break;
-        }
-
-        /* After RXE retrieve and check for any error irqs */
-        irqs |= st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_ERR1 |
-             ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_COL));
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_ERR_CHECK;
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_ERR_CHECK: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        if((irqs & ST25R3916_IRQ_MASK_ERR1) != 0U) {
-            gRFAL.TxRx.status = ERR_FRAMING;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-
-            /* Check if there's a specific error handling for this */
-            rfalErrorHandling();
-            break;
-        }
-        /* Discard Soft Framing errors in AP2P and CE */
-        else if(rfalIsModePassivePoll(gRFAL.mode) && ((irqs & ST25R3916_IRQ_MASK_ERR2) != 0U)) {
-            gRFAL.TxRx.status = ERR_FRAMING;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-
-            /* Check if there's a specific error handling for this */
-            rfalErrorHandling();
-            break;
-        } else if((irqs & ST25R3916_IRQ_MASK_PAR) != 0U) {
-            gRFAL.TxRx.status = ERR_PAR;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-
-            /* Check if there's a specific error handling for this */
-            rfalErrorHandling();
-            break;
-        } else if((irqs & ST25R3916_IRQ_MASK_CRC) != 0U) {
-            gRFAL.TxRx.status = ERR_CRC;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-
-            /* Check if there's a specific error handling for this */
-            rfalErrorHandling();
-            break;
-        } else if((irqs & ST25R3916_IRQ_MASK_COL) != 0U) {
-            gRFAL.TxRx.status = ERR_RF_COLLISION;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-
-            /* Check if there's a specific error handling for this */
-            rfalErrorHandling();
-            break;
-        } else if(rfalIsModePassiveListen(gRFAL.mode) && ((irqs & ST25R3916_IRQ_MASK_EOF) != 0U)) {
-            gRFAL.TxRx.status = ERR_LINK_LOSS;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        } else if((irqs & ST25R3916_IRQ_MASK_RXE) != 0U) {
-            /* Reception ended without any error indication,                  *
-                 * check FIFO status for malformed or incomplete frames           */
-
-            /* Check if the reception ends with an incomplete byte (residual bits) */
-            if(rfalFIFOStatusIsIncompleteByte()) {
-                gRFAL.TxRx.status = ERR_INCOMPLETE_BYTE;
-            }
-            /* Check if the reception ends missing parity bit */
-            else if(rfalFIFOStatusIsMissingPar()) {
-                gRFAL.TxRx.status = ERR_FRAMING;
-            } else {
-                /* MISRA 15.7 - Empty else */
-            }
-
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_READ_DATA;
-        } else {
-            gRFAL.TxRx.status = ERR_IO;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        }
-
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_READ_DATA: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        tmp = rfalFIFOStatusGetNumBytes();
-
-        /*******************************************************************************/
-        /* Check if CRC should not be placed in rxBuf                                  */
-        if(((gRFAL.TxRx.ctx.flags & (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP) == 0U)) {
-            /* if received frame was bigger than CRC */
-            if((uint16_t)(gRFAL.fifo.bytesTotal + tmp) > 0U) {
-                /* By default CRC will not be placed into the rxBuffer */
-                if((tmp > RFAL_CRC_LEN)) {
-                    tmp -= RFAL_CRC_LEN;
-                }
-                /* If the CRC was already placed into rxBuffer (due to WL interrupt where CRC was already in FIFO Read)
-                     * cannot remove it from rxBuf. Can only remove it from rxBufLen not indicate the presence of CRC    */
-                else if(gRFAL.fifo.bytesTotal > RFAL_CRC_LEN) {
-                    gRFAL.fifo.bytesTotal -= RFAL_CRC_LEN;
-                } else {
-                    /* MISRA 15.7 - Empty else */
-                }
-            }
-        }
-
-        gRFAL.fifo.bytesTotal += tmp; /* add to total bytes counter */
-
-        /*******************************************************************************/
-        /* Check if remaining bytes fit on the rxBuf available                         */
-        if(gRFAL.fifo.bytesTotal > rfalConvBitsToBytes(gRFAL.TxRx.ctx.rxBufLen)) {
-            tmp =
-                (uint16_t)(rfalConvBitsToBytes(gRFAL.TxRx.ctx.rxBufLen) - gRFAL.fifo.bytesWritten);
-
-            /* Transmission errors have precedence over buffer error */
-            if(gRFAL.TxRx.status == ERR_BUSY) {
-                gRFAL.TxRx.status = ERR_NOMEM;
-            }
-        }
-
-        /*******************************************************************************/
-        /* Retrieve remaining bytes from FIFO to rxBuf, and assign total length rcvd   */
-        st25r3916ReadFifo(&gRFAL.TxRx.ctx.rxBuf[gRFAL.fifo.bytesWritten], tmp);
-        if(gRFAL.TxRx.ctx.rxRcvdLen != NULL) {
-            (*gRFAL.TxRx.ctx.rxRcvdLen) = (uint16_t)rfalConvBytesToBits(gRFAL.fifo.bytesTotal);
-            if(rfalFIFOStatusIsIncompleteByte()) {
-                (*gRFAL.TxRx.ctx.rxRcvdLen) -=
-                    (RFAL_BITS_IN_BYTE - rfalFIFOGetNumIncompleteBits());
-            }
-        }
-
-#if RFAL_FEATURE_NFCV
-        /*******************************************************************************/
-        /* Decode sub bit stream into payload bits for NFCV, if no error found so far  */
-        if(((RFAL_MODE_POLL_NFCV == gRFAL.mode) || (RFAL_MODE_POLL_PICOPASS == gRFAL.mode)) &&
-           (gRFAL.TxRx.status == ERR_BUSY)) {
-            ReturnCode ret;
-            uint16_t offset = 0; /* REMARK offset not currently used */
-
-            ret = iso15693VICCDecode(
-                gRFAL.TxRx.ctx.rxBuf,
-                gRFAL.fifo.bytesTotal,
-                gRFAL.nfcvData.origCtx.rxBuf,
-                rfalConvBitsToBytes(gRFAL.nfcvData.origCtx.rxBufLen),
-                &offset,
-                gRFAL.nfcvData.origCtx.rxRcvdLen,
-                gRFAL.nfcvData.ignoreBits,
-                (RFAL_MODE_POLL_PICOPASS == gRFAL.mode));
-
-            if(((ERR_NONE == ret) || (ERR_CRC == ret)) &&
-               (((uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP & gRFAL.nfcvData.origCtx.flags) == 0U) &&
-               ((*gRFAL.nfcvData.origCtx.rxRcvdLen % RFAL_BITS_IN_BYTE) == 0U) &&
-               (*gRFAL.nfcvData.origCtx.rxRcvdLen >= rfalConvBytesToBits(RFAL_CRC_LEN))) {
-                *gRFAL.nfcvData.origCtx.rxRcvdLen -=
-                    (uint16_t)rfalConvBytesToBits(RFAL_CRC_LEN); /* Remove CRC */
-            }
-#if 0
-                /* Debugging code: output the payload bits by writing into the FIFO and subsequent clearing */
-                st25r3916WriteFifo(gRFAL.nfcvData.origCtx.rxBuf, rfalConvBitsToBytes( *gRFAL.nfcvData.origCtx.rxRcvdLen));
-                st25r3916ExecuteCommand( ST25R3916_CMD_CLEAR_FIFO );
-#endif
-
-            /* Restore original ctx */
-            gRFAL.TxRx.ctx = gRFAL.nfcvData.origCtx;
-            gRFAL.TxRx.status = ((ret != ERR_NONE) ? ret : ERR_BUSY);
-        }
-#endif /* RFAL_FEATURE_NFCV */
-
-        /*******************************************************************************/
-        /* If an error as been marked/detected don't fall into to RX_DONE  */
-        if(gRFAL.TxRx.status != ERR_BUSY) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-            break;
-        }
-
-        if(rfalIsModeActiveComm(gRFAL.mode)) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_EOF;
-            break;
-        }
-
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_DONE;
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_DONE: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        /*Check if Observation Mode was enabled and disable it on ST25R391x */
-        rfalCheckDisableObsMode();
-
-        /* Clean up Transceive */
-        rfalCleanupTransceive();
-
-        gRFAL.TxRx.status = ERR_NONE;
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_IDLE;
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_READ_FIFO:
-
-        /*******************************************************************************/
-        /* REMARK: Silicon workaround ST25R3916 Errata #TBD                            */
-        /* Rarely on corrupted frames I_rxs gets signaled but I_rxe is not signaled    */
-        /* Use a SW timer to handle an eventual missing RXE                            */
-        rfalTimerStart(gRFAL.tmr.RXE, RFAL_NORXE_TOUT);
-        /*******************************************************************************/
-
-        tmp = rfalFIFOStatusGetNumBytes();
-        gRFAL.fifo.bytesTotal += tmp;
-
-        /*******************************************************************************/
-        /* Calculate the amount of bytes that still fits in rxBuf                      */
-        aux =
-            ((gRFAL.fifo.bytesTotal > rfalConvBitsToBytes(gRFAL.TxRx.ctx.rxBufLen)) ?
-                 (rfalConvBitsToBytes(gRFAL.TxRx.ctx.rxBufLen) - gRFAL.fifo.bytesWritten) :
-                 tmp);
-
-        /*******************************************************************************/
-        /* Retrieve incoming bytes from FIFO to rxBuf, and store already read amount   */
-        st25r3916ReadFifo(&gRFAL.TxRx.ctx.rxBuf[gRFAL.fifo.bytesWritten], aux);
-        gRFAL.fifo.bytesWritten += aux;
-
-        /*******************************************************************************/
-        /* If the bytes already read were not the full FIFO WL, dump the remaining     *
-             * FIFO so that ST25R391x can continue with reception                          */
-        if(aux < tmp) {
-            st25r3916ReadFifo(NULL, (tmp - aux));
-        }
-
-        rfalFIFOStatusClear();
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXE;
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_FAIL:
-
-        /*Check if Observation Mode was enabled and disable it on ST25R391x */
-        rfalCheckDisableObsMode();
-
-        /* Clean up Transceive */
-        rfalCleanupTransceive();
-
-        /* Error should be assigned by previous state */
-        if(gRFAL.TxRx.status == ERR_BUSY) {
-            gRFAL.TxRx.status = ERR_SYSTEM;
-        }
-
-        /*rfalLogD( "RFAL: curSt: %d  Error: %d \r\n", gRFAL.TxRx.state, gRFAL.TxRx.status );*/
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_IDLE;
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_WAIT_EON:
-
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_EON | ST25R3916_IRQ_MASK_NRE | ST25R3916_IRQ_MASK_PPON2));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_EON) != 0U) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_WAIT_RXS;
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_NRE) != 0U) {
-            gRFAL.TxRx.status = ERR_TIMEOUT;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        }
-        if((irqs & ST25R3916_IRQ_MASK_PPON2) != 0U) {
-            gRFAL.TxRx.status = ERR_LINK_LOSS;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_TXRX_STATE_RX_WAIT_EOF:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_CAT | ST25R3916_IRQ_MASK_CAC));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_CAT) != 0U) {
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_DONE;
-        } else if((irqs & ST25R3916_IRQ_MASK_CAC) != 0U) {
-            gRFAL.TxRx.status = ERR_RF_COLLISION;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        } else {
-            gRFAL.TxRx.status = ERR_IO;
-            gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        }
-        break;
-
-    /*******************************************************************************/
-    default:
-        gRFAL.TxRx.status = ERR_SYSTEM;
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_FAIL;
-        break;
-    }
-}
-
-/*******************************************************************************/
-static void rfalFIFOStatusUpdate(void) {
-    if(gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] == RFAL_FIFO_STATUS_INVALID) {
-        st25r3916ReadMultipleRegisters(
-            ST25R3916_REG_FIFO_STATUS1, gRFAL.fifo.status, ST25R3916_FIFO_STATUS_LEN);
-    }
-}
-
-/*******************************************************************************/
-static void rfalFIFOStatusClear(void) {
-    gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] = RFAL_FIFO_STATUS_INVALID;
-}
-
-/*******************************************************************************/
-static uint16_t rfalFIFOStatusGetNumBytes(void) {
-    uint16_t result;
-
-    rfalFIFOStatusUpdate();
-
-    result =
-        ((((uint16_t)gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] &
-           ST25R3916_REG_FIFO_STATUS2_fifo_b_mask) >>
-          ST25R3916_REG_FIFO_STATUS2_fifo_b_shift)
-         << RFAL_BITS_IN_BYTE);
-    result |= (((uint16_t)gRFAL.fifo.status[RFAL_FIFO_STATUS_REG1]) & 0x00FFU);
-    return result;
-}
-
-/*******************************************************************************/
-static bool rfalFIFOStatusIsIncompleteByte(void) {
-    rfalFIFOStatusUpdate();
-    return (
-        (gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] & ST25R3916_REG_FIFO_STATUS2_fifo_lb_mask) !=
-        0U);
-}
-
-/*******************************************************************************/
-static bool rfalFIFOStatusIsMissingPar(void) {
-    rfalFIFOStatusUpdate();
-    return ((gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] & ST25R3916_REG_FIFO_STATUS2_np_lb) != 0U);
-}
-
-/*******************************************************************************/
-static uint8_t rfalFIFOGetNumIncompleteBits(void) {
-    rfalFIFOStatusUpdate();
-    return (
-        (gRFAL.fifo.status[RFAL_FIFO_STATUS_REG2] & ST25R3916_REG_FIFO_STATUS2_fifo_lb_mask) >>
-        ST25R3916_REG_FIFO_STATUS2_fifo_lb_shift);
-}
-
-#if RFAL_FEATURE_NFCA
-
-/*******************************************************************************/
-ReturnCode rfalISO14443ATransceiveShortFrame(
-    rfal14443AShortFrameCmd txCmd,
-    uint8_t* rxBuf,
-    uint8_t rxBufLen,
-    uint16_t* rxRcvdLen,
-    uint32_t fwt) {
-    ReturnCode ret;
-    uint8_t directCmd;
-
-    /* Check if RFAL is properly initialized */
-    if(!st25r3916IsTxEnabled() || (gRFAL.state < RFAL_STATE_MODE_SET) ||
-       ((gRFAL.mode != RFAL_MODE_POLL_NFCA) && (gRFAL.mode != RFAL_MODE_POLL_NFCA_T1T))) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check for valid parameters */
-    if((rxBuf == NULL) || (rxRcvdLen == NULL) || (fwt == RFAL_FWT_NONE)) {
-        return ERR_PARAM;
-    }
-
-    /*******************************************************************************/
-    /* Select the Direct Command to be performed                                   */
-    switch(txCmd) {
-    case RFAL_14443A_SHORTFRAME_CMD_WUPA:
-        directCmd = ST25R3916_CMD_TRANSMIT_WUPA;
-        break;
-
-    case RFAL_14443A_SHORTFRAME_CMD_REQA:
-        directCmd = ST25R3916_CMD_TRANSMIT_REQA;
-        break;
-
-    default:
-        return ERR_PARAM;
-    }
-
-    /* Disable CRC while receiving since ATQA has no CRC included */
-    st25r3916SetRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
-
-    /*******************************************************************************/
-    /* Wait for GT and FDT */
-    while(!rfalIsGTExpired()) { /* MISRA 15.6: mandatory brackets */
-    };
-    while(st25r3916IsGPTRunning()) { /* MISRA 15.6: mandatory brackets */
-    };
-
-    rfalTimerDestroy(gRFAL.tmr.GT);
-    gRFAL.tmr.GT = RFAL_TIMING_NONE;
-
-    /*******************************************************************************/
-    /* Prepare for Transceive, Receive only (bypass Tx states) */
-    gRFAL.TxRx.ctx.flags =
-        ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP);
-    gRFAL.TxRx.ctx.rxBuf = rxBuf;
-    gRFAL.TxRx.ctx.rxBufLen = rxBufLen;
-    gRFAL.TxRx.ctx.rxRcvdLen = rxRcvdLen;
-    gRFAL.TxRx.ctx.fwt = fwt;
-
-    /*******************************************************************************/
-    /* Load NRT with FWT */
-    st25r3916SetNoResponseTime(rfalConv1fcTo64fc(
-        MIN((fwt + RFAL_FWT_ADJUSTMENT + RFAL_FWT_A_ADJUSTMENT), RFAL_ST25R3916_NRT_MAX_1FC)));
-
-    if(gRFAL.timings.FDTListen != RFAL_TIMING_NONE) {
-        /* Ensure that MRT is using 64/fc steps */
-        st25r3916ClrRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step);
-
-        /* Set Minimum FDT(Listen) in which PICC is not allowed to send a response */
-        st25r3916WriteRegister(
-            ST25R3916_REG_MASK_RX_TIMER,
-            (uint8_t)rfalConv1fcTo64fc(
-                ((RFAL_FDT_LISTEN_MRT_ADJUSTMENT + RFAL_FDT_LISTEN_A_ADJUSTMENT) >
-                 gRFAL.timings.FDTListen) ?
-                    RFAL_ST25R3916_MRT_MIN_1FC :
-                    (gRFAL.timings.FDTListen -
-                     (RFAL_FDT_LISTEN_MRT_ADJUSTMENT + RFAL_FDT_LISTEN_A_ADJUSTMENT))));
-    }
-
-    /* In Passive communications General Purpose Timer is used to measure FDT Poll */
-    if(gRFAL.timings.FDTPoll != RFAL_TIMING_NONE) {
-        /* Configure GPT to start at RX end */
-        st25r3916SetStartGPTimer(
-            (uint16_t)rfalConv1fcTo8fc(
-                MIN(gRFAL.timings.FDTPoll, (gRFAL.timings.FDTPoll - RFAL_FDT_POLL_ADJUSTMENT))),
-            ST25R3916_REG_TIMER_EMV_CONTROL_gptc_erx);
-    }
-
-    /*******************************************************************************/
-    rfalPrepareTransceive();
-
-    /* Also enable bit collision interrupt */
-    st25r3916GetInterrupt(ST25R3916_IRQ_MASK_COL);
-    st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_COL);
-
-    /*Check if Observation Mode is enabled and set it on ST25R391x */
-    rfalCheckEnableObsModeTx();
-
-    /*******************************************************************************/
-    /* Clear nbtx bits before sending WUPA/REQA - otherwise ST25R3916 will report parity error, Note2 of the register */
-    st25r3916WriteRegister(ST25R3916_REG_NUM_TX_BYTES2, 0);
-
-    /* Send either WUPA or REQA. All affected tags will backscatter ATQA and change to READY state */
-    st25r3916ExecuteCommand(directCmd);
-
-    /* Wait for TXE */
-    if(st25r3916WaitForInterruptsTimed(
-           ST25R3916_IRQ_MASK_TXE,
-           (uint16_t)MAX(rfalConv1fcToMs(fwt), RFAL_ST25R3916_SW_TMR_MIN_1MS)) == 0U) {
-        ret = ERR_IO;
-    } else {
-        /*Check if Observation Mode is enabled and set it on ST25R391x */
-        rfalCheckEnableObsModeRx();
-
-        /* Jump into a transceive Rx state for reception (bypass Tx states) */
-        gRFAL.state = RFAL_STATE_TXRX;
-        gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_IDLE;
-        gRFAL.TxRx.status = ERR_BUSY;
-
-        /* Execute Transceive Rx blocking */
-        ret = rfalTransceiveBlockingRx();
-    }
-
-    /* Disable Collision interrupt */
-    st25r3916DisableInterrupts((ST25R3916_IRQ_MASK_COL));
-
-    /* ReEnable CRC on Rx */
-    st25r3916ClrRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalISO14443ATransceiveAnticollisionFrame(
-    uint8_t* buf,
-    uint8_t* bytesToSend,
-    uint8_t* bitsToSend,
-    uint16_t* rxLength,
-    uint32_t fwt) {
-    ReturnCode ret;
-    rfalTransceiveContext ctx;
-    uint8_t collByte;
-    uint8_t collData;
-
-    /* Check if RFAL is properly initialized */
-    if((gRFAL.state < RFAL_STATE_MODE_SET) || (gRFAL.mode != RFAL_MODE_POLL_NFCA)) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Check for valid parameters */
-    if((buf == NULL) || (bytesToSend == NULL) || (bitsToSend == NULL) || (rxLength == NULL)) {
-        return ERR_PARAM;
-    }
-
-    /*******************************************************************************/
-    /* Set specific Analog Config for Anticolission if needed */
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_ANTICOL));
-
-    /*******************************************************************************/
-    /* Enable anti collision to recognise collision in first byte of SENS_REQ */
-    st25r3916SetRegisterBits(ST25R3916_REG_ISO14443A_NFC, ST25R3916_REG_ISO14443A_NFC_antcl);
-
-    /* Disable CRC while receiving */
-    st25r3916SetRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
-
-    /*******************************************************************************/
-    /* Prepare for Transceive                                                      */
-    ctx.flags = ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP);
-    ctx.txBuf = buf;
-    ctx.txBufLen = (uint16_t)(rfalConvBytesToBits(*bytesToSend) + *bitsToSend);
-    ctx.rxBuf = &buf[*bytesToSend];
-    ctx.rxBufLen = (uint16_t)rfalConvBytesToBits(RFAL_ISO14443A_SDD_RES_LEN);
-    ctx.rxRcvdLen = rxLength;
-    ctx.fwt = fwt;
-
-    /* Disable Automatic Gain Control (AGC) for better detection of collisions if using Coherent Receiver */
-    ctx.flags |=
-        (st25r3916CheckReg(
-             ST25R3916_REG_AUX, ST25R3916_REG_AUX_dis_corr, ST25R3916_REG_AUX_dis_corr) ?
-             (uint32_t)RFAL_TXRX_FLAGS_AGC_OFF :
-             0x00U);
-
-    rfalStartTransceive(&ctx);
-
-    /* Additionally enable bit collision interrupt */
-    st25r3916GetInterrupt(ST25R3916_IRQ_MASK_COL);
-    st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_COL);
-
-    /*******************************************************************************/
-    collByte = 0;
-
-    /* save the collision byte */
-    if((*bitsToSend) > 0U) {
-        buf[(*bytesToSend)] <<= (RFAL_BITS_IN_BYTE - (*bitsToSend));
-        buf[(*bytesToSend)] >>= (RFAL_BITS_IN_BYTE - (*bitsToSend));
-        collByte = buf[(*bytesToSend)];
-    }
-
-    /*******************************************************************************/
-    /* Run Transceive blocking */
-    ret = rfalTransceiveRunBlockingTx();
-    if(ret == ERR_NONE) {
-        ret = rfalTransceiveBlockingRx();
-
-        /*******************************************************************************/
-        if((*bitsToSend) > 0U) {
-            buf[(*bytesToSend)] >>= (*bitsToSend);
-            buf[(*bytesToSend)] <<= (*bitsToSend);
-            buf[(*bytesToSend)] |= collByte;
-        }
-
-        if((ERR_RF_COLLISION == ret)) {
-            /* read out collision register */
-            st25r3916ReadRegister(ST25R3916_REG_COLLISION_STATUS, &collData);
-
-            (*bytesToSend) =
-                ((collData >> ST25R3916_REG_COLLISION_STATUS_c_byte_shift) &
-                 0x0FU); // 4-bits Byte information
-            (*bitsToSend) =
-                ((collData >> ST25R3916_REG_COLLISION_STATUS_c_bit_shift) &
-                 0x07U); // 3-bits bit information
-        }
-    }
-
-    /*******************************************************************************/
-    /* Disable Collision interrupt */
-    st25r3916DisableInterrupts((ST25R3916_IRQ_MASK_COL));
-
-    /* Disable anti collision again */
-    st25r3916ClrRegisterBits(ST25R3916_REG_ISO14443A_NFC, ST25R3916_REG_ISO14443A_NFC_antcl);
-
-    /* ReEnable CRC on Rx */
-    st25r3916ClrRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
-    /*******************************************************************************/
-
-    /* Restore common Analog configurations for this mode */
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | rfalConvBR2ACBR(gRFAL.txBR) |
-         RFAL_ANALOG_CONFIG_TX));
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCA | rfalConvBR2ACBR(gRFAL.rxBR) |
-         RFAL_ANALOG_CONFIG_RX));
-
-    return ret;
-}
-
-#endif /* RFAL_FEATURE_NFCA */
-
-#if RFAL_FEATURE_NFCV
-
-/*******************************************************************************/
-ReturnCode rfalISO15693TransceiveAnticollisionFrame(
-    uint8_t* txBuf,
-    uint8_t txBufLen,
-    uint8_t* rxBuf,
-    uint8_t rxBufLen,
-    uint16_t* actLen) {
-    ReturnCode ret;
-    rfalTransceiveContext ctx;
-
-    /* Check if RFAL is properly initialized */
-    if((gRFAL.state < RFAL_STATE_MODE_SET) || (gRFAL.mode != RFAL_MODE_POLL_NFCV)) {
-        return ERR_WRONG_STATE;
-    }
-
-    /*******************************************************************************/
-    /* Set specific Analog Config for Anticolission if needed */
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV |
-         RFAL_ANALOG_CONFIG_BITRATE_COMMON | RFAL_ANALOG_CONFIG_ANTICOL));
-
-    /* Ignoring collisions before the UID (RES_FLAG + DSFID) */
-    gRFAL.nfcvData.ignoreBits = (uint16_t)RFAL_ISO15693_IGNORE_BITS;
-
-    /*******************************************************************************/
-    /* Prepare for Transceive  */
-    ctx.flags =
-        ((txBufLen == 0U) ? (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL :
-                            (uint32_t)RFAL_TXRX_FLAGS_CRC_TX_AUTO) |
-        (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP | (uint32_t)RFAL_TXRX_FLAGS_AGC_OFF |
-        ((txBufLen == 0U) ?
-             (uint32_t)RFAL_TXRX_FLAGS_NFCV_FLAG_MANUAL :
-             (uint32_t)
-                 RFAL_TXRX_FLAGS_NFCV_FLAG_AUTO); /* Disable Automatic Gain Control (AGC) for better detection of collision */
-    ctx.txBuf = txBuf;
-    ctx.txBufLen = (uint16_t)rfalConvBytesToBits(txBufLen);
-    ctx.rxBuf = rxBuf;
-    ctx.rxBufLen = (uint16_t)rfalConvBytesToBits(rxBufLen);
-    ctx.rxRcvdLen = actLen;
-    ctx.fwt = rfalConv64fcTo1fc(ISO15693_FWT);
-
-    rfalStartTransceive(&ctx);
-
-    /*******************************************************************************/
-    /* Run Transceive blocking */
-    ret = rfalTransceiveRunBlockingTx();
-    if(ret == ERR_NONE) {
-        ret = rfalTransceiveBlockingRx();
-    }
-
-    /* Check if a Transmission error and received data is less then expected */
-    if(((ret == ERR_RF_COLLISION) || (ret == ERR_CRC) || (ret == ERR_FRAMING)) &&
-       (rfalConvBitsToBytes(*ctx.rxRcvdLen) < RFAL_ISO15693_INV_RES_LEN)) {
-        /* If INVENTORY_RES is shorter than expected, tag is still modulating *
-         * Ensure that response is complete before next frame                 */
-        platformDelay((uint8_t)((RFAL_ISO15693_INV_RES_LEN - rfalConvBitsToBytes(*ctx.rxRcvdLen)) /
-                                ((RFAL_ISO15693_INV_RES_LEN / RFAL_ISO15693_INV_RES_DUR) + 1U)));
-    }
-
-    /* Restore common Analog configurations for this mode */
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV | rfalConvBR2ACBR(gRFAL.txBR) |
-         RFAL_ANALOG_CONFIG_TX));
-    rfalSetAnalogConfig(
-        (RFAL_ANALOG_CONFIG_POLL | RFAL_ANALOG_CONFIG_TECH_NFCV | rfalConvBR2ACBR(gRFAL.rxBR) |
-         RFAL_ANALOG_CONFIG_RX));
-
-    gRFAL.nfcvData.ignoreBits = 0;
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode
-    rfalISO15693TransceiveEOFAnticollision(uint8_t* rxBuf, uint8_t rxBufLen, uint16_t* actLen) {
-    uint8_t dummy;
-
-    return rfalISO15693TransceiveAnticollisionFrame(&dummy, 0, rxBuf, rxBufLen, actLen);
-}
-
-/*******************************************************************************/
-ReturnCode rfalISO15693TransceiveEOF(uint8_t* rxBuf, uint8_t rxBufLen, uint16_t* actLen) {
-    ReturnCode ret;
-    uint8_t dummy;
-
-    /* Check if RFAL is properly initialized */
-    if((gRFAL.state < RFAL_STATE_MODE_SET) || (gRFAL.mode != RFAL_MODE_POLL_NFCV)) {
-        return ERR_WRONG_STATE;
-    }
-
-    /*******************************************************************************/
-    /* Run Transceive blocking */
-    ret = rfalTransceiveBlockingTxRx(
-        &dummy,
-        0,
-        rxBuf,
-        rxBufLen,
-        actLen,
-        ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP |
-         (uint32_t)RFAL_TXRX_FLAGS_AGC_ON),
-        rfalConv64fcTo1fc(ISO15693_FWT));
-    return ret;
-}
-
-#endif /* RFAL_FEATURE_NFCV */
-
-#if RFAL_FEATURE_NFCF
-
-/*******************************************************************************/
-ReturnCode rfalFeliCaPoll(
-    rfalFeliCaPollSlots slots,
-    uint16_t sysCode,
-    uint8_t reqCode,
-    rfalFeliCaPollRes* pollResList,
-    uint8_t pollResListSize,
-    uint8_t* devicesDetected,
-    uint8_t* collisionsDetected) {
-    ReturnCode ret;
-    uint8_t frame
-        [RFAL_FELICA_POLL_REQ_LEN - RFAL_FELICA_LEN_LEN]; // LEN is added by ST25R391x automatically
-    uint16_t actLen;
-    uint8_t frameIdx;
-    uint8_t devDetected;
-    uint8_t colDetected;
-    rfalEHandling curHandling;
-    uint8_t nbSlots;
-
-    /* Check if RFAL is properly initialized */
-    if((gRFAL.state < RFAL_STATE_MODE_SET) || (gRFAL.mode != RFAL_MODE_POLL_NFCF)) {
-        return ERR_WRONG_STATE;
-    }
-
-    frameIdx = 0;
-    colDetected = 0;
-    devDetected = 0;
-    nbSlots = (uint8_t)slots;
-
-    /*******************************************************************************/
-    /* Compute SENSF_REQ frame */
-    frame[frameIdx++] = (uint8_t)FELICA_CMD_POLLING; /* CMD: SENF_REQ                       */
-    frame[frameIdx++] = (uint8_t)(sysCode >> 8); /* System Code (SC)                    */
-    frame[frameIdx++] = (uint8_t)(sysCode & 0xFFU); /* System Code (SC)                    */
-    frame[frameIdx++] = reqCode; /* Communication Parameter Request (RC)*/
-    frame[frameIdx++] = nbSlots; /* TimeSlot (TSN)                      */
-
-    /*******************************************************************************/
-    /* NRT should not stop on reception - Use EMVCo mode to run NRT in nrt_emv     *
-     * ERRORHANDLING_EMVCO has no special handling for NFC-F mode                  */
-    curHandling = gRFAL.conf.eHandling;
-    rfalSetErrorHandling(RFAL_ERRORHANDLING_EMVCO);
-
-    /*******************************************************************************/
-    /* Run transceive blocking, 
-     * Calculate Total Response Time in(64/fc): 
-     *                       512 PICC process time + (n * 256 Time Slot duration)  */
-    ret = rfalTransceiveBlockingTx(
-        frame,
-        (uint16_t)frameIdx,
-        (uint8_t*)gRFAL.nfcfData.pollResponses,
-        RFAL_FELICA_POLL_RES_LEN,
-        &actLen,
-        (RFAL_TXRX_FLAGS_DEFAULT),
-        rfalConv64fcTo1fc(
-            RFAL_FELICA_POLL_DELAY_TIME +
-            (RFAL_FELICA_POLL_SLOT_TIME * ((uint32_t)nbSlots + 1U))));
-
-    /*******************************************************************************/
-    /* If Tx OK, Wait for all responses, store them as soon as they appear         */
-    if(ret == ERR_NONE) {
-        bool timeout;
-
-        do {
-            ret = rfalTransceiveBlockingRx();
-            if(ret == ERR_TIMEOUT) {
-                /* Upon timeout the full Poll Delay + (Slot time)*(nbSlots) has expired */
-                timeout = true;
-            } else {
-                /* Reception done, reEnabled Rx for following Slot */
-                st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-                st25r3916ExecuteCommand(ST25R3916_CMD_RESET_RXGAIN);
-
-                /* If the reception was OK, new device found */
-                if(ret == ERR_NONE) {
-                    devDetected++;
-
-                    /* Overwrite the Transceive context for the next reception */
-                    gRFAL.TxRx.ctx.rxBuf = (uint8_t*)gRFAL.nfcfData.pollResponses[devDetected];
-                }
-                /* If the reception was not OK, mark as collision */
-                else {
-                    colDetected++;
-                }
-
-                /* Check whether NRT has expired meanwhile  */
-                timeout = st25r3916CheckReg(
-                    ST25R3916_REG_NFCIP1_BIT_RATE, ST25R3916_REG_NFCIP1_BIT_RATE_nrt_on, 0x00);
-                if(!timeout) {
-                    /* Jump again into transceive Rx state for the following reception */
-                    gRFAL.TxRx.status = ERR_BUSY;
-                    gRFAL.state = RFAL_STATE_TXRX;
-                    gRFAL.TxRx.state = RFAL_TXRX_STATE_RX_IDLE;
-                }
-            }
-        } while(((nbSlots--) != 0U) && !timeout);
-    }
-
-    /*******************************************************************************/
-    /* Restore NRT to normal mode - back to previous error handling */
-    rfalSetErrorHandling(curHandling);
-
-    /*******************************************************************************/
-    /* Assign output parameters if requested                                       */
-
-    if((pollResList != NULL) && (pollResListSize > 0U) && (devDetected > 0U)) {
-        ST_MEMCPY(
-            pollResList,
-            gRFAL.nfcfData.pollResponses,
-            (RFAL_FELICA_POLL_RES_LEN * (uint32_t)MIN(pollResListSize, devDetected)));
-    }
-
-    if(devicesDetected != NULL) {
-        *devicesDetected = devDetected;
-    }
-
-    if(collisionsDetected != NULL) {
-        *collisionsDetected = colDetected;
-    }
-
-    return (((colDetected != 0U) || (devDetected != 0U)) ? ERR_NONE : ret);
-}
-
-#endif /* RFAL_FEATURE_NFCF */
-
-/*****************************************************************************
- *  Listen Mode                                                              *  
- *****************************************************************************/
-
-/*******************************************************************************/
-bool rfalIsExtFieldOn(void) {
-    return st25r3916IsExtFieldOn();
-}
-
-#if RFAL_FEATURE_LISTEN_MODE
-
-/*******************************************************************************/
-ReturnCode rfalListenStart(
-    uint32_t lmMask,
-    const rfalLmConfPA* confA,
-    const rfalLmConfPB* confB,
-    const rfalLmConfPF* confF,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* rxLen) {
-    t_rfalPTMem
-        PTMem; /*  PRQA S 0759 # MISRA 19.2 - Allocating Union where members are of the same type, just different names.  Thus no problem can occur. */
-    uint8_t* pPTMem;
-    uint8_t autoResp;
-
-    /* Check if RFAL is initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    gRFAL.Lm.state = RFAL_LM_STATE_NOT_INIT;
-    gRFAL.Lm.mdIrqs = ST25R3916_IRQ_MASK_NONE;
-    gRFAL.Lm.mdReg =
-        (ST25R3916_REG_MODE_targ_init | ST25R3916_REG_MODE_om_nfc | ST25R3916_REG_MODE_nfc_ar_off);
-
-    /* By default disable all automatic responses */
-    autoResp =
-        (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a | ST25R3916_REG_PASSIVE_TARGET_rfu |
-         ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r | ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p);
-
-    /*******************************************************************************/
-    if((lmMask & RFAL_LM_MASK_NFCA) != 0U) {
-        /* Check if the conf has been provided */
-        if(confA == NULL) {
-            return ERR_PARAM;
-        }
-
-        pPTMem = (uint8_t*)PTMem.PTMem_A;
-
-        /*******************************************************************************/
-        /* Check and set supported NFCID Length */
-        switch(confA->nfcidLen) {
-        case RFAL_LM_NFCID_LEN_04:
-            st25r3916ChangeRegisterBits(
-                ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_id_mask, ST25R3916_REG_AUX_nfc_id_4bytes);
-            break;
-
-        case RFAL_LM_NFCID_LEN_07:
-            st25r3916ChangeRegisterBits(
-                ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_id_mask, ST25R3916_REG_AUX_nfc_id_7bytes);
-            break;
-
-        default:
-            return ERR_PARAM;
-        }
-
-        /*******************************************************************************/
-        /* Set NFCID */
-        ST_MEMCPY(pPTMem, confA->nfcid, RFAL_NFCID1_TRIPLE_LEN);
-        pPTMem = &pPTMem[RFAL_NFCID1_TRIPLE_LEN]; /* MISRA 18.4 */
-
-        /* Set SENS_RES */
-        ST_MEMCPY(pPTMem, confA->SENS_RES, RFAL_LM_SENS_RES_LEN);
-        pPTMem = &pPTMem[RFAL_LM_SENS_RES_LEN]; /* MISRA 18.4 */
-
-        /* Set SEL_RES */
-        *pPTMem++ =
-            ((confA->nfcidLen == RFAL_LM_NFCID_LEN_04) ?
-                 (confA->SEL_RES & ~RFAL_LM_NFCID_INCOMPLETE) :
-                 (confA->SEL_RES | RFAL_LM_NFCID_INCOMPLETE));
-        *pPTMem++ = (confA->SEL_RES & ~RFAL_LM_NFCID_INCOMPLETE);
-        *pPTMem++ = (confA->SEL_RES & ~RFAL_LM_NFCID_INCOMPLETE);
-
-        /* Write into PTMem-A */
-        st25r3916WritePTMem(PTMem.PTMem_A, ST25R3916_PTM_A_LEN);
-
-        /*******************************************************************************/
-        /* Enable automatic responses for A */
-        autoResp &= ~ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a;
-
-        /* Set Target mode, Bit Rate detection and Listen Mode for NFC-F */
-        gRFAL.Lm.mdReg |=
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om0 |
-             ST25R3916_REG_MODE_nfc_ar_off);
-
-        gRFAL.Lm.mdIrqs |=
-            (ST25R3916_IRQ_MASK_WU_A | ST25R3916_IRQ_MASK_WU_A_X | ST25R3916_IRQ_MASK_RXE_PTA);
-    }
-
-    /*******************************************************************************/
-    if((lmMask & RFAL_LM_MASK_NFCB) != 0U) {
-        /* Check if the conf has been provided */
-        if(confB == NULL) {
-            return ERR_PARAM;
-        }
-
-        return ERR_NOTSUPP;
-    }
-
-    /*******************************************************************************/
-    if((lmMask & RFAL_LM_MASK_NFCF) != 0U) {
-        pPTMem = (uint8_t*)PTMem.PTMem_F;
-
-        /* Check if the conf has been provided */
-        if(confF == NULL) {
-            return ERR_PARAM;
-        }
-
-        /*******************************************************************************/
-        /* Set System Code */
-        ST_MEMCPY(pPTMem, confF->SC, RFAL_LM_SENSF_SC_LEN);
-        pPTMem = &pPTMem[RFAL_LM_SENSF_SC_LEN]; /* MISRA 18.4 */
-
-        /* Set SENSF_RES */
-        ST_MEMCPY(pPTMem, confF->SENSF_RES, RFAL_LM_SENSF_RES_LEN);
-
-        /* Set RD bytes to 0x00 as ST25R3916 cannot support advances features */
-        pPTMem[RFAL_LM_SENSF_RD0_POS] =
-            0x00; /* NFC Forum Digital 1.1 Table 46: 0x00                   */
-        pPTMem[RFAL_LM_SENSF_RD1_POS] =
-            0x00; /* NFC Forum Digital 1.1 Table 47: No automatic bit rates */
-
-        pPTMem = &pPTMem[RFAL_LM_SENS_RES_LEN]; /* MISRA 18.4 */
-
-        /* Write into PTMem-F */
-        st25r3916WritePTMemF(PTMem.PTMem_F, ST25R3916_PTM_F_LEN);
-
-        /*******************************************************************************/
-        /* Write 24 TSN "Random" Numbers at first initialization and let it rollover   */
-        if(!gRFAL.Lm.iniFlag) {
-            pPTMem = (uint8_t*)PTMem.TSN;
-
-            *pPTMem++ = 0x12;
-            *pPTMem++ = 0x34;
-            *pPTMem++ = 0x56;
-            *pPTMem++ = 0x78;
-            *pPTMem++ = 0x9A;
-            *pPTMem++ = 0xBC;
-            *pPTMem++ = 0xDF;
-            *pPTMem++ = 0x21;
-            *pPTMem++ = 0x43;
-            *pPTMem++ = 0x65;
-            *pPTMem++ = 0x87;
-            *pPTMem++ = 0xA9;
-
-            /* Write into PTMem-TSN */
-            st25r3916WritePTMemTSN(PTMem.TSN, ST25R3916_PTM_TSN_LEN);
-        }
-
-        /*******************************************************************************/
-        /* Enable automatic responses for F */
-        autoResp &= ~(ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r);
-
-        /* Set Target mode, Bit Rate detection and Listen Mode for NFC-F */
-        gRFAL.Lm.mdReg |=
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om2 |
-             ST25R3916_REG_MODE_nfc_ar_off);
-
-        /* In CE NFC-F any data without error will be passed to FIFO, to support CUP */
-        gRFAL.Lm.mdIrqs |=
-            (ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RXE_PTA | ST25R3916_IRQ_MASK_RXE);
-    }
-
-    /*******************************************************************************/
-    if((lmMask & RFAL_LM_MASK_ACTIVE_P2P) != 0U) {
-        /* Enable Reception of P2P frames */
-        autoResp &= ~(ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p);
-
-        /* Set Target mode, Bit Rate detection and Automatic Response RF Collision Avoidance */
-        gRFAL.Lm.mdReg |=
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om2 |
-             ST25R3916_REG_MODE_om0 | ST25R3916_REG_MODE_nfc_ar_auto_rx);
-
-        /* n * TRFW timing shall vary  Activity 2.1  3.4.1.1 */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_n_mask, gRFAL.timings.nTRFW);
-        gRFAL.timings.nTRFW = rfalGennTRFW(gRFAL.timings.nTRFW);
-
-        gRFAL.Lm.mdIrqs |= (ST25R3916_IRQ_MASK_RXE);
-    }
-
-    /* Check if one of the modes were selected */
-    if((gRFAL.Lm.mdReg & ST25R3916_REG_MODE_targ) == ST25R3916_REG_MODE_targ_targ) {
-        gRFAL.state = RFAL_STATE_LM;
-        gRFAL.Lm.mdMask = lmMask;
-
-        gRFAL.Lm.rxBuf = rxBuf;
-        gRFAL.Lm.rxBufLen = rxBufLen;
-        gRFAL.Lm.rxLen = rxLen;
-        *gRFAL.Lm.rxLen = 0;
-        gRFAL.Lm.dataFlag = false;
-        gRFAL.Lm.iniFlag = true;
-
-        /* Apply the Automatic Responses configuration */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_PASSIVE_TARGET,
-            (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a | ST25R3916_REG_PASSIVE_TARGET_rfu |
-             ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r | ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p),
-            autoResp);
-
-        /* Disable GPT trigger source */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL,
-            ST25R3916_REG_TIMER_EMV_CONTROL_gptc_mask,
-            ST25R3916_REG_TIMER_EMV_CONTROL_gptc_no_trigger);
-
-        /* On Bit Rate Detection Mode ST25R391x will filter incoming frames during MRT time starting on External Field On event, use 512/fc steps */
-        st25r3916SetRegisterBits(
-            ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step_512);
-        st25r3916WriteRegister(
-            ST25R3916_REG_MASK_RX_TIMER, (uint8_t)rfalConv1fcTo512fc(RFAL_LM_GT));
-
-        /* Restore default settings on NFCIP1 mode, Receiving parity + CRC bits and manual Tx Parity*/
-        st25r3916ClrRegisterBits(
-            ST25R3916_REG_ISO14443A_NFC,
-            (ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par |
-             ST25R3916_REG_ISO14443A_NFC_nfc_f0));
-
-        /* External Field Detector enabled as Automatics on rfalInitialize() */
-
-        /* Set Analog configurations for generic Listen mode */
-        /* Not on SetState(POWER OFF) as otherwise would be applied on every Field Event */
-        rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_ON));
-
-        /* Initialize as POWER_OFF and set proper mode in RF Chip */
-        rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-    } else {
-        return ERR_REQUEST; /* Listen Start called but no mode was enabled */
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-static ReturnCode rfalRunListenModeWorker(void) {
-    volatile uint32_t irqs;
-    uint8_t tmp;
-
-    if(gRFAL.state != RFAL_STATE_LM) {
-        return ERR_WRONG_STATE;
-    }
-
-    switch(gRFAL.Lm.state) {
-    /*******************************************************************************/
-    case RFAL_LM_STATE_POWER_OFF:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_EON));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_EON) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_IDLE);
-        } else {
-            break;
-        }
-        /* fall through */
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_IDLE: /*  PRQA S 2003 # MISRA 16.3 - Intentional fall through */
-
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_NFCT | ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RXE |
-             ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_RXE_PTA));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_NFCT) != 0U) {
-            /* Retrieve detected bitrate */
-            uint8_t newBr;
-            st25r3916ReadRegister(ST25R3916_REG_NFCIP1_BIT_RATE, &newBr);
-            newBr >>= ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate_shift;
-
-            if(newBr > ST25R3916_REG_BIT_RATE_rxrate_424) {
-                newBr = ST25R3916_REG_BIT_RATE_rxrate_424;
-            }
-
-            gRFAL.Lm.brDetected =
-                (rfalBitRate)(newBr); /* PRQA S 4342 # MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.*/
-        }
-
-        if(((irqs & ST25R3916_IRQ_MASK_WU_F) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            rfalListenSetState(RFAL_LM_STATE_READY_F);
-        } else if(((irqs & ST25R3916_IRQ_MASK_RXE) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            irqs = st25r3916GetInterrupt(
-                (ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_EOF |
-                 ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_ERR2 |
-                 ST25R3916_IRQ_MASK_ERR1));
-
-            if(((irqs & ST25R3916_IRQ_MASK_CRC) != 0U) ||
-               ((irqs & ST25R3916_IRQ_MASK_PAR) != 0U) ||
-               ((irqs & ST25R3916_IRQ_MASK_ERR1) != 0U)) {
-                st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-                st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-                st25r3916TxOff();
-                break; /* A bad reception occurred, remain in same state */
-            }
-
-            /* Retrieve received data */
-            *gRFAL.Lm.rxLen = st25r3916GetNumFIFOBytes();
-            st25r3916ReadFifo(
-                gRFAL.Lm.rxBuf, MIN(*gRFAL.Lm.rxLen, rfalConvBitsToBytes(gRFAL.Lm.rxBufLen)));
-
-            /*******************************************************************************/
-            /* REMARK: Silicon workaround ST25R3916 Errata #TBD                            */
-            /* In bitrate detection mode CRC is now checked for NFC-A frames               */
-            if((*gRFAL.Lm.rxLen > RFAL_CRC_LEN) && (gRFAL.Lm.brDetected == RFAL_BR_106)) {
-                if(rfalCrcCalculateCcitt(
-                       RFAL_ISO14443A_CRC_INTVAL, gRFAL.Lm.rxBuf, *gRFAL.Lm.rxLen) != 0U) {
-                    st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-                    st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-                    st25r3916TxOff();
-                    break; /* A bad reception occurred, remain in same state */
-                }
-            }
-            /*******************************************************************************/
-
-            /* Check if the data we got has at least the CRC and remove it, otherwise leave at 0 */
-            *gRFAL.Lm.rxLen -= ((*gRFAL.Lm.rxLen > RFAL_CRC_LEN) ? RFAL_CRC_LEN : *gRFAL.Lm.rxLen);
-            *gRFAL.Lm.rxLen = (uint16_t)rfalConvBytesToBits(*gRFAL.Lm.rxLen);
-            gRFAL.Lm.dataFlag = true;
-
-            /*Check if Observation Mode was enabled and disable it on ST25R391x */
-            rfalCheckDisableObsMode();
-        } else if(
-            ((irqs & ST25R3916_IRQ_MASK_RXE_PTA) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            if(((gRFAL.Lm.mdMask & RFAL_LM_MASK_NFCA) != 0U) &&
-               (gRFAL.Lm.brDetected == RFAL_BR_106)) {
-                st25r3916ReadRegister(ST25R3916_REG_PASSIVE_TARGET_STATUS, &tmp);
-                if(tmp > ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_idle) {
-                    rfalListenSetState(RFAL_LM_STATE_READY_A);
-                }
-            }
-        } else if(((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) && (!gRFAL.Lm.dataFlag)) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_READY_F:
-
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_EOF));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WU_F) != 0U) {
-            break;
-        } else if((irqs & ST25R3916_IRQ_MASK_RXE) != 0U) {
-            /* Retrieve the error flags/irqs */
-            irqs |= st25r3916GetInterrupt(
-                (ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_ERR1));
-
-            if(((irqs & ST25R3916_IRQ_MASK_CRC) != 0U) ||
-               ((irqs & ST25R3916_IRQ_MASK_ERR1) != 0U)) {
-                st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-                st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-                break; /* A bad reception occurred, remain in same state */
-            }
-
-            /* Retrieve received data */
-            *gRFAL.Lm.rxLen = st25r3916GetNumFIFOBytes();
-            st25r3916ReadFifo(
-                gRFAL.Lm.rxBuf, MIN(*gRFAL.Lm.rxLen, rfalConvBitsToBytes(gRFAL.Lm.rxBufLen)));
-
-            /* Check if the data we got has at least the CRC and remove it, otherwise leave at 0 */
-            *gRFAL.Lm.rxLen -= ((*gRFAL.Lm.rxLen > RFAL_CRC_LEN) ? RFAL_CRC_LEN : *gRFAL.Lm.rxLen);
-            *gRFAL.Lm.rxLen = (uint16_t)rfalConvBytesToBits(*gRFAL.Lm.rxLen);
-            gRFAL.Lm.dataFlag = true;
-        } else if((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_READY_A:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_WU_A));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WU_A) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_ACTIVE_A);
-        } else if((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_ACTIVE_A:
-    case RFAL_LM_STATE_ACTIVE_Ax:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_EOF));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_RXE) != 0U) {
-            /* Retrieve the error flags/irqs */
-            irqs |= st25r3916GetInterrupt(
-                (ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_ERR2 |
-                 ST25R3916_IRQ_MASK_ERR1));
-            *gRFAL.Lm.rxLen = st25r3916GetNumFIFOBytes();
-
-            if(((irqs & ST25R3916_IRQ_MASK_CRC) != 0U) ||
-               ((irqs & ST25R3916_IRQ_MASK_ERR1) != 0U) ||
-               ((irqs & ST25R3916_IRQ_MASK_PAR) != 0U) || (*gRFAL.Lm.rxLen <= RFAL_CRC_LEN)) {
-                /* Clear rx context and FIFO */
-                *gRFAL.Lm.rxLen = 0;
-                st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-                st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-                /* Check if we should go to IDLE or Sleep */
-                if(gRFAL.Lm.state == RFAL_LM_STATE_ACTIVE_Ax) {
-                    rfalListenSleepStart(
-                        RFAL_LM_STATE_SLEEP_A, gRFAL.Lm.rxBuf, gRFAL.Lm.rxBufLen, gRFAL.Lm.rxLen);
-                } else {
-                    rfalListenSetState(RFAL_LM_STATE_IDLE);
-                }
-
-                st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_RXE);
-                break;
-            }
-
-            /* Remove CRC from length */
-            *gRFAL.Lm.rxLen -= RFAL_CRC_LEN;
-
-            /* Retrieve received data */
-            st25r3916ReadFifo(
-                gRFAL.Lm.rxBuf, MIN(*gRFAL.Lm.rxLen, rfalConvBitsToBytes(gRFAL.Lm.rxBufLen)));
-            *gRFAL.Lm.rxLen = (uint16_t)rfalConvBytesToBits(*gRFAL.Lm.rxLen);
-            gRFAL.Lm.dataFlag = true;
-        } else if((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_SLEEP_A:
-    case RFAL_LM_STATE_SLEEP_B:
-    case RFAL_LM_STATE_SLEEP_AF:
-
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_NFCT | ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RXE |
-             ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_RXE_PTA));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_NFCT) != 0U) {
-            uint8_t newBr;
-            /* Retrieve detected bitrate */
-            st25r3916ReadRegister(ST25R3916_REG_NFCIP1_BIT_RATE, &newBr);
-            newBr >>= ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate_shift;
-
-            if(newBr > ST25R3916_REG_BIT_RATE_rxrate_424) {
-                newBr = ST25R3916_REG_BIT_RATE_rxrate_424;
-            }
-
-            gRFAL.Lm.brDetected =
-                (rfalBitRate)(newBr); /* PRQA S 4342 # MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.*/
-        }
-
-        if(((irqs & ST25R3916_IRQ_MASK_WU_F) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            rfalListenSetState(RFAL_LM_STATE_READY_F);
-        } else if(((irqs & ST25R3916_IRQ_MASK_RXE) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            /* Clear rx context and FIFO */
-            *gRFAL.Lm.rxLen = 0;
-            st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-            st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-            /* REMARK: In order to support CUP or proprietary frames, handling could be added here */
-        } else if(
-            ((irqs & ST25R3916_IRQ_MASK_RXE_PTA) != 0U) && (gRFAL.Lm.brDetected != RFAL_BR_KEEP)) {
-            if(((gRFAL.Lm.mdMask & RFAL_LM_MASK_NFCA) != 0U) &&
-               (gRFAL.Lm.brDetected == RFAL_BR_106)) {
-                st25r3916ReadRegister(ST25R3916_REG_PASSIVE_TARGET_STATUS, &tmp);
-                if(tmp > ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_halt) {
-                    rfalListenSetState(RFAL_LM_STATE_READY_Ax);
-                }
-            }
-        } else if((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_READY_Ax:
-
-        irqs = st25r3916GetInterrupt((ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_WU_A_X));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WU_A_X) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_ACTIVE_Ax);
-        } else if((irqs & ST25R3916_IRQ_MASK_EOF) != 0U) {
-            rfalListenSetState(RFAL_LM_STATE_POWER_OFF);
-        } else {
-            /* MISRA 15.7 - Empty else */
-        }
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_CARDEMU_4A:
-    case RFAL_LM_STATE_CARDEMU_4B:
-    case RFAL_LM_STATE_CARDEMU_3:
-    case RFAL_LM_STATE_TARGET_F:
-    case RFAL_LM_STATE_TARGET_A:
-        break;
-
-    /*******************************************************************************/
-    default:
-        return ERR_WRONG_STATE;
-    }
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalListenStop(void) {
-    /* Check if RFAL is initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    gRFAL.Lm.state = RFAL_LM_STATE_NOT_INIT;
-
-    /*Check if Observation Mode was enabled and disable it on ST25R391x */
-    rfalCheckDisableObsMode();
-
-    /* Re-Enable the Oscillator if not running */
-    st25r3916OscOn();
-
-    /* Disable Receiver and Transmitter */
-    rfalFieldOff();
-
-    /* Disable all automatic responses */
-    st25r3916SetRegisterBits(
-        ST25R3916_REG_PASSIVE_TARGET,
-        (ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r | ST25R3916_REG_PASSIVE_TARGET_rfu |
-         ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a | ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p));
-
-    /* As there's no Off mode, set default value: ISO14443A with automatic RF Collision Avoidance Off */
-    st25r3916WriteRegister(
-        ST25R3916_REG_MODE,
-        (ST25R3916_REG_MODE_om_iso14443a | ST25R3916_REG_MODE_tr_am_ook |
-         ST25R3916_REG_MODE_nfc_ar_off));
-
-    st25r3916DisableInterrupts(
-        (ST25R3916_IRQ_MASK_RXE_PTA | ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_WU_A |
-         ST25R3916_IRQ_MASK_WU_A_X | ST25R3916_IRQ_MASK_RFU2 | ST25R3916_IRQ_MASK_OSC));
-    st25r3916GetInterrupt(
-        (ST25R3916_IRQ_MASK_RXE_PTA | ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_WU_A |
-         ST25R3916_IRQ_MASK_WU_A_X | ST25R3916_IRQ_MASK_RFU2));
-
-    /* Set Analog configurations for Listen Off event */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LISTEN_OFF));
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode
-    rfalListenSleepStart(rfalLmState sleepSt, uint8_t* rxBuf, uint16_t rxBufLen, uint16_t* rxLen) {
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    switch(sleepSt) {
-    /*******************************************************************************/
-    case RFAL_LM_STATE_SLEEP_A:
-
-        /* Enable automatic responses for A */
-        st25r3916ClrRegisterBits(
-            ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a));
-
-        /* Reset NFCA target */
-        st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SLEEP);
-
-        /* Set Target mode, Bit Rate detection and Listen Mode for NFC-A */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_mask |
-             ST25R3916_REG_MODE_nfc_ar_mask),
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om0 |
-             ST25R3916_REG_MODE_nfc_ar_off));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_SLEEP_AF:
-
-        /* Enable automatic responses for A + F */
-        st25r3916ClrRegisterBits(
-            ST25R3916_REG_PASSIVE_TARGET,
-            (ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r | ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a));
-
-        /* Reset NFCA target state */
-        st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SLEEP);
-
-        /* Set Target mode, Bit Rate detection, Listen Mode for NFC-A and NFC-F */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_MODE,
-            (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_mask |
-             ST25R3916_REG_MODE_nfc_ar_mask),
-            (ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om2 |
-             ST25R3916_REG_MODE_om0 | ST25R3916_REG_MODE_nfc_ar_off));
-        break;
-
-    /*******************************************************************************/
-    case RFAL_LM_STATE_SLEEP_B:
-        /* REMARK: Support for CE-B would be added here  */
-        return ERR_NOT_IMPLEMENTED;
-
-    /*******************************************************************************/
-    default:
-        return ERR_PARAM;
-    }
-
-    /* Ensure that the  NFCIP1 mode is disabled */
-    st25r3916ClrRegisterBits(ST25R3916_REG_ISO14443A_NFC, ST25R3916_REG_ISO14443A_NFC_nfc_f0);
-
-    st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-    /* Clear and enable required IRQs */
-    st25r3916ClearAndEnableInterrupts(
-        (ST25R3916_IRQ_MASK_NFCT | ST25R3916_IRQ_MASK_RXS | ST25R3916_IRQ_MASK_CRC |
-         ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_PAR |
-         ST25R3916_IRQ_MASK_EON | ST25R3916_IRQ_MASK_EOF | gRFAL.Lm.mdIrqs));
-
-    /* Check whether the field was turn off right after the Sleep request */
-    if(!rfalIsExtFieldOn()) {
-        /*rfalLogD( "RFAL: curState: %02X newState: %02X \r\n", gRFAL.Lm.state, RFAL_LM_STATE_NOT_INIT );*/
-
-        rfalListenStop();
-        return ERR_LINK_LOSS;
-    }
-
-    /*rfalLogD( "RFAL: curState: %02X newState: %02X \r\n", gRFAL.Lm.state, sleepSt );*/
-
-    /* Set the new Sleep State*/
-    gRFAL.Lm.state = sleepSt;
-    gRFAL.state = RFAL_STATE_LM;
-
-    gRFAL.Lm.rxBuf = rxBuf;
-    gRFAL.Lm.rxBufLen = rxBufLen;
-    gRFAL.Lm.rxLen = rxLen;
-    *gRFAL.Lm.rxLen = 0;
-    gRFAL.Lm.dataFlag = false;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-rfalLmState rfalListenGetState(bool* dataFlag, rfalBitRate* lastBR) {
-    /* Allow state retrieval even if gRFAL.state != RFAL_STATE_LM so  *
-     * that this Lm state can be used by caller after activation      */
-
-    if(lastBR != NULL) {
-        *lastBR = gRFAL.Lm.brDetected;
-    }
-
-    if(dataFlag != NULL) {
-        *dataFlag = gRFAL.Lm.dataFlag;
-    }
-
-    return gRFAL.Lm.state;
-}
-
-/*******************************************************************************/
-ReturnCode rfalListenSetState(rfalLmState newSt) {
-    ReturnCode ret;
-    rfalLmState newState;
-    bool reSetState;
-
-    /* Check if RFAL is initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* SetState clears the Data flag */
-    gRFAL.Lm.dataFlag = false;
-    newState = newSt;
-    ret = ERR_NONE;
-
-    do {
-        reSetState = false;
-
-        /*******************************************************************************/
-        switch(newState) {
-        /*******************************************************************************/
-        case RFAL_LM_STATE_POWER_OFF:
-
-            /* Enable the receiver and reset logic */
-            st25r3916SetRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_rx_en);
-            st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-
-            if((gRFAL.Lm.mdMask & RFAL_LM_MASK_NFCA) != 0U) {
-                /* Enable automatic responses for A */
-                st25r3916ClrRegisterBits(
-                    ST25R3916_REG_PASSIVE_TARGET, ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a);
-
-                /* Prepares the NFCIP-1 Passive target logic to wait in the Sense/Idle state */
-                st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SENSE);
-            }
-
-            if((gRFAL.Lm.mdMask & RFAL_LM_MASK_NFCF) != 0U) {
-                /* Enable automatic responses for F */
-                st25r3916ClrRegisterBits(
-                    ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r));
-            }
-
-            if((gRFAL.Lm.mdMask & RFAL_LM_MASK_ACTIVE_P2P) != 0U) {
-                /* Ensure automatic response RF Collision Avoidance is back to only after Rx */
-                st25r3916ChangeRegisterBits(
-                    ST25R3916_REG_MODE,
-                    ST25R3916_REG_MODE_nfc_ar_mask,
-                    ST25R3916_REG_MODE_nfc_ar_auto_rx);
-
-                /* Ensure that our field is Off, as automatic response RF Collision Avoidance may have been triggered */
-                st25r3916TxOff();
-            }
-
-            /*******************************************************************************/
-            /* Ensure that the  NFCIP1 mode is disabled */
-            st25r3916ClrRegisterBits(
-                ST25R3916_REG_ISO14443A_NFC, ST25R3916_REG_ISO14443A_NFC_nfc_f0);
-
-            /*******************************************************************************/
-            /* Clear and enable required IRQs */
-            st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_ALL);
-
-            st25r3916ClearAndEnableInterrupts(
-                (ST25R3916_IRQ_MASK_NFCT | ST25R3916_IRQ_MASK_RXS | ST25R3916_IRQ_MASK_CRC |
-                 ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_OSC | ST25R3916_IRQ_MASK_ERR2 |
-                 ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_EON | ST25R3916_IRQ_MASK_EOF |
-                 gRFAL.Lm.mdIrqs));
-
-            /*******************************************************************************/
-            /* Clear the bitRate previously detected */
-            gRFAL.Lm.brDetected = RFAL_BR_KEEP;
-
-            /*******************************************************************************/
-            /* Apply the initial mode */
-            st25r3916ChangeRegisterBits(
-                ST25R3916_REG_MODE,
-                (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_mask |
-                 ST25R3916_REG_MODE_nfc_ar_mask),
-                (uint8_t)gRFAL.Lm.mdReg);
-
-            /*******************************************************************************/
-            /* Check if external Field is already On */
-            if(rfalIsExtFieldOn()) {
-                reSetState = true;
-                newState = RFAL_LM_STATE_IDLE; /* Set IDLE state */
-            }
-#if 1 /* Perform bit rate detection in Low power mode */
-            else {
-                st25r3916ClrRegisterBits(
-                    ST25R3916_REG_OP_CONTROL,
-                    (ST25R3916_REG_OP_CONTROL_tx_en | ST25R3916_REG_OP_CONTROL_rx_en |
-                     ST25R3916_REG_OP_CONTROL_en));
-            }
-#endif
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_IDLE:
-
-            /*******************************************************************************/
-            /* Check if device is coming from Low Power bit rate detection */
-            if(!st25r3916CheckReg(
-                   ST25R3916_REG_OP_CONTROL,
-                   ST25R3916_REG_OP_CONTROL_en,
-                   ST25R3916_REG_OP_CONTROL_en)) {
-                /* Exit Low Power mode and confirm the temporarily enable */
-                st25r3916SetRegisterBits(
-                    ST25R3916_REG_OP_CONTROL,
-                    (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en));
-
-                if(!st25r3916CheckReg(
-                       ST25R3916_REG_AUX_DISPLAY,
-                       ST25R3916_REG_AUX_DISPLAY_osc_ok,
-                       ST25R3916_REG_AUX_DISPLAY_osc_ok)) {
-                    /* Wait for Oscillator ready */
-                    if(st25r3916WaitForInterruptsTimed(
-                           ST25R3916_IRQ_MASK_OSC, ST25R3916_TOUT_OSC_STABLE) == 0U) {
-                        ret = ERR_IO;
-                        break;
-                    }
-                }
-            } else {
-                st25r3916GetInterrupt(ST25R3916_IRQ_MASK_OSC);
-            }
-
-            /*******************************************************************************/
-            /* In Active P2P the Initiator may:  Turn its field On;  LM goes into IDLE state;
-                 *      Initiator sends an unexpected frame raising a Protocol error; Initiator 
-                 *      turns its field Off and ST25R3916 performs the automatic RF Collision 
-                 *      Avoidance keeping our field On; upon a Protocol error upper layer sets 
-                 *      again the state to IDLE to clear dataFlag and wait for next data.
-                 *      
-                 * Ensure that when upper layer calls SetState(IDLE), it restores initial 
-                 * configuration and that check whether an external Field is still present     */
-            if((gRFAL.Lm.mdMask & RFAL_LM_MASK_ACTIVE_P2P) != 0U) {
-                /* Ensure nfc_ar is reset and back to only after Rx */
-                st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-                st25r3916ChangeRegisterBits(
-                    ST25R3916_REG_MODE,
-                    ST25R3916_REG_MODE_nfc_ar_mask,
-                    ST25R3916_REG_MODE_nfc_ar_auto_rx);
-
-                /* Ensure that our field is Off, as automatic response RF Collision Avoidance may have been triggered */
-                st25r3916TxOff();
-
-                /* If external Field is no longer detected go back to POWER_OFF */
-                if(!st25r3916IsExtFieldOn()) {
-                    reSetState = true;
-                    newState = RFAL_LM_STATE_POWER_OFF; /* Set POWER_OFF state */
-                }
-            }
-            /*******************************************************************************/
-
-            /* If we are in ACTIVE_A, reEnable Listen for A before going to IDLE, otherwise do nothing */
-            if(gRFAL.Lm.state == RFAL_LM_STATE_ACTIVE_A) {
-                /* Enable automatic responses for A and Reset NFCA target state */
-                st25r3916ClrRegisterBits(
-                    ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a));
-                st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SENSE);
-            }
-
-            /* ReEnable the receiver */
-            st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-            st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-            /*******************************************************************************/
-            /*Check if Observation Mode is enabled and set it on ST25R391x */
-            rfalCheckEnableObsModeRx();
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_READY_F:
-
-            /*******************************************************************************/
-            /* If we're coming from BitRate detection mode, the Bit Rate Definition reg 
-                 * still has the last bit rate used.
-                 * If a frame is received between setting the mode to Listen NFCA and 
-                 * setting Bit Rate Definition reg, it will raise a framing error.
-                 * Set the bitrate immediately, and then the normal SetMode procedure          */
-            st25r3916SetBitrate((uint8_t)gRFAL.Lm.brDetected, (uint8_t)gRFAL.Lm.brDetected);
-            /*******************************************************************************/
-
-            /* Disable automatic responses for NFC-A */
-            st25r3916SetRegisterBits(
-                ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a));
-
-            /* Set Mode NFC-F only */
-            ret = rfalSetMode(RFAL_MODE_LISTEN_NFCF, gRFAL.Lm.brDetected, gRFAL.Lm.brDetected);
-            gRFAL.state = RFAL_STATE_LM; /* Keep in Listen Mode */
-
-            /* ReEnable the receiver */
-            st25r3916ExecuteCommand(ST25R3916_CMD_CLEAR_FIFO);
-            st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-            /* Clear any previous transmission errors (if Reader polled for other/unsupported technologies) */
-            st25r3916GetInterrupt(
-                (ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_ERR2 |
-                 ST25R3916_IRQ_MASK_ERR1));
-
-            st25r3916EnableInterrupts(
-                ST25R3916_IRQ_MASK_RXE); /* Start looking for any incoming data */
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_CARDEMU_3:
-
-            /* Set Listen NFCF mode  */
-            ret = rfalSetMode(RFAL_MODE_LISTEN_NFCF, gRFAL.Lm.brDetected, gRFAL.Lm.brDetected);
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_READY_Ax:
-        case RFAL_LM_STATE_READY_A:
-
-            /*******************************************************************************/
-            /* If we're coming from BitRate detection mode, the Bit Rate Definition reg 
-                 * still has the last bit rate used.
-                 * If a frame is received between setting the mode to Listen NFCA and 
-                 * setting Bit Rate Definition reg, it will raise a framing error.
-                 * Set the bitrate immediately, and then the normal SetMode procedure          */
-            st25r3916SetBitrate((uint8_t)gRFAL.Lm.brDetected, (uint8_t)gRFAL.Lm.brDetected);
-            /*******************************************************************************/
-
-            /* Disable automatic responses for NFC-F */
-            st25r3916SetRegisterBits(
-                ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r));
-
-            /* Set Mode NFC-A only */
-            ret = rfalSetMode(RFAL_MODE_LISTEN_NFCA, gRFAL.Lm.brDetected, gRFAL.Lm.brDetected);
-
-            gRFAL.state = RFAL_STATE_LM; /* Keep in Listen Mode */
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_ACTIVE_Ax:
-        case RFAL_LM_STATE_ACTIVE_A:
-
-            /* Disable automatic responses for A */
-            st25r3916SetRegisterBits(
-                ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a));
-
-            /* Clear any previous transmission errors (if Reader polled for other/unsupported technologies) */
-            st25r3916GetInterrupt(
-                (ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC | ST25R3916_IRQ_MASK_ERR2 |
-                 ST25R3916_IRQ_MASK_ERR1));
-
-            st25r3916EnableInterrupts(
-                ST25R3916_IRQ_MASK_RXE); /* Start looking for any incoming data */
-            break;
-
-        case RFAL_LM_STATE_TARGET_F:
-            /* Disable Automatic response SENSF_REQ */
-            st25r3916SetRegisterBits(
-                ST25R3916_REG_PASSIVE_TARGET, (ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r));
-            break;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_SLEEP_A:
-        case RFAL_LM_STATE_SLEEP_B:
-        case RFAL_LM_STATE_SLEEP_AF:
-            /* These sleep states have to be set by the rfalListenSleepStart() method */
-            return ERR_REQUEST;
-
-        /*******************************************************************************/
-        case RFAL_LM_STATE_CARDEMU_4A:
-        case RFAL_LM_STATE_CARDEMU_4B:
-        case RFAL_LM_STATE_TARGET_A:
-            /* States not handled by the LM, just keep state context */
-            break;
-
-        /*******************************************************************************/
-        default:
-            return ERR_WRONG_STATE;
-        }
-    } while(reSetState);
-
-    gRFAL.Lm.state = newState;
-
-    // Call callback on state change
-    if(gRFAL.callbacks.state_changed_cb) {
-        gRFAL.callbacks.state_changed_cb(gRFAL.callbacks.ctx);
-    }
-
-    return ret;
-}
-
-#endif /* RFAL_FEATURE_LISTEN_MODE */
-
-/*******************************************************************************
- *  Wake-Up Mode                                                               *
- *******************************************************************************/
-
-#if RFAL_FEATURE_WAKEUP_MODE
-
-/*******************************************************************************/
-ReturnCode rfalWakeUpModeStart(const rfalWakeUpConfig* config) {
-    uint8_t aux;
-    uint8_t reg;
-    uint32_t irqs;
-
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* The Wake-Up procedure is explained in detail in Application Note: AN4985 */
-
-    if(config == NULL) {
-        gRFAL.wum.cfg.period = RFAL_WUM_PERIOD_200MS;
-        gRFAL.wum.cfg.irqTout = false;
-        gRFAL.wum.cfg.indAmp.enabled = true;
-        gRFAL.wum.cfg.indPha.enabled = false;
-        gRFAL.wum.cfg.cap.enabled = false;
-        gRFAL.wum.cfg.indAmp.delta = 2U;
-        gRFAL.wum.cfg.indAmp.reference = RFAL_WUM_REFERENCE_AUTO;
-        gRFAL.wum.cfg.indAmp.autoAvg = false;
-
-        /*******************************************************************************/
-        /* Check if AAT is enabled and if so make use of the SW Tag Detection          */
-        if(st25r3916CheckReg(
-               ST25R3916_REG_IO_CONF2,
-               ST25R3916_REG_IO_CONF2_aat_en,
-               ST25R3916_REG_IO_CONF2_aat_en)) {
-            gRFAL.wum.cfg.swTagDetect = true;
-            gRFAL.wum.cfg.indAmp.autoAvg = true;
-            gRFAL.wum.cfg.indAmp.aaWeight = RFAL_WUM_AA_WEIGHT_16;
-        }
-    } else {
-        gRFAL.wum.cfg = *config;
-    }
-
-    /* Check for valid configuration */
-    if((!gRFAL.wum.cfg.cap.enabled && !gRFAL.wum.cfg.indAmp.enabled &&
-        !gRFAL.wum.cfg.indPha.enabled) ||
-       (gRFAL.wum.cfg.cap.enabled &&
-        (gRFAL.wum.cfg.indAmp.enabled || gRFAL.wum.cfg.indPha.enabled)) ||
-       (gRFAL.wum.cfg.cap.enabled && gRFAL.wum.cfg.swTagDetect) ||
-       ((gRFAL.wum.cfg.indAmp.reference > RFAL_WUM_REFERENCE_AUTO) ||
-        (gRFAL.wum.cfg.indPha.reference > RFAL_WUM_REFERENCE_AUTO) ||
-        (gRFAL.wum.cfg.cap.reference > RFAL_WUM_REFERENCE_AUTO))) {
-        return ERR_PARAM;
-    }
-
-    irqs = ST25R3916_IRQ_MASK_NONE;
-
-    /* Disable Tx, Rx, External Field Detector and set default ISO14443A mode */
-    st25r3916TxRxOff();
-    st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_en_fd_mask);
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_MODE,
-        (ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om_mask),
-        (ST25R3916_REG_MODE_targ_init | ST25R3916_REG_MODE_om_iso14443a));
-
-    /* Set Analog configurations for Wake-up On event */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_WAKEUP_ON));
-
-    /*******************************************************************************/
-    /* Prepare Wake-Up Timer Control Register */
-    reg = (uint8_t)(((uint8_t)gRFAL.wum.cfg.period & 0x0FU)
-                    << ST25R3916_REG_WUP_TIMER_CONTROL_wut_shift);
-    reg |= (uint8_t)(((uint8_t)gRFAL.wum.cfg.period < (uint8_t)RFAL_WUM_PERIOD_100MS) ?
-                         ST25R3916_REG_WUP_TIMER_CONTROL_wur :
-                         0x00U);
-
-    if(gRFAL.wum.cfg.irqTout || gRFAL.wum.cfg.swTagDetect) {
-        reg |= ST25R3916_REG_WUP_TIMER_CONTROL_wto;
-        irqs |= ST25R3916_IRQ_MASK_WT;
-    }
-
-    /* Check if HW Wake-up is to be used or SW Tag detection */
-    if(gRFAL.wum.cfg.swTagDetect) {
-        gRFAL.wum.cfg.indAmp.reference = 0U;
-        gRFAL.wum.cfg.indPha.reference = 0U;
-        gRFAL.wum.cfg.cap.reference = 0U;
-    } else {
-        /*******************************************************************************/
-        /* Check if Inductive Amplitude is to be performed */
-        if(gRFAL.wum.cfg.indAmp.enabled) {
-            aux = (uint8_t)((gRFAL.wum.cfg.indAmp.delta)
-                            << ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d_shift);
-            aux |= (uint8_t)(gRFAL.wum.cfg.indAmp.aaInclMeas ?
-                                 ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aam :
-                                 0x00U);
-            aux |= (uint8_t)(((uint8_t)gRFAL.wum.cfg.indAmp.aaWeight
-                              << ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew_shift) &
-                             ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew_mask);
-            aux |= (uint8_t)(gRFAL.wum.cfg.indAmp.autoAvg ?
-                                 ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_ae :
-                                 0x00U);
-
-            st25r3916WriteRegister(ST25R3916_REG_AMPLITUDE_MEASURE_CONF, aux);
-
-            /* Only need to set the reference if not using Auto Average */
-            if(!gRFAL.wum.cfg.indAmp.autoAvg) {
-                if(gRFAL.wum.cfg.indAmp.reference == RFAL_WUM_REFERENCE_AUTO) {
-                    st25r3916MeasureAmplitude(&aux);
-                    gRFAL.wum.cfg.indAmp.reference = aux;
-                }
-                st25r3916WriteRegister(
-                    ST25R3916_REG_AMPLITUDE_MEASURE_REF, (uint8_t)gRFAL.wum.cfg.indAmp.reference);
-            }
-
-            reg |= ST25R3916_REG_WUP_TIMER_CONTROL_wam;
-            irqs |= ST25R3916_IRQ_MASK_WAM;
-        }
-
-        /*******************************************************************************/
-        /* Check if Inductive Phase is to be performed */
-        if(gRFAL.wum.cfg.indPha.enabled) {
-            aux = (uint8_t)((gRFAL.wum.cfg.indPha.delta)
-                            << ST25R3916_REG_PHASE_MEASURE_CONF_pm_d_shift);
-            aux |= (uint8_t)(gRFAL.wum.cfg.indPha.aaInclMeas ?
-                                 ST25R3916_REG_PHASE_MEASURE_CONF_pm_aam :
-                                 0x00U);
-            aux |= (uint8_t)(((uint8_t)gRFAL.wum.cfg.indPha.aaWeight
-                              << ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew_shift) &
-                             ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew_mask);
-            aux |= (uint8_t)(gRFAL.wum.cfg.indPha.autoAvg ?
-                                 ST25R3916_REG_PHASE_MEASURE_CONF_pm_ae :
-                                 0x00U);
-
-            st25r3916WriteRegister(ST25R3916_REG_PHASE_MEASURE_CONF, aux);
-
-            /* Only need to set the reference if not using Auto Average */
-            if(!gRFAL.wum.cfg.indPha.autoAvg) {
-                if(gRFAL.wum.cfg.indPha.reference == RFAL_WUM_REFERENCE_AUTO) {
-                    st25r3916MeasurePhase(&aux);
-                    gRFAL.wum.cfg.indPha.reference = aux;
-                }
-                st25r3916WriteRegister(
-                    ST25R3916_REG_PHASE_MEASURE_REF, (uint8_t)gRFAL.wum.cfg.indPha.reference);
-            }
-
-            reg |= ST25R3916_REG_WUP_TIMER_CONTROL_wph;
-            irqs |= ST25R3916_IRQ_MASK_WPH;
-        }
-
-        /*******************************************************************************/
-        /* Check if Capacitive is to be performed */
-        if(gRFAL.wum.cfg.cap.enabled) {
-            /*******************************************************************************/
-            /* Perform Capacitive sensor calibration */
-
-            /* Disable Oscillator and Field */
-            st25r3916ClrRegisterBits(
-                ST25R3916_REG_OP_CONTROL,
-                (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_tx_en));
-
-            /* Sensor gain should be configured on Analog Config: RFAL_ANALOG_CONFIG_CHIP_WAKEUP_ON */
-
-            /* Perform calibration procedure */
-            st25r3916CalibrateCapacitiveSensor(NULL);
-
-            /*******************************************************************************/
-            aux = (uint8_t)((gRFAL.wum.cfg.cap.delta)
-                            << ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d_shift);
-            aux |= (uint8_t)(gRFAL.wum.cfg.cap.aaInclMeas ?
-                                 ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aam :
-                                 0x00U);
-            aux |= (uint8_t)(((uint8_t)gRFAL.wum.cfg.cap.aaWeight
-                              << ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew_shift) &
-                             ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew_mask);
-            aux |= (uint8_t)(gRFAL.wum.cfg.cap.autoAvg ?
-                                 ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_ae :
-                                 0x00U);
-
-            st25r3916WriteRegister(ST25R3916_REG_CAPACITANCE_MEASURE_CONF, aux);
-
-            /* Only need to set the reference if not using Auto Average */
-            if(!gRFAL.wum.cfg.cap.autoAvg || gRFAL.wum.cfg.swTagDetect) {
-                if(gRFAL.wum.cfg.indPha.reference == RFAL_WUM_REFERENCE_AUTO) {
-                    st25r3916MeasureCapacitance(&aux);
-                    gRFAL.wum.cfg.cap.reference = aux;
-                }
-                st25r3916WriteRegister(
-                    ST25R3916_REG_CAPACITANCE_MEASURE_REF, (uint8_t)gRFAL.wum.cfg.cap.reference);
-            }
-
-            reg |= ST25R3916_REG_WUP_TIMER_CONTROL_wcap;
-            irqs |= ST25R3916_IRQ_MASK_WCAP;
-        }
-    }
-
-    /* Disable and clear all interrupts except Wake-Up IRQs */
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_ALL);
-    st25r3916GetInterrupt(irqs);
-    st25r3916EnableInterrupts(irqs);
-
-    /* Enable Low Power Wake-Up Mode (Disable: Oscilattor, Tx, Rx and External Field Detector) */
-    st25r3916WriteRegister(ST25R3916_REG_WUP_TIMER_CONTROL, reg);
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_OP_CONTROL,
-        (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en |
-         ST25R3916_REG_OP_CONTROL_tx_en | ST25R3916_REG_OP_CONTROL_en_fd_mask |
-         ST25R3916_REG_OP_CONTROL_wu),
-        ST25R3916_REG_OP_CONTROL_wu);
-
-    gRFAL.wum.state = RFAL_WUM_STATE_ENABLED;
-    gRFAL.state = RFAL_STATE_WUM;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-bool rfalWakeUpModeHasWoke(void) {
-    return (gRFAL.wum.state >= RFAL_WUM_STATE_ENABLED_WOKE);
-}
-
-/*******************************************************************************/
-static uint16_t rfalWakeUpModeFilter(uint16_t curRef, uint16_t curVal, uint8_t weight) {
-    uint16_t newRef;
-
-    /* Perform the averaging|filter as describded in ST25R3916 DS */
-
-    /* Avoid signed arithmetics by splitting in two cases */
-    if(curVal > curRef) {
-        newRef = curRef + ((curVal - curRef) / weight);
-
-        /* In order for the reference to converge to final value   *
-         * increment once the diff is smaller that the weight      */
-        if((curVal != curRef) && (curRef == newRef)) {
-            newRef &= 0xFF00U;
-            newRef += 0x0100U;
-        }
-    } else {
-        newRef = curRef - ((curRef - curVal) / weight);
-
-        /* In order for the reference to converge to final value   *
-         * decrement once the diff is smaller that the weight      */
-        if((curVal != curRef) && (curRef == newRef)) {
-            newRef &= 0xFF00U;
-        }
-    }
-
-    return newRef;
-}
-
-/*******************************************************************************/
-static void rfalRunWakeUpModeWorker(void) {
-    uint32_t irqs;
-    uint8_t reg;
-    uint16_t value;
-    uint16_t delta;
-
-    if(gRFAL.state != RFAL_STATE_WUM) {
-        return;
-    }
-
-    switch(gRFAL.wum.state) {
-    case RFAL_WUM_STATE_ENABLED:
-    case RFAL_WUM_STATE_ENABLED_WOKE:
-
-        irqs = st25r3916GetInterrupt(
-            (ST25R3916_IRQ_MASK_WT | ST25R3916_IRQ_MASK_WAM | ST25R3916_IRQ_MASK_WPH |
-             ST25R3916_IRQ_MASK_WCAP));
-        if(irqs == ST25R3916_IRQ_MASK_NONE) {
-            break; /* No interrupt to process */
-        }
-
-        /*******************************************************************************/
-        /* Check and mark which measurement(s) cause interrupt */
-        if((irqs & ST25R3916_IRQ_MASK_WAM) != 0U) {
-            st25r3916ReadRegister(ST25R3916_REG_AMPLITUDE_MEASURE_RESULT, &reg);
-            gRFAL.wum.state = RFAL_WUM_STATE_ENABLED_WOKE;
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WPH) != 0U) {
-            st25r3916ReadRegister(ST25R3916_REG_PHASE_MEASURE_RESULT, &reg);
-            gRFAL.wum.state = RFAL_WUM_STATE_ENABLED_WOKE;
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WCAP) != 0U) {
-            st25r3916ReadRegister(ST25R3916_REG_CAPACITANCE_MEASURE_RESULT, &reg);
-            gRFAL.wum.state = RFAL_WUM_STATE_ENABLED_WOKE;
-        }
-
-        if((irqs & ST25R3916_IRQ_MASK_WT) != 0U) {
-            /*******************************************************************************/
-            if(gRFAL.wum.cfg.swTagDetect) {
-                /* Enable Ready mode and wait the settle time */
-                st25r3916ChangeRegisterBits(
-                    ST25R3916_REG_OP_CONTROL,
-                    (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_wu),
-                    ST25R3916_REG_OP_CONTROL_en);
-                platformDelay(RFAL_ST25R3916_AAT_SETTLE);
-
-                /*******************************************************************************/
-                if(gRFAL.wum.cfg.indAmp.enabled) {
-                    /* Perform amplitude measurement */
-                    st25r3916MeasureAmplitude(&reg);
-
-                    /* Convert inputs to TD format */
-                    value = rfalConvTDFormat(reg);
-                    delta = rfalConvTDFormat(gRFAL.wum.cfg.indAmp.delta);
-
-                    /* Set first measurement as reference */
-                    if(gRFAL.wum.cfg.indAmp.reference == 0U) {
-                        gRFAL.wum.cfg.indAmp.reference = value;
-                    }
-
-                    /* Check if device should be woken */
-                    if((value >= (gRFAL.wum.cfg.indAmp.reference + delta)) ||
-                       (value <= (gRFAL.wum.cfg.indAmp.reference - delta))) {
-                        gRFAL.wum.state = RFAL_WUM_STATE_ENABLED_WOKE;
-                        break;
-                    }
-
-                    /* Update moving reference if enabled */
-                    if(gRFAL.wum.cfg.indAmp.autoAvg) {
-                        gRFAL.wum.cfg.indAmp.reference = rfalWakeUpModeFilter(
-                            gRFAL.wum.cfg.indAmp.reference,
-                            value,
-                            (RFAL_WU_MIN_WEIGHT_VAL << (uint8_t)gRFAL.wum.cfg.indAmp.aaWeight));
-                    }
-                }
-
-                /*******************************************************************************/
-                if(gRFAL.wum.cfg.indPha.enabled) {
-                    /* Perform Phase measurement */
-                    st25r3916MeasurePhase(&reg);
-
-                    /* Convert inputs to TD format */
-                    value = rfalConvTDFormat(reg);
-                    delta = rfalConvTDFormat(gRFAL.wum.cfg.indPha.delta);
-
-                    /* Set first measurement as reference */
-                    if(gRFAL.wum.cfg.indPha.reference == 0U) {
-                        gRFAL.wum.cfg.indPha.reference = value;
-                    }
-
-                    /* Check if device should be woken */
-                    if((value >= (gRFAL.wum.cfg.indPha.reference + delta)) ||
-                       (value <= (gRFAL.wum.cfg.indPha.reference - delta))) {
-                        gRFAL.wum.state = RFAL_WUM_STATE_ENABLED_WOKE;
-                        break;
-                    }
-
-                    /* Update moving reference if enabled */
-                    if(gRFAL.wum.cfg.indPha.autoAvg) {
-                        gRFAL.wum.cfg.indPha.reference = rfalWakeUpModeFilter(
-                            gRFAL.wum.cfg.indPha.reference,
-                            value,
-                            (RFAL_WU_MIN_WEIGHT_VAL << (uint8_t)gRFAL.wum.cfg.indPha.aaWeight));
-                    }
-                }
-
-                /* Re-Enable low power Wake-Up mode for wto to trigger another measurement(s) */
-                st25r3916ChangeRegisterBits(
-                    ST25R3916_REG_OP_CONTROL,
-                    (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_wu),
-                    (ST25R3916_REG_OP_CONTROL_wu));
-            }
-        }
-        break;
-
-    default:
-        /* MISRA 16.4: no empty default statement (a comment being enough) */
-        break;
-    }
-}
-
-/*******************************************************************************/
-ReturnCode rfalWakeUpModeStop(void) {
-    /* Check if RFAL is in Wake-up mode */
-    if(gRFAL.state != RFAL_STATE_WUM) {
-        return ERR_WRONG_STATE;
-    }
-
-    gRFAL.wum.state = RFAL_WUM_STATE_NOT_INIT;
-
-    /* Disable Wake-Up Mode */
-    st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
-    st25r3916DisableInterrupts(
-        (ST25R3916_IRQ_MASK_WT | ST25R3916_IRQ_MASK_WAM | ST25R3916_IRQ_MASK_WPH |
-         ST25R3916_IRQ_MASK_WCAP));
-
-    /* Re-Enable External Field Detector as: Automatics */
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_OP_CONTROL,
-        ST25R3916_REG_OP_CONTROL_en_fd_mask,
-        ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
-
-    /* Re-Enable the Oscillator */
-    st25r3916OscOn();
-
-    /* Set Analog configurations for Wake-up Off event */
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_WAKEUP_OFF));
-
-    return ERR_NONE;
-}
-
-#endif /* RFAL_FEATURE_WAKEUP_MODE */
-
-/*******************************************************************************
- *  Low-Power Mode                                                               *
- *******************************************************************************/
-
-#if RFAL_FEATURE_LOWPOWER_MODE
-
-/*******************************************************************************/
-ReturnCode rfalLowPowerModeStart(void) {
-    /* Check if RFAL is not initialized */
-    if(gRFAL.state < RFAL_STATE_INIT) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Stop any ongoing activity and set the device in low power by disabling oscillator, transmitter, receiver and external field detector */
-    st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-    st25r3916ClrRegisterBits(
-        ST25R3916_REG_OP_CONTROL,
-        (ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en |
-         ST25R3916_REG_OP_CONTROL_wu | ST25R3916_REG_OP_CONTROL_tx_en |
-         ST25R3916_REG_OP_CONTROL_en_fd_mask));
-
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LOWPOWER_ON));
-
-    gRFAL.state = RFAL_STATE_IDLE;
-    gRFAL.lpm.isRunning = true;
-
-    platformDisableIrqCallback();
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalLowPowerModeStop(void) {
-    ReturnCode ret;
-
-    platformEnableIrqCallback();
-
-    /* Check if RFAL is on right state */
-    if(!gRFAL.lpm.isRunning) {
-        return ERR_WRONG_STATE;
-    }
-
-    /* Re-enable device */
-    EXIT_ON_ERR(ret, st25r3916OscOn());
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_OP_CONTROL,
-        ST25R3916_REG_OP_CONTROL_en_fd_mask,
-        ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
-
-    rfalSetAnalogConfig((RFAL_ANALOG_CONFIG_TECH_CHIP | RFAL_ANALOG_CONFIG_CHIP_LOWPOWER_OFF));
-
-    gRFAL.state = RFAL_STATE_INIT;
-    return ERR_NONE;
-}
-
-#endif /* RFAL_FEATURE_LOWPOWER_MODE */
-
-/*******************************************************************************
- *  RF Chip                                                                    *  
- *******************************************************************************/
-
-/*******************************************************************************/
-ReturnCode rfalChipWriteReg(uint16_t reg, const uint8_t* values, uint8_t len) {
-    if(!st25r3916IsRegValid((uint8_t)reg)) {
-        return ERR_PARAM;
-    }
-
-    return st25r3916WriteMultipleRegisters((uint8_t)reg, values, len);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipReadReg(uint16_t reg, uint8_t* values, uint8_t len) {
-    if(!st25r3916IsRegValid((uint8_t)reg)) {
-        return ERR_PARAM;
-    }
-
-    return st25r3916ReadMultipleRegisters((uint8_t)reg, values, len);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipExecCmd(uint16_t cmd) {
-    if(!st25r3916IsCmdValid((uint8_t)cmd)) {
-        return ERR_PARAM;
-    }
-
-    return st25r3916ExecuteCommand((uint8_t)cmd);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipWriteTestReg(uint16_t reg, uint8_t value) {
-    return st25r3916WriteTestRegister((uint8_t)reg, value);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipReadTestReg(uint16_t reg, uint8_t* value) {
-    return st25r3916ReadTestRegister((uint8_t)reg, value);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipChangeRegBits(uint16_t reg, uint8_t valueMask, uint8_t value) {
-    if(!st25r3916IsRegValid((uint8_t)reg)) {
-        return ERR_PARAM;
-    }
-
-    return st25r3916ChangeRegisterBits((uint8_t)reg, valueMask, value);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipChangeTestRegBits(uint16_t reg, uint8_t valueMask, uint8_t value) {
-    st25r3916ChangeTestRegisterBits((uint8_t)reg, valueMask, value);
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipSetRFO(uint8_t rfo) {
-    return st25r3916ChangeRegisterBits(
-        ST25R3916_REG_TX_DRIVER, ST25R3916_REG_TX_DRIVER_d_res_mask, rfo);
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipGetRFO(uint8_t* result) {
-    ReturnCode ret;
-
-    ret = st25r3916ReadRegister(ST25R3916_REG_TX_DRIVER, result);
-
-    (*result) = ((*result) & ST25R3916_REG_TX_DRIVER_d_res_mask);
-
-    return ret;
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipMeasureAmplitude(uint8_t* result) {
-    ReturnCode err;
-    uint8_t reg_opc, reg_mode, reg_conf1, reg_conf2;
-
-    /* Save registers which will be adjusted below */
-    st25r3916ReadRegister(ST25R3916_REG_OP_CONTROL, &reg_opc);
-    st25r3916ReadRegister(ST25R3916_REG_MODE, &reg_mode);
-    st25r3916ReadRegister(ST25R3916_REG_RX_CONF1, &reg_conf1);
-    st25r3916ReadRegister(ST25R3916_REG_RX_CONF2, &reg_conf2);
-
-    /* Set values as per defaults of DS. These regs/bits influence receiver chain and change amplitude */
-    /* Doing so achieves an amplitude comparable over a complete polling cylce */
-    st25r3916WriteRegister(ST25R3916_REG_OP_CONTROL, (reg_opc & ~ST25R3916_REG_OP_CONTROL_rx_chn));
-    st25r3916WriteRegister(
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_om_iso14443a | ST25R3916_REG_MODE_targ_init |
-            ST25R3916_REG_MODE_tr_am_ook | ST25R3916_REG_MODE_nfc_ar_off);
-    st25r3916WriteRegister(
-        ST25R3916_REG_RX_CONF1, (reg_conf1 & ~ST25R3916_REG_RX_CONF1_ch_sel_AM));
-    st25r3916WriteRegister(
-        ST25R3916_REG_RX_CONF2,
-        ((reg_conf2 & ~(ST25R3916_REG_RX_CONF2_demod_mode | ST25R3916_REG_RX_CONF2_amd_sel)) |
-         ST25R3916_REG_RX_CONF2_amd_sel_peak));
-
-    /* Perform the actual measurement */
-    err = st25r3916MeasureAmplitude(result);
-
-    /* Restore values */
-    st25r3916WriteRegister(ST25R3916_REG_OP_CONTROL, reg_opc);
-    st25r3916WriteRegister(ST25R3916_REG_MODE, reg_mode);
-    st25r3916WriteRegister(ST25R3916_REG_RX_CONF1, reg_conf1);
-    st25r3916WriteRegister(ST25R3916_REG_RX_CONF2, reg_conf2);
-
-    return err;
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipMeasurePhase(uint8_t* result) {
-    st25r3916MeasurePhase(result);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipMeasureCapacitance(uint8_t* result) {
-    st25r3916MeasureCapacitance(result);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode rfalChipMeasurePowerSupply(uint8_t param, uint8_t* result) {
-    *result = st25r3916MeasurePowerSupply(param);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-extern uint8_t invalid_size_of_stream_configs
-    [(sizeof(struct st25r3916StreamConfig) == sizeof(struct iso15693StreamConfig)) ? 1 : (-1)];

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916.c

@@ -1,801 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 high level interface
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "st25r3916.h"
-#include "st25r3916_com.h"
-#include "st25r3916_led.h"
-#include "st25r3916_irq.h"
-#include "../../utils.h"
-
-/*
-******************************************************************************
-* LOCAL DEFINES
-******************************************************************************
-*/
-
-#define ST25R3916_SUPPLY_THRESHOLD \
-    3600U /*!< Power supply measure threshold between 3.3V or 5V                   */
-#define ST25R3916_NRT_MAX \
-    0xFFFFU /*!< Max Register value of NRT                                           */
-
-#define ST25R3916_TOUT_MEASURE_VDD \
-    100U /*!< Max duration time of Measure Power Supply command  Datasheet: 25us  */
-#define ST25R3916_TOUT_MEASURE_AMPLITUDE \
-    10U /*!< Max duration time of Measure Amplitude command     Datasheet: 25us  */
-#define ST25R3916_TOUT_MEASURE_PHASE \
-    10U /*!< Max duration time of Measure Phase command         Datasheet: 25us  */
-#define ST25R3916_TOUT_MEASURE_CAPACITANCE \
-    10U /*!< Max duration time of Measure Capacitance command   Datasheet: 25us  */
-#define ST25R3916_TOUT_CALIBRATE_CAP_SENSOR \
-    4U /*!< Max duration Calibrate Capacitive Sensor command   Datasheet: 3ms   */
-#define ST25R3916_TOUT_ADJUST_REGULATORS \
-    6U /*!< Max duration time of Adjust Regulators command     Datasheet: 5ms   */
-#define ST25R3916_TOUT_CA \
-    10U /*!< Max duration time of Collision Avoidance command                    */
-
-#define ST25R3916_TEST_REG_PATTERN \
-    0x33U /*!< Register Read Write test pattern used during selftest               */
-#define ST25R3916_TEST_WU_TOUT \
-    12U /*!< Timeout used on WU timer during self test                           */
-#define ST25R3916_TEST_TMR_TOUT \
-    20U /*!< Timeout used during self test                                       */
-#define ST25R3916_TEST_TMR_TOUT_DELTA \
-    2U /*!< Timeout used during self test                                       */
-#define ST25R3916_TEST_TMR_TOUT_8FC \
-    (ST25R3916_TEST_TMR_TOUT * 16950U) /*!< Timeout in 8/fc                          */
-
-/*
-******************************************************************************
-* LOCAL CONSTANTS
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-static uint32_t gST25R3916NRT_64fcs;
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*
- ******************************************************************************
- * LOCAL FUNCTION
- ******************************************************************************
- */
-
-ReturnCode st25r3916ExecuteCommandAndGetResult(
-    uint8_t cmd,
-    uint8_t resReg,
-    uint8_t tout,
-    uint8_t* result) {
-    /* Clear and enable Direct Command interrupt */
-    st25r3916GetInterrupt(ST25R3916_IRQ_MASK_DCT);
-    st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_DCT);
-
-    st25r3916ExecuteCommand(cmd);
-
-    st25r3916WaitForInterruptsTimed(ST25R3916_IRQ_MASK_DCT, tout);
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_DCT);
-
-    /* After execution read out the result if the pointer is not NULL */
-    if(result != NULL) {
-        st25r3916ReadRegister(resReg, result);
-    }
-
-    return ERR_NONE;
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-ReturnCode st25r3916Initialize(void) {
-    uint16_t vdd_mV;
-    ReturnCode ret;
-
-    /* Set default state on the ST25R3916 */
-    st25r3916ExecuteCommand(ST25R3916_CMD_SET_DEFAULT);
-
-#ifndef RFAL_USE_I2C
-    /* Increase MISO driving level as SPI can go up to 10MHz */
-    st25r3916WriteRegister(ST25R3916_REG_IO_CONF2, ST25R3916_REG_IO_CONF2_io_drv_lvl);
-#endif /* RFAL_USE_I2C */
-
-    if(!st25r3916CheckChipID(NULL)) {
-        platformErrorHandle();
-        return ERR_HW_MISMATCH;
-    }
-
-    st25r3916InitInterrupts();
-    st25r3916ledInit();
-
-    gST25R3916NRT_64fcs = 0;
-
-#ifndef RFAL_USE_I2C
-    /* Enable pull downs on MISO line */
-    st25r3916SetRegisterBits(
-        ST25R3916_REG_IO_CONF2,
-        (ST25R3916_REG_IO_CONF2_miso_pd1 | ST25R3916_REG_IO_CONF2_miso_pd2));
-#endif /* RFAL_USE_I2C */
-
-    /* Disable internal overheat protection */
-    st25r3916ChangeTestRegisterBits(0x04, 0x10, 0x10);
-
-#ifdef ST25R_SELFTEST
-    /******************************************************************************
-     * Check communication interface: 
-     *  - write a pattern in a register
-     *  - reads back the register value
-     *  - return ERR_IO in case the read value is different
-     */
-    st25r3916WriteRegister(ST25R3916_REG_BIT_RATE, ST25R3916_TEST_REG_PATTERN);
-    if(!st25r3916CheckReg(
-           ST25R3916_REG_BIT_RATE,
-           (ST25R3916_REG_BIT_RATE_rxrate_mask | ST25R3916_REG_BIT_RATE_txrate_mask),
-           ST25R3916_TEST_REG_PATTERN)) {
-        platformErrorHandle();
-        return ERR_IO;
-    }
-
-    /* Restore default value */
-    st25r3916WriteRegister(ST25R3916_REG_BIT_RATE, 0x00);
-
-    /*
-     * Check IRQ Handling:
-     *  - use the Wake-up timer to trigger an IRQ
-     *  - wait the Wake-up timer interrupt
-     *  - return ERR_TIMEOUT when the Wake-up timer interrupt is not received
-     */
-    st25r3916WriteRegister(
-        ST25R3916_REG_WUP_TIMER_CONTROL,
-        ST25R3916_REG_WUP_TIMER_CONTROL_wur | ST25R3916_REG_WUP_TIMER_CONTROL_wto);
-    st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_WT);
-    st25r3916ExecuteCommand(ST25R3916_CMD_START_WUP_TIMER);
-    if(st25r3916WaitForInterruptsTimed(ST25R3916_IRQ_MASK_WT, ST25R3916_TEST_WU_TOUT) == 0U) {
-        platformErrorHandle();
-        return ERR_TIMEOUT;
-    }
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_WT);
-    st25r3916WriteRegister(ST25R3916_REG_WUP_TIMER_CONTROL, 0U);
-    /*******************************************************************************/
-#endif /* ST25R_SELFTEST */
-
-    /* Enable Oscillator and wait until it gets stable */
-    ret = st25r3916OscOn();
-    if(ret != ERR_NONE) {
-        platformErrorHandle();
-        return ret;
-    }
-
-    /* Measure VDD and set sup3V bit according to Power supplied  */
-    vdd_mV = st25r3916MeasureVoltage(ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd);
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_IO_CONF2,
-        ST25R3916_REG_IO_CONF2_sup3V,
-        ((vdd_mV < ST25R3916_SUPPLY_THRESHOLD) ? ST25R3916_REG_IO_CONF2_sup3V_3V :
-                                                 ST25R3916_REG_IO_CONF2_sup3V_5V));
-
-    /* Make sure Transmitter and Receiver are disabled */
-    st25r3916TxRxOff();
-
-#ifdef ST25R_SELFTEST_TIMER
-    /******************************************************************************
-     * Check SW timer operation :
-     *  - use the General Purpose timer to measure an amount of time
-     *  - test whether an interrupt is seen when less time was given
-     *  - test whether an interrupt is seen when sufficient time was given
-     */
-
-    st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_GPE);
-    st25r3916SetStartGPTimer(
-        (uint16_t)ST25R3916_TEST_TMR_TOUT_8FC, ST25R3916_REG_TIMER_EMV_CONTROL_gptc_no_trigger);
-    if(st25r3916WaitForInterruptsTimed(
-           ST25R3916_IRQ_MASK_GPE, (ST25R3916_TEST_TMR_TOUT - ST25R3916_TEST_TMR_TOUT_DELTA)) !=
-       0U) {
-        platformErrorHandle();
-        return ERR_SYSTEM;
-    }
-
-    /* Stop all activities to stop the GP timer */
-    st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-    st25r3916ClearAndEnableInterrupts(ST25R3916_IRQ_MASK_GPE);
-    st25r3916SetStartGPTimer(
-        (uint16_t)ST25R3916_TEST_TMR_TOUT_8FC, ST25R3916_REG_TIMER_EMV_CONTROL_gptc_no_trigger);
-    if(st25r3916WaitForInterruptsTimed(
-           ST25R3916_IRQ_MASK_GPE, (ST25R3916_TEST_TMR_TOUT + ST25R3916_TEST_TMR_TOUT_DELTA)) ==
-       0U) {
-        platformErrorHandle();
-        return ERR_SYSTEM;
-    }
-
-    /* Stop all activities to stop the GP timer */
-    st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-    /*******************************************************************************/
-#endif /* ST25R_SELFTEST_TIMER */
-
-    /* After reset all interrupts are enabled, so disable them at first */
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_ALL);
-
-    /* And clear them, just to be sure */
-    st25r3916ClearInterrupts();
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-void st25r3916Deinitialize(void) {
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_ALL);
-
-    /* Disable Tx and Rx, Keep OSC On */
-    st25r3916TxRxOff();
-
-    return;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916OscOn(void) {
-    /* Check if oscillator is already turned on and stable                                                */
-    /* Use ST25R3916_REG_OP_CONTROL_en instead of ST25R3916_REG_AUX_DISPLAY_osc_ok to be on the safe side */
-    if(!st25r3916CheckReg(
-           ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_en, ST25R3916_REG_OP_CONTROL_en)) {
-        /* Clear any eventual previous oscillator IRQ */
-        st25r3916GetInterrupt(ST25R3916_IRQ_MASK_OSC);
-
-        /* Enable oscillator frequency stable interrupt */
-        st25r3916EnableInterrupts(ST25R3916_IRQ_MASK_OSC);
-
-        /* Enable oscillator and regulator output */
-        st25r3916SetRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_en);
-
-        /* Wait for the oscillator interrupt */
-        st25r3916WaitForInterruptsTimed(ST25R3916_IRQ_MASK_OSC, ST25R3916_TOUT_OSC_STABLE);
-        st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_OSC);
-    }
-
-    if(!st25r3916CheckReg(
-           ST25R3916_REG_AUX_DISPLAY,
-           ST25R3916_REG_AUX_DISPLAY_osc_ok,
-           ST25R3916_REG_AUX_DISPLAY_osc_ok)) {
-        return ERR_SYSTEM;
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-uint8_t st25r3916MeasurePowerSupply(uint8_t mpsv) {
-    uint8_t result;
-
-    /* Set the source of direct command: Measure Power Supply Voltage */
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_mpsv_mask, mpsv);
-
-    /* Execute command: Measure Power Supply Voltage */
-    st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_MEASURE_VDD, ST25R3916_REG_AD_RESULT, ST25R3916_TOUT_MEASURE_VDD, &result);
-
-    return result;
-}
-
-/*******************************************************************************/
-uint16_t st25r3916MeasureVoltage(uint8_t mpsv) {
-    uint8_t result;
-    uint16_t mV;
-
-    result = st25r3916MeasurePowerSupply(mpsv);
-
-    /* Convert cmd output into mV (each step represents 23.4 mV )*/
-    mV = ((uint16_t)result) * 23U;
-    mV += (((((uint16_t)result) * 4U) + 5U) / 10U);
-
-    return mV;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916AdjustRegulators(uint16_t* result_mV) {
-    uint8_t result;
-
-    /* Reset logic and set regulated voltages to be defined by result of Adjust Regulators command */
-    st25r3916SetRegisterBits(
-        ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_reg_s);
-    st25r3916ClrRegisterBits(
-        ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_reg_s);
-
-    /* Execute Adjust regulators cmd and retrieve result */
-    st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_ADJUST_REGULATORS,
-        ST25R3916_REG_REGULATOR_RESULT,
-        ST25R3916_TOUT_ADJUST_REGULATORS,
-        &result);
-
-    /* Calculate result in mV */
-    result >>= ST25R3916_REG_REGULATOR_RESULT_reg_shift;
-
-    if(result_mV != NULL) {
-        if(st25r3916CheckReg(
-               ST25R3916_REG_IO_CONF2,
-               ST25R3916_REG_IO_CONF2_sup3V,
-               ST25R3916_REG_IO_CONF2_sup3V)) {
-            result =
-                MIN(result,
-                    (uint8_t)(result -
-                              5U)); /* In 3.3V mode [0,4] are not used                       */
-            *result_mV = 2400U; /* Minimum regulated voltage 2.4V in case of 3.3V supply */
-        } else {
-            *result_mV = 3600U; /* Minimum regulated voltage 3.6V in case of 5V supply   */
-        }
-
-        *result_mV +=
-            (uint16_t)result * 100U; /* 100mV steps in both 3.3V and 5V supply                */
-    }
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916MeasureAmplitude(uint8_t* result) {
-    return st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_MEASURE_AMPLITUDE,
-        ST25R3916_REG_AD_RESULT,
-        ST25R3916_TOUT_MEASURE_AMPLITUDE,
-        result);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916MeasurePhase(uint8_t* result) {
-    return st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_MEASURE_PHASE, ST25R3916_REG_AD_RESULT, ST25R3916_TOUT_MEASURE_PHASE, result);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916MeasureCapacitance(uint8_t* result) {
-    return st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_MEASURE_CAPACITANCE,
-        ST25R3916_REG_AD_RESULT,
-        ST25R3916_TOUT_MEASURE_CAPACITANCE,
-        result);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916CalibrateCapacitiveSensor(uint8_t* result) {
-    ReturnCode ret;
-    uint8_t res;
-
-    /* Clear Manual calibration values to enable automatic calibration mode */
-    st25r3916ClrRegisterBits(
-        ST25R3916_REG_CAP_SENSOR_CONTROL, ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal_mask);
-
-    /* Execute automatic calibration */
-    ret = st25r3916ExecuteCommandAndGetResult(
-        ST25R3916_CMD_CALIBRATE_C_SENSOR,
-        ST25R3916_REG_CAP_SENSOR_RESULT,
-        ST25R3916_TOUT_CALIBRATE_CAP_SENSOR,
-        &res);
-
-    /* Check whether the calibration was successull */
-    if(((res & ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_end) !=
-        ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_end) ||
-       ((res & ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_err) ==
-        ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_err) ||
-       (ret != ERR_NONE)) {
-        return ERR_IO;
-    }
-
-    if(result != NULL) {
-        (*result) = (uint8_t)(res >> ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_shift);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916SetBitrate(uint8_t txrate, uint8_t rxrate) {
-    uint8_t reg;
-
-    st25r3916ReadRegister(ST25R3916_REG_BIT_RATE, &reg);
-    if(rxrate != ST25R3916_BR_DO_NOT_SET) {
-        if(rxrate > ST25R3916_BR_848) {
-            return ERR_PARAM;
-        }
-
-        reg = (uint8_t)(reg & ~ST25R3916_REG_BIT_RATE_rxrate_mask); /* MISRA 10.3 */
-        reg |= rxrate << ST25R3916_REG_BIT_RATE_rxrate_shift;
-    }
-    if(txrate != ST25R3916_BR_DO_NOT_SET) {
-        if(txrate > ST25R3916_BR_6780) {
-            return ERR_PARAM;
-        }
-
-        reg = (uint8_t)(reg & ~ST25R3916_REG_BIT_RATE_txrate_mask); /* MISRA 10.3 */
-        reg |= txrate << ST25R3916_REG_BIT_RATE_txrate_shift;
-    }
-    return st25r3916WriteRegister(ST25R3916_REG_BIT_RATE, reg);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916PerformCollisionAvoidance(
-    uint8_t FieldONCmd,
-    uint8_t pdThreshold,
-    uint8_t caThreshold,
-    uint8_t nTRFW) {
-    uint8_t treMask;
-    uint32_t irqs;
-    ReturnCode err;
-
-    if((FieldONCmd != ST25R3916_CMD_INITIAL_RF_COLLISION) &&
-       (FieldONCmd != ST25R3916_CMD_RESPONSE_RF_COLLISION_N)) {
-        return ERR_PARAM;
-    }
-
-    err = ERR_INTERNAL;
-
-    /* Check if new thresholds are to be applied */
-    if((pdThreshold != ST25R3916_THRESHOLD_DO_NOT_SET) ||
-       (caThreshold != ST25R3916_THRESHOLD_DO_NOT_SET)) {
-        treMask = 0;
-
-        if(pdThreshold != ST25R3916_THRESHOLD_DO_NOT_SET) {
-            treMask |= ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask;
-        }
-
-        if(caThreshold != ST25R3916_THRESHOLD_DO_NOT_SET) {
-            treMask |= ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask;
-        }
-
-        /* Set Detection Threshold and|or Collision Avoidance Threshold */
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_FIELD_THRESHOLD_ACTV,
-            treMask,
-            (pdThreshold & ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask) |
-                (caThreshold & ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask));
-    }
-
-    /* Set n x TRFW */
-    st25r3916ChangeRegisterBits(ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_n_mask, nTRFW);
-
-    /*******************************************************************************/
-    /* Enable and clear CA specific interrupts and execute command */
-    st25r3916GetInterrupt(
-        (ST25R3916_IRQ_MASK_CAC | ST25R3916_IRQ_MASK_CAT | ST25R3916_IRQ_MASK_APON));
-    st25r3916EnableInterrupts(
-        (ST25R3916_IRQ_MASK_CAC | ST25R3916_IRQ_MASK_CAT | ST25R3916_IRQ_MASK_APON));
-
-    st25r3916ExecuteCommand(FieldONCmd);
-
-    /*******************************************************************************/
-    /* Wait for initial APON interrupt, indicating anticollision avoidance done and ST25R3916's 
-     * field is now on, or a CAC indicating a collision */
-    irqs = st25r3916WaitForInterruptsTimed(
-        (ST25R3916_IRQ_MASK_CAC | ST25R3916_IRQ_MASK_APON), ST25R3916_TOUT_CA);
-
-    if((ST25R3916_IRQ_MASK_CAC & irqs) != 0U) /* Collision occurred */
-    {
-        err = ERR_RF_COLLISION;
-    } else if((ST25R3916_IRQ_MASK_APON & irqs) != 0U) {
-        /* After APON wait for CAT interrupt, indication field was switched on minimum guard time has been fulfilled */
-        irqs = st25r3916WaitForInterruptsTimed((ST25R3916_IRQ_MASK_CAT), ST25R3916_TOUT_CA);
-
-        if((ST25R3916_IRQ_MASK_CAT & irqs) != 0U) /* No Collision detected, Field On */
-        {
-            err = ERR_NONE;
-        }
-    } else {
-        /* MISRA 15.7 - Empty else */
-    }
-
-    /* Clear any previous External Field events and disable CA specific interrupts */
-    st25r3916GetInterrupt((ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_EON));
-    st25r3916DisableInterrupts(
-        (ST25R3916_IRQ_MASK_CAC | ST25R3916_IRQ_MASK_CAT | ST25R3916_IRQ_MASK_APON));
-
-    return err;
-}
-
-/*******************************************************************************/
-void st25r3916SetNumTxBits(uint16_t nBits) {
-    st25r3916WriteRegister(ST25R3916_REG_NUM_TX_BYTES2, (uint8_t)((nBits >> 0) & 0xFFU));
-    st25r3916WriteRegister(ST25R3916_REG_NUM_TX_BYTES1, (uint8_t)((nBits >> 8) & 0xFFU));
-}
-
-/*******************************************************************************/
-uint16_t st25r3916GetNumFIFOBytes(void) {
-    uint8_t reg;
-    uint16_t result;
-
-    st25r3916ReadRegister(ST25R3916_REG_FIFO_STATUS2, &reg);
-    reg =
-        ((reg & ST25R3916_REG_FIFO_STATUS2_fifo_b_mask) >>
-         ST25R3916_REG_FIFO_STATUS2_fifo_b_shift);
-    result = ((uint16_t)reg << 8);
-
-    st25r3916ReadRegister(ST25R3916_REG_FIFO_STATUS1, &reg);
-    result |= (((uint16_t)reg) & 0x00FFU);
-
-    return result;
-}
-
-/*******************************************************************************/
-uint8_t st25r3916GetNumFIFOLastBits(void) {
-    uint8_t reg;
-
-    st25r3916ReadRegister(ST25R3916_REG_FIFO_STATUS2, &reg);
-
-    return (
-        (reg & ST25R3916_REG_FIFO_STATUS2_fifo_lb_mask) >>
-        ST25R3916_REG_FIFO_STATUS2_fifo_lb_shift);
-}
-
-/*******************************************************************************/
-uint32_t st25r3916GetNoResponseTime(void) {
-    return gST25R3916NRT_64fcs;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916SetNoResponseTime(uint32_t nrt_64fcs) {
-    ReturnCode err;
-    uint8_t nrt_step;
-    uint32_t tmpNRT;
-
-    tmpNRT = nrt_64fcs; /* MISRA 17.8 */
-    err = ERR_NONE;
-
-    gST25R3916NRT_64fcs = tmpNRT; /* Store given NRT value in 64/fc into local var       */
-    nrt_step =
-        ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step_64fc; /* Set default NRT in steps of 64/fc                   */
-
-    if(tmpNRT > ST25R3916_NRT_MAX) /* Check if the given NRT value fits using 64/fc steps */
-    {
-        nrt_step =
-            ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step_4096_fc; /* If not, change NRT set to 4096/fc                   */
-        tmpNRT = ((tmpNRT + 63U) / 64U); /* Calculate number of steps in 4096/fc                */
-
-        if(tmpNRT > ST25R3916_NRT_MAX) /* Check if the NRT value fits using 64/fc steps       */
-        {
-            tmpNRT = ST25R3916_NRT_MAX; /* Assign the maximum possible                         */
-            err = ERR_PARAM; /* Signal parameter error                              */
-        }
-        gST25R3916NRT_64fcs = (64U * tmpNRT);
-    }
-
-    /* Set the ST25R3916 NRT step units and the value */
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step, nrt_step);
-    st25r3916WriteRegister(ST25R3916_REG_NO_RESPONSE_TIMER1, (uint8_t)(tmpNRT >> 8U));
-    st25r3916WriteRegister(ST25R3916_REG_NO_RESPONSE_TIMER2, (uint8_t)(tmpNRT & 0xFFU));
-
-    return err;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916SetStartNoResponseTimer(uint32_t nrt_64fcs) {
-    ReturnCode err;
-
-    err = st25r3916SetNoResponseTime(nrt_64fcs);
-    if(err == ERR_NONE) {
-        st25r3916ExecuteCommand(ST25R3916_CMD_START_NO_RESPONSE_TIMER);
-    }
-
-    return err;
-}
-
-/*******************************************************************************/
-void st25r3916SetGPTime(uint16_t gpt_8fcs) {
-    st25r3916WriteRegister(ST25R3916_REG_GPT1, (uint8_t)(gpt_8fcs >> 8));
-    st25r3916WriteRegister(ST25R3916_REG_GPT2, (uint8_t)(gpt_8fcs & 0xFFU));
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916SetStartGPTimer(uint16_t gpt_8fcs, uint8_t trigger_source) {
-    st25r3916SetGPTime(gpt_8fcs);
-    st25r3916ChangeRegisterBits(
-        ST25R3916_REG_TIMER_EMV_CONTROL,
-        ST25R3916_REG_TIMER_EMV_CONTROL_gptc_mask,
-        trigger_source);
-
-    /* If there's no trigger source, start GPT immediately */
-    if(trigger_source == ST25R3916_REG_TIMER_EMV_CONTROL_gptc_no_trigger) {
-        st25r3916ExecuteCommand(ST25R3916_CMD_START_GP_TIMER);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-bool st25r3916CheckChipID(uint8_t* rev) {
-    uint8_t ID;
-
-    ID = 0;
-    st25r3916ReadRegister(ST25R3916_REG_IC_IDENTITY, &ID);
-
-    /* Check if IC Identity Register contains ST25R3916's IC type code */
-    if((ID & ST25R3916_REG_IC_IDENTITY_ic_type_mask) !=
-       ST25R3916_REG_IC_IDENTITY_ic_type_st25r3916) {
-        return false;
-    }
-
-    if(rev != NULL) {
-        *rev = (ID & ST25R3916_REG_IC_IDENTITY_ic_rev_mask);
-    }
-
-    return true;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916GetRegsDump(t_st25r3916Regs* regDump) {
-    uint8_t regIt;
-
-    if(regDump == NULL) {
-        return ERR_PARAM;
-    }
-
-    /* Dump Registers on space A */
-    for(regIt = ST25R3916_REG_IO_CONF1; regIt <= ST25R3916_REG_IC_IDENTITY; regIt++) {
-        st25r3916ReadRegister(regIt, &regDump->RsA[regIt]);
-    }
-
-    regIt = 0;
-
-    /* Read non-consecutive Registers on space B */
-    st25r3916ReadRegister(ST25R3916_REG_EMD_SUP_CONF, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_SUBC_START_TIME, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_P2P_RX_CONF, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_CORR_CONF1, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_CORR_CONF2, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_SQUELCH_TIMER, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_FIELD_ON_GT, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_AUX_MOD, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_TX_DRIVER_TIMING, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_RES_AM_MOD, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_TX_DRIVER_STATUS, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_REGULATOR_RESULT, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_OVERSHOOT_CONF1, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_OVERSHOOT_CONF2, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_UNDERSHOOT_CONF1, &regDump->RsB[regIt++]);
-    st25r3916ReadRegister(ST25R3916_REG_UNDERSHOOT_CONF2, &regDump->RsB[regIt++]);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-bool st25r3916IsCmdValid(uint8_t cmd) {
-    if(!((cmd >= ST25R3916_CMD_SET_DEFAULT) && (cmd <= ST25R3916_CMD_RESPONSE_RF_COLLISION_N)) &&
-       !((cmd >= ST25R3916_CMD_GOTO_SENSE) && (cmd <= ST25R3916_CMD_GOTO_SLEEP)) &&
-       !((cmd >= ST25R3916_CMD_MASK_RECEIVE_DATA) && (cmd <= ST25R3916_CMD_MEASURE_AMPLITUDE)) &&
-       !((cmd >= ST25R3916_CMD_RESET_RXGAIN) && (cmd <= ST25R3916_CMD_ADJUST_REGULATORS)) &&
-       !((cmd >= ST25R3916_CMD_CALIBRATE_DRIVER_TIMING) &&
-         (cmd <= ST25R3916_CMD_START_PPON2_TIMER)) &&
-       (cmd != ST25R3916_CMD_SPACE_B_ACCESS) && (cmd != ST25R3916_CMD_STOP_NRT)) {
-        return false;
-    }
-    return true;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916StreamConfigure(const struct st25r3916StreamConfig* config) {
-    uint8_t smd;
-    uint8_t mode;
-
-    smd = 0;
-
-    if(config->useBPSK != 0U) {
-        mode = ST25R3916_REG_MODE_om_bpsk_stream;
-        if((config->din < 2U) || (config->din > 4U)) /* not in fc/4 .. fc/16 */
-        {
-            return ERR_PARAM;
-        }
-        smd |= ((4U - config->din) << ST25R3916_REG_STREAM_MODE_scf_shift);
-    } else {
-        mode = ST25R3916_REG_MODE_om_subcarrier_stream;
-        if((config->din < 3U) || (config->din > 6U)) /* not in fc/8 .. fc/64 */
-        {
-            return ERR_PARAM;
-        }
-        smd |= ((6U - config->din) << ST25R3916_REG_STREAM_MODE_scf_shift);
-        if(config->report_period_length == 0U) {
-            return ERR_PARAM;
-        }
-    }
-
-    if((config->dout < 1U) || (config->dout > 7U)) /* not in fc/2 .. fc/128 */
-    {
-        return ERR_PARAM;
-    }
-    smd |= (7U - config->dout) << ST25R3916_REG_STREAM_MODE_stx_shift;
-
-    if(config->report_period_length > 3U) {
-        return ERR_PARAM;
-    }
-    smd |= (config->report_period_length << ST25R3916_REG_STREAM_MODE_scp_shift);
-
-    st25r3916WriteRegister(ST25R3916_REG_STREAM_MODE, smd);
-    st25r3916ChangeRegisterBits(ST25R3916_REG_MODE, ST25R3916_REG_MODE_om_mask, mode);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916GetRSSI(uint16_t* amRssi, uint16_t* pmRssi) {
-    /*******************************************************************************/
-    /* MISRA 8.9 An object should be defined at block scope if its identifier only appears in a single function */
-    /*< ST25R3916  RSSI Display Reg values:      0   1   2   3   4   5   6    7    8   9    a     b    c    d  e  f */
-    static const uint16_t st25r3916Rssi2mV[] = {
-        0, 20, 27, 37, 52, 72, 99, 136, 190, 262, 357, 500, 686, 950, 1150, 1150};
-
-    /* ST25R3916 2/3 stage gain reduction [dB]          0    0    0    0    0    3    6    9   12   15   18  na na na na na */
-    static const uint16_t st25r3916Gain2Percent[] = {
-        100, 100, 100, 100, 100, 141, 200, 281, 398, 562, 794, 1, 1, 1, 1, 1};
-    /*******************************************************************************/
-
-    uint8_t rssi;
-    uint8_t gainRed;
-
-    st25r3916ReadRegister(ST25R3916_REG_RSSI_RESULT, &rssi);
-    st25r3916ReadRegister(ST25R3916_REG_GAIN_RED_STATE, &gainRed);
-
-    if(amRssi != NULL) {
-        *amRssi =
-            (uint16_t)(((uint32_t)
-                            st25r3916Rssi2mV[(rssi >> ST25R3916_REG_RSSI_RESULT_rssi_am_shift)] *
-                        (uint32_t)st25r3916Gain2Percent[(
-                            gainRed >> ST25R3916_REG_GAIN_RED_STATE_gs_am_shift)]) /
-                       100U);
-    }
-
-    if(pmRssi != NULL) {
-        *pmRssi =
-            (uint16_t)(((uint32_t)
-                            st25r3916Rssi2mV[(rssi & ST25R3916_REG_RSSI_RESULT_rssi_pm_mask)] *
-                        (uint32_t)st25r3916Gain2Percent[(
-                            gainRed & ST25R3916_REG_GAIN_RED_STATE_gs_pm_mask)]) /
-                       100U);
-    }
-
-    return ERR_NONE;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916.h

@@ -1,669 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 high level interface
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup ST25R3916
- * \brief RFAL ST25R3916 Driver
- * @{
- * 
- * \addtogroup ST25R3916_Driver
- * \brief RFAL ST25R3916 Driver
- * @{
- * 
- */
-
-#ifndef ST25R3916_H
-#define ST25R3916_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../../platform.h"
-#include "../../st_errno.h"
-#include "st25r3916_com.h"
-
-/*
-******************************************************************************
-* GLOBAL DATATYPES
-******************************************************************************
-*/
-
-/*! Struct to represent all regs on ST25R3916                                                             */
-typedef struct {
-    uint8_t RsA[(
-        ST25R3916_REG_IC_IDENTITY + 1U)]; /*!< Registers contained on ST25R3916 space A (Rs-A)     */
-    uint8_t
-        RsB[ST25R3916_SPACE_B_REG_LEN]; /*!< Registers contained on ST25R3916 space B (Rs-B)     */
-} t_st25r3916Regs;
-
-/*! Parameters how the stream mode should work                                                            */
-struct st25r3916StreamConfig {
-    uint8_t useBPSK; /*!< 0: subcarrier, 1:BPSK                                */
-    uint8_t din; /*!< Divider for the in subcarrier frequency: fc/2^din    */
-    uint8_t dout; /*!< Divider for the in subcarrier frequency fc/2^dout    */
-    uint8_t report_period_length; /*!< Length of the reporting period 2^report_period_length*/
-};
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-/* ST25R3916 direct commands */
-#define ST25R3916_CMD_SET_DEFAULT \
-    0xC1U /*!< Puts the chip in default state (same as after power-up) */
-#define ST25R3916_CMD_STOP 0xC2U /*!< Stops all activities and clears FIFO                    */
-#define ST25R3916_CMD_TRANSMIT_WITH_CRC \
-    0xC4U /*!< Transmit with CRC                                       */
-#define ST25R3916_CMD_TRANSMIT_WITHOUT_CRC \
-    0xC5U /*!< Transmit without CRC                                    */
-#define ST25R3916_CMD_TRANSMIT_REQA \
-    0xC6U /*!< Transmit REQA                                           */
-#define ST25R3916_CMD_TRANSMIT_WUPA \
-    0xC7U /*!< Transmit WUPA                                           */
-#define ST25R3916_CMD_INITIAL_RF_COLLISION \
-    0xC8U /*!< NFC transmit with Initial RF Collision Avoidance        */
-#define ST25R3916_CMD_RESPONSE_RF_COLLISION_N \
-    0xC9U /*!< NFC transmit with Response RF Collision Avoidance       */
-#define ST25R3916_CMD_GOTO_SENSE \
-    0xCDU /*!< Passive target logic to Sense/Idle state                */
-#define ST25R3916_CMD_GOTO_SLEEP \
-    0xCEU /*!< Passive target logic to Sleep/Halt state                */
-#define ST25R3916_CMD_MASK_RECEIVE_DATA \
-    0xD0U /*!< Mask receive data                                       */
-#define ST25R3916_CMD_UNMASK_RECEIVE_DATA \
-    0xD1U /*!< Unmask receive data                                     */
-#define ST25R3916_CMD_AM_MOD_STATE_CHANGE \
-    0xD2U /*!< AM Modulation state change                              */
-#define ST25R3916_CMD_MEASURE_AMPLITUDE \
-    0xD3U /*!< Measure signal amplitude on RFI inputs                  */
-#define ST25R3916_CMD_RESET_RXGAIN \
-    0xD5U /*!< Reset RX Gain                                           */
-#define ST25R3916_CMD_ADJUST_REGULATORS \
-    0xD6U /*!< Adjust regulators                                       */
-#define ST25R3916_CMD_CALIBRATE_DRIVER_TIMING \
-    0xD8U /*!< Starts the sequence to adjust the driver timing         */
-#define ST25R3916_CMD_MEASURE_PHASE \
-    0xD9U /*!< Measure phase between RFO and RFI signal                */
-#define ST25R3916_CMD_CLEAR_RSSI \
-    0xDAU /*!< Clear RSSI bits and restart the measurement             */
-#define ST25R3916_CMD_CLEAR_FIFO \
-    0xDBU /*!< Clears FIFO, Collision and IRQ status                   */
-#define ST25R3916_CMD_TRANSPARENT_MODE \
-    0xDCU /*!< Transparent mode                                        */
-#define ST25R3916_CMD_CALIBRATE_C_SENSOR \
-    0xDDU /*!< Calibrate the capacitive sensor                         */
-#define ST25R3916_CMD_MEASURE_CAPACITANCE \
-    0xDEU /*!< Measure capacitance                                     */
-#define ST25R3916_CMD_MEASURE_VDD \
-    0xDFU /*!< Measure power supply voltage                            */
-#define ST25R3916_CMD_START_GP_TIMER \
-    0xE0U /*!< Start the general purpose timer                         */
-#define ST25R3916_CMD_START_WUP_TIMER \
-    0xE1U /*!< Start the wake-up timer                                 */
-#define ST25R3916_CMD_START_MASK_RECEIVE_TIMER \
-    0xE2U /*!< Start the mask-receive timer                            */
-#define ST25R3916_CMD_START_NO_RESPONSE_TIMER \
-    0xE3U /*!< Start the no-response timer                             */
-#define ST25R3916_CMD_START_PPON2_TIMER \
-    0xE4U /*!< Start PPon2 timer                                       */
-#define ST25R3916_CMD_STOP_NRT \
-    0xE8U /*!< Stop No Response Timer                                  */
-#define ST25R3916_CMD_SPACE_B_ACCESS \
-    0xFBU /*!< Enable R/W access to the test registers                 */
-#define ST25R3916_CMD_TEST_ACCESS \
-    0xFCU /*!< Enable R/W access to the test registers                 */
-
-#define ST25R3916_THRESHOLD_DO_NOT_SET \
-    0xFFU /*!< Indicates not to change this Threshold                  */
-
-#define ST25R3916_BR_DO_NOT_SET \
-    0xFFU /*!< Indicates not to change this Bit Rate                   */
-#define ST25R3916_BR_106 0x00U /*!< ST25R3916 Bit Rate  106 kbit/s (fc/128)                 */
-#define ST25R3916_BR_212 0x01U /*!< ST25R3916 Bit Rate  212 kbit/s (fc/64)                  */
-#define ST25R3916_BR_424 0x02U /*!< ST25R3916 Bit Rate  424 kbit/s (fc/32)                  */
-#define ST25R3916_BR_848 0x03U /*!< ST25R3916 Bit Rate  848 kbit/s (fc/16)                  */
-#define ST25R3916_BR_1695 0x04U /*!< ST25R3916 Bit Rate 1696 kbit/s (fc/8)                   */
-#define ST25R3916_BR_3390 0x05U /*!< ST25R3916 Bit Rate 3390 kbit/s (fc/4)                   */
-#define ST25R3916_BR_6780 0x07U /*!< ST25R3916 Bit Rate 6780 kbit/s (fc/2)                   */
-
-#define ST25R3916_FIFO_DEPTH 512U /*!< Depth of FIFO                                           */
-#define ST25R3916_TOUT_OSC_STABLE \
-    10U /*!< Max timeout for Oscillator to get stable      DS: 700us */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-/*! Enables the Transmitter (Field On) and Receiver                                          */
-#define st25r3916TxRxOn()         \
-    st25r3916SetRegisterBits(     \
-        ST25R3916_REG_OP_CONTROL, \
-        (ST25R3916_REG_OP_CONTROL_rx_en | ST25R3916_REG_OP_CONTROL_tx_en))
-
-/*! Disables the Transmitter (Field Off) and Receiver                                         */
-#define st25r3916TxRxOff()        \
-    st25r3916ClrRegisterBits(     \
-        ST25R3916_REG_OP_CONTROL, \
-        (ST25R3916_REG_OP_CONTROL_rx_en | ST25R3916_REG_OP_CONTROL_tx_en))
-
-/*! Disables the Transmitter (Field Off)                                         */
-#define st25r3916TxOff() \
-    st25r3916ClrRegisterBits(ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_tx_en)
-
-/*! Checks if General Purpose Timer is still running by reading gpt_on flag                  */
-#define st25r3916IsGPTRunning()               \
-    st25r3916CheckReg(                        \
-        ST25R3916_REG_NFCIP1_BIT_RATE,        \
-        ST25R3916_REG_NFCIP1_BIT_RATE_gpt_on, \
-        ST25R3916_REG_NFCIP1_BIT_RATE_gpt_on)
-
-/*! Checks if External Filed is detected by reading ST25R3916 External Field Detector output    */
-#define st25r3916IsExtFieldOn()          \
-    st25r3916CheckReg(                   \
-        ST25R3916_REG_AUX_DISPLAY,       \
-        ST25R3916_REG_AUX_DISPLAY_efd_o, \
-        ST25R3916_REG_AUX_DISPLAY_efd_o)
-
-/*! Checks if Transmitter is enabled (Field On) */
-#define st25r3916IsTxEnabled() \
-    st25r3916CheckReg(         \
-        ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_tx_en, ST25R3916_REG_OP_CONTROL_tx_en)
-
-/*! Checks if NRT is in EMV mode */
-#define st25r3916IsNRTinEMV()                    \
-    st25r3916CheckReg(                           \
-        ST25R3916_REG_TIMER_EMV_CONTROL,         \
-        ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv, \
-        ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv_on)
-
-/*! Checks if last FIFO byte is complete */
-#define st25r3916IsLastFIFOComplete() \
-    st25r3916CheckReg(ST25R3916_REG_FIFO_STATUS2, ST25R3916_REG_FIFO_STATUS2_fifo_lb_mask, 0)
-
-/*! Checks if the Oscillator is enabled  */
-#define st25r3916IsOscOn() \
-    st25r3916CheckReg(     \
-        ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_en, ST25R3916_REG_OP_CONTROL_en)
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- *  \brief  Initialise ST25R3916 driver
- *
- *  This function initialises the ST25R3916 driver.
- *
- *  \return ERR_NONE         : Operation successful
- *  \return ERR_HW_MISMATCH  : Expected HW do not match or communication error
- *  \return ERR_IO           : Error during communication selftest. Check communication interface
- *  \return ERR_TIMEOUT      : Timeout during IRQ selftest. Check IRQ handling
- *  \return ERR_SYSTEM       : Failure during oscillator activation or timer error 
- *
- *****************************************************************************
- */
-ReturnCode st25r3916Initialize(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Deinitialize ST25R3916 driver
- *
- *  Calling this function deinitializes the ST25R3916 driver.
- *
- *****************************************************************************
- */
-void st25r3916Deinitialize(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Turn on Oscillator and Regulator
- *  
- *  This function turn on oscillator and regulator and waits for the 
- *  oscillator to become stable
- * 
- *  \return ERR_SYSTEM : Failure dusring Oscillator activation
- *  \return ERR_NONE   : No error, Oscillator is active and stable, Regulator is on
- *
- *****************************************************************************
- */
-ReturnCode st25r3916OscOn(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Sets the bitrate
- *
- *  This function sets the bitrates for rx and tx
- *
- *  \param txrate : speed is 2^txrate * 106 kb/s
- *                  0xff : don't set txrate (ST25R3916_BR_DO_NOT_SET)
- *  \param rxrate : speed is 2^rxrate * 106 kb/s
- *                  0xff : don't set rxrate (ST25R3916_BR_DO_NOT_SET)
- *
- *  \return ERR_PARAM: At least one bit rate was invalid
- *  \return ERR_NONE : No error, both bit rates were set
- *
- *****************************************************************************
- */
-ReturnCode st25r3916SetBitrate(uint8_t txrate, uint8_t rxrate);
-
-/*! 
- *****************************************************************************
- *  \brief  Adjusts supply regulators according to the current supply voltage
- *
- *  This function the power level is measured in maximum load conditions and
- *  the regulated voltage reference is set to 250mV below this level.
- *  Execution of this function lasts around 5ms. 
- *
- *  The regulated voltages will be set to the result of Adjust Regulators
- *  
- *  \param [out] result_mV : Result of calibration in milliVolts
- *
- *  \return ERR_IO : Error during communication with ST25R3916
- *  \return ERR_NONE : No error
- *
- *****************************************************************************
- */
-ReturnCode st25r3916AdjustRegulators(uint16_t* result_mV);
-
-/*! 
- *****************************************************************************
- *  \brief  Measure Amplitude
- *
- *  This function measured the amplitude on the RFI inputs and stores the
- *  result in parameter \a result.
- *
- *  \param[out] result:  result of RF measurement.
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916MeasureAmplitude(uint8_t* result);
-
-/*! 
- *****************************************************************************
- *  \brief  Measure Power Supply
- *
- *  This function executes Measure Power Supply and returns the raw value
- *
- *  \param[in] mpsv : one of ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_rf
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_a
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_d
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_am
- *
- *  \return the measured voltage in raw format.
- *
- *****************************************************************************
- */
-uint8_t st25r3916MeasurePowerSupply(uint8_t mpsv);
-
-/*! 
- *****************************************************************************
- *  \brief  Measure Voltage
- *
- *  This function measures the voltage on one of VDD and VDD_* and returns 
- *  the result in mV
- *
- *  \param[in] mpsv : one of ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_rf
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_a
- *                           ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_d
- *                    or     ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_am
- *
- *  \return the measured voltage in mV
- *
- *****************************************************************************
- */
-uint16_t st25r3916MeasureVoltage(uint8_t mpsv);
-
-/*! 
- *****************************************************************************
- *  \brief  Measure Phase
- *
- *  This function performs a Phase measurement.
- *  The result is stored in the \a result parameter.
- *
- *  \param[out] result: 8 bit long result of the measurement.
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916MeasurePhase(uint8_t* result);
-
-/*! 
- *****************************************************************************
- *  \brief  Measure Capacitance
- *
- *  This function performs the capacitance measurement and stores the
- *  result in parameter \a result.
- *
- *  \param[out] result: 8 bit long result of RF measurement.
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916MeasureCapacitance(uint8_t* result);
-
-/*! 
- *****************************************************************************
- *  \brief  Calibrates Capacitive Sensor
- *
- *  This function performs automatic calibration of the capacitive sensor 
- *  and stores the result in parameter \a result.
- *
- * \warning To avoid interference with Xtal oscillator and reader magnetic 
- *          field, it is strongly recommended to perform calibration
- *          in Power-down mode only.
- *          This method does not modify the Oscillator nor transmitter state, 
- *          these should be configured before by user.
- *
- *  \param[out] result: 5 bit long result of the calibration.
- *                      Binary weighted, step 0.1 pF, max 3.1 pF
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_IO    : The calibration was not successful 
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916CalibrateCapacitiveSensor(uint8_t* result);
-
-/*! 
- *****************************************************************************
- *  \brief  Get NRT time
- *
- *  This returns the last value set on the NRT
- *   
- *  \warning it does not read chip register, just the sw var that contains the 
- *  last value set before
- *
- *  \return the value of the NRT in 64/fc 
- */
-uint32_t st25r3916GetNoResponseTime(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Set NRT time
- *
- *  This function sets the No Response Time with the given value
- *
- *  \param [in] nrt_64fcs : no response time in steps of 64/fc (4.72us)
- *
- *  \return ERR_PARAM : Invalid parameter (time is too large)
- *  \return ERR_NONE  : No error
- *
- *****************************************************************************  
- */
-ReturnCode st25r3916SetNoResponseTime(uint32_t nrt_64fcs);
-
-/*! 
- *****************************************************************************
- *  \brief  Set and Start NRT
- *
- *  This function sets the No Response Time with the given value and 
- *  immediately starts it
- *  Used when needs to add more time before timeout without performing Tx
- *
- *  \param [in] nrt_64fcs : no response time in steps of 64/fc (4.72us)
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *
- *****************************************************************************  
- */
-ReturnCode st25r3916SetStartNoResponseTimer(uint32_t nrt_64fcs);
-
-/*! 
- *****************************************************************************
- *  \brief  Set GPT time
- *
- *  This function sets the General Purpose Timer time registers
- *
- *  \param [in] gpt_8fcs : general purpose timer timeout in steps of 8/fc (590ns)
- *
- *****************************************************************************
- */
-void st25r3916SetGPTime(uint16_t gpt_8fcs);
-
-/*! 
- *****************************************************************************
- *  \brief  Set and Start GPT
- *
- *  This function sets the General Purpose Timer with the given timeout and 
- *  immediately starts it ONLY if the trigger source is not set to none.
- *
- *  \param [in] gpt_8fcs : general purpose timer timeout in  steps of8/fc (590ns)
- *  \param [in] trigger_source : no trigger, start of Rx, end of Rx, end of Tx in NFC mode
- *   
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error 
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916SetStartGPTimer(uint16_t gpt_8fcs, uint8_t trigger_source);
-
-/*! 
- *****************************************************************************
- *  \brief  Sets the number Tx Bits
- *  
- *  Sets ST25R3916 internal registers with correct number of complete bytes and
- *  bits to be sent
- *  
- *  \param [in] nBits : number of bits to be set/transmitted
- *    
- *****************************************************************************
- */
-void st25r3916SetNumTxBits(uint16_t nBits);
-
-/*! 
- *****************************************************************************
- *  \brief  Get amount of bytes in FIFO
- *  
- *  Gets the number of bytes currently in the FIFO
- *  
- *  \return the number of bytes currently in the FIFO
- *    
- *****************************************************************************
- */
-uint16_t st25r3916GetNumFIFOBytes(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Get amount of bits of the last FIFO byte if incomplete
- *  
- *  Gets the number of bits of the last FIFO byte if incomplete
- *  
- *  \return the number of bits of the last FIFO byte if incomplete, 0 if 
- *          the last byte is complete
- *    
- *****************************************************************************
- */
-uint8_t st25r3916GetNumFIFOLastBits(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Perform Collision Avoidance
- *
- *  Performs Collision Avoidance with the given threshold and with the  
- *  n number of TRFW 
- *  
- *  \param[in] FieldONCmd  : Field ON command to be executed ST25R3916_CMD_INITIAL_RF_COLLISION
- *                           or ST25R3916_CMD_RESPONSE_RF_COLLISION_N  
- *  \param[in] pdThreshold : Peer Detection Threshold  (ST25R3916_REG_FIELD_THRESHOLD_trg_xx)
- *                           0xff : don't set Threshold (ST25R3916_THRESHOLD_DO_NOT_SET)
- *  \param[in] caThreshold : Collision Avoidance Threshold (ST25R3916_REG_FIELD_THRESHOLD_rfe_xx)
- *                           0xff : don't set Threshold (ST25R3916_THRESHOLD_DO_NOT_SET)
- *  \param[in] nTRFW       : Number of TRFW
- *
- *  \return ERR_PARAM        : Invalid parameter 
- *  \return ERR_RF_COLLISION : Collision detected
- *  \return ERR_NONE         : No collision detected
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916PerformCollisionAvoidance(
-    uint8_t FieldONCmd,
-    uint8_t pdThreshold,
-    uint8_t caThreshold,
-    uint8_t nTRFW);
-
-/*! 
- *****************************************************************************
- *  \brief  Check Identity
- *
- *  Checks if the chip ID is as expected.
- *  
- *  5 bit IC type code for ST25R3916: 00101
- *  The 3 lsb contain the IC revision code
- *   
- *  \param[out] rev : the IC revision code
- *    
- *  \return  true when IC type is as expected
- *  \return  false otherwise
- */
-bool st25r3916CheckChipID(uint8_t* rev);
-
-/*! 
- *****************************************************************************
- *  \brief  Retrieves all  internal registers from ST25R3916
- *  
- *  \param[out] regDump : pointer to the struct/buffer where the reg dump
- *                        will be written
- *  
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *****************************************************************************
- */
-ReturnCode st25r3916GetRegsDump(t_st25r3916Regs* regDump);
-
-/*! 
- *****************************************************************************
- *  \brief  Check if command is valid
- *
- *  Checks if the given command is a valid ST25R3916 command
- *
- *  \param[in] cmd: Command to check
- *  
- *  \return  true if is a valid command
- *  \return  false otherwise
- *
- *****************************************************************************
- */
-bool st25r3916IsCmdValid(uint8_t cmd);
-
-/*! 
- *****************************************************************************
- *  \brief  Configure the stream mode of ST25R3916
- *
- *  This function initializes the stream with the given parameters
- *
- *  \param[in] config : all settings for bitrates, type, etc.
- *
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error, stream mode driver initialized
- *
- *****************************************************************************
- */
-ReturnCode st25r3916StreamConfigure(const struct st25r3916StreamConfig* config);
-
-/*! 
- *****************************************************************************
- *  \brief  Executes a direct command and returns the result
- *
- *  This function executes the direct command given by \a cmd waits for
- *  \a sleeptime for I_dct and returns the result read from register \a resreg.
- *  The value of cmd is not checked.
- *
- *  \param[in]  cmd   : direct command to execute
- *  \param[in]  resReg: address of the register containing the result
- *  \param[in]  tout  : time in milliseconds to wait before reading the result
- *  \param[out] result: result
- *
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode
-    st25r3916ExecuteCommandAndGetResult(uint8_t cmd, uint8_t resReg, uint8_t tout, uint8_t* result);
-
-/*! 
- *****************************************************************************
- *  \brief  Gets the RSSI values
- *
- *  This function gets the RSSI value of the previous reception taking into 
- *  account the gain reductions that were used. 
- *  RSSI value for both AM and PM channel can be retrieved.
- *
- *  \param[out] amRssi: the RSSI on the AM channel expressed in mV 
- *  \param[out] pmRssi: the RSSI on the PM channel expressed in mV 
- *  
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_NONE  : No error
- *  
- *****************************************************************************
- */
-ReturnCode st25r3916GetRSSI(uint16_t* amRssi, uint16_t* pmRssi);
-#endif /* ST25R3916_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  * 
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_aat.c

@@ -1,366 +0,0 @@
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file st25r3916_aat.c
- *
- *  \author 
- *
- *  \brief ST25R3916 Antenna Tuning 
- *
- * The antenna tuning algorithm tries to find the optimal settings for 
- * the AAT_A and AAT_B registers, which are connected to variable capacitors 
- * to tune the antenna matching.
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "st25r3916_aat.h"
-#include "../../utils.h"
-#include "../../st_errno.h"
-#include "st25r3916.h"
-#include "st25r3916_com.h"
-#include "../../platform.h"
-#include "../../include/rfal_chip.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-#define ST25R3916_AAT_CAP_DELAY_MAX 10 /*!< Max Variable Capacitor settle delay */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-#define st25r3916AatLog(...) /* platformLog(__VA_ARGS__) */ /*!< Logging macro */
-
-/*
-******************************************************************************
-* LOCAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-static ReturnCode aatHillClimb(
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus);
-static int32_t aatGreedyDescent(
-    uint32_t* f_min,
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus,
-    int32_t previousDir);
-static int32_t aatSteepestDescent(
-    uint32_t* f_min,
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus,
-    int32_t previousDir,
-    int32_t previousDir2);
-
-static ReturnCode aatMeasure(
-    uint8_t serCap,
-    uint8_t parCap,
-    uint8_t* amplitude,
-    uint8_t* phase,
-    uint16_t* measureCnt);
-static uint32_t
-    aatCalcF(const struct st25r3916AatTuneParams* tuningParams, uint8_t amplitude, uint8_t phase);
-static ReturnCode aatStepDacVals(
-    const struct st25r3916AatTuneParams* tuningParams,
-    uint8_t* a,
-    uint8_t* b,
-    int32_t dir);
-
-/*******************************************************************************/
-ReturnCode st25r3916AatTune(
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus) {
-    ReturnCode err;
-    const struct st25r3916AatTuneParams* tp = tuningParams;
-    struct st25r3916AatTuneResult* ts = tuningStatus;
-    struct st25r3916AatTuneParams defaultTuningParams = {
-        .aat_a_min = 0,
-        .aat_a_max = 255,
-        .aat_a_start = 127,
-        .aat_a_stepWidth = 32,
-        .aat_b_min = 0,
-        .aat_b_max = 255,
-        .aat_b_start = 127,
-        .aat_b_stepWidth = 32,
-
-        .phaTarget = 128,
-        .phaWeight = 2,
-        .ampTarget = 196,
-        .ampWeight = 1,
-
-        .doDynamicSteps = true,
-        .measureLimit = 50,
-    };
-    struct st25r3916AatTuneResult defaultTuneResult;
-
-    if((NULL != tp) && ((tp->aat_a_min > tp->aat_a_max) || (tp->aat_a_start < tp->aat_a_min) ||
-                        (tp->aat_a_start > tp->aat_a_max) || (tp->aat_b_min > tp->aat_b_max) ||
-                        (tp->aat_b_start < tp->aat_b_min) || (tp->aat_b_start > tp->aat_b_max))) {
-        return ERR_PARAM;
-    }
-
-    if(NULL == tp) { /* Start from current caps with default params */
-        st25r3916ReadRegister(ST25R3916_REG_ANT_TUNE_A, &defaultTuningParams.aat_a_start);
-        st25r3916ReadRegister(ST25R3916_REG_ANT_TUNE_B, &defaultTuningParams.aat_b_start);
-        tp = &defaultTuningParams;
-    }
-
-    if(NULL == ts) {
-        ts = &defaultTuneResult;
-    }
-
-    ts->measureCnt = 0; /* Clear current measure count */
-
-    err = aatHillClimb(tp, ts);
-
-    return err;
-}
-
-/*******************************************************************************/
-static ReturnCode aatHillClimb(
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus) {
-    ReturnCode err = ERR_NONE;
-    uint32_t f_min;
-    int32_t direction, gdirection;
-    uint8_t amp, phs;
-    struct st25r3916AatTuneParams tp = *tuningParams; // local copy to obey const
-
-    tuningStatus->aat_a = tuningParams->aat_a_start;
-    tuningStatus->aat_b = tuningParams->aat_b_start;
-
-    /* Get a proper start value */
-    aatMeasure(tuningStatus->aat_a, tuningStatus->aat_b, &amp, &phs, &tuningStatus->measureCnt);
-    f_min = aatCalcF(&tp, amp, phs);
-    direction = 0;
-
-    st25r3916AatLog("%d %d: %d***\n", tuningStatus->aat_a, tuningStatus->aat_b, f_min);
-
-    do {
-        direction =
-            0; /* Initially and after reducing step sizes we don't have a previous direction */
-        do {
-            /* With the greedy step below always executed aftwards the -direction does never need to be investigated */
-            direction = aatSteepestDescent(&f_min, &tp, tuningStatus, direction, -direction);
-            if(tuningStatus->measureCnt > tp.measureLimit) {
-                err = ERR_OVERRUN;
-                break;
-            }
-            do {
-                gdirection = aatGreedyDescent(&f_min, &tp, tuningStatus, direction);
-                if(tuningStatus->measureCnt > tp.measureLimit) {
-                    err = ERR_OVERRUN;
-                    break;
-                }
-            } while(0 != gdirection);
-        } while(0 != direction);
-        tp.aat_a_stepWidth /= 2U; /* Reduce step sizes */
-        tp.aat_b_stepWidth /= 2U;
-    } while(tp.doDynamicSteps && ((tp.aat_a_stepWidth > 0U) || (tp.aat_b_stepWidth > 0U)));
-
-    return err;
-}
-
-/*******************************************************************************/
-static int32_t aatSteepestDescent(
-    uint32_t* f_min,
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus,
-    int32_t previousDir,
-    int32_t previousDir2) {
-    int32_t i;
-    uint8_t amp, phs;
-    uint32_t f;
-    int32_t bestdir =
-        0; /* Negative direction: decrease, Positive: increase. (-)1: aat_a, (-)2: aat_b */
-
-    for(i = -2; i <= 2; i++) {
-        uint8_t a = tuningStatus->aat_a, b = tuningStatus->aat_b;
-
-        if((0 == i) || (i == -previousDir) ||
-           (i == -previousDir2)) { /* Skip no direction and avoid going backwards */
-            continue;
-        }
-        if(0U != aatStepDacVals(
-                     tuningParams,
-                     &a,
-                     &b,
-                     i)) { /* If stepping did not change the value, omit this direction */
-            continue;
-        }
-
-        aatMeasure(a, b, &amp, &phs, &tuningStatus->measureCnt);
-        f = aatCalcF(tuningParams, amp, phs);
-        st25r3916AatLog("%d : %d %d: %d", i, a, b, f);
-        if(f < *f_min) { /* Value is better than all previous ones */
-            st25r3916AatLog("*");
-            *f_min = f;
-            bestdir = i;
-        }
-        st25r3916AatLog("\n");
-    }
-    if(0 != bestdir) { /* Walk into the best direction */
-        aatStepDacVals(tuningParams, &tuningStatus->aat_a, &tuningStatus->aat_b, bestdir);
-    }
-    return bestdir;
-}
-
-/*******************************************************************************/
-static int32_t aatGreedyDescent(
-    uint32_t* f_min,
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus,
-    int32_t previousDir) {
-    uint8_t amp, phs;
-    uint32_t f;
-    uint8_t a = tuningStatus->aat_a, b = tuningStatus->aat_b;
-
-    if(0U != aatStepDacVals(
-                 tuningParams,
-                 &a,
-                 &b,
-                 previousDir)) { /* If stepping did not change the value, omit this direction */
-        return 0;
-    }
-
-    aatMeasure(a, b, &amp, &phs, &tuningStatus->measureCnt);
-    f = aatCalcF(tuningParams, amp, phs);
-    st25r3916AatLog("g : %d %d: %d", a, b, f);
-    if(f < *f_min) { /* Value is better than previous one */
-        st25r3916AatLog("*\n");
-        tuningStatus->aat_a = a;
-        tuningStatus->aat_b = b;
-        *f_min = f;
-        return previousDir;
-    }
-
-    st25r3916AatLog("\n");
-    return 0;
-}
-
-/*******************************************************************************/
-static uint32_t
-    aatCalcF(const struct st25r3916AatTuneParams* tuningParams, uint8_t amplitude, uint8_t phase) {
-    /* f(amp, pha) = (ampWeight * |amp - ampTarget|) + (phaWeight * |pha - phaTarget|) */
-    uint8_t ampTarget = tuningParams->ampTarget;
-    uint8_t phaTarget = tuningParams->phaTarget;
-
-    uint32_t ampWeight = tuningParams->ampWeight;
-    uint32_t phaWeight = tuningParams->phaWeight;
-
-    /* Temp variables to avoid MISRA R10.8 (cast on composite expression) */
-    uint8_t ad = ((amplitude > ampTarget) ? (amplitude - ampTarget) : (ampTarget - amplitude));
-    uint8_t pd = ((phase > phaTarget) ? (phase - phaTarget) : (phaTarget - phase));
-
-    uint32_t ampDelta = (uint32_t)ad;
-    uint32_t phaDelta = (uint32_t)pd;
-
-    return ((ampWeight * ampDelta) + (phaWeight * phaDelta));
-}
-
-/*******************************************************************************/
-static ReturnCode aatStepDacVals(
-    const struct st25r3916AatTuneParams* tuningParams,
-    uint8_t* a,
-    uint8_t* b,
-    int32_t dir) {
-    int16_t aat_a = (int16_t)*a, aat_b = (int16_t)*b;
-
-    switch(abs(dir)) { /* Advance by steps size in requested direction */
-    case 1:
-        aat_a = (dir < 0) ? (aat_a - (int16_t)tuningParams->aat_a_stepWidth) :
-                            (aat_a + (int16_t)tuningParams->aat_a_stepWidth);
-        if(aat_a < (int16_t)tuningParams->aat_a_min) {
-            aat_a = (int16_t)tuningParams->aat_a_min;
-        }
-        if(aat_a > (int16_t)tuningParams->aat_a_max) {
-            aat_a = (int16_t)tuningParams->aat_a_max;
-        }
-        if((int16_t)*a == aat_a) {
-            return ERR_PARAM;
-        }
-        break;
-    case 2:
-        aat_b = (dir < 0) ? (aat_b - (int16_t)tuningParams->aat_b_stepWidth) :
-                            (aat_b + (int16_t)tuningParams->aat_b_stepWidth);
-        if(aat_b < (int16_t)tuningParams->aat_b_min) {
-            aat_b = (int16_t)tuningParams->aat_b_min;
-        }
-        if(aat_b > (int16_t)tuningParams->aat_b_max) {
-            aat_b = (int16_t)tuningParams->aat_b_max;
-        }
-        if((int16_t)*b == aat_b) {
-            return ERR_PARAM;
-        }
-        break;
-    default:
-        return ERR_REQUEST;
-    }
-    /* We only get here if actual values have changed. In all other cases an error is returned */
-    *a = (uint8_t)aat_a;
-    *b = (uint8_t)aat_b;
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-static ReturnCode aatMeasure(
-    uint8_t serCap,
-    uint8_t parCap,
-    uint8_t* amplitude,
-    uint8_t* phase,
-    uint16_t* measureCnt) {
-    ReturnCode err;
-
-    *amplitude = 0;
-    *phase = 0;
-
-    st25r3916WriteRegister(ST25R3916_REG_ANT_TUNE_A, serCap);
-    st25r3916WriteRegister(ST25R3916_REG_ANT_TUNE_B, parCap);
-
-    /* Wait till caps have settled.. */
-    platformDelay(ST25R3916_AAT_CAP_DELAY_MAX);
-
-    /* Get amplitude and phase .. */
-    err = rfalChipMeasureAmplitude(amplitude);
-    if(ERR_NONE == err) {
-        err = rfalChipMeasurePhase(phase);
-    }
-
-    if(measureCnt != NULL) {
-        (*measureCnt)++;
-    }
-    return err;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_aat.h

@@ -1,109 +0,0 @@
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file st25r3916_aat.h
- *
- *  \author
- *
- *  \brief ST25R3916 Antenna Tuning 
- *
- * The antenna tuning algorithm tries to find the optimal settings for 
- * the AAT_A and AAT_B registers, which are connected to variable capacitors 
- * to tune the antenna matching.
- *
- */
-
-#ifndef ST25R3916_AAT_H
-#define ST25R3916_AAT_H
-
-#include "../../platform.h"
-#include "../../st_errno.h"
-
-/*
-******************************************************************************
-* GLOBAL DATATYPES
-******************************************************************************
-*/
-
-/*!
- * struct representing input parameters for the antenna tuning
- */
-struct st25r3916AatTuneParams {
-    uint8_t aat_a_min; /*!< min value of A cap */
-    uint8_t aat_a_max; /*!< max value of A cap */
-    uint8_t aat_a_start; /*!< start value of A cap */
-    uint8_t aat_a_stepWidth; /*!< increment stepWidth for A cap */
-    uint8_t aat_b_min; /*!< min value of B cap */
-    uint8_t aat_b_max; /*!< max value of B cap */
-    uint8_t aat_b_start; /*!< start value of B cap */
-    uint8_t aat_b_stepWidth; /*!< increment stepWidth for B cap */
-
-    uint8_t phaTarget; /*!< target phase */
-    uint8_t phaWeight; /*!< weight of target phase */
-    uint8_t ampTarget; /*!< target amplitude */
-    uint8_t ampWeight; /*!< weight of target amplitude */
-
-    bool doDynamicSteps; /*!< dynamically reduce step size in algo */
-    uint8_t measureLimit; /*!< max number of allowed steps/measurements */
-};
-
-/*!
- * struct representing out parameters for the antenna tuning
- */
-struct st25r3916AatTuneResult {
-    uint8_t aat_a; /*!< serial cap after tuning */
-    uint8_t aat_b; /*!< parallel cap after tuning */
-    uint8_t pha; /*!< phase after tuning */
-    uint8_t amp; /*!< amplitude after tuning */
-    uint16_t measureCnt; /*!< number of measures performed */
-};
-
-/*! 
- *****************************************************************************
- *  \brief  Perform antenna tuning
- *
- *  This function starts an antenna tuning procedure by modifying the serial 
- *  and parallel capacitors of the antenna matching circuit via the AAT_A
- *  and AAT_B registers. 
- *   
- *  \param[in] tuningParams : Input parameters for the tuning algorithm. If NULL
- *                            default values will be used.
- *  \param[out] tuningStatus : Result information of performed tuning. If NULL
- *                             no further information is returned, only registers
- *                             ST25R3916 (AAT_A,B) will be adapted.
- *
- *  \return ERR_IO    : Error during communication.
- *  \return ERR_PARAM : Invalid input parameters
- *  \return ERR_NONE  : No error.
- *
- *****************************************************************************
- */
-extern ReturnCode st25r3916AatTune(
-    const struct st25r3916AatTuneParams* tuningParams,
-    struct st25r3916AatTuneResult* tuningStatus);
-
-#endif /* ST25R3916_AAT_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_com.c

@@ -1,618 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief Implementation of ST25R3916 communication
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "st25r3916.h"
-#include "st25r3916_com.h"
-#include "st25r3916_led.h"
-#include "../../st_errno.h"
-#include "../../platform.h"
-#include "../../utils.h"
-
-/*
-******************************************************************************
-* LOCAL DEFINES
-******************************************************************************
-*/
-
-#define ST25R3916_OPTIMIZE \
-    true /*!< Optimization switch: false always write value to register      */
-#define ST25R3916_I2C_ADDR \
-    (0xA0U >> 1) /*!< ST25R3916's default I2C address                                */
-#define ST25R3916_REG_LEN 1U /*!< Byte length of a ST25R3916 register                            */
-
-#define ST25R3916_WRITE_MODE \
-    (0U << 6) /*!< ST25R3916 Operation Mode: Write                                */
-#define ST25R3916_READ_MODE \
-    (1U << 6) /*!< ST25R3916 Operation Mode: Read                                 */
-#define ST25R3916_CMD_MODE \
-    (3U << 6) /*!< ST25R3916 Operation Mode: Direct Command                       */
-#define ST25R3916_FIFO_LOAD \
-    (0x80U) /*!< ST25R3916 Operation Mode: FIFO Load                            */
-#define ST25R3916_FIFO_READ \
-    (0x9FU) /*!< ST25R3916 Operation Mode: FIFO Read                            */
-#define ST25R3916_PT_A_CONFIG_LOAD \
-    (0xA0U) /*!< ST25R3916 Operation Mode: Passive Target Memory A-Config Load  */
-#define ST25R3916_PT_F_CONFIG_LOAD \
-    (0xA8U) /*!< ST25R3916 Operation Mode: Passive Target Memory F-Config Load  */
-#define ST25R3916_PT_TSN_DATA_LOAD \
-    (0xACU) /*!< ST25R3916 Operation Mode: Passive Target Memory TSN Load       */
-#define ST25R3916_PT_MEM_READ \
-    (0xBFU) /*!< ST25R3916 Operation Mode: Passive Target Memory Read           */
-
-#define ST25R3916_CMD_LEN \
-    (1U) /*!< ST25R3916 CMD length                                           */
-#define ST25R3916_BUF_LEN \
-    (ST25R3916_CMD_LEN +  \
-     ST25R3916_FIFO_DEPTH) /*!< ST25R3916 communication buffer: CMD + FIFO length    */
-
-/*
-******************************************************************************
-* MACROS
-******************************************************************************
-*/
-#ifdef RFAL_USE_I2C
-#define st25r3916I2CStart() \
-    platformI2CStart() /*!< ST25R3916 HAL I2C driver macro to start a I2C transfer         */
-#define st25r3916I2CStop() \
-    platformI2CStop() /*!< ST25R3916 HAL I2C driver macro to stop a I2C transfer          */
-#define st25r3916I2CRepeatStart() \
-    platformI2CRepeatStart() /*!< ST25R3916 HAL I2C driver macro to repeat Start                 */
-#define st25r3916I2CSlaveAddrWR(sA) \
-    platformI2CSlaveAddrWR(         \
-        sA) /*!< ST25R3916 HAL I2C driver macro to repeat Start                 */
-#define st25r3916I2CSlaveAddrRD(sA) \
-    platformI2CSlaveAddrRD(         \
-        sA) /*!< ST25R3916 HAL I2C driver macro to repeat Start                 */
-#endif /* RFAL_USE_I2C */
-
-#if defined(ST25R_COM_SINGLETXRX) && !defined(RFAL_USE_I2C)
-static uint8_t
-    comBuf[ST25R3916_BUF_LEN]; /*!< ST25R3916 communication buffer                                 */
-static uint16_t comBufIt; /*!< ST25R3916 communication buffer iterator                        */
-#endif /* ST25R_COM_SINGLETXRX */
-
-/*
- ******************************************************************************
- * LOCAL FUNCTION PROTOTYPES
- ******************************************************************************
- */
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Start
- * 
- * This method performs the required actions to start communications with 
- * ST25R3916, either by SPI or I2C 
- ******************************************************************************
- */
-static void st25r3916comStart(void);
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Stop
- * 
- * This method performs the required actions to terminate communications with 
- * ST25R3916, either by SPI or I2C 
- ******************************************************************************
- */
-static void st25r3916comStop(void);
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Repeat Start
- * 
- * This method performs the required actions to repeat start a transmission
- * with ST25R3916, either by SPI or I2C 
- ******************************************************************************
- */
-#ifdef RFAL_USE_I2C
-static void st25r3916comRepeatStart(void);
-#else
-#define st25r3916comRepeatStart()
-#endif /* RFAL_USE_I2C */
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Tx
- * 
- * This method performs the required actions to transmit the given buffer
- * to ST25R3916, either by SPI or I2C
- * 
- * \param[in]  txBuf : the buffer to transmit
- * \param[in]  txLen : the length of the buffer to transmit
- * \param[in]  last   : true if last data to be transmitted
- * \param[in]  txOnly : true no reception is to be performed
- *  
- ******************************************************************************
- */
-static void st25r3916comTx(const uint8_t* txBuf, uint16_t txLen, bool last, bool txOnly);
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Rx
- * 
- * This method performs the required actions to receive from ST25R3916 the given 
- * amount of bytes, either by SPI or I2C
- * 
- * \param[out]  rxBuf : the buffer place the received bytes
- * \param[in]   rxLen : the length to receive
- *  
- ******************************************************************************
- */
-static void st25r3916comRx(uint8_t* rxBuf, uint16_t rxLen);
-
-/*!
- ******************************************************************************
- * \brief ST25R3916 communication Tx Byte
- * 
- * This helper method transmits a byte passed by value and not by reference
- * 
- * \param[in]   txByte : the value of the byte to be transmitted
- * \param[in]   last   : true if last byte to be transmitted
- * \param[in]   txOnly : true no reception is to be performed
- *  
- ******************************************************************************
- */
-static void st25r3916comTxByte(uint8_t txByte, bool last, bool txOnly);
-
-/*
- ******************************************************************************
- * LOCAL FUNCTION
- ******************************************************************************
- */
-static void st25r3916comStart(void) {
-    /* Make this operation atomic, disabling ST25R3916 interrupt during communications*/
-    platformProtectST25RComm();
-
-#ifdef RFAL_USE_I2C
-    /* I2C Start and send Slave Address */
-    st25r3916I2CStart();
-    st25r3916I2CSlaveAddrWR(ST25R3916_I2C_ADDR);
-#else
-    /* Perform the chip select */
-    platformSpiSelect();
-
-#if defined(ST25R_COM_SINGLETXRX)
-    comBufIt = 0; /* reset local buffer position   */
-#endif /* ST25R_COM_SINGLETXRX */
-
-#endif /* RFAL_USE_I2C */
-}
-
-/*******************************************************************************/
-static void st25r3916comStop(void) {
-#ifdef RFAL_USE_I2C
-    /* Generate Stop signal */
-    st25r3916I2CStop();
-#else
-    /* Release the chip select */
-    platformSpiDeselect();
-#endif /* RFAL_USE_I2C */
-
-    /* reEnable the ST25R3916 interrupt */
-    platformUnprotectST25RComm();
-}
-
-/*******************************************************************************/
-#ifdef RFAL_USE_I2C
-static void st25r3916comRepeatStart(void) {
-    st25r3916I2CRepeatStart();
-    st25r3916I2CSlaveAddrRD(ST25R3916_I2C_ADDR);
-}
-#endif /* RFAL_USE_I2C */
-
-/*******************************************************************************/
-static void st25r3916comTx(const uint8_t* txBuf, uint16_t txLen, bool last, bool txOnly) {
-    NO_WARNING(last);
-    NO_WARNING(txOnly);
-
-    if(txLen > 0U) {
-#ifdef RFAL_USE_I2C
-        platformI2CTx(txBuf, txLen, last, txOnly);
-#else /* RFAL_USE_I2C */
-
-#ifdef ST25R_COM_SINGLETXRX
-
-        ST_MEMCPY(
-            &comBuf[comBufIt],
-            txBuf,
-            MIN(txLen,
-                (ST25R3916_BUF_LEN -
-                 comBufIt))); /* copy tx data to local buffer                      */
-        comBufIt +=
-            MIN(txLen,
-                (ST25R3916_BUF_LEN -
-                 comBufIt)); /* store position on local buffer                    */
-
-        if(last && txOnly) /* only perform SPI transaction if no Rx will follow */
-        {
-            platformSpiTxRx(comBuf, NULL, comBufIt);
-        }
-
-#else
-        platformSpiTxRx(txBuf, NULL, txLen);
-#endif /* ST25R_COM_SINGLETXRX */
-
-#endif /* RFAL_USE_I2C */
-    }
-}
-
-/*******************************************************************************/
-static void st25r3916comRx(uint8_t* rxBuf, uint16_t rxLen) {
-    if(rxLen > 0U) {
-#ifdef RFAL_USE_I2C
-        platformI2CRx(rxBuf, rxLen);
-#else /* RFAL_USE_I2C */
-
-#ifdef ST25R_COM_SINGLETXRX
-        ST_MEMSET(
-            &comBuf[comBufIt],
-            0x00,
-            MIN(rxLen,
-                (ST25R3916_BUF_LEN -
-                 comBufIt))); /* clear outgoing buffer                                  */
-        platformSpiTxRx(
-            comBuf,
-            comBuf,
-            MIN((comBufIt + rxLen),
-                ST25R3916_BUF_LEN)); /* transceive as a single SPI call                        */
-        ST_MEMCPY(
-            rxBuf,
-            &comBuf[comBufIt],
-            MIN(rxLen,
-                (ST25R3916_BUF_LEN -
-                 comBufIt))); /* copy from local buf to output buffer and skip cmd byte */
-#else
-        if(rxBuf != NULL) {
-            ST_MEMSET(
-                rxBuf, 0x00, rxLen); /* clear outgoing buffer                                  */
-        }
-        platformSpiTxRx(NULL, rxBuf, rxLen);
-#endif /* ST25R_COM_SINGLETXRX */
-#endif /* RFAL_USE_I2C */
-    }
-}
-
-/*******************************************************************************/
-static void st25r3916comTxByte(uint8_t txByte, bool last, bool txOnly) {
-    uint8_t val = txByte; /* MISRA 17.8: use intermediate variable */
-    st25r3916comTx(&val, ST25R3916_REG_LEN, last, txOnly);
-}
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-ReturnCode st25r3916ReadRegister(uint8_t reg, uint8_t* val) {
-    return st25r3916ReadMultipleRegisters(reg, val, ST25R3916_REG_LEN);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ReadMultipleRegisters(uint8_t reg, uint8_t* values, uint8_t length) {
-    if(length > 0U) {
-        st25r3916comStart();
-
-        /* If is a space-B register send a direct command first */
-        if((reg & ST25R3916_SPACE_B) != 0U) {
-            st25r3916comTxByte(ST25R3916_CMD_SPACE_B_ACCESS, false, false);
-        }
-
-        st25r3916comTxByte(((reg & ~ST25R3916_SPACE_B) | ST25R3916_READ_MODE), true, false);
-        st25r3916comRepeatStart();
-        st25r3916comRx(values, length);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WriteRegister(uint8_t reg, uint8_t val) {
-    uint8_t value = val; /* MISRA 17.8: use intermediate variable */
-    return st25r3916WriteMultipleRegisters(reg, &value, ST25R3916_REG_LEN);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WriteMultipleRegisters(uint8_t reg, const uint8_t* values, uint8_t length) {
-    if(length > 0U) {
-        st25r3916comStart();
-
-        if((reg & ST25R3916_SPACE_B) != 0U) {
-            st25r3916comTxByte(ST25R3916_CMD_SPACE_B_ACCESS, false, true);
-        }
-
-        st25r3916comTxByte(((reg & ~ST25R3916_SPACE_B) | ST25R3916_WRITE_MODE), false, true);
-        st25r3916comTx(values, length, true, true);
-        st25r3916comStop();
-
-        /* Send a WriteMultiReg event to LED handling */
-        st25r3916ledEvtWrMultiReg(reg, values, length);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WriteFifo(const uint8_t* values, uint16_t length) {
-    if(length > ST25R3916_FIFO_DEPTH) {
-        return ERR_PARAM;
-    }
-
-    if(length > 0U) {
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_FIFO_LOAD, false, true);
-        st25r3916comTx(values, length, true, true);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ReadFifo(uint8_t* buf, uint16_t length) {
-    if(length > 0U) {
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_FIFO_READ, true, false);
-
-        st25r3916comRepeatStart();
-        st25r3916comRx(buf, length);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WritePTMem(const uint8_t* values, uint16_t length) {
-    if(length > ST25R3916_PTM_LEN) {
-        return ERR_PARAM;
-    }
-
-    if(length > 0U) {
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_PT_A_CONFIG_LOAD, false, true);
-        st25r3916comTx(values, length, true, true);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ReadPTMem(uint8_t* values, uint16_t length) {
-    uint8_t
-        tmp[ST25R3916_REG_LEN +
-            ST25R3916_PTM_LEN]; /* local buffer to handle prepended byte on I2C and SPI */
-
-    if(length > 0U) {
-        if(length > ST25R3916_PTM_LEN) {
-            return ERR_PARAM;
-        }
-
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_PT_MEM_READ, true, false);
-
-        st25r3916comRepeatStart();
-        st25r3916comRx(tmp, (ST25R3916_REG_LEN + length)); /* skip prepended byte */
-        st25r3916comStop();
-
-        /* Copy PTMem content without prepended byte */
-        ST_MEMCPY(values, (tmp + ST25R3916_REG_LEN), length);
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WritePTMemF(const uint8_t* values, uint16_t length) {
-    if(length > (ST25R3916_PTM_F_LEN + ST25R3916_PTM_TSN_LEN)) {
-        return ERR_PARAM;
-    }
-
-    if(length > 0U) {
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_PT_F_CONFIG_LOAD, false, true);
-        st25r3916comTx(values, length, true, true);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WritePTMemTSN(const uint8_t* values, uint16_t length) {
-    if(length > ST25R3916_PTM_TSN_LEN) {
-        return ERR_PARAM;
-    }
-
-    if(length > 0U) {
-        st25r3916comStart();
-        st25r3916comTxByte(ST25R3916_PT_TSN_DATA_LOAD, false, true);
-        st25r3916comTx(values, length, true, true);
-        st25r3916comStop();
-    }
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ExecuteCommand(uint8_t cmd) {
-    st25r3916comStart();
-    st25r3916comTxByte((cmd | ST25R3916_CMD_MODE), true, true);
-    st25r3916comStop();
-
-    /* Send a cmd event to LED handling */
-    st25r3916ledEvtCmd(cmd);
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ReadTestRegister(uint8_t reg, uint8_t* val) {
-    st25r3916comStart();
-    st25r3916comTxByte(ST25R3916_CMD_TEST_ACCESS, false, false);
-    st25r3916comTxByte((reg | ST25R3916_READ_MODE), true, false);
-    st25r3916comRepeatStart();
-    st25r3916comRx(val, ST25R3916_REG_LEN);
-    st25r3916comStop();
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916WriteTestRegister(uint8_t reg, uint8_t val) {
-    uint8_t value = val; /* MISRA 17.8: use intermediate variable */
-
-    st25r3916comStart();
-    st25r3916comTxByte(ST25R3916_CMD_TEST_ACCESS, false, true);
-    st25r3916comTxByte((reg | ST25R3916_WRITE_MODE), false, true);
-    st25r3916comTx(&value, ST25R3916_REG_LEN, true, true);
-    st25r3916comStop();
-
-    return ERR_NONE;
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ClrRegisterBits(uint8_t reg, uint8_t clr_mask) {
-    ReturnCode ret;
-    uint8_t rdVal;
-
-    /* Read current reg value */
-    EXIT_ON_ERR(ret, st25r3916ReadRegister(reg, &rdVal));
-
-    /* Only perform a Write if value to be written is different */
-    if(ST25R3916_OPTIMIZE && (rdVal == (uint8_t)(rdVal & ~clr_mask))) {
-        return ERR_NONE;
-    }
-
-    /* Write new reg value */
-    return st25r3916WriteRegister(reg, (uint8_t)(rdVal & ~clr_mask));
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916SetRegisterBits(uint8_t reg, uint8_t set_mask) {
-    ReturnCode ret;
-    uint8_t rdVal;
-
-    /* Read current reg value */
-    EXIT_ON_ERR(ret, st25r3916ReadRegister(reg, &rdVal));
-
-    /* Only perform a Write if the value to be written is different */
-    if(ST25R3916_OPTIMIZE && (rdVal == (rdVal | set_mask))) {
-        return ERR_NONE;
-    }
-
-    /* Write new reg value */
-    return st25r3916WriteRegister(reg, (rdVal | set_mask));
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ChangeRegisterBits(uint8_t reg, uint8_t valueMask, uint8_t value) {
-    return st25r3916ModifyRegister(reg, valueMask, (valueMask & value));
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ModifyRegister(uint8_t reg, uint8_t clr_mask, uint8_t set_mask) {
-    ReturnCode ret;
-    uint8_t rdVal;
-    uint8_t wrVal;
-
-    /* Read current reg value */
-    EXIT_ON_ERR(ret, st25r3916ReadRegister(reg, &rdVal));
-
-    /* Compute new value */
-    wrVal = (uint8_t)(rdVal & ~clr_mask);
-    wrVal |= set_mask;
-
-    /* Only perform a Write if the value to be written is different */
-    if(ST25R3916_OPTIMIZE && (rdVal == wrVal)) {
-        return ERR_NONE;
-    }
-
-    /* Write new reg value */
-    return st25r3916WriteRegister(reg, wrVal);
-}
-
-/*******************************************************************************/
-ReturnCode st25r3916ChangeTestRegisterBits(uint8_t reg, uint8_t valueMask, uint8_t value) {
-    ReturnCode ret;
-    uint8_t rdVal;
-    uint8_t wrVal;
-
-    /* Read current reg value */
-    EXIT_ON_ERR(ret, st25r3916ReadTestRegister(reg, &rdVal));
-
-    /* Compute new value */
-    wrVal = (uint8_t)(rdVal & ~valueMask);
-    wrVal |= (uint8_t)(value & valueMask);
-
-    /* Only perform a Write if the value to be written is different */
-    if(ST25R3916_OPTIMIZE && (rdVal == wrVal)) {
-        return ERR_NONE;
-    }
-
-    /* Write new reg value */
-    return st25r3916WriteTestRegister(reg, wrVal);
-}
-
-/*******************************************************************************/
-bool st25r3916CheckReg(uint8_t reg, uint8_t mask, uint8_t val) {
-    uint8_t regVal;
-
-    regVal = 0;
-    st25r3916ReadRegister(reg, &regVal);
-
-    return ((regVal & mask) == val);
-}
-
-/*******************************************************************************/
-bool st25r3916IsRegValid(uint8_t reg) {
-#pragma GCC diagnostic ignored "-Wtype-limits"
-    if(!(((int16_t)reg >= (int32_t)ST25R3916_REG_IO_CONF1) &&
-         (reg <= (ST25R3916_SPACE_B | ST25R3916_REG_IC_IDENTITY)))) {
-        return false;
-    }
-    return true;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_com.h

@@ -1,1384 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 communication declaration file
- *  
- *  This driver provides basic abstraction for communication with the ST25R3916
- *  
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup ST25R3916
- * \brief RFAL ST25R3916 Driver
- * @{
- * 
- * \addtogroup ST25R3916_COM
- * \brief RFAL ST25R3916 Communications
- * @{
- * 
- */
-
-#ifndef ST25R3916_COM_H
-#define ST25R3916_COM_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "../../platform.h"
-#include "../../st_errno.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-#define ST25R3916_SPACE_B 0x40U /*!< ST25R3916 Space-B indicator                          */
-#define ST25R3916_SPACE_B_REG_LEN 16U /*!< Number of register in the space B                    */
-
-#define ST25R3916_FIFO_STATUS_LEN 2 /*!< Number of FIFO Status Register                       */
-
-#define ST25R3916_PTM_A_LEN 15U /*!< Passive target memory A config length                */
-#define ST25R3916_PTM_B_LEN 0U /*!< Passive target memory B config length                */
-#define ST25R3916_PTM_F_LEN 21U /*!< Passive target memory F config length                */
-#define ST25R3916_PTM_TSN_LEN 12U /*!< Passive target memory TSN data length                */
-
-/*! Full Passive target memory length */
-#define ST25R3916_PTM_LEN \
-    (ST25R3916_PTM_A_LEN + ST25R3916_PTM_B_LEN + ST25R3916_PTM_F_LEN + ST25R3916_PTM_TSN_LEN)
-
-/* IO configuration registers */
-#define ST25R3916_REG_IO_CONF1 0x00U /*!< RW IO Configuration Register 1                       */
-#define ST25R3916_REG_IO_CONF2 0x01U /*!< RW IO Configuration Register 2                       */
-
-/* Operation control and mode definition registers */
-#define ST25R3916_REG_OP_CONTROL 0x02U /*!< RW Operation Control Register                        */
-#define ST25R3916_REG_MODE 0x03U /*!< RW Mode Definition Register                          */
-#define ST25R3916_REG_BIT_RATE 0x04U /*!< RW Bit Rate Definition Register                      */
-
-/* Protocol Configuration registers */
-#define ST25R3916_REG_ISO14443A_NFC \
-    0x05U /*!< RW ISO14443A and NFC 106 kBit/s Settings Register    */
-#define ST25R3916_REG_EMD_SUP_CONF \
-    (ST25R3916_SPACE_B | 0x05U) /*!< RW EMD Suppression Configuration Register            */
-#define ST25R3916_REG_ISO14443B_1 \
-    0x06U /*!< RW ISO14443B Settings Register 1                     */
-#define ST25R3916_REG_SUBC_START_TIME \
-    (ST25R3916_SPACE_B | 0x06U) /*!< RW Subcarrier Start Time Register                    */
-#define ST25R3916_REG_ISO14443B_2 \
-    0x07U /*!< RW ISO14443B Settings Register 2                     */
-#define ST25R3916_REG_PASSIVE_TARGET \
-    0x08U /*!< RW Passive Target Definition Register                */
-#define ST25R3916_REG_STREAM_MODE \
-    0x09U /*!< RW Stream Mode Definition Register                   */
-#define ST25R3916_REG_AUX 0x0AU /*!< RW Auxiliary Definition Register                     */
-
-/* Receiver Configuration registers */
-#define ST25R3916_REG_RX_CONF1 0x0BU /*!< RW Receiver Configuration Register 1                 */
-#define ST25R3916_REG_RX_CONF2 0x0CU /*!< RW Receiver Configuration Register 2                 */
-#define ST25R3916_REG_RX_CONF3 0x0DU /*!< RW Receiver Configuration Register 3                 */
-#define ST25R3916_REG_RX_CONF4 0x0EU /*!< RW Receiver Configuration Register 4                 */
-#define ST25R3916_REG_P2P_RX_CONF \
-    (ST25R3916_SPACE_B | 0x0BU) /*!< RW P2P Receiver Configuration Register 1             */
-#define ST25R3916_REG_CORR_CONF1 \
-    (ST25R3916_SPACE_B | 0x0CU) /*!< RW Correlator configuration register 1               */
-#define ST25R3916_REG_CORR_CONF2 \
-    (ST25R3916_SPACE_B | 0x0DU) /*!< RW Correlator configuration register 2               */
-
-/* Timer definition registers */
-#define ST25R3916_REG_MASK_RX_TIMER \
-    0x0FU /*!< RW Mask Receive Timer Register                       */
-#define ST25R3916_REG_NO_RESPONSE_TIMER1 \
-    0x10U /*!< RW No-response Timer Register 1                      */
-#define ST25R3916_REG_NO_RESPONSE_TIMER2 \
-    0x11U /*!< RW No-response Timer Register 2                      */
-#define ST25R3916_REG_TIMER_EMV_CONTROL \
-    0x12U /*!< RW Timer and EMV Control                             */
-#define ST25R3916_REG_GPT1 0x13U /*!< RW General Purpose Timer Register 1                  */
-#define ST25R3916_REG_GPT2 0x14U /*!< RW General Purpose Timer Register 2                  */
-#define ST25R3916_REG_PPON2 0x15U /*!< RW PPON2 Field waiting Timer Register                */
-#define ST25R3916_REG_SQUELCH_TIMER \
-    (ST25R3916_SPACE_B | 0x0FU) /*!< RW Squelch timeout Register                          */
-#define ST25R3916_REG_FIELD_ON_GT \
-    (ST25R3916_SPACE_B | 0x15U) /*!< RW NFC Field on guard time                           */
-
-/* Interrupt and associated reporting registers */
-#define ST25R3916_REG_IRQ_MASK_MAIN \
-    0x16U /*!< RW Mask Main Interrupt Register                      */
-#define ST25R3916_REG_IRQ_MASK_TIMER_NFC \
-    0x17U /*!< RW Mask Timer and NFC Interrupt Register             */
-#define ST25R3916_REG_IRQ_MASK_ERROR_WUP \
-    0x18U /*!< RW Mask Error and Wake-up Interrupt Register         */
-#define ST25R3916_REG_IRQ_MASK_TARGET \
-    0x19U /*!< RW Mask 3916 Target Interrupt Register               */
-#define ST25R3916_REG_IRQ_MAIN 0x1AU /*!< R  Main Interrupt Register                           */
-#define ST25R3916_REG_IRQ_TIMER_NFC \
-    0x1BU /*!< R  Timer and NFC Interrupt Register                  */
-#define ST25R3916_REG_IRQ_ERROR_WUP \
-    0x1CU /*!< R  Error and Wake-up Interrupt Register              */
-#define ST25R3916_REG_IRQ_TARGET 0x1DU /*!< R  ST25R3916 Target Interrupt Register               */
-#define ST25R3916_REG_FIFO_STATUS1 \
-    0x1EU /*!< R  FIFO Status Register 1                            */
-#define ST25R3916_REG_FIFO_STATUS2 \
-    0x1FU /*!< R  FIFO Status Register 2                            */
-#define ST25R3916_REG_COLLISION_STATUS \
-    0x20U /*!< R  Collision Display Register                        */
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS \
-    0x21U /*!< R  Passive target state status                       */
-
-/* Definition of number of transmitted bytes */
-#define ST25R3916_REG_NUM_TX_BYTES1 \
-    0x22U /*!< RW Number of Transmitted Bytes Register 1            */
-#define ST25R3916_REG_NUM_TX_BYTES2 \
-    0x23U /*!< RW Number of Transmitted Bytes Register 2            */
-
-/* NFCIP Bit Rate Display Register */
-#define ST25R3916_REG_NFCIP1_BIT_RATE \
-    0x24U /*!< R  NFCIP Bit Rate Detection Display Register         */
-
-/* A/D Converter Output Register */
-#define ST25R3916_REG_AD_RESULT 0x25U /*!< R  A/D Converter Output Register                     */
-
-/* Antenna tuning registers */
-#define ST25R3916_REG_ANT_TUNE_A 0x26U /*!< RW Antenna Tuning Control (AAT-A) Register 1         */
-#define ST25R3916_REG_ANT_TUNE_B 0x27U /*!< RW Antenna Tuning Control (AAT-B) Register 2         */
-
-/* Antenna Driver and Modulation registers */
-#define ST25R3916_REG_TX_DRIVER 0x28U /*!< RW TX driver register                                */
-#define ST25R3916_REG_PT_MOD 0x29U /*!< RW PT modulation Register                            */
-#define ST25R3916_REG_AUX_MOD \
-    (ST25R3916_SPACE_B | 0x28U) /*!< RW Aux Modulation setting Register                   */
-#define ST25R3916_REG_TX_DRIVER_TIMING \
-    (ST25R3916_SPACE_B | 0x29U) /*!< RW TX driver timing Register                         */
-#define ST25R3916_REG_RES_AM_MOD \
-    (ST25R3916_SPACE_B | 0x2AU) /*!< RW Resistive AM modulation register                  */
-#define ST25R3916_REG_TX_DRIVER_STATUS \
-    (ST25R3916_SPACE_B | 0x2BU) /*!< R  TX driver timing readout Register                 */
-
-/* External Field Detector Threshold Registers */
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV \
-    0x2AU /*!< RW External Field Detector Activation Threshold Reg  */
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV \
-    0x2BU /*!< RW External Field Detector Deactivation Threshold Reg*/
-
-/* Regulator registers */
-#define ST25R3916_REG_REGULATOR_CONTROL \
-    0x2CU /*!< RW Regulated Voltage Control Register                */
-#define ST25R3916_REG_REGULATOR_RESULT \
-    (ST25R3916_SPACE_B | 0x2CU) /*!< R Regulator Display Register                         */
-
-/* Receiver State Display Register */
-#define ST25R3916_REG_RSSI_RESULT \
-    0x2DU /*!< R RSSI Display Register                              */
-#define ST25R3916_REG_GAIN_RED_STATE \
-    0x2EU /*!< R Gain Reduction State Register                      */
-#define ST25R3916_REG_CAP_SENSOR_CONTROL \
-    0x2FU /*!< RW Capacitive Sensor Control Register                */
-#define ST25R3916_REG_CAP_SENSOR_RESULT \
-    0x30U /*!< R  Capacitive Sensor Display Register                */
-#define ST25R3916_REG_AUX_DISPLAY \
-    0x31U /*!< R Auxiliary Display Register                         */
-
-/* Over/Undershoot Protection Configuration Registers */
-#define ST25R3916_REG_OVERSHOOT_CONF1 \
-    (ST25R3916_SPACE_B | 0x30U) /*!< RW  Overshoot Protection Configuration Register 1    */
-#define ST25R3916_REG_OVERSHOOT_CONF2 \
-    (ST25R3916_SPACE_B | 0x31U) /*!< RW  Overshoot Protection Configuration Register 2    */
-#define ST25R3916_REG_UNDERSHOOT_CONF1 \
-    (ST25R3916_SPACE_B | 0x32U) /*!< RW  Undershoot Protection Configuration Register 1   */
-#define ST25R3916_REG_UNDERSHOOT_CONF2 \
-    (ST25R3916_SPACE_B | 0x33U) /*!< RW  Undershoot Protection Configuration Register 2   */
-
-/* Detection of card presence */
-#define ST25R3916_REG_WUP_TIMER_CONTROL \
-    0x32U /*!< RW Wake-up Timer Control Register                    */
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF \
-    0x33U /*!< RW Amplitude Measurement Configuration Register      */
-#define ST25R3916_REG_AMPLITUDE_MEASURE_REF \
-    0x34U /*!< RW Amplitude Measurement Reference Register          */
-#define ST25R3916_REG_AMPLITUDE_MEASURE_AA_RESULT \
-    0x35U /*!< R  Amplitude Measurement Auto Averaging Display Reg  */
-#define ST25R3916_REG_AMPLITUDE_MEASURE_RESULT \
-    0x36U /*!< R  Amplitude Measurement Display Register            */
-#define ST25R3916_REG_PHASE_MEASURE_CONF \
-    0x37U /*!< RW Phase Measurement Configuration Register          */
-#define ST25R3916_REG_PHASE_MEASURE_REF \
-    0x38U /*!< RW Phase Measurement Reference Register              */
-#define ST25R3916_REG_PHASE_MEASURE_AA_RESULT \
-    0x39U /*!< R  Phase Measurement Auto Averaging Display Register */
-#define ST25R3916_REG_PHASE_MEASURE_RESULT \
-    0x3AU /*!< R  Phase Measurement Display Register                */
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF \
-    0x3BU /*!< RW Capacitance Measurement Configuration Register    */
-#define ST25R3916_REG_CAPACITANCE_MEASURE_REF \
-    0x3CU /*!< RW Capacitance Measurement Reference Register        */
-#define ST25R3916_REG_CAPACITANCE_MEASURE_AA_RESULT \
-    0x3DU /*!< R  Capacitance Measurement Auto Averaging Display Reg*/
-#define ST25R3916_REG_CAPACITANCE_MEASURE_RESULT \
-    0x3EU /*!< R  Capacitance Measurement Display Register          */
-
-/* IC identity  */
-#define ST25R3916_REG_IC_IDENTITY \
-    0x3FU /*!< R  Chip Id: 0 for old silicon, v2 silicon: 0x09      */
-
-/*! Register bit definitions  \cond DOXYGEN_SUPRESS */
-
-#define ST25R3916_REG_IO_CONF1_single (1U << 7)
-#define ST25R3916_REG_IO_CONF1_rfo2 (1U << 6)
-#define ST25R3916_REG_IO_CONF1_i2c_thd1 (1U << 5)
-#define ST25R3916_REG_IO_CONF1_i2c_thd0 (1U << 4)
-#define ST25R3916_REG_IO_CONF1_i2c_thd_mask (3U << 4)
-#define ST25R3916_REG_IO_CONF1_i2c_thd_shift (4U)
-#define ST25R3916_REG_IO_CONF1_rfu (1U << 3)
-#define ST25R3916_REG_IO_CONF1_out_cl1 (1U << 2)
-#define ST25R3916_REG_IO_CONF1_out_cl0 (1U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_disabled (3U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_13_56MHZ (2U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_4_78MHZ (1U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_3_39MHZ (0U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_mask (3U << 1)
-#define ST25R3916_REG_IO_CONF1_out_cl_shift (1U)
-#define ST25R3916_REG_IO_CONF1_lf_clk_off (1U << 0)
-#define ST25R3916_REG_IO_CONF1_lf_clk_off_on (1U << 0)
-#define ST25R3916_REG_IO_CONF1_lf_clk_off_off (0U << 0)
-
-#define ST25R3916_REG_IO_CONF2_sup3V (1U << 7)
-#define ST25R3916_REG_IO_CONF2_sup3V_3V (1U << 7)
-#define ST25R3916_REG_IO_CONF2_sup3V_5V (0U << 7)
-#define ST25R3916_REG_IO_CONF2_vspd_off (1U << 6)
-#define ST25R3916_REG_IO_CONF2_aat_en (1U << 5)
-#define ST25R3916_REG_IO_CONF2_miso_pd2 (1U << 4)
-#define ST25R3916_REG_IO_CONF2_miso_pd1 (1U << 3)
-#define ST25R3916_REG_IO_CONF2_io_drv_lvl (1U << 2)
-#define ST25R3916_REG_IO_CONF2_slow_up (1U << 0)
-
-#define ST25R3916_REG_OP_CONTROL_en (1U << 7)
-#define ST25R3916_REG_OP_CONTROL_rx_en (1U << 6)
-#define ST25R3916_REG_OP_CONTROL_rx_chn (1U << 5)
-#define ST25R3916_REG_OP_CONTROL_rx_man (1U << 4)
-#define ST25R3916_REG_OP_CONTROL_tx_en (1U << 3)
-#define ST25R3916_REG_OP_CONTROL_wu (1U << 2)
-#define ST25R3916_REG_OP_CONTROL_en_fd_c1 (1U << 1)
-#define ST25R3916_REG_OP_CONTROL_en_fd_c0 (1U << 0)
-#define ST25R3916_REG_OP_CONTROL_en_fd_efd_off (0U << 0)
-#define ST25R3916_REG_OP_CONTROL_en_fd_manual_efd_ca (1U << 0)
-#define ST25R3916_REG_OP_CONTROL_en_fd_manual_efd_pdt (2U << 0)
-#define ST25R3916_REG_OP_CONTROL_en_fd_auto_efd (3U << 0)
-#define ST25R3916_REG_OP_CONTROL_en_fd_shift (0U)
-#define ST25R3916_REG_OP_CONTROL_en_fd_mask (3U << 0)
-
-#define ST25R3916_REG_MODE_targ (1U << 7)
-#define ST25R3916_REG_MODE_targ_targ (1U << 7)
-#define ST25R3916_REG_MODE_targ_init (0U << 7)
-#define ST25R3916_REG_MODE_om3 (1U << 6)
-#define ST25R3916_REG_MODE_om2 (1U << 5)
-#define ST25R3916_REG_MODE_om1 (1U << 4)
-#define ST25R3916_REG_MODE_om0 (1U << 3)
-#define ST25R3916_REG_MODE_om_bpsk_stream (0xfU << 3)
-#define ST25R3916_REG_MODE_om_subcarrier_stream (0xeU << 3)
-#define ST25R3916_REG_MODE_om_topaz (0x4U << 3)
-#define ST25R3916_REG_MODE_om_felica (0x3U << 3)
-#define ST25R3916_REG_MODE_om_iso14443b (0x2U << 3)
-#define ST25R3916_REG_MODE_om_iso14443a (0x1U << 3)
-#define ST25R3916_REG_MODE_om_targ_nfca (0x1U << 3)
-#define ST25R3916_REG_MODE_om_targ_nfcb (0x2U << 3)
-#define ST25R3916_REG_MODE_om_targ_nfcf (0x4U << 3)
-#define ST25R3916_REG_MODE_om_targ_nfcip (0x7U << 3)
-#define ST25R3916_REG_MODE_om_nfc (0x0U << 3)
-#define ST25R3916_REG_MODE_om_mask (0xfU << 3)
-#define ST25R3916_REG_MODE_om_shift (3U)
-#define ST25R3916_REG_MODE_tr_am (1U << 2)
-#define ST25R3916_REG_MODE_tr_am_ook (0U << 2)
-#define ST25R3916_REG_MODE_tr_am_am (1U << 2)
-#define ST25R3916_REG_MODE_nfc_ar1 (1U << 1)
-#define ST25R3916_REG_MODE_nfc_ar0 (1U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_off (0U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_auto_rx (1U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_eof (2U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_rfu (3U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_mask (3U << 0)
-#define ST25R3916_REG_MODE_nfc_ar_shift (0U)
-
-#define ST25R3916_REG_BIT_RATE_txrate_106 (0x0U << 4)
-#define ST25R3916_REG_BIT_RATE_txrate_212 (0x1U << 4)
-#define ST25R3916_REG_BIT_RATE_txrate_424 (0x2U << 4)
-#define ST25R3916_REG_BIT_RATE_txrate_848 (0x3U << 4)
-#define ST25R3916_REG_BIT_RATE_txrate_mask (0x3U << 4)
-#define ST25R3916_REG_BIT_RATE_txrate_shift (4U)
-#define ST25R3916_REG_BIT_RATE_rxrate_106 (0x0U << 0)
-#define ST25R3916_REG_BIT_RATE_rxrate_212 (0x1U << 0)
-#define ST25R3916_REG_BIT_RATE_rxrate_424 (0x2U << 0)
-#define ST25R3916_REG_BIT_RATE_rxrate_848 (0x3U << 0)
-#define ST25R3916_REG_BIT_RATE_rxrate_mask (0x3U << 0)
-#define ST25R3916_REG_BIT_RATE_rxrate_shift (0U)
-
-#define ST25R3916_REG_ISO14443A_NFC_no_tx_par (1U << 7)
-#define ST25R3916_REG_ISO14443A_NFC_no_tx_par_off (0U << 7)
-#define ST25R3916_REG_ISO14443A_NFC_no_rx_par (1U << 6)
-#define ST25R3916_REG_ISO14443A_NFC_no_rx_par_off (0U << 6)
-#define ST25R3916_REG_ISO14443A_NFC_nfc_f0 (1U << 5)
-#define ST25R3916_REG_ISO14443A_NFC_nfc_f0_off (0U << 5)
-#define ST25R3916_REG_ISO14443A_NFC_p_len3 (1U << 4)
-#define ST25R3916_REG_ISO14443A_NFC_p_len2 (1U << 3)
-#define ST25R3916_REG_ISO14443A_NFC_p_len1 (1U << 2)
-#define ST25R3916_REG_ISO14443A_NFC_p_len0 (1U << 1)
-#define ST25R3916_REG_ISO14443A_NFC_p_len_mask (0xfU << 1)
-#define ST25R3916_REG_ISO14443A_NFC_p_len_shift (1U)
-#define ST25R3916_REG_ISO14443A_NFC_antcl (1U << 0)
-
-#define ST25R3916_REG_EMD_SUP_CONF_emd_emv (1U << 7)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_emv_on (1U << 7)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_emv_off (0U << 7)
-#define ST25R3916_REG_EMD_SUP_CONF_rx_start_emv (1U << 6)
-#define ST25R3916_REG_EMD_SUP_CONF_rx_start_emv_on (1U << 6)
-#define ST25R3916_REG_EMD_SUP_CONF_rx_start_emv_off (0U << 6)
-#define ST25R3916_REG_EMD_SUP_CONF_rfu1 (1U << 5)
-#define ST25R3916_REG_EMD_SUP_CONF_rfu0 (1U << 4)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld3 (1U << 3)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld2 (1U << 2)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld1 (1U << 1)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld0 (1U << 0)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld_mask (0xfU << 0)
-#define ST25R3916_REG_EMD_SUP_CONF_emd_thld_shift (0U)
-
-#define ST25R3916_REG_SUBC_START_TIME_rfu2 (1U << 7)
-#define ST25R3916_REG_SUBC_START_TIME_rfu1 (1U << 6)
-#define ST25R3916_REG_SUBC_START_TIME_rfu0 (1U << 5)
-#define ST25R3916_REG_SUBC_START_TIME_sst4 (1U << 4)
-#define ST25R3916_REG_SUBC_START_TIME_sst3 (1U << 3)
-#define ST25R3916_REG_SUBC_START_TIME_sst2 (1U << 2)
-#define ST25R3916_REG_SUBC_START_TIME_sst1 (1U << 1)
-#define ST25R3916_REG_SUBC_START_TIME_sst0 (1U << 0)
-#define ST25R3916_REG_SUBC_START_TIME_sst_mask (0x1fU << 0)
-#define ST25R3916_REG_SUBC_START_TIME_sst_shift (0U)
-
-#define ST25R3916_REG_ISO14443B_1_egt2 (1U << 7)
-#define ST25R3916_REG_ISO14443B_1_egt1 (1U << 6)
-#define ST25R3916_REG_ISO14443B_1_egt0 (1U << 5)
-#define ST25R3916_REG_ISO14443B_1_egt_shift (5U)
-#define ST25R3916_REG_ISO14443B_1_egt_mask (7U << 5)
-#define ST25R3916_REG_ISO14443B_1_sof_1 (1U << 3)
-#define ST25R3916_REG_ISO14443B_1_sof_1_3etu (1U << 3)
-#define ST25R3916_REG_ISO14443B_1_sof_1_2etu (0U << 3)
-#define ST25R3916_REG_ISO14443B_1_sof_0 (1U << 4)
-#define ST25R3916_REG_ISO14443B_1_sof_0_11etu (1U << 4)
-#define ST25R3916_REG_ISO14443B_1_sof_0_10etu (0U << 4)
-#define ST25R3916_REG_ISO14443B_1_sof_mask (3U << 3)
-#define ST25R3916_REG_ISO14443B_1_eof (1U << 2)
-#define ST25R3916_REG_ISO14443B_1_eof_11etu (1U << 2)
-#define ST25R3916_REG_ISO14443B_1_eof_10etu (0U << 2)
-#define ST25R3916_REG_ISO14443B_1_half (1U << 1)
-#define ST25R3916_REG_ISO14443B_1_rx_st_om (1U << 0)
-
-#define ST25R3916_REG_ISO14443B_2_tr1_1 (1U << 7)
-#define ST25R3916_REG_ISO14443B_2_tr1_0 (1U << 6)
-#define ST25R3916_REG_ISO14443B_2_tr1_64fs32fs (1U << 6)
-#define ST25R3916_REG_ISO14443B_2_tr1_80fs80fs (0U << 6)
-#define ST25R3916_REG_ISO14443B_2_tr1_mask (3U << 6)
-#define ST25R3916_REG_ISO14443B_2_tr1_shift (6U)
-#define ST25R3916_REG_ISO14443B_2_no_sof (1U << 5)
-#define ST25R3916_REG_ISO14443B_2_no_eof (1U << 4)
-#define ST25R3916_REG_ISO14443B_rfu1 (1U << 3)
-#define ST25R3916_REG_ISO14443B_rfu0 (1U << 2)
-#define ST25R3916_REG_ISO14443B_2_f_p1 (1U << 1)
-#define ST25R3916_REG_ISO14443B_2_f_p0 (1U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_96 (3U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_80 (2U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_64 (1U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_48 (0U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_mask (3U << 0)
-#define ST25R3916_REG_ISO14443B_2_f_p_shift (0U)
-
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_3 (1U << 7)
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_2 (1U << 6)
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_1 (1U << 5)
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_0 (1U << 4)
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_mask (0xfU << 4)
-#define ST25R3916_REG_PASSIVE_TARGET_fdel_shift (4U)
-#define ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p (1U << 3)
-#define ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r (1U << 2)
-#define ST25R3916_REG_PASSIVE_TARGET_rfu (1U << 1)
-#define ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a (1U << 0)
-
-#define ST25R3916_REG_STREAM_MODE_rfu (1U << 7)
-#define ST25R3916_REG_STREAM_MODE_scf1 (1U << 6)
-#define ST25R3916_REG_STREAM_MODE_scf0 (1U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_sc212 (0U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_sc424 (1U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_sc848 (2U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_sc1695 (3U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_bpsk848 (0U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_bpsk1695 (1U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_bpsk3390 (2U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_bpsk106 (3U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_mask (3U << 5)
-#define ST25R3916_REG_STREAM_MODE_scf_shift (5U)
-#define ST25R3916_REG_STREAM_MODE_scp1 (1U << 4)
-#define ST25R3916_REG_STREAM_MODE_scp0 (1U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_1pulse (0U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_2pulses (1U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_4pulses (2U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_8pulses (3U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_mask (3U << 3)
-#define ST25R3916_REG_STREAM_MODE_scp_shift (3U)
-#define ST25R3916_REG_STREAM_MODE_stx2 (1U << 2)
-#define ST25R3916_REG_STREAM_MODE_stx1 (1U << 1)
-#define ST25R3916_REG_STREAM_MODE_stx0 (1U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_106 (0U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_212 (1U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_424 (2U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_848 (3U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_mask (7U << 0)
-#define ST25R3916_REG_STREAM_MODE_stx_shift (0U)
-
-#define ST25R3916_REG_AUX_no_crc_rx (1U << 7)
-#define ST25R3916_REG_AUX_rfu (1U << 6)
-#define ST25R3916_REG_AUX_nfc_id1 (1U << 5)
-#define ST25R3916_REG_AUX_nfc_id0 (1U << 4)
-#define ST25R3916_REG_AUX_nfc_id_7bytes (1U << 4)
-#define ST25R3916_REG_AUX_nfc_id_4bytes (0U << 4)
-#define ST25R3916_REG_AUX_nfc_id_mask (3U << 4)
-#define ST25R3916_REG_AUX_nfc_id_shift (4U)
-#define ST25R3916_REG_AUX_mfaz_cl90 (1U << 3)
-#define ST25R3916_REG_AUX_dis_corr (1U << 2)
-#define ST25R3916_REG_AUX_dis_corr_coherent (1U << 2)
-#define ST25R3916_REG_AUX_dis_corr_correlator (0U << 2)
-#define ST25R3916_REG_AUX_nfc_n1 (1U << 1)
-#define ST25R3916_REG_AUX_nfc_n0 (1U << 0)
-#define ST25R3916_REG_AUX_nfc_n_mask (3U << 0)
-#define ST25R3916_REG_AUX_nfc_n_shift (0U)
-
-#define ST25R3916_REG_RX_CONF1_ch_sel (1U << 7)
-#define ST25R3916_REG_RX_CONF1_ch_sel_PM (1U << 7)
-#define ST25R3916_REG_RX_CONF1_ch_sel_AM (0U << 7)
-#define ST25R3916_REG_RX_CONF1_lp2 (1U << 6)
-#define ST25R3916_REG_RX_CONF1_lp1 (1U << 5)
-#define ST25R3916_REG_RX_CONF1_lp0 (1U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_1200khz (0U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_600khz (1U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_300khz (2U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_2000khz (4U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_7000khz (5U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_mask (7U << 4)
-#define ST25R3916_REG_RX_CONF1_lp_shift (4U)
-#define ST25R3916_REG_RX_CONF1_z600k (1U << 3)
-#define ST25R3916_REG_RX_CONF1_h200 (1U << 2)
-#define ST25R3916_REG_RX_CONF1_h80 (1U << 1)
-#define ST25R3916_REG_RX_CONF1_z12k (1U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_60_400khz (0U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_60_200khz (4U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_40_80khz (2U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_12_200khz (1U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_12_80khz (3U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_12_200khz_alt (5U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_600_400khz (8U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_600_200khz (12U << 0)
-#define ST25R3916_REG_RX_CONF1_hz_mask (0xfU << 0)
-#define ST25R3916_REG_RX_CONF1_hz_shift (0U)
-
-#define ST25R3916_REG_RX_CONF2_demod_mode (1U << 7)
-#define ST25R3916_REG_RX_CONF2_amd_sel (1U << 6)
-#define ST25R3916_REG_RX_CONF2_amd_sel_mixer (1U << 6)
-#define ST25R3916_REG_RX_CONF2_amd_sel_peak (0U << 6)
-#define ST25R3916_REG_RX_CONF2_sqm_dyn (1U << 5)
-#define ST25R3916_REG_RX_CONF2_pulz_61 (1U << 4)
-#define ST25R3916_REG_RX_CONF2_agc_en (1U << 3)
-#define ST25R3916_REG_RX_CONF2_agc_m (1U << 2)
-#define ST25R3916_REG_RX_CONF2_agc_alg (1U << 1)
-#define ST25R3916_REG_RX_CONF2_agc6_3 (1U << 0)
-
-#define ST25R3916_REG_RX_CONF3_rg1_am2 (1U << 7)
-#define ST25R3916_REG_RX_CONF3_rg1_am1 (1U << 6)
-#define ST25R3916_REG_RX_CONF3_rg1_am0 (1U << 5)
-#define ST25R3916_REG_RX_CONF3_rg1_am_mask (0x7U << 5)
-#define ST25R3916_REG_RX_CONF3_rg1_am_shift (5U)
-#define ST25R3916_REG_RX_CONF3_rg1_pm2 (1U << 4)
-#define ST25R3916_REG_RX_CONF3_rg1_pm1 (1U << 3)
-#define ST25R3916_REG_RX_CONF3_rg1_pm0 (1U << 2)
-#define ST25R3916_REG_RX_CONF3_rg1_pm_mask (0x7U << 2)
-#define ST25R3916_REG_RX_CONF3_rg1_pm_shift (2U)
-#define ST25R3916_REG_RX_CONF3_lf_en (1U << 1)
-#define ST25R3916_REG_RX_CONF3_lf_op (1U << 0)
-
-#define ST25R3916_REG_RX_CONF4_rg2_am3 (1U << 7)
-#define ST25R3916_REG_RX_CONF4_rg2_am2 (1U << 6)
-#define ST25R3916_REG_RX_CONF4_rg2_am1 (1U << 5)
-#define ST25R3916_REG_RX_CONF4_rg2_am0 (1U << 4)
-#define ST25R3916_REG_RX_CONF4_rg2_am_mask (0xfU << 4)
-#define ST25R3916_REG_RX_CONF4_rg2_am_shift (4U)
-#define ST25R3916_REG_RX_CONF4_rg2_pm3 (1U << 3)
-#define ST25R3916_REG_RX_CONF4_rg2_pm2 (1U << 2)
-#define ST25R3916_REG_RX_CONF4_rg2_pm1 (1U << 1)
-#define ST25R3916_REG_RX_CONF4_rg2_pm0 (1U << 0)
-#define ST25R3916_REG_RX_CONF4_rg2_pm_mask (0xfU << 0)
-#define ST25R3916_REG_RX_CONF4_rg2_pm_shift (0U)
-
-#define ST25R3916_REG_P2P_RX_CONF_ook_fd (1U << 7)
-#define ST25R3916_REG_P2P_RX_CONF_ook_rc1 (1U << 6)
-#define ST25R3916_REG_P2P_RX_CONF_ook_rc0 (1U << 5)
-#define ST25R3916_REG_P2P_RX_CONF_ook_thd1 (1U << 4)
-#define ST25R3916_REG_P2P_RX_CONF_ook_thd0 (1U << 3)
-#define ST25R3916_REG_P2P_RX_CONF_ask_rc1 (1U << 2)
-#define ST25R3916_REG_P2P_RX_CONF_ask_rc0 (1U << 1)
-#define ST25R3916_REG_P2P_RX_CONF_ask_thd (1U << 0)
-
-#define ST25R3916_REG_CORR_CONF1_corr_s7 (1U << 7)
-#define ST25R3916_REG_CORR_CONF1_corr_s6 (1U << 6)
-#define ST25R3916_REG_CORR_CONF1_corr_s5 (1U << 5)
-#define ST25R3916_REG_CORR_CONF1_corr_s4 (1U << 4)
-#define ST25R3916_REG_CORR_CONF1_corr_s3 (1U << 3)
-#define ST25R3916_REG_CORR_CONF1_corr_s2 (1U << 2)
-#define ST25R3916_REG_CORR_CONF1_corr_s1 (1U << 1)
-#define ST25R3916_REG_CORR_CONF1_corr_s0 (1U << 0)
-
-#define ST25R3916_REG_CORR_CONF2_rfu5 (1U << 7)
-#define ST25R3916_REG_CORR_CONF2_rfu4 (1U << 6)
-#define ST25R3916_REG_CORR_CONF2_rfu3 (1U << 5)
-#define ST25R3916_REG_CORR_CONF2_rfu2 (1U << 4)
-#define ST25R3916_REG_CORR_CONF2_rfu1 (1U << 3)
-#define ST25R3916_REG_CORR_CONF2_rfu0 (1U << 2)
-#define ST25R3916_REG_CORR_CONF2_corr_s9 (1U << 1)
-#define ST25R3916_REG_CORR_CONF2_corr_s8 (1U << 0)
-
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc2 (1U << 7)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc1 (1U << 6)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc0 (1U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_no_trigger (0U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_erx (1U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_srx (2U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_etx_nfc (3U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_mask (7U << 5)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_gptc_shift (5U)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_rfu (1U << 4)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step (1U << 3)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step_512 (1U << 3)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_mrt_step_64 (0U << 3)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc (1U << 2)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc_on (1U << 2)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_nfc_off (0U << 2)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv (1U << 1)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv_on (1U << 1)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv_off (0U << 1)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step (1U << 0)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step_64fc (0U << 0)
-#define ST25R3916_REG_TIMER_EMV_CONTROL_nrt_step_4096_fc (1U << 0)
-
-#define ST25R3916_REG_FIFO_STATUS2_fifo_b9 (1U << 7)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_b8 (1U << 6)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_b_mask (3U << 6)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_b_shift (6U)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_unf (1U << 5)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_ovr (1U << 4)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_lb2 (1U << 3)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_lb1 (1U << 2)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_lb0 (1U << 1)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_lb_mask (7U << 1)
-#define ST25R3916_REG_FIFO_STATUS2_fifo_lb_shift (1U)
-#define ST25R3916_REG_FIFO_STATUS2_np_lb (1U << 0)
-
-#define ST25R3916_REG_COLLISION_STATUS_c_byte3 (1U << 7)
-#define ST25R3916_REG_COLLISION_STATUS_c_byte2 (1U << 6)
-#define ST25R3916_REG_COLLISION_STATUS_c_byte1 (1U << 5)
-#define ST25R3916_REG_COLLISION_STATUS_c_byte0 (1U << 4)
-#define ST25R3916_REG_COLLISION_STATUS_c_byte_mask (0xfU << 4)
-#define ST25R3916_REG_COLLISION_STATUS_c_byte_shift (4U)
-#define ST25R3916_REG_COLLISION_STATUS_c_bit2 (1U << 3)
-#define ST25R3916_REG_COLLISION_STATUS_c_bit1 (1U << 2)
-#define ST25R3916_REG_COLLISION_STATUS_c_bit0 (1U << 1)
-#define ST25R3916_REG_COLLISION_STATUS_c_pb (1U << 0)
-#define ST25R3916_REG_COLLISION_STATUS_c_bit_mask (3U << 1)
-#define ST25R3916_REG_COLLISION_STATUS_c_bit_shift (1U)
-
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_rfu (1U << 7)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_rfu1 (1U << 6)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_rfu2 (1U << 5)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_rfu3 (1U << 4)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state3 (1U << 3)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state2 (1U << 2)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state1 (1U << 1)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state0 (1U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_power_off (0x0U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_idle (0x1U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_ready_l1 (0x2U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_ready_l2 (0x3U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_rfu4 (0x4U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_active (0x5U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_rfu6 (0x6U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_rfu7 (0x7U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_rfu8 (0x8U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_halt (0x9U << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_ready_l1_x (0xaU << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_ready_l2_x (0xbU << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_rfu12 (0xcU << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_st_active_x (0xdU << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state_mask (0xfU << 0)
-#define ST25R3916_REG_PASSIVE_TARGET_STATUS_pta_state_shift (0U)
-
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx4 (1U << 7)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx3 (1U << 6)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx2 (1U << 5)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx1 (1U << 4)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx0 (1U << 3)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx_mask (0x1fU << 3)
-#define ST25R3916_REG_NUM_TX_BYTES2_ntx_shift (3U)
-#define ST25R3916_REG_NUM_TX_BYTES2_nbtx2 (1U << 2)
-#define ST25R3916_REG_NUM_TX_BYTES2_nbtx1 (1U << 1)
-#define ST25R3916_REG_NUM_TX_BYTES2_nbtx0 (1U << 0)
-#define ST25R3916_REG_NUM_TX_BYTES2_nbtx_mask (7U << 0)
-#define ST25R3916_REG_NUM_TX_BYTES2_nbtx_shift (0U)
-
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rfu1 (1U << 7)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rfu0 (1U << 6)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate1 (1U << 5)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate0 (1U << 4)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate_mask (0x3U << 4)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nfc_rate_shift (4U)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_ppt2_on (1U << 3)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_gpt_on (1U << 2)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_nrt_on (1U << 1)
-#define ST25R3916_REG_NFCIP1_BIT_RATE_mrt_on (1U << 0)
-
-#define ST25R3916_REG_TX_DRIVER_am_mod3 (1U << 7)
-#define ST25R3916_REG_TX_DRIVER_am_mod2 (1U << 6)
-#define ST25R3916_REG_TX_DRIVER_am_mod1 (1U << 5)
-#define ST25R3916_REG_TX_DRIVER_am_mod0 (1U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_5percent (0x0U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_6percent (0x1U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_7percent (0x2U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_8percent (0x3U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_9percent (0x4U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_10percent (0x5U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_11percent (0x6U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_12percent (0x7U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_13percent (0x8U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_14percent (0x9U << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_15percent (0xaU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_17percent (0xbU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_19percent (0xcU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_22percent (0xdU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_26percent (0xeU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_40percent (0xfU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_mask (0xfU << 4)
-#define ST25R3916_REG_TX_DRIVER_am_mod_shift (4U)
-#define ST25R3916_REG_TX_DRIVER_d_res3 (1U << 3)
-#define ST25R3916_REG_TX_DRIVER_d_res2 (1U << 2)
-#define ST25R3916_REG_TX_DRIVER_d_res1 (1U << 1)
-#define ST25R3916_REG_TX_DRIVER_d_res0 (1U << 0)
-#define ST25R3916_REG_TX_DRIVER_d_res_mask (0xfU << 0)
-#define ST25R3916_REG_TX_DRIVER_d_res_shift (0U)
-
-#define ST25R3916_REG_PT_MOD_ptm_res3 (1U << 7)
-#define ST25R3916_REG_PT_MOD_ptm_res2 (1U << 6)
-#define ST25R3916_REG_PT_MOD_ptm_res1 (1U << 5)
-#define ST25R3916_REG_PT_MOD_ptm_res0 (1U << 4)
-#define ST25R3916_REG_PT_MOD_ptm_res_mask (0xfU << 4)
-#define ST25R3916_REG_PT_MOD_ptm_res_shift (4U)
-#define ST25R3916_REG_PT_MOD_pt_res3 (1U << 3)
-#define ST25R3916_REG_PT_MOD_pt_res2 (1U << 2)
-#define ST25R3916_REG_PT_MOD_pt_res1 (1U << 1)
-#define ST25R3916_REG_PT_MOD_pt_res0 (1U << 0)
-#define ST25R3916_REG_PT_MOD_pt_res_mask (0xfU << 0)
-#define ST25R3916_REG_PT_MOD_pt_res_shift (0U)
-
-#define ST25R3916_REG_AUX_MOD_dis_reg_am (1U << 7)
-#define ST25R3916_REG_AUX_MOD_lm_ext_pol (1U << 6)
-#define ST25R3916_REG_AUX_MOD_lm_ext (1U << 5)
-#define ST25R3916_REG_AUX_MOD_lm_dri (1U << 4)
-#define ST25R3916_REG_AUX_MOD_res_am (1U << 3)
-#define ST25R3916_REG_AUX_MOD_rfu2 (1U << 2)
-#define ST25R3916_REG_AUX_MOD_rfu1 (1U << 1)
-#define ST25R3916_REG_AUX_MOD_rfu0 (1U << 0)
-
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_t3 (1U << 7)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_t2 (1U << 6)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_t1 (1U << 5)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_t0 (1U << 4)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_mask (0xfU << 4)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_rat_shift (4U)
-#define ST25R3916_REG_TX_DRIVER_TIMING_rfu (1U << 3)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_tim_m2 (1U << 2)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_tim_m1 (1U << 1)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_tim_m0 (1U << 0)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_tim_m_mask (0x7U << 0)
-#define ST25R3916_REG_TX_DRIVER_TIMING_d_tim_m_shift (0U)
-
-#define ST25R3916_REG_RES_AM_MOD_fa3_f (1U << 7)
-#define ST25R3916_REG_RES_AM_MOD_md_res6 (1U << 6)
-#define ST25R3916_REG_RES_AM_MOD_md_res5 (1U << 5)
-#define ST25R3916_REG_RES_AM_MOD_md_res4 (1U << 4)
-#define ST25R3916_REG_RES_AM_MOD_md_res3 (1U << 3)
-#define ST25R3916_REG_RES_AM_MOD_md_res2 (1U << 2)
-#define ST25R3916_REG_RES_AM_MOD_md_res1 (1U << 1)
-#define ST25R3916_REG_RES_AM_MOD_md_res0 (1U << 0)
-#define ST25R3916_REG_RES_AM_MOD_md_res_mask (0x7FU << 0)
-#define ST25R3916_REG_RES_AM_MOD_md_res_shift (0U)
-
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_r3 (1U << 7)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_r2 (1U << 6)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_r1 (1U << 5)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_r0 (1U << 4)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_mask (0xfU << 4)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_rat_shift (4U)
-#define ST25R3916_REG_TX_DRIVER_STATUS_rfu (1U << 3)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_tim_r2 (1U << 2)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_tim_r1 (1U << 1)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_tim_r0 (1U << 0)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_tim_mask (0x7U << 0)
-#define ST25R3916_REG_TX_DRIVER_STATUS_d_tim_shift (0U)
-
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_l2a (1U << 6)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_l1a (1U << 5)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_l0a (1U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_75mV (0x0U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_105mV (0x1U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_150mV (0x2U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_205mV (0x3U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_290mV (0x4U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_400mV (0x5U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_560mV (0x6U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_800mV (0x7U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask (7U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_shift (4U)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_t3a (1U << 3)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_t2a (1U << 2)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_t1a (1U << 1)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_t0a (1U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_75mV (0x0U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_105mV (0x1U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_150mV (0x2U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_205mV (0x3U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_290mV (0x4U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_400mV (0x5U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_560mV (0x6U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_800mV (0x7U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_25mV (0x8U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_33mV (0x9U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_47mV (0xAU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_64mV (0xBU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_90mV (0xCU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_125mV (0xDU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_175mV (0xEU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_250mV (0xFU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask (0xfU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_shift (0U)
-
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_l2d (1U << 6)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_l1d (1U << 5)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_l0d (1U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_75mV (0x0U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_105mV (0x1U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_150mV (0x2U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_205mV (0x3U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_290mV (0x4U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_400mV (0x5U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_560mV (0x6U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_800mV (0x7U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_mask (7U << 4)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_shift (4U)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_t3d (1U << 3)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_t2d (1U << 2)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_t1d (1U << 1)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_t0d (1U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_75mV (0x0U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_105mV (0x1U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_150mV (0x2U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_205mV (0x3U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_290mV (0x4U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_400mV (0x5U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_560mV (0x6U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_800mV (0x7U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_25mV (0x8U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_33mV (0x9U << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_47mV (0xAU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_64mV (0xBU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_90mV (0xCU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_125mV (0xDU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_175mV (0xEU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_250mV (0xFU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_mask (0xfU << 0)
-#define ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_shift (0U)
-
-#define ST25R3916_REG_REGULATOR_CONTROL_reg_s (1U << 7)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_3 (1U << 6)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_2 (1U << 5)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_1 (1U << 4)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_0 (1U << 3)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_mask (0xfU << 3)
-#define ST25R3916_REG_REGULATOR_CONTROL_rege_shift (3U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv2 (2U << 2)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv1 (1U << 1)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv0 (1U << 0)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd (0U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_a (1U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_d (2U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_rf (3U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd_am (4U)
-#define ST25R3916_REG_REGULATOR_CONTROL_rfu (5U)
-#define ST25R3916_REG_REGULATOR_CONTROL_rfu1 (6U)
-#define ST25R3916_REG_REGULATOR_CONTROL_rfu2 (7U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_mask (7U)
-#define ST25R3916_REG_REGULATOR_CONTROL_mpsv_shift (0U)
-
-#define ST25R3916_REG_REGULATOR_RESULT_reg_3 (1U << 7)
-#define ST25R3916_REG_REGULATOR_RESULT_reg_2 (1U << 6)
-#define ST25R3916_REG_REGULATOR_RESULT_reg_1 (1U << 5)
-#define ST25R3916_REG_REGULATOR_RESULT_reg_0 (1U << 4)
-#define ST25R3916_REG_REGULATOR_RESULT_reg_mask (0xfU << 4)
-#define ST25R3916_REG_REGULATOR_RESULT_reg_shift (4U)
-#define ST25R3916_REG_REGULATOR_RESULT_i_lim (1U << 0)
-
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_3 (1U << 7)
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_2 (1U << 6)
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_1 (1U << 5)
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_0 (1U << 4)
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_mask (0xfU << 4)
-#define ST25R3916_REG_RSSI_RESULT_rssi_am_shift (4U)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm3 (1U << 3)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm2 (1U << 2)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm1 (1U << 1)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm0 (1U << 0)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm_mask (0xfU << 0)
-#define ST25R3916_REG_RSSI_RESULT_rssi_pm_shift (0U)
-
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_3 (1U << 7)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_2 (1U << 6)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_1 (1U << 5)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_0 (1U << 4)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_mask (0xfU << 4)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_am_shift (4U)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_3 (1U << 3)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_2 (1U << 2)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_1 (1U << 1)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_0 (1U << 0)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_mask (0xfU << 0)
-#define ST25R3916_REG_GAIN_RED_STATE_gs_pm_shift (0U)
-
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal4 (1U << 7)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal3 (1U << 6)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal2 (1U << 5)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal1 (1U << 4)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal0 (1U << 3)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal_mask (0x1fU << 3)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_mcal_shift (3U)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_g2 (1U << 2)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_g1 (1U << 1)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_g0 (1U << 0)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_g_mask (7U << 0)
-#define ST25R3916_REG_CAP_SENSOR_CONTROL_cs_g_shift (0U)
-
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal4 (1U << 7)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal3 (1U << 6)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal2 (1U << 5)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal1 (1U << 4)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal0 (1U << 3)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_mask (0x1fU << 3)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_shift (3U)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_end (1U << 2)
-#define ST25R3916_REG_CAP_SENSOR_RESULT_cs_cal_err (1U << 1)
-
-#define ST25R3916_REG_AUX_DISPLAY_a_cha (1U << 7)
-#define ST25R3916_REG_AUX_DISPLAY_efd_o (1U << 6)
-#define ST25R3916_REG_AUX_DISPLAY_tx_on (1U << 5)
-#define ST25R3916_REG_AUX_DISPLAY_osc_ok (1U << 4)
-#define ST25R3916_REG_AUX_DISPLAY_rx_on (1U << 3)
-#define ST25R3916_REG_AUX_DISPLAY_rx_act (1U << 2)
-#define ST25R3916_REG_AUX_DISPLAY_en_peer (1U << 1)
-#define ST25R3916_REG_AUX_DISPLAY_en_ac (1U << 0)
-
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_tx_mode1 (1U << 7)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_tx_mode0 (1U << 6)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern13 (1U << 5)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern12 (1U << 4)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern11 (1U << 3)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern10 (1U << 2)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern9 (1U << 1)
-#define ST25R3916_REG_OVERSHOOT_CONF1_ov_pattern8 (1U << 0)
-
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern7 (1U << 7)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern6 (1U << 6)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern5 (1U << 5)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern4 (1U << 4)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern3 (1U << 3)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern2 (1U << 2)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern1 (1U << 1)
-#define ST25R3916_REG_OVERSHOOT_CONF2_ov_pattern0 (1U << 0)
-
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_tx_mode1 (1U << 7)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_tx_mode0 (1U << 6)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern13 (1U << 5)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern12 (1U << 4)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern11 (1U << 3)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern10 (1U << 2)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern9 (1U << 1)
-#define ST25R3916_REG_UNDERSHOOT_CONF1_un_pattern8 (1U << 0)
-
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern7 (1U << 7)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern6 (1U << 6)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern5 (1U << 5)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern4 (1U << 4)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern3 (1U << 3)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern2 (1U << 2)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern1 (1U << 1)
-#define ST25R3916_REG_UNDERSHOOT_CONF2_un_pattern0 (1U << 0)
-
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wur (1U << 7)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wut2 (1U << 6)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wut1 (1U << 5)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wut0 (1U << 4)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wut_mask (7U << 4)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wut_shift (4U)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wto (1U << 3)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wam (1U << 2)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wph (1U << 1)
-#define ST25R3916_REG_WUP_TIMER_CONTROL_wcap (1U << 0)
-
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d3 (1U << 7)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d2 (1U << 6)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d1 (1U << 5)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d0 (1U << 4)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d_mask (0xfU << 4)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_d_shift (4U)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aam (1U << 3)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew1 (1U << 2)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew0 (1U << 1)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew_mask (0x3U << 1)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_aew_shift (1U)
-#define ST25R3916_REG_AMPLITUDE_MEASURE_CONF_am_ae (1U << 0)
-
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d3 (1U << 7)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d2 (1U << 6)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d1 (1U << 5)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d0 (1U << 4)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d_mask (0xfU << 4)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_d_shift (4U)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_aam (1U << 3)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew1 (1U << 2)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew0 (1U << 1)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew_mask (0x3U << 1)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_aew_shift (1U)
-#define ST25R3916_REG_PHASE_MEASURE_CONF_pm_ae (1U << 0)
-
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d3 (1U << 7)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d2 (1U << 6)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d1 (1U << 5)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d0 (1U << 4)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d_mask (0xfU << 4)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_d_shift (4U)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aam (1U << 3)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew1 (1U << 2)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew0 (1U << 1)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew_mask (0x3U << 1)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_aew_shift (1U)
-#define ST25R3916_REG_CAPACITANCE_MEASURE_CONF_cm_ae (1U << 0)
-
-#define ST25R3916_REG_IC_IDENTITY_ic_type4 (1U << 7)
-#define ST25R3916_REG_IC_IDENTITY_ic_type3 (1U << 6)
-#define ST25R3916_REG_IC_IDENTITY_ic_type2 (1U << 5)
-#define ST25R3916_REG_IC_IDENTITY_ic_type1 (1U << 4)
-#define ST25R3916_REG_IC_IDENTITY_ic_type0 (1U << 3)
-#define ST25R3916_REG_IC_IDENTITY_ic_type_st25r3916 (5U << 3)
-#define ST25R3916_REG_IC_IDENTITY_ic_type_mask (0x1fU << 3)
-#define ST25R3916_REG_IC_IDENTITY_ic_type_shift (3U)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev2 (1U << 2)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev1 (1U << 1)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev0 (1U << 0)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev_v0 (0U << 0)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev_mask (7U << 0)
-#define ST25R3916_REG_IC_IDENTITY_ic_rev_shift (0U)
-
-/*! \endcond DOXYGEN_SUPRESS */
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- *  \brief  Returns the content of a register within the ST25R3916
- *
- *  This function is used to read out the content of ST25R3916 registers.
- *
- *  \param[in]  reg: Address of register to read.
- *  \param[out] val: Returned value.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ReadRegister(uint8_t reg, uint8_t* val);
-
-/*! 
- *****************************************************************************
- *  \brief  Reads from multiple ST25R3916 registers
- *
- *  This function is used to read from multiple registers using the
- *  auto-increment feature. That is, after each read the address pointer
- *  inside the ST25R3916 gets incremented automatically.
- *
- *  \param[in]  reg: Address of the first register to read from.
- *  \param[in]  values: pointer to a buffer where the result shall be written to.
- *  \param[in]  length: Number of registers to be read out.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ReadMultipleRegisters(uint8_t reg, uint8_t* values, uint8_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes a given value to a register within the ST25R3916
- *
- *  This function is used to write \a val to address \a reg within the ST25R3916.
- *
- *  \param[in]  reg: Address of the register to write.
- *  \param[in]  val: Value to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WriteRegister(uint8_t reg, uint8_t val);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes multiple values to ST25R3916 registers
- *
- *  This function is used to write multiple values to the ST25R3916 using the
- *  auto-increment feature. That is, after each write the address pointer
- *  inside the ST25R3916 gets incremented automatically.
- *
- *  \param[in]  reg: Address of the first register to write.
- *  \param[in]  values: pointer to a buffer containing the values to be written.
- *  \param[in]  length: Number of values to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WriteMultipleRegisters(uint8_t reg, const uint8_t* values, uint8_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes values to ST25R3916 FIFO
- *
- *  This function needs to be called in order to write to the ST25R3916 FIFO.
- *
- *  \param[in]  values: pointer to a buffer containing the values to be written
- *                      to the FIFO.
- *  \param[in]  length: Number of values to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WriteFifo(const uint8_t* values, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Read values from ST25R3916 FIFO
- *
- *  This function needs to be called in order to read from ST25R3916 FIFO.
- *
- *  \param[out]  buf: pointer to a buffer where the FIFO content shall be
- *                       written to.
- *  \param[in]  length: Number of bytes to read.
- *  
- *  \note: This function doesn't check whether \a length is really the
- *  number of available bytes in FIFO
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ReadFifo(uint8_t* buf, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes values to ST25R3916 PTM
- *
- *  Accesses to the begging of ST25R3916 Passive Target Memory (PTM A Config)
- *  and writes the given values 
- *
- *  \param[in]  values: pointer to a buffer containing the values to be written
- *                      to the Passive Target Memory.
- *  \param[in]  length: Number of values to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WritePTMem(const uint8_t* values, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Reads the ST25R3916 PTM
- *
- *  Accesses to the begging of ST25R3916 Passive Target Memory (PTM A Config)
- *  and reads the memory for the given length 
- *
- *  \param[out] values: pointer to a buffer where the PTM content shall be
- *                       written to.
- *  \param[in]  length: Number of bytes to read.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ReadPTMem(uint8_t* values, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes values to ST25R3916 PTM F config
- *
- *  Accesses ST25R3916 Passive Target Memory F config and writes the given values 
- *
- *  \param[in]  values: pointer to a buffer containing the values to be written
- *                      to the Passive Target Memory 
- *  \param[in]  length: Number of values to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WritePTMemF(const uint8_t* values, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes values to ST25R3916 PTM TSN Data
- *
- *  Accesses ST25R3916 Passive Target Memory TSN data and writes the given values 
- *
- *  \param[in]  values: pointer to a buffer containing the values to be written
- *                      to the Passive Target Memory.
- *  \param[in]  length: Number of values to be written.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WritePTMemTSN(const uint8_t* values, uint16_t length);
-
-/*! 
- *****************************************************************************
- *  \brief  Execute a direct command
- *
- *  This function is used to start so-called direct command. These commands
- *  are implemented inside the chip and each command has unique code (see
- *  datasheet).
- *
- *  \param[in]  cmd : code of the direct command to be executed.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ExecuteCommand(uint8_t cmd);
-
-/*! 
- *****************************************************************************
- *  \brief  Read a test register within the ST25R3916
- *
- *  This function is used to read the content of test address \a reg within the ST25R3916
- *
- *  \param[in]   reg: Address of the register to read
- *  \param[out]  val: Returned read value
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ReadTestRegister(uint8_t reg, uint8_t* val);
-
-/*! 
- *****************************************************************************
- *  \brief  Writes a given value to a test register within the ST25R3916
- *
- *  This function is used to write \a val to test address \a reg within the ST25R3916
- *
- *  \param[in]  reg: Address of the register to write
- *  \param[in]  val: Value to be written
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916WriteTestRegister(uint8_t reg, uint8_t val);
-
-/*! 
- *****************************************************************************
- *  \brief  Cleart bits on Register
- *
- *  This function clears the given bitmask on the register 
- *
- *  \param[in]  reg: Address of the register clear
- *  \param[in]  clr_mask: Bitmask of bit to be cleared
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ClrRegisterBits(uint8_t reg, uint8_t clr_mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Set bits on Register
- *
- *  This function sets the given bitmask on the register 
- *
- *  \param[in]  reg: Address of the register clear
- *  \param[in]  set_mask: Bitmask of bit to be cleared
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916SetRegisterBits(uint8_t reg, uint8_t set_mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Changes the given bits on a ST25R3916 register
- *
- *  This function is used if only a particular bits should be changed within
- *  an ST25R3916 register.
- *
- *  \param[in]  reg: Address of the register to change.
- *  \param[in]  valueMask: bitmask of bits to be changed
- *  \param[in]  value: the bits to be written on the enabled valueMask bits
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ChangeRegisterBits(uint8_t reg, uint8_t valueMask, uint8_t value);
-
-/*! 
- *****************************************************************************
- *  \brief  Modifies a value within a ST25R3916 register
- *
- *  This function is used if only a particular bits should be changed within
- *  an ST25R3916 register.
- *
- *  \param[in]  reg: Address of the register to write.
- *  \param[in]  clr_mask: bitmask of bits to be cleared to 0.
- *  \param[in]  set_mask: bitmask of bits to be set to 1.
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ModifyRegister(uint8_t reg, uint8_t clr_mask, uint8_t set_mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Changes the given bits on a ST25R3916 Test register
- *
- *  This function is used if only a particular bits should be changed within
- *  an ST25R3916 register.
- *
- *  \param[in]  reg: Address of the Test register to change.
- *  \param[in]  valueMask: bitmask of bits to be changed
- *  \param[in]  value: the bits to be written on the enabled valueMask bits
- *
- *  \return ERR_NONE  : Operation successful
- *  \return ERR_PARAM : Invalid parameter
- *  \return ERR_SEND  : Transmission error or acknowledge not received
- *****************************************************************************
- */
-ReturnCode st25r3916ChangeTestRegisterBits(uint8_t reg, uint8_t valueMask, uint8_t value);
-
-/*! 
- *****************************************************************************
- *  \brief  Checks if register contains a expected value
- *
- *  This function checks if the given reg contains a value that once masked
- *  equals the expected value
- *
- *  \param reg  : the register to check the value
- *  \param mask : the mask apply on register value
- *  \param val  : expected value to be compared to
- *    
- *  \return  true when reg contains the expected value | false otherwise
- */
-bool st25r3916CheckReg(uint8_t reg, uint8_t mask, uint8_t val);
-
-/*! 
- *****************************************************************************
- *  \brief  Check if register ID is valid
- *
- *  Checks if the given register ID a valid ST25R3916 register
- *
- *  \param[in]  reg: Address of register to check
- *  
- *  \return  true if is a valid register ID
- *  \return  false otherwise
- *
- *****************************************************************************
- */
-bool st25r3916IsRegValid(uint8_t reg);
-
-#endif /* ST25R3916_COM_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  * 
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_irq.c

@@ -1,231 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 Interrupt handling
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "st25r3916_irq.h"
-#include "st25r3916_com.h"
-#include "st25r3916_led.h"
-#include "st25r3916.h"
-#include "../../utils.h"
-
-/*
- ******************************************************************************
- * LOCAL DATA TYPES
- ******************************************************************************
- */
-
-/*! Holds current and previous interrupt callback pointer as well as current Interrupt status and mask */
-typedef struct {
-    void (*prevCallback)(void); /*!< call back function for ST25R3916 interrupt          */
-    void (*callback)(void); /*!< call back function for ST25R3916 interrupt          */
-    uint32_t status; /*!< latest interrupt status                             */
-    uint32_t mask; /*!< Interrupt mask. Negative mask = ST25R3916 mask regs */
-} st25r3916Interrupt;
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-/*! Length of the interrupt registers       */
-#define ST25R3916_INT_REGS_LEN ((ST25R3916_REG_IRQ_TARGET - ST25R3916_REG_IRQ_MAIN) + 1U)
-
-/*
-******************************************************************************
-* GLOBAL VARIABLES
-******************************************************************************
-*/
-
-static volatile st25r3916Interrupt st25r3916interrupt; /*!< Instance of ST25R3916 interrupt */
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-void st25r3916InitInterrupts(void) {
-    platformIrqST25RPinInitialize();
-    platformIrqST25RSetCallback(st25r3916Isr);
-
-    st25r3916interrupt.callback = NULL;
-    st25r3916interrupt.prevCallback = NULL;
-    st25r3916interrupt.status = ST25R3916_IRQ_MASK_NONE;
-    st25r3916interrupt.mask = ST25R3916_IRQ_MASK_NONE;
-}
-
-/*******************************************************************************/
-void st25r3916Isr(void) {
-    st25r3916CheckForReceivedInterrupts();
-
-    // Check if callback is set and run it
-    if(NULL != st25r3916interrupt.callback) {
-        st25r3916interrupt.callback();
-    }
-}
-
-/*******************************************************************************/
-void st25r3916CheckForReceivedInterrupts(void) {
-    uint8_t iregs[ST25R3916_INT_REGS_LEN];
-    uint32_t irqStatus;
-
-    /* Initialize iregs */
-    irqStatus = ST25R3916_IRQ_MASK_NONE;
-    ST_MEMSET(iregs, (int32_t)(ST25R3916_IRQ_MASK_ALL & 0xFFU), ST25R3916_INT_REGS_LEN);
-
-    /* In case the IRQ is Edge (not Level) triggered read IRQs until done */
-    while(platformGpioIsHigh(ST25R_INT_PORT, ST25R_INT_PIN)) {
-        st25r3916ReadMultipleRegisters(ST25R3916_REG_IRQ_MAIN, iregs, ST25R3916_INT_REGS_LEN);
-
-        irqStatus |= (uint32_t)iregs[0];
-        irqStatus |= (uint32_t)iregs[1] << 8;
-        irqStatus |= (uint32_t)iregs[2] << 16;
-        irqStatus |= (uint32_t)iregs[3] << 24;
-    }
-
-    /* Forward all interrupts, even masked ones to application */
-    platformProtectST25RIrqStatus();
-    st25r3916interrupt.status |= irqStatus;
-    platformUnprotectST25RIrqStatus();
-
-    /* Send an IRQ event to LED handling */
-    st25r3916ledEvtIrq(st25r3916interrupt.status);
-}
-
-/*******************************************************************************/
-void st25r3916ModifyInterrupts(uint32_t clr_mask, uint32_t set_mask) {
-    uint8_t i;
-    uint32_t old_mask;
-    uint32_t new_mask;
-
-    old_mask = st25r3916interrupt.mask;
-    new_mask = ((~old_mask & set_mask) | (old_mask & clr_mask));
-    st25r3916interrupt.mask &= ~clr_mask;
-    st25r3916interrupt.mask |= set_mask;
-
-    for(i = 0; i < ST25R3916_INT_REGS_LEN; i++) {
-        if(((new_mask >> (8U * i)) & 0xFFU) == 0U) {
-            continue;
-        }
-
-        st25r3916WriteRegister(
-            ST25R3916_REG_IRQ_MASK_MAIN + i,
-            (uint8_t)((st25r3916interrupt.mask >> (8U * i)) & 0xFFU));
-    }
-    return;
-}
-
-/*******************************************************************************/
-uint32_t st25r3916WaitForInterruptsTimed(uint32_t mask, uint16_t tmo) {
-    uint32_t tmrDelay;
-    uint32_t status;
-
-    tmrDelay = platformTimerCreate(tmo);
-
-    /* Run until specific interrupt has happen or the timer has expired */
-    do {
-        status = (st25r3916interrupt.status & mask);
-    } while((!platformTimerIsExpired(tmrDelay) || (tmo == 0U)) && (status == 0U));
-
-    platformTimerDestroy(tmrDelay);
-
-    status = st25r3916interrupt.status & mask;
-
-    platformProtectST25RIrqStatus();
-    st25r3916interrupt.status &= ~status;
-    platformUnprotectST25RIrqStatus();
-
-    return status;
-}
-
-/*******************************************************************************/
-uint32_t st25r3916GetInterrupt(uint32_t mask) {
-    uint32_t irqs;
-
-    irqs = (st25r3916interrupt.status & mask);
-    if(irqs != ST25R3916_IRQ_MASK_NONE) {
-        platformProtectST25RIrqStatus();
-        st25r3916interrupt.status &= ~irqs;
-        platformUnprotectST25RIrqStatus();
-    }
-
-    return irqs;
-}
-
-/*******************************************************************************/
-void st25r3916ClearAndEnableInterrupts(uint32_t mask) {
-    st25r3916GetInterrupt(mask);
-    st25r3916EnableInterrupts(mask);
-}
-
-/*******************************************************************************/
-void st25r3916EnableInterrupts(uint32_t mask) {
-    st25r3916ModifyInterrupts(mask, 0);
-}
-
-/*******************************************************************************/
-void st25r3916DisableInterrupts(uint32_t mask) {
-    st25r3916ModifyInterrupts(0, mask);
-}
-
-/*******************************************************************************/
-void st25r3916ClearInterrupts(void) {
-    uint8_t iregs[ST25R3916_INT_REGS_LEN];
-
-    st25r3916ReadMultipleRegisters(ST25R3916_REG_IRQ_MAIN, iregs, ST25R3916_INT_REGS_LEN);
-
-    platformProtectST25RIrqStatus();
-    st25r3916interrupt.status = ST25R3916_IRQ_MASK_NONE;
-    platformUnprotectST25RIrqStatus();
-    return;
-}
-
-/*******************************************************************************/
-void st25r3916IRQCallbackSet(void (*cb)(void)) {
-    st25r3916interrupt.prevCallback = st25r3916interrupt.callback;
-    st25r3916interrupt.callback = cb;
-}
-
-/*******************************************************************************/
-void st25r3916IRQCallbackRestore(void) {
-    st25r3916interrupt.callback = st25r3916interrupt.prevCallback;
-    st25r3916interrupt.prevCallback = NULL;
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_irq.h

@@ -1,296 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 Interrupt handling
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup ST25R3916
- * \brief RFAL ST25R3916 Driver
- * @{
- * 
- * \addtogroup ST25R3916_IRQ
- * \brief RFAL ST25R3916 IRQ
- * @{
- * 
- */
-
-#ifndef ST25R3916_IRQ_H
-#define ST25R3916_IRQ_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "../../platform.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-#define ST25R3916_IRQ_MASK_ALL \
-    (uint32_t)(0xFFFFFFFFUL) /*!< All ST25R3916 interrupt sources                             */
-#define ST25R3916_IRQ_MASK_NONE \
-    (uint32_t)(0x00000000UL) /*!< No ST25R3916 interrupt source                               */
-
-/* Main interrupt register */
-#define ST25R3916_IRQ_MASK_OSC \
-    (uint32_t)(0x00000080U) /*!< ST25R3916 oscillator stable interrupt                       */
-#define ST25R3916_IRQ_MASK_FWL \
-    (uint32_t)(0x00000040U) /*!< ST25R3916 FIFO water level interrupt                        */
-#define ST25R3916_IRQ_MASK_RXS \
-    (uint32_t)(0x00000020U) /*!< ST25R3916 start of receive interrupt                        */
-#define ST25R3916_IRQ_MASK_RXE \
-    (uint32_t)(0x00000010U) /*!< ST25R3916 end of receive interrupt                          */
-#define ST25R3916_IRQ_MASK_TXE \
-    (uint32_t)(0x00000008U) /*!< ST25R3916 end of transmission interrupt                     */
-#define ST25R3916_IRQ_MASK_COL \
-    (uint32_t)(0x00000004U) /*!< ST25R3916 bit collision interrupt                           */
-#define ST25R3916_IRQ_MASK_RX_REST \
-    (uint32_t)(0x00000002U) /*!< ST25R3916 automatic reception restart interrupt             */
-#define ST25R3916_IRQ_MASK_RFU \
-    (uint32_t)(0x00000001U) /*!< ST25R3916 RFU interrupt                                     */
-
-/* Timer and NFC interrupt register */
-#define ST25R3916_IRQ_MASK_DCT \
-    (uint32_t)(0x00008000U) /*!< ST25R3916 termination of direct command interrupt.          */
-#define ST25R3916_IRQ_MASK_NRE \
-    (uint32_t)(0x00004000U) /*!< ST25R3916 no-response timer expired interrupt               */
-#define ST25R3916_IRQ_MASK_GPE \
-    (uint32_t)(0x00002000U) /*!< ST25R3916 general purpose timer expired interrupt           */
-#define ST25R3916_IRQ_MASK_EON \
-    (uint32_t)(0x00001000U) /*!< ST25R3916 external field on interrupt                       */
-#define ST25R3916_IRQ_MASK_EOF \
-    (uint32_t)(0x00000800U) /*!< ST25R3916 external field off interrupt                      */
-#define ST25R3916_IRQ_MASK_CAC \
-    (uint32_t)(0x00000400U) /*!< ST25R3916 collision during RF collision avoidance interrupt */
-#define ST25R3916_IRQ_MASK_CAT \
-    (uint32_t)(0x00000200U) /*!< ST25R3916 minimum guard time expired interrupt              */
-#define ST25R3916_IRQ_MASK_NFCT \
-    (uint32_t)(0x00000100U) /*!< ST25R3916 initiator bit rate recognised interrupt           */
-
-/* Error and wake-up interrupt register */
-#define ST25R3916_IRQ_MASK_CRC \
-    (uint32_t)(0x00800000U) /*!< ST25R3916 CRC error interrupt                               */
-#define ST25R3916_IRQ_MASK_PAR \
-    (uint32_t)(0x00400000U) /*!< ST25R3916 parity error interrupt                            */
-#define ST25R3916_IRQ_MASK_ERR2 \
-    (uint32_t)(0x00200000U) /*!< ST25R3916 soft framing error interrupt                      */
-#define ST25R3916_IRQ_MASK_ERR1 \
-    (uint32_t)(0x00100000U) /*!< ST25R3916 hard framing error interrupt                      */
-#define ST25R3916_IRQ_MASK_WT \
-    (uint32_t)(0x00080000U) /*!< ST25R3916 wake-up interrupt                                 */
-#define ST25R3916_IRQ_MASK_WAM \
-    (uint32_t)(0x00040000U) /*!< ST25R3916 wake-up due to amplitude interrupt                */
-#define ST25R3916_IRQ_MASK_WPH \
-    (uint32_t)(0x00020000U) /*!< ST25R3916 wake-up due to phase interrupt                    */
-#define ST25R3916_IRQ_MASK_WCAP \
-    (uint32_t)(0x00010000U) /*!< ST25R3916 wake-up due to capacitance measurement            */
-
-/* Passive Target Interrupt Register */
-#define ST25R3916_IRQ_MASK_PPON2 \
-    (uint32_t)(0x80000000U) /*!< ST25R3916 PPON2 Field on waiting Timer interrupt            */
-#define ST25R3916_IRQ_MASK_SL_WL \
-    (uint32_t)(0x40000000U) /*!< ST25R3916 Passive target slot number water level interrupt  */
-#define ST25R3916_IRQ_MASK_APON \
-    (uint32_t)(0x20000000U) /*!< ST25R3916 Anticollision done and Field On interrupt         */
-#define ST25R3916_IRQ_MASK_RXE_PTA \
-    (uint32_t)(0x10000000U) /*!< ST25R3916 RXE with an automatic response interrupt          */
-#define ST25R3916_IRQ_MASK_WU_F \
-    (uint32_t)(0x08000000U) /*!< ST25R3916 212/424b/s Passive target interrupt: Active       */
-#define ST25R3916_IRQ_MASK_RFU2 \
-    (uint32_t)(0x04000000U) /*!< ST25R3916 RFU2 interrupt                                    */
-#define ST25R3916_IRQ_MASK_WU_A_X \
-    (uint32_t)(0x02000000U) /*!< ST25R3916 106kb/s Passive target state interrupt: Active*   */
-#define ST25R3916_IRQ_MASK_WU_A \
-    (uint32_t)(0x01000000U) /*!< ST25R3916 106kb/s Passive target state interrupt: Active    */
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- *  \brief  Wait until an ST25R3916 interrupt occurs
- *
- *  This function is used to access the ST25R3916 interrupt flags. Use this
- *  to wait for max. \a tmo milliseconds for the \b first interrupt indicated
- *  with mask \a mask to occur.
- *
- *  \param[in] mask : mask indicating the interrupts to wait for.
- *  \param[in] tmo : time in milliseconds until timeout occurs. If set to 0
- *                   the functions waits forever.
- *
- *  \return : 0 if timeout occurred otherwise a mask indicating the cleared
- *              interrupts.
- *
- *****************************************************************************
- */
-uint32_t st25r3916WaitForInterruptsTimed(uint32_t mask, uint16_t tmo);
-
-/*! 
- *****************************************************************************
- *  \brief  Get status for the given interrupt
- *
- *  This function is used to check whether the interrupt given by \a mask
- *  has occurred. If yes the interrupt gets cleared. This function returns
- *  only status bits which are inside \a mask.
- *
- *  \param[in] mask : mask indicating the interrupt to check for.
- *
- *  \return the mask of the interrupts occurred
- *
- *****************************************************************************
- */
-uint32_t st25r3916GetInterrupt(uint32_t mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Init the 3916 interrupt
- *
- *  This function is used to check whether the interrupt given by \a mask
- *  has occurred. 
- *
- *****************************************************************************
- */
-void st25r3916InitInterrupts(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Modifies the Interrupt
- *
- *  This function modifies the interrupt
- *  
- *  \param[in] clr_mask : bit mask to be cleared on the interrupt mask 
- *  \param[in] set_mask : bit mask to be set on the interrupt mask 
- *****************************************************************************
- */
-void st25r3916ModifyInterrupts(uint32_t clr_mask, uint32_t set_mask);
-
-/*! 
- *****************************************************************************
- *  \brief Checks received interrupts
- *
- *  Checks received interrupts and saves the result into global params
- *****************************************************************************
- */
-void st25r3916CheckForReceivedInterrupts(void);
-
-/*! 
- *****************************************************************************
- *  \brief  ISR Service routine
- *
- *  This function modiefies the interrupt
- *****************************************************************************
- */
-void st25r3916Isr(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Enable a given ST25R3916 Interrupt source
- *
- *  This function enables all interrupts given by \a mask, 
- *  ST25R3916_IRQ_MASK_ALL enables all interrupts.
- *
- *  \param[in] mask: mask indicating the interrupts to be enabled
- *
- *****************************************************************************
- */
-void st25r3916EnableInterrupts(uint32_t mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Disable one or more a given ST25R3916 Interrupt sources
- *
- *  This function disables all interrupts given by \a mask. 0xff disables all.
- *
- *  \param[in] mask: mask indicating the interrupts to be disabled.
- *
- *****************************************************************************
- */
-void st25r3916DisableInterrupts(uint32_t mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Clear all ST25R3916 irq flags
- *
- *****************************************************************************
- */
-void st25r3916ClearInterrupts(void);
-
-/*! 
- *****************************************************************************
- *  \brief  Clears and then enables the given ST25R3916 Interrupt sources
- *
- *  \param[in] mask: mask indicating the interrupts to be cleared and enabled
- *****************************************************************************
- */
-void st25r3916ClearAndEnableInterrupts(uint32_t mask);
-
-/*! 
- *****************************************************************************
- *  \brief  Sets IRQ callback for the ST25R3916 interrupt
- *
- *****************************************************************************
- */
-void st25r3916IRQCallbackSet(void (*cb)(void));
-
-/*! 
- *****************************************************************************
- *  \brief  Sets IRQ callback for the ST25R3916 interrupt
- *
- *****************************************************************************
- */
-void st25r3916IRQCallbackRestore(void);
-
-#endif /* ST25R3916_IRQ_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  * 
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_led.c

@@ -1,148 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 LEDs handling
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "st25r3916_led.h"
-#include "st25r3916_irq.h"
-#include "st25r3916_com.h"
-#include "st25r3916.h"
-
-/*
-******************************************************************************
-* MACROS
-******************************************************************************
-*/
-
-#ifdef PLATFORM_LED_RX_PIN
-#define st25r3916ledRxOn()    \
-    platformLedOn(            \
-        PLATFORM_LED_RX_PORT, \
-        PLATFORM_LED_RX_PIN); /*!< LED Rx Pin On from system HAL            */
-#define st25r3916ledRxOff()   \
-    platformLedOff(           \
-        PLATFORM_LED_RX_PORT, \
-        PLATFORM_LED_RX_PIN); /*!< LED Rx Pin Off from system HAL           */
-#else /* PLATFORM_LED_RX_PIN */
-#define st25r3916ledRxOn()
-#define st25r3916ledRxOff()
-#endif /* PLATFORM_LED_RX_PIN */
-
-#ifdef PLATFORM_LED_FIELD_PIN
-#define st25r3916ledFieldOn()    \
-    platformLedOn(               \
-        PLATFORM_LED_FIELD_PORT, \
-        PLATFORM_LED_FIELD_PIN); /*!< LED Field Pin On from system HAL            */
-#define st25r3916ledFieldOff()   \
-    platformLedOff(              \
-        PLATFORM_LED_FIELD_PORT, \
-        PLATFORM_LED_FIELD_PIN); /*!< LED Field Pin Off from system HAL           */
-#else /* PLATFORM_LED_FIELD_PIN */
-#define st25r3916ledFieldOn()
-#define st25r3916ledFieldOff()
-#endif /* PLATFORM_LED_FIELD_PIN */
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-void st25r3916ledInit(void) {
-    /* Initialize LEDs if existing and defined */
-    platformLedsInitialize();
-
-    st25r3916ledRxOff();
-    st25r3916ledFieldOff();
-}
-
-/*******************************************************************************/
-void st25r3916ledEvtIrq(uint32_t irqs) {
-    if((irqs & (ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_CAT)) != 0U) {
-        st25r3916ledFieldOn();
-    }
-
-    if((irqs & (ST25R3916_IRQ_MASK_RXS | ST25R3916_IRQ_MASK_NFCT)) != 0U) {
-        st25r3916ledRxOn();
-    }
-
-    if((irqs & (ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_NRE | ST25R3916_IRQ_MASK_RX_REST |
-                ST25R3916_IRQ_MASK_RXE_PTA | ST25R3916_IRQ_MASK_WU_A | ST25R3916_IRQ_MASK_WU_A_X |
-                ST25R3916_IRQ_MASK_WU_F | ST25R3916_IRQ_MASK_RFU2)) != 0U) {
-        st25r3916ledRxOff();
-    }
-}
-
-/*******************************************************************************/
-void st25r3916ledEvtWrReg(uint8_t reg, uint8_t val) {
-    if(reg == ST25R3916_REG_OP_CONTROL) {
-        if((ST25R3916_REG_OP_CONTROL_tx_en & val) != 0U) {
-            st25r3916ledFieldOn();
-        } else {
-            st25r3916ledFieldOff();
-        }
-    }
-}
-
-/*******************************************************************************/
-void st25r3916ledEvtWrMultiReg(uint8_t reg, const uint8_t* vals, uint8_t len) {
-    uint8_t i;
-
-    for(i = 0; i < (len); i++) {
-        st25r3916ledEvtWrReg((reg + i), vals[i]);
-    }
-}
-
-/*******************************************************************************/
-void st25r3916ledEvtCmd(uint8_t cmd) {
-    if((cmd >= ST25R3916_CMD_TRANSMIT_WITH_CRC) &&
-       (cmd <= ST25R3916_CMD_RESPONSE_RF_COLLISION_N)) {
-        st25r3916ledFieldOff();
-    }
-
-    if(cmd == ST25R3916_CMD_UNMASK_RECEIVE_DATA) {
-        st25r3916ledRxOff();
-    }
-
-    if(cmd == ST25R3916_CMD_SET_DEFAULT) {
-        st25r3916ledFieldOff();
-        st25r3916ledRxOff();
-    }
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/source/st25r3916/st25r3916_led.h

@@ -1,151 +0,0 @@
-
-/******************************************************************************
-  * \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:   ST25R3916 firmware
- *      Revision: 
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Gustavo Patricio
- *
- *  \brief ST25R3916 LEDs handling
- *
- *
- * \addtogroup RFAL
- * @{
- *
- * \addtogroup RFAL-HAL
- * \brief RFAL Hardware Abstraction Layer
- * @{
- *
- * \addtogroup ST25R3916
- * \brief RFAL ST25R3916 Driver
- * @{
- * 
- * \addtogroup ST25R3916_LED
- * \brief RFAL ST25R3916 LED
- * @{
- * 
- */
-
-#ifndef ST25R3916_LED_H
-#define ST25R3916_LED_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include "../../platform.h"
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- *  \brief  ST25R3916 LED Initialize
- *
- *  This function initializes the LEDs that represent ST25R3916 activity 
- *
- *****************************************************************************
- */
-void st25r3916ledInit(void);
-
-/*! 
- *****************************************************************************
- *  \brief   ST25R3916 LED Event Interrupt
- *
- *  This function should be called upon a ST25R3916 Interrupt, providing 
- *  the interrupt event with ST25R3916 irq flags to update LEDs 
- *
- *  \param[in] irqs: ST25R3916 irqs mask
- *
- *****************************************************************************
- */
-void st25r3916ledEvtIrq(uint32_t irqs);
-
-/*! 
- *****************************************************************************
- *  \brief   ST25R3916 LED Event Write Register
- *
- *  This function should be called on a ST25R3916 Write Register operation
- *  providing the event with the register and value to update LEDs 
- *
- *  \param[in] reg: ST25R3916 register to be written
- *  \param[in] val: value to be written on the register
- *
- *****************************************************************************
- */
-void st25r3916ledEvtWrReg(uint8_t reg, uint8_t val);
-
-/*! 
- *****************************************************************************
- *  \brief   ST25R3916 LED Event Write Multiple Register
- *
- *  This function should be called upon a ST25R3916 Write Multiple Registers, 
- *  providing the event with the registers and values to update LEDs 
- *
- *  \param[in] reg : ST25R3916 first register written
- *  \param[in] vals: pointer to the values written
- *  \param[in] len : number of registers written
- *
- *****************************************************************************
- */
-void st25r3916ledEvtWrMultiReg(uint8_t reg, const uint8_t* vals, uint8_t len);
-
-/*! 
- *****************************************************************************
- *  \brief   ST25R3916 LED Event Direct Command
- *
- *  This function should be called upon a ST25R3916 direct command, providing 
- *  the event with the command executed
- *
- *  \param[in] cmd: ST25R3916 cmd executed
- *
- *****************************************************************************
- */
-void st25r3916ledEvtCmd(uint8_t cmd);
-
-#endif /* ST25R3916_LED_H */
-
-/**
-  * @}
-  *
-  * @}
-  *
-  * @}
-  * 
-  * @}
-  */

esubghz_chat/lib/nfclegacy/ST25RFAL002/st_errno.h

@@ -1,158 +0,0 @@
-
-/******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2018 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:
-  *
-  *        http://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:   STxxxx firmware
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file st_errno.h
- *
- *  \author 
- *
- *  \brief Main error codes
- *
- */
-
-#ifndef ST_ERRNO_H
-#define ST_ERRNO_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-
-#include <stdint.h>
-
-/*
-******************************************************************************
-* GLOBAL DATA TYPES
-******************************************************************************
-*/
-
-typedef uint16_t ReturnCode; /*!< Standard Return Code type from function. */
-
-/*
-******************************************************************************
-* DEFINES
-******************************************************************************
-*/
-
-/*
- * Error codes to be used within the application.
- * They are represented by an uint8_t
- */
-enum {
-    ERR_NONE = 0, /*!< no error occurred */
-    ERR_NOMEM = 1, /*!< not enough memory to perform the requested operation */
-    ERR_BUSY = 2, /*!< device or resource busy */
-    ERR_IO = 3, /*!< generic IO error */
-    ERR_TIMEOUT = 4, /*!< error due to timeout */
-    ERR_REQUEST = 5, /*!< invalid request or requested function can't be executed at the moment */
-    ERR_NOMSG = 6, /*!< No message of desired type */
-    ERR_PARAM = 7, /*!< Parameter error */
-    ERR_SYSTEM = 8, /*!< System error */
-    ERR_FRAMING = 9, /*!< Framing error */
-    ERR_OVERRUN = 10, /*!< lost one or more received bytes */
-    ERR_PROTO = 11, /*!< protocol error */
-    ERR_INTERNAL = 12, /*!< Internal Error */
-    ERR_AGAIN = 13, /*!< Call again */
-    ERR_MEM_CORRUPT = 14, /*!< memory corruption */
-    ERR_NOT_IMPLEMENTED = 15, /*!< not implemented */
-    ERR_PC_CORRUPT =
-        16, /*!< Program Counter has been manipulated or spike/noise trigger illegal operation */
-    ERR_SEND = 17, /*!< error sending*/
-    ERR_IGNORE = 18, /*!< indicates error detected but to be ignored */
-    ERR_SEMANTIC = 19, /*!< indicates error in state machine (unexpected cmd) */
-    ERR_SYNTAX = 20, /*!< indicates error in state machine (unknown cmd) */
-    ERR_CRC = 21, /*!< crc error */
-    ERR_NOTFOUND = 22, /*!< transponder not found */
-    ERR_NOTUNIQUE = 23, /*!< transponder not unique - more than one transponder in field */
-    ERR_NOTSUPP = 24, /*!< requested operation not supported */
-    ERR_WRITE = 25, /*!< write error */
-    ERR_FIFO = 26, /*!< fifo over or underflow error */
-    ERR_PAR = 27, /*!< parity error */
-    ERR_DONE = 28, /*!< transfer has already finished */
-    ERR_RF_COLLISION =
-        29, /*!< collision error (Bit Collision or during RF Collision avoidance ) */
-    ERR_HW_OVERRUN = 30, /*!< lost one or more received bytes */
-    ERR_RELEASE_REQ = 31, /*!< device requested release */
-    ERR_SLEEP_REQ = 32, /*!< device requested sleep */
-    ERR_WRONG_STATE = 33, /*!< incorrent state for requested operation */
-    ERR_MAX_RERUNS = 34, /*!< blocking procedure reached maximum runs */
-    ERR_DISABLED = 35, /*!< operation aborted due to disabled configuration */
-    ERR_HW_MISMATCH = 36, /*!< expected hw do not match  */
-    ERR_LINK_LOSS =
-        37, /*!< Other device's field didn't behave as expected: turned off by Initiator in Passive mode, or AP2P did not turn on field */
-    ERR_INVALID_HANDLE = 38, /*!< invalid or not initalized device handle */
-
-    ERR_INCOMPLETE_BYTE = 40, /*!< Incomplete byte rcvd         */
-    ERR_INCOMPLETE_BYTE_01 = 41, /*!< Incomplete byte rcvd - 1 bit */
-    ERR_INCOMPLETE_BYTE_02 = 42, /*!< Incomplete byte rcvd - 2 bit */
-    ERR_INCOMPLETE_BYTE_03 = 43, /*!< Incomplete byte rcvd - 3 bit */
-    ERR_INCOMPLETE_BYTE_04 = 44, /*!< Incomplete byte rcvd - 4 bit */
-    ERR_INCOMPLETE_BYTE_05 = 45, /*!< Incomplete byte rcvd - 5 bit */
-    ERR_INCOMPLETE_BYTE_06 = 46, /*!< Incomplete byte rcvd - 6 bit */
-    ERR_INCOMPLETE_BYTE_07 = 47, /*!< Incomplete byte rcvd - 7 bit */
-};
-
-/* General Sub-category number */
-#define ERR_GENERIC_GRP (0x0000) /*!< Reserved value for generic error no */
-#define ERR_WARN_GRP (0x0100) /*!< Errors which are not expected in normal operation */
-#define ERR_PROCESS_GRP (0x0200) /*!< Processes management errors */
-#define ERR_SIO_GRP (0x0800) /*!< SIO errors due to logging */
-#define ERR_RINGBUF_GRP (0x0900) /*!< Ring Buffer errors */
-#define ERR_MQ_GRP (0x0A00) /*!< MQ errors */
-#define ERR_TIMER_GRP (0x0B00) /*!< Timer errors */
-#define ERR_RFAL_GRP (0x0C00) /*!< RFAL errors */
-#define ERR_UART_GRP (0x0D00) /*!< UART errors */
-#define ERR_SPI_GRP (0x0E00) /*!< SPI errors */
-#define ERR_I2C_GRP (0x0F00) /*!< I2c errors */
-
-#define ERR_INSERT_SIO_GRP(x) (ERR_SIO_GRP | x) /*!< Insert the SIO grp */
-#define ERR_INSERT_RINGBUF_GRP(x) (ERR_RINGBUF_GRP | x) /*!< Insert the Ring Buffer grp */
-#define ERR_INSERT_RFAL_GRP(x) (ERR_RFAL_GRP | x) /*!< Insert the RFAL grp */
-#define ERR_INSERT_SPI_GRP(x) (ERR_SPI_GRP | x) /*!< Insert the spi grp */
-#define ERR_INSERT_I2C_GRP(x) (ERR_I2C_GRP | x) /*!< Insert the i2c grp */
-#define ERR_INSERT_UART_GRP(x) (ERR_UART_GRP | x) /*!< Insert the uart grp */
-#define ERR_INSERT_TIMER_GRP(x) (ERR_TIMER_GRP | x) /*!< Insert the timer grp */
-#define ERR_INSERT_MQ_GRP(x) (ERR_MQ_GRP | x) /*!< Insert the mq grp */
-#define ERR_INSERT_PROCESS_GRP(x) (ERR_PROCESS_GRP | x) /*!< Insert the process grp */
-#define ERR_INSERT_WARN_GRP(x) (ERR_WARN_GRP | x) /*!< Insert the i2c grp */
-#define ERR_INSERT_GENERIC_GRP(x) (ERR_GENERIC_GRP | x) /*!< Insert the generic grp */
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-
-#define ERR_NO_MASK(x) (x & 0x00FF) /*!< Mask the error number */
-
-/*! Common code to exit a function with the error if function f return error */
-#define EXIT_ON_ERR(r, f)     \
-    if(ERR_NONE != (r = f)) { \
-        return r;             \
-    }
-
-#endif /* ST_ERRNO_H */

esubghz_chat/lib/nfclegacy/ST25RFAL002/timer.c

@@ -1,105 +0,0 @@
-/******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2016 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:
-  *
-  *        http://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:  ANSI C
- */
-
-/*! \file timer.c
- *
- *  \brief SW Timer implementation
- *
- *  \author Gustavo Patricio
- *
- *   This module makes use of a System Tick in millisconds and provides
- *   an abstraction for SW timers
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include "timer.h"
-#include <furi.h>
-
-/*
-******************************************************************************
-* LOCAL DEFINES
-******************************************************************************
-*/
-
-/*
-******************************************************************************
-* LOCAL VARIABLES
-******************************************************************************
-*/
-
-static uint32_t timerStopwatchTick;
-
-/*
-******************************************************************************
-* GLOBAL FUNCTIONS
-******************************************************************************
-*/
-
-/*******************************************************************************/
-uint32_t timerCalculateTimer(uint16_t time) {
-    return (furi_get_tick() + time);
-}
-
-/*******************************************************************************/
-bool timerIsExpired(uint32_t timer) {
-    uint32_t uDiff;
-    int32_t sDiff;
-
-    uDiff = (timer - furi_get_tick()); /* Calculate the diff between the timers */
-    sDiff = uDiff; /* Convert the diff to a signed var      */
-
-    /* Check if the given timer has expired already */
-    if(sDiff < 0) {
-        return true;
-    }
-
-    return false;
-}
-
-/*******************************************************************************/
-void timerDelay(uint16_t tOut) {
-    uint32_t t;
-
-    /* Calculate the timer and wait blocking until is running */
-    t = timerCalculateTimer(tOut);
-    while(timerIsRunning(t))
-        ;
-}
-
-/*******************************************************************************/
-void timerStopwatchStart(void) {
-    timerStopwatchTick = furi_get_tick();
-}
-
-/*******************************************************************************/
-uint32_t timerStopwatchMeasure(void) {
-    return (uint32_t)(furi_get_tick() - timerStopwatchTick);
-}

esubghz_chat/lib/nfclegacy/ST25RFAL002/timer.h

@@ -1,125 +0,0 @@
-#pragma once
-/******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2016 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:
-  *
-  *        http://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:  ANSI C
- */
-
-/*! \file timer.h
- *
- *  \brief SW Timer implementation header file
- *   
- *   This module makes use of a System Tick in millisconds and provides
- *   an abstraction for SW timers
- *
- */
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include <stdint.h>
-#include <stdbool.h>
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-#define timerIsRunning(t) (!timerIsExpired(t))
-
-/*
-******************************************************************************
-* GLOBAL DEFINES
-******************************************************************************
-*/
-
-/*! 
- *****************************************************************************
- * \brief  Calculate Timer
- *  
- * This method calculates when the timer will be expired given the amount
- * time in milliseconds /a tOut.
- * Once the timer has been calculated it will then be used to check when
- * it expires.
- * 
- * \see timersIsExpired
- *
- * \param[in]  time : time/duration in Milliseconds for the timer
- *
- * \return u32 : The new timer calculated based on the given time 
- *****************************************************************************
- */
-uint32_t timerCalculateTimer(uint16_t time);
-
-/*! 
- *****************************************************************************
- * \brief  Checks if a Timer is Expired
- *  
- * This method checks if a timer has already expired.
- * Based on the given timer previously calculated it checks if this timer
- * has already elapsed
- * 
- * \see timersCalculateTimer
- *
- * \param[in]  timer : the timer to check 
- *
- * \return true  : timer has already expired
- * \return false : timer is still running
- *****************************************************************************
- */
-bool timerIsExpired(uint32_t timer);
-
-/*! 
- *****************************************************************************
- * \brief  Performs a Delay
- *  
- * This method performs a delay for the given amount of time in Milliseconds
- * 
- * \param[in]  time : time/duration in Milliseconds of the delay
- *
- *****************************************************************************
- */
-void timerDelay(uint16_t time);
-
-/*! 
- *****************************************************************************
- * \brief  Stopwatch start
- *  
- * This method initiates the stopwatch to later measure the time in ms
- * 
- *****************************************************************************
- */
-void timerStopwatchStart(void);
-
-/*! 
- *****************************************************************************
- * \brief  Stopwatch Measure
- *  
- * This method returns the elapsed time in ms since the stopwatch was initiated
- * 
- * \return The time in ms since the stopwatch was started
- *****************************************************************************
- */
-uint32_t timerStopwatchMeasure(void);

esubghz_chat/lib/nfclegacy/ST25RFAL002/utils.h

@@ -1,100 +0,0 @@
-
-/******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2018 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:
-  *
-  *        http://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
- *      $Revision: $
- *      LANGUAGE:  ISO C99
- */
-
-/*! \file
- *
- *  \author Ulrich Herrmann
- *
- *  \brief Common and helpful macros
- *
- */
-
-#ifndef UTILS_H
-#define UTILS_H
-
-/*
-******************************************************************************
-* INCLUDES
-******************************************************************************
-*/
-#include <string.h>
-#include <stdint.h>
-
-/*
-******************************************************************************
-* GLOBAL MACROS
-******************************************************************************
-*/
-/*! 
- * this macro evaluates an error variable \a ERR against an error code \a EC.
- * in case it is not equal it jumps to the given label \a LABEL.
- */
-#define EVAL_ERR_NE_GOTO(EC, ERR, LABEL) \
-    if(EC != ERR) goto LABEL;
-
-/*! 
- * this macro evaluates an error variable \a ERR against an error code \a EC.
- * in case it is equal it jumps to the given label \a LABEL.
- */
-#define EVAL_ERR_EQ_GOTO(EC, ERR, LABEL) \
-    if(EC == ERR) goto LABEL;
-#define BITMASK_1 (0x01) /*!< Bit mask for lsb bit                   */
-#define BITMASK_2 (0x03) /*!< Bit mask for two lsb bits              */
-#define BITMASK_3 (0x07) /*!< Bit mask for three lsb bits            */
-#define BITMASK_4 (0x0F) /*!< Bit mask for four lsb bits             */
-#define U16TOU8(a) ((a)&0x00FF) /*!< Cast 16-bit unsigned to 8-bit unsigned */
-#define GETU16(a) \
-    (uint16_t)(   \
-        (a[0] << 8) | a[1]) /*!< Cast two Big Endian 8-bits byte array to 16-bits unsigned */
-
-#define REVERSE_BYTES(pData, nDataSize)                           \
-    unsigned char swap, *lo = pData, *hi = pData + nDataSize - 1; \
-    while(lo < hi) {                                              \
-        swap = *lo;                                               \
-        *lo++ = *hi;                                              \
-        *hi-- = swap;                                             \
-    }
-
-#define ST_MEMMOVE memmove /*!< map memmove to string library code */
-#define ST_MEMCPY memcpy /*!< map memcpy to string library code  */
-#define ST_MEMSET memset /*!< map memset to string library code  */
-#define ST_BYTECMP memcmp /*!< map bytecmp to string library code */
-
-#define NO_WARNING(v) ((void)(v)) /*!< Macro to suppress compiler warning */
-
-#ifndef NULL
-#define NULL (void*)0 /*!< represents a NULL pointer */
-#endif /* !NULL */
-
-/*
-******************************************************************************
-* GLOBAL FUNCTION PROTOTYPES
-******************************************************************************
-*/
-
-#endif /* UTILS_H */

esubghz_chat/lib/nfclegacy/digital_signal/digital_signal.c

@@ -1,666 +0,0 @@
-#include "digital_signal.h"
-
-#include <furi.h>
-#include <furi_hal.h>
-#include <furi_hal_resources.h>
-#include <math.h>
-
-#include <stm32wbxx_ll_dma.h>
-#include <stm32wbxx_ll_tim.h>
-
-/* must be on bank B */
-// For debugging purposes use `--extra-define=DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN=gpio_ext_pb3` fbt option
-
-struct ReloadBuffer {
-    uint32_t* buffer; /* DMA ringbuffer */
-    uint32_t size; /* maximum entry count of the ring buffer */
-    uint32_t write_pos; /* current buffer write index */
-    uint32_t read_pos; /* current buffer read index */
-    bool dma_active;
-};
-
-struct DigitalSequence {
-    uint8_t signals_size;
-    bool bake;
-    uint32_t sequence_used;
-    uint32_t sequence_size;
-    DigitalSignal** signals;
-    uint8_t* sequence;
-    const GpioPin* gpio;
-    uint32_t send_time;
-    bool send_time_active;
-    LL_DMA_InitTypeDef dma_config_gpio;
-    LL_DMA_InitTypeDef dma_config_timer;
-    uint32_t* gpio_buff;
-    struct ReloadBuffer* dma_buffer;
-};
-
-struct DigitalSignalInternals {
-    uint64_t factor;
-    uint32_t reload_reg_entries;
-    uint32_t reload_reg_remainder;
-    uint32_t gpio_buff[2];
-    const GpioPin* gpio;
-    LL_DMA_InitTypeDef dma_config_gpio;
-    LL_DMA_InitTypeDef dma_config_timer;
-};
-
-#define TAG "DigitalSignal"
-
-#define F_TIM (64000000.0)
-#define T_TIM 1562 /* 15.625 ns *100 */
-#define T_TIM_DIV2 781 /* 15.625 ns / 2 *100 */
-
-/* end marker in DMA ringbuffer, will get written into timer register at the end */
-#define SEQ_TIMER_MAX 0xFFFFFFFF
-
-/* time to wait in loops before returning */
-#define SEQ_LOCK_WAIT_MS 10UL
-#define SEQ_LOCK_WAIT_TICKS (SEQ_LOCK_WAIT_MS * 1000 * 64)
-
-/* maximum entry count of the sequence dma ring buffer */
-#define RINGBUFFER_SIZE 128
-
-/* maximum number of DigitalSignals in a sequence */
-#define SEQUENCE_SIGNALS_SIZE 32
-/*
- * if sequence size runs out from the initial value passed to digital_sequence_alloc
- * the size will be increased by this amount and reallocated
- */
-#define SEQUENCE_SIZE_REALLOCATE_INCREMENT 256
-
-DigitalSignal* digital_signal_alloc(uint32_t max_edges_cnt) {
-    DigitalSignal* signal = malloc(sizeof(DigitalSignal));
-    signal->start_level = true;
-    signal->edges_max_cnt = max_edges_cnt;
-    signal->edge_timings = malloc(signal->edges_max_cnt * sizeof(uint32_t));
-    signal->edge_cnt = 0;
-    signal->reload_reg_buff = malloc(signal->edges_max_cnt * sizeof(uint32_t));
-
-    signal->internals = malloc(sizeof(DigitalSignalInternals));
-    DigitalSignalInternals* internals = signal->internals;
-
-    internals->factor = 1024 * 1024;
-
-    internals->dma_config_gpio.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
-    internals->dma_config_gpio.Mode = LL_DMA_MODE_CIRCULAR;
-    internals->dma_config_gpio.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    internals->dma_config_gpio.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    internals->dma_config_gpio.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    internals->dma_config_gpio.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    internals->dma_config_gpio.NbData = 2;
-    internals->dma_config_gpio.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
-    internals->dma_config_gpio.Priority = LL_DMA_PRIORITY_VERYHIGH;
-
-    internals->dma_config_timer.PeriphOrM2MSrcAddress = (uint32_t) & (TIM2->ARR);
-    internals->dma_config_timer.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
-    internals->dma_config_timer.Mode = LL_DMA_MODE_NORMAL;
-    internals->dma_config_timer.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    internals->dma_config_timer.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    internals->dma_config_timer.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    internals->dma_config_timer.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    internals->dma_config_timer.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
-    internals->dma_config_timer.Priority = LL_DMA_PRIORITY_HIGH;
-
-    return signal;
-}
-
-void digital_signal_free(DigitalSignal* signal) {
-    furi_assert(signal);
-
-    free(signal->edge_timings);
-    free(signal->reload_reg_buff);
-    free(signal->internals);
-    free(signal);
-}
-
-bool digital_signal_append(DigitalSignal* signal_a, DigitalSignal* signal_b) {
-    furi_assert(signal_a);
-    furi_assert(signal_b);
-
-    if(signal_a->edges_max_cnt < signal_a->edge_cnt + signal_b->edge_cnt) {
-        return false;
-    }
-    /* in case there are no edges in our target signal, the signal to append makes the rules */
-    if(!signal_a->edge_cnt) {
-        signal_a->start_level = signal_b->start_level;
-    }
-    bool end_level = signal_a->start_level;
-    if(signal_a->edge_cnt) {
-        end_level = signal_a->start_level ^ !(signal_a->edge_cnt % 2);
-    }
-    uint8_t start_copy = 0;
-    if(end_level == signal_b->start_level) {
-        if(signal_a->edge_cnt) {
-            signal_a->edge_timings[signal_a->edge_cnt - 1] += signal_b->edge_timings[0];
-            start_copy += 1;
-        } else {
-            signal_a->edge_timings[signal_a->edge_cnt] += signal_b->edge_timings[0];
-        }
-    }
-
-    for(size_t i = 0; i < signal_b->edge_cnt - start_copy; i++) {
-        signal_a->edge_timings[signal_a->edge_cnt + i] = signal_b->edge_timings[start_copy + i];
-    }
-    signal_a->edge_cnt += signal_b->edge_cnt - start_copy;
-
-    return true;
-}
-
-bool digital_signal_get_start_level(DigitalSignal* signal) {
-    furi_assert(signal);
-
-    return signal->start_level;
-}
-
-uint32_t digital_signal_get_edges_cnt(DigitalSignal* signal) {
-    furi_assert(signal);
-
-    return signal->edge_cnt;
-}
-
-void digital_signal_add(DigitalSignal* signal, uint32_t ticks) {
-    furi_assert(signal);
-    furi_assert(signal->edge_cnt < signal->edges_max_cnt);
-
-    signal->edge_timings[signal->edge_cnt++] = ticks;
-}
-
-void digital_signal_add_pulse(DigitalSignal* signal, uint32_t ticks, bool level) {
-    furi_assert(signal);
-    furi_assert(signal->edge_cnt < signal->edges_max_cnt);
-
-    /* virgin signal? add it as the only level */
-    if(signal->edge_cnt == 0) {
-        signal->start_level = level;
-        signal->edge_timings[signal->edge_cnt++] = ticks;
-    } else {
-        bool end_level = signal->start_level ^ !(signal->edge_cnt % 2);
-
-        if(level != end_level) {
-            signal->edge_timings[signal->edge_cnt++] = ticks;
-        } else {
-            signal->edge_timings[signal->edge_cnt - 1] += ticks;
-        }
-    }
-}
-
-uint32_t digital_signal_get_edge(DigitalSignal* signal, uint32_t edge_num) {
-    furi_assert(signal);
-    furi_assert(edge_num < signal->edge_cnt);
-
-    return signal->edge_timings[edge_num];
-}
-
-void digital_signal_prepare_arr(DigitalSignal* signal) {
-    furi_assert(signal);
-
-    DigitalSignalInternals* internals = signal->internals;
-
-    /* set up signal polarities */
-    if(internals->gpio) {
-        uint32_t bit_set = internals->gpio->pin;
-        uint32_t bit_reset = internals->gpio->pin << 16;
-
-#ifdef DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN
-        bit_set |= DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN.pin;
-        bit_reset |= DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN.pin << 16;
-#endif
-
-        if(signal->start_level) {
-            internals->gpio_buff[0] = bit_set;
-            internals->gpio_buff[1] = bit_reset;
-        } else {
-            internals->gpio_buff[0] = bit_reset;
-            internals->gpio_buff[1] = bit_set;
-        }
-    }
-
-    /* set up edge timings */
-    internals->reload_reg_entries = 0;
-
-    for(size_t pos = 0; pos < signal->edge_cnt; pos++) {
-        uint32_t pulse_duration = signal->edge_timings[pos] + internals->reload_reg_remainder;
-        if(pulse_duration < 10 || pulse_duration > 10000000) {
-            FURI_LOG_D(
-                TAG,
-                "[prepare] pulse_duration out of range: %lu = %lu * %llu",
-                pulse_duration,
-                signal->edge_timings[pos],
-                internals->factor);
-            pulse_duration = 100;
-        }
-        uint32_t pulse_ticks = (pulse_duration + T_TIM_DIV2) / T_TIM;
-        internals->reload_reg_remainder = pulse_duration - (pulse_ticks * T_TIM);
-
-        if(pulse_ticks > 1) {
-            signal->reload_reg_buff[internals->reload_reg_entries++] = pulse_ticks - 1;
-        }
-    }
-}
-
-static void digital_signal_stop_dma() {
-    LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_1);
-    LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_2);
-    LL_DMA_ClearFlag_TC1(DMA1);
-    LL_DMA_ClearFlag_TC2(DMA1);
-}
-
-static void digital_signal_stop_timer() {
-    LL_TIM_DisableCounter(TIM2);
-    LL_TIM_DisableUpdateEvent(TIM2);
-    LL_TIM_DisableDMAReq_UPDATE(TIM2);
-
-    furi_hal_bus_disable(FuriHalBusTIM2);
-}
-
-static void digital_signal_setup_timer() {
-    furi_hal_bus_enable(FuriHalBusTIM2);
-
-    LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);
-    LL_TIM_SetClockDivision(TIM2, LL_TIM_CLOCKDIVISION_DIV1);
-    LL_TIM_SetPrescaler(TIM2, 0);
-    LL_TIM_SetAutoReload(TIM2, SEQ_TIMER_MAX);
-    LL_TIM_SetCounter(TIM2, 0);
-}
-
-static void digital_signal_start_timer() {
-    LL_TIM_EnableCounter(TIM2);
-    LL_TIM_EnableUpdateEvent(TIM2);
-    LL_TIM_EnableDMAReq_UPDATE(TIM2);
-    LL_TIM_GenerateEvent_UPDATE(TIM2);
-}
-
-static bool digital_signal_setup_dma(DigitalSignal* signal) {
-    furi_assert(signal);
-    DigitalSignalInternals* internals = signal->internals;
-
-    if(!signal->internals->reload_reg_entries) {
-        return false;
-    }
-    digital_signal_stop_dma();
-
-    internals->dma_config_gpio.MemoryOrM2MDstAddress = (uint32_t)internals->gpio_buff;
-    internals->dma_config_gpio.PeriphOrM2MSrcAddress = (uint32_t) & (internals->gpio->port->BSRR);
-    internals->dma_config_timer.MemoryOrM2MDstAddress = (uint32_t)signal->reload_reg_buff;
-    internals->dma_config_timer.NbData = signal->internals->reload_reg_entries;
-
-    /* set up DMA channel 1 and 2 for GPIO and timer copy operations */
-    LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &internals->dma_config_gpio);
-    LL_DMA_Init(DMA1, LL_DMA_CHANNEL_2, &internals->dma_config_timer);
-
-    /* enable both DMA channels */
-    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
-    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
-
-    return true;
-}
-
-void digital_signal_send(DigitalSignal* signal, const GpioPin* gpio) {
-    furi_assert(signal);
-
-    if(!signal->edge_cnt) {
-        return;
-    }
-
-    /* Configure gpio as output */
-    signal->internals->gpio = gpio;
-    furi_hal_gpio_init(
-        signal->internals->gpio, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-
-    digital_signal_prepare_arr(signal);
-
-    digital_signal_setup_dma(signal);
-    digital_signal_setup_timer();
-    digital_signal_start_timer();
-
-    while(!LL_DMA_IsActiveFlag_TC2(DMA1)) {
-    }
-
-    digital_signal_stop_timer();
-    digital_signal_stop_dma();
-}
-
-static void digital_sequence_alloc_signals(DigitalSequence* sequence, uint32_t size) {
-    sequence->signals_size = size;
-    sequence->signals = malloc(sequence->signals_size * sizeof(DigitalSignal*));
-}
-
-static void digital_sequence_alloc_sequence(DigitalSequence* sequence, uint32_t size) {
-    sequence->sequence_used = 0;
-    sequence->sequence_size = size;
-    sequence->sequence = malloc(sequence->sequence_size);
-    sequence->send_time = 0;
-    sequence->send_time_active = false;
-}
-
-DigitalSequence* digital_sequence_alloc(uint32_t size, const GpioPin* gpio) {
-    furi_assert(gpio);
-
-    DigitalSequence* sequence = malloc(sizeof(DigitalSequence));
-
-    sequence->gpio = gpio;
-    sequence->bake = false;
-
-    sequence->dma_buffer = malloc(sizeof(struct ReloadBuffer));
-    sequence->dma_buffer->size = RINGBUFFER_SIZE;
-    sequence->dma_buffer->buffer = malloc(sequence->dma_buffer->size * sizeof(uint32_t));
-
-    sequence->dma_config_gpio.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
-    sequence->dma_config_gpio.Mode = LL_DMA_MODE_CIRCULAR;
-    sequence->dma_config_gpio.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    sequence->dma_config_gpio.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    sequence->dma_config_gpio.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    sequence->dma_config_gpio.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    sequence->dma_config_gpio.NbData = 2;
-    sequence->dma_config_gpio.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
-    sequence->dma_config_gpio.Priority = LL_DMA_PRIORITY_VERYHIGH;
-
-    sequence->dma_config_timer.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
-    sequence->dma_config_timer.Mode = LL_DMA_MODE_CIRCULAR;
-    sequence->dma_config_timer.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    sequence->dma_config_timer.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    sequence->dma_config_timer.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    sequence->dma_config_timer.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    sequence->dma_config_timer.PeriphOrM2MSrcAddress = (uint32_t) & (TIM2->ARR);
-    sequence->dma_config_timer.MemoryOrM2MDstAddress = (uint32_t)sequence->dma_buffer->buffer;
-    sequence->dma_config_timer.NbData = sequence->dma_buffer->size;
-    sequence->dma_config_timer.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
-    sequence->dma_config_timer.Priority = LL_DMA_PRIORITY_HIGH;
-
-    digital_sequence_alloc_signals(sequence, SEQUENCE_SIGNALS_SIZE);
-    digital_sequence_alloc_sequence(sequence, size);
-
-    return sequence;
-}
-
-void digital_sequence_free(DigitalSequence* sequence) {
-    furi_assert(sequence);
-
-    free(sequence->signals);
-    free(sequence->sequence);
-    free(sequence->dma_buffer->buffer);
-    free(sequence->dma_buffer);
-    free(sequence);
-}
-
-void digital_sequence_set_signal(
-    DigitalSequence* sequence,
-    uint8_t signal_index,
-    DigitalSignal* signal) {
-    furi_assert(sequence);
-    furi_assert(signal);
-    furi_assert(signal_index < sequence->signals_size);
-
-    sequence->signals[signal_index] = signal;
-    signal->internals->gpio = sequence->gpio;
-    signal->internals->reload_reg_remainder = 0;
-
-    digital_signal_prepare_arr(signal);
-}
-
-void digital_sequence_set_sendtime(DigitalSequence* sequence, uint32_t send_time) {
-    furi_assert(sequence);
-
-    sequence->send_time = send_time;
-    sequence->send_time_active = true;
-}
-
-void digital_sequence_add(DigitalSequence* sequence, uint8_t signal_index) {
-    furi_assert(sequence);
-    furi_assert(signal_index < sequence->signals_size);
-
-    if(sequence->sequence_used >= sequence->sequence_size) {
-        sequence->sequence_size += SEQUENCE_SIZE_REALLOCATE_INCREMENT;
-        sequence->sequence = realloc(sequence->sequence, sequence->sequence_size); //-V701
-        furi_assert(sequence->sequence);
-    }
-
-    sequence->sequence[sequence->sequence_used++] = signal_index;
-}
-
-static bool digital_sequence_setup_dma(DigitalSequence* sequence) {
-    furi_assert(sequence);
-
-    digital_signal_stop_dma();
-
-    sequence->dma_config_gpio.MemoryOrM2MDstAddress = (uint32_t)sequence->gpio_buff;
-    sequence->dma_config_gpio.PeriphOrM2MSrcAddress = (uint32_t) & (sequence->gpio->port->BSRR);
-
-    /* set up DMA channel 1 and 2 for GPIO and timer copy operations */
-    LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &sequence->dma_config_gpio);
-    LL_DMA_Init(DMA1, LL_DMA_CHANNEL_2, &sequence->dma_config_timer);
-
-    /* enable both DMA channels */
-    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
-    LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
-
-    return true;
-}
-
-static DigitalSignal* digital_sequence_bake(DigitalSequence* sequence) {
-    furi_assert(sequence);
-
-    uint32_t edges = 0;
-
-    for(uint32_t pos = 0; pos < sequence->sequence_used; pos++) {
-        uint8_t signal_index = sequence->sequence[pos];
-        DigitalSignal* sig = sequence->signals[signal_index];
-
-        edges += sig->edge_cnt;
-    }
-
-    DigitalSignal* ret = digital_signal_alloc(edges);
-
-    for(uint32_t pos = 0; pos < sequence->sequence_used; pos++) {
-        uint8_t signal_index = sequence->sequence[pos];
-        DigitalSignal* sig = sequence->signals[signal_index];
-
-        digital_signal_append(ret, sig);
-    }
-
-    return ret;
-}
-
-static void digital_sequence_finish(DigitalSequence* sequence) {
-    struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
-
-    if(dma_buffer->dma_active) {
-        uint32_t prev_timer = DWT->CYCCNT;
-        do {
-            /* we are finished, when the DMA transferred the SEQ_TIMER_MAX marker */
-            if(TIM2->ARR == SEQ_TIMER_MAX) {
-                break;
-            }
-            if(DWT->CYCCNT - prev_timer > SEQ_LOCK_WAIT_TICKS) {
-                dma_buffer->read_pos =
-                    RINGBUFFER_SIZE - LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2);
-                FURI_LOG_D(
-                    TAG,
-                    "[SEQ] hung %lu ms in finish (ARR 0x%08lx, read %lu, write %lu)",
-                    SEQ_LOCK_WAIT_MS,
-                    TIM2->ARR,
-                    dma_buffer->read_pos,
-                    dma_buffer->write_pos);
-                break;
-            }
-        } while(1);
-    }
-
-    digital_signal_stop_timer();
-    digital_signal_stop_dma();
-}
-
-static void digital_sequence_queue_pulse(DigitalSequence* sequence, uint32_t length) {
-    struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
-
-    if(dma_buffer->dma_active) {
-        uint32_t prev_timer = DWT->CYCCNT;
-        do {
-            dma_buffer->read_pos = RINGBUFFER_SIZE - LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2);
-
-            uint32_t free =
-                (RINGBUFFER_SIZE + dma_buffer->read_pos - dma_buffer->write_pos) % RINGBUFFER_SIZE;
-
-            if(free > 2) {
-                break;
-            }
-
-            if(DWT->CYCCNT - prev_timer > SEQ_LOCK_WAIT_TICKS) {
-                FURI_LOG_D(
-                    TAG,
-                    "[SEQ] hung %lu ms in queue (ARR 0x%08lx, read %lu, write %lu)",
-                    SEQ_LOCK_WAIT_MS,
-                    TIM2->ARR,
-                    dma_buffer->read_pos,
-                    dma_buffer->write_pos);
-                break;
-            }
-            if(TIM2->ARR == SEQ_TIMER_MAX) {
-                FURI_LOG_D(
-                    TAG,
-                    "[SEQ] buffer underrun in queue (ARR 0x%08lx, read %lu, write %lu)",
-                    TIM2->ARR,
-                    dma_buffer->read_pos,
-                    dma_buffer->write_pos);
-                break;
-            }
-        } while(1);
-    }
-
-    dma_buffer->buffer[dma_buffer->write_pos] = length;
-    dma_buffer->write_pos++;
-    dma_buffer->write_pos %= RINGBUFFER_SIZE;
-    dma_buffer->buffer[dma_buffer->write_pos] = SEQ_TIMER_MAX;
-}
-
-bool digital_sequence_send(DigitalSequence* sequence) {
-    furi_assert(sequence);
-
-    struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
-
-    furi_hal_gpio_init(sequence->gpio, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-#ifdef DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN
-    furi_hal_gpio_init(
-        &DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-#endif
-
-    if(sequence->bake) {
-        DigitalSignal* sig = digital_sequence_bake(sequence);
-
-        digital_signal_send(sig, sequence->gpio);
-        digital_signal_free(sig);
-        return true;
-    }
-
-    if(!sequence->sequence_used) {
-        return false;
-    }
-
-    int32_t remainder = 0;
-    uint32_t trade_for_next = 0;
-    uint32_t seq_pos_next = 1;
-
-    dma_buffer->dma_active = false;
-    dma_buffer->buffer[0] = SEQ_TIMER_MAX;
-    dma_buffer->read_pos = 0;
-    dma_buffer->write_pos = 0;
-
-    /* already prepare the current signal pointer */
-    DigitalSignal* sig = sequence->signals[sequence->sequence[0]];
-    DigitalSignal* sig_next = NULL;
-    /* re-use the GPIO buffer from the first signal */
-    sequence->gpio_buff = sig->internals->gpio_buff;
-
-    FURI_CRITICAL_ENTER();
-
-    while(sig) {
-        bool last_signal = (seq_pos_next >= sequence->sequence_used);
-
-        if(!last_signal) {
-            sig_next = sequence->signals[sequence->sequence[seq_pos_next++]];
-        }
-
-        for(uint32_t pulse_pos = 0; pulse_pos < sig->internals->reload_reg_entries; pulse_pos++) {
-            bool last_pulse = ((pulse_pos + 1) >= sig->internals->reload_reg_entries);
-            uint32_t pulse_length = sig->reload_reg_buff[pulse_pos] + trade_for_next;
-
-            trade_for_next = 0;
-
-            /* when we are too late more than half a tick, make the first edge temporarily longer */
-            if(remainder >= T_TIM_DIV2) {
-                remainder -= T_TIM;
-                pulse_length += 1;
-            }
-
-            /* last pulse in current signal and have a next signal? */
-            if(last_pulse && sig_next) {
-                /* when a signal ends with the same level as the next signal begins, let the next signal generate the whole pulse.
-                   beware, we do not want the level after the last edge, but the last level before that edge */
-                bool end_level = sig->start_level ^ ((sig->edge_cnt % 2) == 0);
-
-                /* if they have the same level, pass the duration to the next pulse(s) */
-                if(end_level == sig_next->start_level) {
-                    trade_for_next = pulse_length;
-                }
-            }
-
-            /* if it was decided, that the next signal's first pulse shall also handle our "length", then do not queue here */
-            if(!trade_for_next) {
-                digital_sequence_queue_pulse(sequence, pulse_length);
-
-                if(!dma_buffer->dma_active) {
-                    /* start transmission when buffer was filled enough */
-                    bool start_send = sequence->dma_buffer->write_pos >= (RINGBUFFER_SIZE - 2);
-
-                    /* or it was the last pulse */
-                    if(last_pulse && last_signal) {
-                        start_send = true;
-                    }
-
-                    /* start transmission */
-                    if(start_send) {
-                        digital_sequence_setup_dma(sequence);
-                        digital_signal_setup_timer();
-
-                        /* if the send time is specified, wait till the core timer passed beyond that time */
-                        if(sequence->send_time_active) {
-                            sequence->send_time_active = false;
-                            while(sequence->send_time - DWT->CYCCNT < 0x80000000) {
-                            }
-                        }
-                        digital_signal_start_timer();
-                        dma_buffer->dma_active = true;
-                    }
-                }
-            }
-        }
-
-        remainder += sig->internals->reload_reg_remainder;
-        sig = sig_next;
-        sig_next = NULL;
-    }
-
-    /* wait until last dma transaction was finished */
-    FURI_CRITICAL_EXIT();
-    digital_sequence_finish(sequence);
-
-    return true;
-}
-
-void digital_sequence_clear(DigitalSequence* sequence) {
-    furi_assert(sequence);
-
-    sequence->sequence_used = 0;
-}
-
-void digital_sequence_timebase_correction(DigitalSequence* sequence, float factor) {
-    for(uint32_t sig_pos = 0; sig_pos < sequence->signals_size; sig_pos++) {
-        DigitalSignal* signal = sequence->signals[sig_pos];
-
-        if(signal) {
-            signal->internals->factor = (uint32_t)(1024 * 1024 * factor);
-            digital_signal_prepare_arr(signal);
-        }
-    }
-}

esubghz_chat/lib/nfclegacy/digital_signal/digital_signal.h

@@ -1,75 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdbool.h>
-
-#include <furi_hal_gpio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* helper for easier signal generation */
-#define DIGITAL_SIGNAL_MS(x) ((x)*100000000UL)
-#define DIGITAL_SIGNAL_US(x) ((x)*100000UL)
-#define DIGITAL_SIGNAL_NS(x) ((x)*100UL)
-#define DIGITAL_SIGNAL_PS(x) ((x) / 10UL)
-
-/* using an anonymous type for the internals */
-typedef struct DigitalSignalInternals DigitalSignalInternals;
-
-/* and a public one for accessing user-side fields */
-typedef struct DigitalSignal {
-    bool start_level;
-    uint32_t edge_cnt;
-    uint32_t edges_max_cnt;
-    uint32_t* edge_timings;
-    uint32_t* reload_reg_buff; /* internal, but used by unit tests */
-    DigitalSignalInternals* internals;
-} DigitalSignal;
-
-typedef struct DigitalSequence DigitalSequence;
-
-DigitalSignal* digital_signal_alloc(uint32_t max_edges_cnt);
-
-void digital_signal_free(DigitalSignal* signal);
-
-void digital_signal_add(DigitalSignal* signal, uint32_t ticks);
-
-void digital_signal_add_pulse(DigitalSignal* signal, uint32_t ticks, bool level);
-
-bool digital_signal_append(DigitalSignal* signal_a, DigitalSignal* signal_b);
-
-void digital_signal_prepare_arr(DigitalSignal* signal);
-
-bool digital_signal_get_start_level(DigitalSignal* signal);
-
-uint32_t digital_signal_get_edges_cnt(DigitalSignal* signal);
-
-uint32_t digital_signal_get_edge(DigitalSignal* signal, uint32_t edge_num);
-
-void digital_signal_send(DigitalSignal* signal, const GpioPin* gpio);
-
-DigitalSequence* digital_sequence_alloc(uint32_t size, const GpioPin* gpio);
-
-void digital_sequence_free(DigitalSequence* sequence);
-
-void digital_sequence_set_signal(
-    DigitalSequence* sequence,
-    uint8_t signal_index,
-    DigitalSignal* signal);
-
-void digital_sequence_set_sendtime(DigitalSequence* sequence, uint32_t send_time);
-
-void digital_sequence_add(DigitalSequence* sequence, uint8_t signal_index);
-
-bool digital_sequence_send(DigitalSequence* sequence);
-
-void digital_sequence_clear(DigitalSequence* sequence);
-
-void digital_sequence_timebase_correction(DigitalSequence* sequence, float factor);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/furi_hal_nfc.c

@@ -1,839 +0,0 @@
-#include <limits.h>
-#include "./furi_hal_nfc.h"
-#include "ST25RFAL002/source/st25r3916/st25r3916.h"
-#include "ST25RFAL002/source/st25r3916/st25r3916_irq.h"
-#include "ST25RFAL002/include/rfal_rf.h"
-#include <furi.h>
-
-#include "digital_signal/digital_signal.h"
-#include <furi_hal_spi.h>
-#include <furi_hal_gpio.h>
-#include <furi_hal_cortex.h>
-#include <furi_hal_resources.h>
-
-#define TAG "FurryHalNfc"
-
-static const uint32_t clocks_in_ms = 64 * 1000;
-
-FuriEventFlag* event = NULL;
-#define EVENT_FLAG_INTERRUPT (1UL << 0)
-#define EVENT_FLAG_STATE_CHANGED (1UL << 1)
-#define EVENT_FLAG_STOP (1UL << 2)
-#define EVENT_FLAG_ALL (EVENT_FLAG_INTERRUPT | EVENT_FLAG_STATE_CHANGED | EVENT_FLAG_STOP)
-
-#define FURRY_HAL_NFC_UID_INCOMPLETE (0x04)
-
-void furry_hal_nfc_init() {
-    furi_assert(!event);
-    event = furi_event_flag_alloc();
-
-    ReturnCode ret = rfalNfcInitialize();
-    if(ret == ERR_NONE) {
-        furry_hal_nfc_start_sleep();
-        FURI_LOG_I(TAG, "Init OK");
-    } else {
-        FURI_LOG_W(TAG, "Init Failed, RFAL returned: %d", ret);
-    }
-}
-
-void furry_hal_nfc_deinit() {
-    ReturnCode ret = rfalDeinitialize();
-    if(ret == ERR_NONE) {
-        FURI_LOG_I(TAG, "Deinit OK");
-    } else {
-        FURI_LOG_W(TAG, "Deinit Failed, RFAL returned: %d", ret);
-    }
-
-    if(event) {
-        furi_event_flag_free(event);
-        event = NULL;
-    }
-}
-
-bool furry_hal_nfc_is_busy() {
-    return rfalNfcGetState() != RFAL_NFC_STATE_IDLE;
-}
-
-bool furry_hal_nfc_is_init() {
-    return rfalNfcGetState() != RFAL_NFC_STATE_NOTINIT;
-}
-
-void furry_hal_nfc_field_on() {
-    furry_hal_nfc_exit_sleep();
-    st25r3916TxRxOn();
-}
-
-void furry_hal_nfc_field_off() {
-    st25r3916TxRxOff();
-    furry_hal_nfc_start_sleep();
-}
-
-void furry_hal_nfc_start_sleep() {
-    rfalLowPowerModeStart();
-}
-
-void furry_hal_nfc_exit_sleep() {
-    rfalLowPowerModeStop();
-}
-
-bool furry_hal_nfc_detect(FurryHalNfcDevData* nfc_data, uint32_t timeout) {
-    furi_assert(nfc_data);
-
-    rfalNfcDevice* dev_list = NULL;
-    uint8_t dev_cnt = 0;
-    bool detected = false;
-
-    rfalLowPowerModeStop();
-    rfalNfcState state = rfalNfcGetState();
-    rfalNfcState state_old = 0;
-    if(state == RFAL_NFC_STATE_NOTINIT) {
-        rfalNfcInitialize();
-    }
-    rfalNfcDiscoverParam params;
-    params.compMode = RFAL_COMPLIANCE_MODE_EMV;
-    params.techs2Find = RFAL_NFC_POLL_TECH_A | RFAL_NFC_POLL_TECH_B | RFAL_NFC_POLL_TECH_F |
-                        RFAL_NFC_POLL_TECH_V | RFAL_NFC_POLL_TECH_AP2P | RFAL_NFC_POLL_TECH_ST25TB;
-    params.totalDuration = 1000;
-    params.devLimit = 3;
-    params.wakeupEnabled = false;
-    params.wakeupConfigDefault = true;
-    params.nfcfBR = RFAL_BR_212;
-    params.ap2pBR = RFAL_BR_424;
-    params.maxBR = RFAL_BR_KEEP;
-    params.GBLen = RFAL_NFCDEP_GB_MAX_LEN;
-    params.notifyCb = NULL;
-
-    uint32_t start = DWT->CYCCNT;
-    rfalNfcDiscover(&params);
-    while(true) {
-        rfalNfcWorker();
-        state = rfalNfcGetState();
-        if(state != state_old) {
-            FURI_LOG_T(TAG, "State change %d -> %d", state_old, state);
-        }
-        state_old = state;
-        if(state == RFAL_NFC_STATE_ACTIVATED) {
-            detected = true;
-            break;
-        }
-        if(state == RFAL_NFC_STATE_POLL_ACTIVATION) {
-            start = DWT->CYCCNT;
-            continue;
-        }
-        if(state == RFAL_NFC_STATE_POLL_SELECT) {
-            rfalNfcSelect(0);
-        }
-        if(DWT->CYCCNT - start > timeout * clocks_in_ms) {
-            rfalNfcDeactivate(true);
-            FURI_LOG_T(TAG, "Timeout");
-            break;
-        }
-        furi_delay_tick(1);
-    }
-    rfalNfcGetDevicesFound(&dev_list, &dev_cnt);
-    if(detected) {
-        if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCA) {
-            nfc_data->type = FurryHalNfcTypeA;
-            nfc_data->atqa[0] = dev_list[0].dev.nfca.sensRes.anticollisionInfo;
-            nfc_data->atqa[1] = dev_list[0].dev.nfca.sensRes.platformInfo;
-            nfc_data->sak = dev_list[0].dev.nfca.selRes.sak;
-            uint8_t* cuid_start = dev_list[0].nfcid;
-            if(dev_list[0].nfcidLen == 7) {
-                cuid_start = &dev_list[0].nfcid[3];
-            }
-            nfc_data->cuid = (cuid_start[0] << 24) | (cuid_start[1] << 16) | (cuid_start[2] << 8) |
-                             (cuid_start[3]);
-        } else if(
-            dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCB ||
-            dev_list[0].type == RFAL_NFC_LISTEN_TYPE_ST25TB) {
-            nfc_data->type = FurryHalNfcTypeB;
-        } else if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCF) {
-            nfc_data->type = FurryHalNfcTypeF;
-        } else if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCV) {
-            nfc_data->type = FurryHalNfcTypeV;
-        }
-        if(dev_list[0].rfInterface == RFAL_NFC_INTERFACE_RF) {
-            nfc_data->interface = FurryHalNfcInterfaceRf;
-        } else if(dev_list[0].rfInterface == RFAL_NFC_INTERFACE_ISODEP) {
-            nfc_data->interface = FurryHalNfcInterfaceIsoDep;
-        } else if(dev_list[0].rfInterface == RFAL_NFC_INTERFACE_NFCDEP) {
-            nfc_data->interface = FurryHalNfcInterfaceNfcDep;
-        }
-        nfc_data->uid_len = dev_list[0].nfcidLen;
-        memcpy(nfc_data->uid, dev_list[0].nfcid, nfc_data->uid_len);
-    }
-
-    return detected;
-}
-
-bool furry_hal_nfc_activate_nfca(uint32_t timeout, uint32_t* cuid) {
-    rfalNfcDevice* dev_list;
-    uint8_t dev_cnt = 0;
-    rfalLowPowerModeStop();
-    rfalNfcState state = rfalNfcGetState();
-    if(state == RFAL_NFC_STATE_NOTINIT) {
-        rfalNfcInitialize();
-    }
-    rfalNfcDiscoverParam params = {
-        .compMode = RFAL_COMPLIANCE_MODE_NFC,
-        .techs2Find = RFAL_NFC_POLL_TECH_A,
-        .totalDuration = 1000,
-        .devLimit = 3,
-        .wakeupEnabled = false,
-        .wakeupConfigDefault = true,
-        .nfcfBR = RFAL_BR_212,
-        .ap2pBR = RFAL_BR_424,
-        .maxBR = RFAL_BR_KEEP,
-        .GBLen = RFAL_NFCDEP_GB_MAX_LEN,
-        .notifyCb = NULL,
-    };
-    uint32_t start = DWT->CYCCNT;
-    rfalNfcDiscover(&params);
-    while(state != RFAL_NFC_STATE_ACTIVATED) {
-        rfalNfcWorker();
-        state = rfalNfcGetState();
-        FURI_LOG_T(TAG, "Current state %d", state);
-        if(state == RFAL_NFC_STATE_POLL_ACTIVATION) {
-            start = DWT->CYCCNT;
-            continue;
-        }
-        if(state == RFAL_NFC_STATE_POLL_SELECT) {
-            rfalNfcSelect(0);
-        }
-        if(DWT->CYCCNT - start > timeout * clocks_in_ms) {
-            rfalNfcDeactivate(true);
-            FURI_LOG_T(TAG, "Timeout");
-            return false;
-        }
-        furi_thread_yield();
-    }
-    rfalNfcGetDevicesFound(&dev_list, &dev_cnt);
-    // Take first device and set cuid
-    if(cuid) {
-        uint8_t* cuid_start = dev_list[0].nfcid;
-        if(dev_list[0].nfcidLen == 7) {
-            cuid_start = &dev_list[0].nfcid[3];
-        }
-        *cuid = (cuid_start[0] << 24) | (cuid_start[1] << 16) | (cuid_start[2] << 8) |
-                (cuid_start[3]);
-        FURI_LOG_T(TAG, "Activated tag with cuid: %lX", *cuid);
-    }
-    return true;
-}
-
-bool furry_hal_nfc_listen(
-    uint8_t* uid,
-    uint8_t uid_len,
-    uint8_t* atqa,
-    uint8_t sak,
-    bool activate_after_sak,
-    uint32_t timeout) {
-    rfalNfcState state = rfalNfcGetState();
-    if(state == RFAL_NFC_STATE_NOTINIT) {
-        rfalNfcInitialize();
-    } else if(state >= RFAL_NFC_STATE_ACTIVATED) {
-        rfalNfcDeactivate(false);
-    }
-    rfalLowPowerModeStop();
-    rfalNfcDiscoverParam params = {
-        .techs2Find = RFAL_NFC_LISTEN_TECH_A,
-        .totalDuration = 1000,
-        .devLimit = 1,
-        .wakeupEnabled = false,
-        .wakeupConfigDefault = true,
-        .nfcfBR = RFAL_BR_212,
-        .ap2pBR = RFAL_BR_424,
-        .maxBR = RFAL_BR_KEEP,
-        .GBLen = RFAL_NFCDEP_GB_MAX_LEN,
-        .notifyCb = NULL,
-        .activate_after_sak = activate_after_sak,
-    };
-    if(FURI_BIT(sak, 5)) {
-        params.compMode = RFAL_COMPLIANCE_MODE_EMV;
-    } else {
-        params.compMode = RFAL_COMPLIANCE_MODE_NFC;
-    }
-    params.lmConfigPA.nfcidLen = uid_len;
-    memcpy(params.lmConfigPA.nfcid, uid, uid_len);
-    params.lmConfigPA.SENS_RES[0] = atqa[0];
-    params.lmConfigPA.SENS_RES[1] = atqa[1];
-    params.lmConfigPA.SEL_RES = sak;
-    rfalNfcDiscover(&params);
-
-    // Disable EMD suppression.
-    st25r3916ModifyRegister(ST25R3916_REG_EMD_SUP_CONF, ST25R3916_REG_EMD_SUP_CONF_emd_emv, 0);
-
-    uint32_t start = DWT->CYCCNT;
-    while(state != RFAL_NFC_STATE_ACTIVATED) {
-        rfalNfcWorker();
-        state = rfalNfcGetState();
-        if(DWT->CYCCNT - start > timeout * clocks_in_ms) {
-            rfalNfcDeactivate(true);
-            return false;
-        }
-        furi_delay_tick(1);
-    }
-    return true;
-}
-
-static void furry_hal_nfc_read_fifo(uint8_t* data, uint16_t* bits) {
-    uint8_t fifo_status[2];
-    uint8_t rx_buff[64];
-
-    st25r3916ReadMultipleRegisters(
-        ST25R3916_REG_FIFO_STATUS1, fifo_status, ST25R3916_FIFO_STATUS_LEN);
-    uint16_t rx_bytes =
-        ((((uint16_t)fifo_status[1] & ST25R3916_REG_FIFO_STATUS2_fifo_b_mask) >>
-          ST25R3916_REG_FIFO_STATUS2_fifo_b_shift)
-         << 8);
-    rx_bytes |= (((uint16_t)fifo_status[0]) & 0x00FFU);
-    st25r3916ReadFifo(rx_buff, rx_bytes);
-
-    memcpy(data, rx_buff, rx_bytes);
-    *bits = rx_bytes * 8;
-}
-
-void furry_hal_nfc_listen_sleep() {
-    st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SLEEP);
-}
-
-void furry_hal_nfc_stop_cmd() {
-    st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-}
-
-bool furry_hal_nfc_listen_rx(FurryHalNfcTxRxContext* tx_rx, uint32_t timeout_ms) {
-    furi_assert(tx_rx);
-
-    // Wait for interrupts
-    uint32_t start = furi_get_tick();
-    bool data_received = false;
-    while(true) {
-        if(furi_hal_gpio_read(&gpio_nfc_irq_rfid_pull) == true) {
-            st25r3916CheckForReceivedInterrupts();
-            if(st25r3916GetInterrupt(ST25R3916_IRQ_MASK_RXE)) {
-                furry_hal_nfc_read_fifo(tx_rx->rx_data, &tx_rx->rx_bits);
-                data_received = true;
-                if(tx_rx->sniff_rx) {
-                    tx_rx->sniff_rx(tx_rx->rx_data, tx_rx->rx_bits, false, tx_rx->sniff_context);
-                }
-                break;
-            }
-            continue;
-        }
-        if(furi_get_tick() - start > timeout_ms) {
-            FURI_LOG_T(TAG, "Interrupt waiting timeout");
-            furi_delay_tick(1);
-            break;
-        }
-    }
-
-    return data_received;
-}
-
-void furry_hal_nfc_listen_start(FurryHalNfcDevData* nfc_data) {
-    furi_assert(nfc_data);
-
-    furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeInput, GpioPullDown, GpioSpeedVeryHigh);
-    // Clear interrupts
-    st25r3916ClearInterrupts();
-    // Mask all interrupts
-    st25r3916DisableInterrupts(ST25R3916_IRQ_MASK_ALL);
-    // RESET
-    st25r3916ExecuteCommand(ST25R3916_CMD_STOP);
-    // Setup registers
-    st25r3916WriteRegister(
-        ST25R3916_REG_OP_CONTROL,
-        ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en |
-            ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
-    st25r3916WriteRegister(
-        ST25R3916_REG_MODE,
-        ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om3 | ST25R3916_REG_MODE_om0);
-    st25r3916WriteRegister(
-        ST25R3916_REG_PASSIVE_TARGET,
-        ST25R3916_REG_PASSIVE_TARGET_fdel_2 | ST25R3916_REG_PASSIVE_TARGET_fdel_0 |
-            ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p | ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r);
-    st25r3916WriteRegister(ST25R3916_REG_MASK_RX_TIMER, 0x02);
-
-    // Mask interrupts
-    uint32_t clear_irq_mask =
-        (ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_RXE_PTA | ST25R3916_IRQ_MASK_WU_A_X |
-         ST25R3916_IRQ_MASK_WU_A);
-    st25r3916EnableInterrupts(clear_irq_mask);
-
-    // Set 4 or 7 bytes UID
-    if(nfc_data->uid_len == 4) {
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_id_mask, ST25R3916_REG_AUX_nfc_id_4bytes);
-    } else {
-        st25r3916ChangeRegisterBits(
-            ST25R3916_REG_AUX, ST25R3916_REG_AUX_nfc_id_mask, ST25R3916_REG_AUX_nfc_id_7bytes);
-    }
-    // Write PT Memory
-    uint8_t pt_memory[15] = {};
-    memcpy(pt_memory, nfc_data->uid, nfc_data->uid_len);
-    pt_memory[10] = nfc_data->atqa[0];
-    pt_memory[11] = nfc_data->atqa[1];
-    if(nfc_data->uid_len == 4) {
-        pt_memory[12] = nfc_data->sak & ~FURRY_HAL_NFC_UID_INCOMPLETE;
-    } else {
-        pt_memory[12] = FURRY_HAL_NFC_UID_INCOMPLETE;
-    }
-    pt_memory[13] = nfc_data->sak & ~FURRY_HAL_NFC_UID_INCOMPLETE;
-    pt_memory[14] = nfc_data->sak & ~FURRY_HAL_NFC_UID_INCOMPLETE;
-
-    st25r3916WritePTMem(pt_memory, sizeof(pt_memory));
-    // Go to sense
-    st25r3916ExecuteCommand(ST25R3916_CMD_GOTO_SENSE);
-}
-
-void rfal_interrupt_callback_handler() {
-    furi_event_flag_set(event, EVENT_FLAG_INTERRUPT);
-}
-
-void rfal_state_changed_callback(void* context) {
-    UNUSED(context);
-    furi_event_flag_set(event, EVENT_FLAG_STATE_CHANGED);
-}
-
-void furry_hal_nfc_stop() {
-    if(event) {
-        furi_event_flag_set(event, EVENT_FLAG_STOP);
-    }
-}
-
-bool furry_hal_nfc_emulate_nfca(
-    uint8_t* uid,
-    uint8_t uid_len,
-    uint8_t* atqa,
-    uint8_t sak,
-    FurryHalNfcEmulateCallback callback,
-    void* context,
-    uint32_t timeout) {
-    rfalSetUpperLayerCallback(rfal_interrupt_callback_handler);
-    rfal_set_state_changed_callback(rfal_state_changed_callback);
-
-    rfalLmConfPA config;
-    config.nfcidLen = uid_len;
-    memcpy(config.nfcid, uid, uid_len);
-    memcpy(config.SENS_RES, atqa, RFAL_LM_SENS_RES_LEN);
-    config.SEL_RES = sak;
-    uint8_t buff_rx[256];
-    uint16_t buff_rx_size = 256;
-    uint16_t buff_rx_len = 0;
-    uint8_t buff_tx[1040];
-    uint16_t buff_tx_len = 0;
-    uint32_t data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-
-    rfalLowPowerModeStop();
-    if(rfalListenStart(
-           RFAL_LM_MASK_NFCA,
-           &config,
-           NULL,
-           NULL,
-           buff_rx,
-           rfalConvBytesToBits(buff_rx_size),
-           &buff_rx_len)) {
-        rfalListenStop();
-        FURI_LOG_E(TAG, "Failed to start listen mode");
-        return false;
-    }
-    while(true) {
-        buff_rx_len = 0;
-        buff_tx_len = 0;
-        uint32_t flag = furi_event_flag_wait(event, EVENT_FLAG_ALL, FuriFlagWaitAny, timeout);
-        if(flag == (unsigned)FuriFlagErrorTimeout || flag == EVENT_FLAG_STOP) {
-            break;
-        }
-        bool data_received = false;
-        buff_rx_len = 0;
-        rfalWorker();
-        rfalLmState state = rfalListenGetState(&data_received, NULL);
-        if(data_received) {
-            rfalTransceiveBlockingRx();
-            if(nfca_emulation_handler(buff_rx, buff_rx_len, buff_tx, &buff_tx_len)) {
-                if(rfalListenSleepStart(
-                       RFAL_LM_STATE_SLEEP_A,
-                       buff_rx,
-                       rfalConvBytesToBits(buff_rx_size),
-                       &buff_rx_len)) {
-                    FURI_LOG_E(TAG, "Failed to enter sleep mode");
-                    break;
-                } else {
-                    continue;
-                }
-            }
-            if(buff_tx_len) {
-                ReturnCode ret = rfalTransceiveBitsBlockingTx(
-                    buff_tx,
-                    buff_tx_len,
-                    buff_rx,
-                    rfalConvBytesToBits(buff_rx_size),
-                    &buff_rx_len,
-                    data_type,
-                    RFAL_FWT_NONE);
-                if(ret) {
-                    FURI_LOG_E(TAG, "Tranceive failed with status %d", ret);
-                    break;
-                }
-                continue;
-            }
-            if((state == RFAL_LM_STATE_ACTIVE_A || state == RFAL_LM_STATE_ACTIVE_Ax)) {
-                if(callback) {
-                    callback(buff_rx, buff_rx_len, buff_tx, &buff_tx_len, &data_type, context);
-                }
-                if(!rfalIsExtFieldOn()) {
-                    break;
-                }
-                if(buff_tx_len) {
-                    if(buff_tx_len == UINT16_MAX) buff_tx_len = 0;
-
-                    ReturnCode ret = rfalTransceiveBitsBlockingTx(
-                        buff_tx,
-                        buff_tx_len,
-                        buff_rx,
-                        rfalConvBytesToBits(buff_rx_size),
-                        &buff_rx_len,
-                        data_type,
-                        RFAL_FWT_NONE);
-                    if(ret) {
-                        FURI_LOG_E(TAG, "Tranceive failed with status %d", ret);
-                        continue;
-                    }
-                } else {
-                    break;
-                }
-            }
-        }
-    }
-    rfalListenStop();
-    return true;
-}
-
-static bool furry_hal_nfc_transparent_tx_rx(FurryHalNfcTxRxContext* tx_rx, uint16_t timeout_ms) {
-    furi_assert(tx_rx->nfca_signal);
-
-    bool ret = false;
-
-    // Start transparent mode
-    st25r3916ExecuteCommand(ST25R3916_CMD_TRANSPARENT_MODE);
-    // Reconfigure gpio for Transparent mode
-    furi_hal_spi_bus_handle_deinit(&furi_hal_spi_bus_handle_nfc);
-
-    // Send signal
-    FURI_CRITICAL_ENTER();
-    nfca_signal_encode(tx_rx->nfca_signal, tx_rx->tx_data, tx_rx->tx_bits, tx_rx->tx_parity);
-    digital_signal_send(tx_rx->nfca_signal->tx_signal, &gpio_spi_r_mosi);
-    FURI_CRITICAL_EXIT();
-    furi_hal_gpio_write(&gpio_spi_r_mosi, false);
-
-    // Configure gpio back to SPI and exit transparent
-    furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_nfc);
-    st25r3916ExecuteCommand(ST25R3916_CMD_UNMASK_RECEIVE_DATA);
-
-    // Manually wait for interrupt
-    furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeInput, GpioPullDown, GpioSpeedVeryHigh);
-    st25r3916ClearAndEnableInterrupts(ST25R3916_IRQ_MASK_RXE);
-
-    if(tx_rx->sniff_tx) {
-        tx_rx->sniff_tx(tx_rx->tx_data, tx_rx->tx_bits, false, tx_rx->sniff_context);
-    }
-
-    uint32_t irq = 0;
-    uint8_t rxe = 0;
-    uint32_t start = DWT->CYCCNT;
-    while(true) {
-        if(!rfalIsExtFieldOn()) {
-            return false;
-        }
-        if(furi_hal_gpio_read(&gpio_nfc_irq_rfid_pull) == true) {
-            st25r3916ReadRegister(ST25R3916_REG_IRQ_MAIN, &rxe);
-            if(rxe & (1 << 4)) {
-                irq = 1;
-                break;
-            }
-        }
-        uint32_t timeout = DWT->CYCCNT - start;
-        if(timeout / furi_hal_cortex_instructions_per_microsecond() > timeout_ms * 1000) {
-            FURI_LOG_D(TAG, "Interrupt waiting timeout");
-            break;
-        }
-    }
-    if(irq) {
-        uint8_t fifo_stat[2];
-        st25r3916ReadMultipleRegisters(
-            ST25R3916_REG_FIFO_STATUS1, fifo_stat, ST25R3916_FIFO_STATUS_LEN);
-        uint16_t len =
-            ((((uint16_t)fifo_stat[1] & ST25R3916_REG_FIFO_STATUS2_fifo_b_mask) >>
-              ST25R3916_REG_FIFO_STATUS2_fifo_b_shift)
-             << RFAL_BITS_IN_BYTE);
-        len |= (((uint16_t)fifo_stat[0]) & 0x00FFU);
-        uint8_t rx[100];
-        st25r3916ReadFifo(rx, len);
-
-        tx_rx->rx_bits = len * 8;
-        memcpy(tx_rx->rx_data, rx, len);
-
-        if(tx_rx->sniff_rx) {
-            tx_rx->sniff_rx(tx_rx->rx_data, tx_rx->rx_bits, false, tx_rx->sniff_context);
-        }
-
-        ret = true;
-    } else {
-        FURI_LOG_E(TAG, "Timeout error");
-        ret = false;
-    }
-
-    st25r3916ClearInterrupts();
-
-    return ret;
-}
-
-static uint32_t furry_hal_nfc_tx_rx_get_flag(FurryHalNfcTxRxType type) {
-    uint32_t flags = 0;
-
-    if(type == FurryHalNfcTxRxTypeRxNoCrc) {
-        flags = RFAL_TXRX_FLAGS_CRC_RX_KEEP;
-    } else if(type == FurryHalNfcTxRxTypeRxKeepPar) {
-        flags = RFAL_TXRX_FLAGS_CRC_TX_MANUAL | RFAL_TXRX_FLAGS_CRC_RX_KEEP |
-                RFAL_TXRX_FLAGS_PAR_RX_KEEP;
-    } else if(type == FurryHalNfcTxRxTypeRaw) {
-        flags = RFAL_TXRX_FLAGS_CRC_TX_MANUAL | RFAL_TXRX_FLAGS_CRC_RX_KEEP |
-                RFAL_TXRX_FLAGS_PAR_RX_KEEP | RFAL_TXRX_FLAGS_PAR_TX_NONE;
-    } else if(type == FurryHalNfcTxRxTypeRxRaw) {
-        flags = RFAL_TXRX_FLAGS_CRC_TX_MANUAL | RFAL_TXRX_FLAGS_CRC_RX_KEEP |
-                RFAL_TXRX_FLAGS_PAR_RX_KEEP | RFAL_TXRX_FLAGS_PAR_TX_NONE;
-    }
-
-    return flags;
-}
-
-static uint16_t furry_hal_nfc_data_and_parity_to_bitstream(
-    uint8_t* data,
-    uint16_t len,
-    uint8_t* parity,
-    uint8_t* out) {
-    furi_assert(data);
-    furi_assert(out);
-
-    uint8_t next_par_bit = 0;
-    uint16_t curr_bit_pos = 0;
-    for(uint16_t i = 0; i < len; i++) {
-        next_par_bit = FURI_BIT(parity[i / 8], 7 - (i % 8));
-        if(curr_bit_pos % 8 == 0) {
-            out[curr_bit_pos / 8] = data[i];
-            curr_bit_pos += 8;
-            out[curr_bit_pos / 8] = next_par_bit;
-            curr_bit_pos++;
-        } else {
-            out[curr_bit_pos / 8] |= data[i] << (curr_bit_pos % 8);
-            out[curr_bit_pos / 8 + 1] = data[i] >> (8 - curr_bit_pos % 8);
-            out[curr_bit_pos / 8 + 1] |= next_par_bit << (curr_bit_pos % 8);
-            curr_bit_pos += 9;
-        }
-    }
-    return curr_bit_pos;
-}
-
-uint16_t furry_hal_nfc_bitstream_to_data_and_parity(
-    uint8_t* in_buff,
-    uint16_t in_buff_bits,
-    uint8_t* out_data,
-    uint8_t* out_parity) {
-    if(in_buff_bits < 8) {
-        out_data[0] = in_buff[0];
-        return in_buff_bits;
-    }
-    if(in_buff_bits % 9 != 0) {
-        return 0;
-    }
-
-    uint8_t curr_byte = 0;
-    uint16_t bit_processed = 0;
-    memset(out_parity, 0, in_buff_bits / 9);
-    while(bit_processed < in_buff_bits) {
-        out_data[curr_byte] = in_buff[bit_processed / 8] >> (bit_processed % 8);
-        out_data[curr_byte] |= in_buff[bit_processed / 8 + 1] << (8 - bit_processed % 8);
-        out_parity[curr_byte / 8] |= FURI_BIT(in_buff[bit_processed / 8 + 1], bit_processed % 8)
-                                     << (7 - curr_byte % 8);
-        bit_processed += 9;
-        curr_byte++;
-    }
-    return curr_byte * 8;
-}
-
-bool furry_hal_nfc_tx_rx(FurryHalNfcTxRxContext* tx_rx, uint16_t timeout_ms) {
-    furi_assert(tx_rx);
-
-    ReturnCode ret;
-    rfalNfcState state = RFAL_NFC_STATE_ACTIVATED;
-    uint8_t temp_tx_buff[FURRY_HAL_NFC_DATA_BUFF_SIZE] = {};
-    uint16_t temp_tx_bits = 0;
-    uint8_t* temp_rx_buff = NULL;
-    uint16_t* temp_rx_bits = NULL;
-
-    if(tx_rx->tx_rx_type == FurryHalNfcTxRxTransparent) {
-        return furry_hal_nfc_transparent_tx_rx(tx_rx, timeout_ms);
-    }
-
-    // Prepare data for FIFO if necessary
-    uint32_t flags = furry_hal_nfc_tx_rx_get_flag(tx_rx->tx_rx_type);
-    if(tx_rx->tx_rx_type == FurryHalNfcTxRxTypeRaw) {
-        temp_tx_bits = furry_hal_nfc_data_and_parity_to_bitstream(
-            tx_rx->tx_data, tx_rx->tx_bits / 8, tx_rx->tx_parity, temp_tx_buff);
-        ret = rfalNfcDataExchangeCustomStart(
-            temp_tx_buff, temp_tx_bits, &temp_rx_buff, &temp_rx_bits, RFAL_FWT_NONE, flags);
-    } else {
-        ret = rfalNfcDataExchangeCustomStart(
-            tx_rx->tx_data, tx_rx->tx_bits, &temp_rx_buff, &temp_rx_bits, RFAL_FWT_NONE, flags);
-    }
-    if(ret != ERR_NONE) {
-        FURI_LOG_E(TAG, "Failed to start data exchange");
-        return false;
-    }
-
-    if(tx_rx->sniff_tx) {
-        bool crc_dropped = !(flags & RFAL_TXRX_FLAGS_CRC_TX_MANUAL);
-        tx_rx->sniff_tx(tx_rx->tx_data, tx_rx->tx_bits, crc_dropped, tx_rx->sniff_context);
-    }
-
-    uint32_t start = DWT->CYCCNT;
-    while(state != RFAL_NFC_STATE_DATAEXCHANGE_DONE) {
-        rfalNfcWorker();
-        state = rfalNfcGetState();
-        ret = rfalNfcDataExchangeGetStatus();
-        if(ret == ERR_WRONG_STATE) {
-            return false;
-        } else if(ret == ERR_BUSY) {
-            if(DWT->CYCCNT - start > timeout_ms * clocks_in_ms) {
-                FURI_LOG_D(TAG, "Timeout during data exchange");
-                return false;
-            }
-            continue;
-        } else {
-            start = DWT->CYCCNT;
-        }
-        furi_delay_tick(1);
-    }
-
-    if(tx_rx->tx_rx_type == FurryHalNfcTxRxTypeRaw ||
-       tx_rx->tx_rx_type == FurryHalNfcTxRxTypeRxRaw) {
-        tx_rx->rx_bits = furry_hal_nfc_bitstream_to_data_and_parity(
-            temp_rx_buff, *temp_rx_bits, tx_rx->rx_data, tx_rx->rx_parity);
-    } else {
-        memcpy(tx_rx->rx_data, temp_rx_buff, MIN(*temp_rx_bits / 8, FURRY_HAL_NFC_DATA_BUFF_SIZE));
-        tx_rx->rx_bits = *temp_rx_bits;
-    }
-
-    if(tx_rx->sniff_rx) {
-        bool crc_dropped = !(flags & RFAL_TXRX_FLAGS_CRC_RX_KEEP);
-        tx_rx->sniff_rx(tx_rx->rx_data, tx_rx->rx_bits, crc_dropped, tx_rx->sniff_context);
-    }
-
-    return true;
-}
-
-bool furry_hal_nfc_tx_rx_full(FurryHalNfcTxRxContext* tx_rx) {
-    uint16_t part_len_bytes;
-
-    if(!furry_hal_nfc_tx_rx(tx_rx, 1000)) {
-        return false;
-    }
-    while(tx_rx->rx_bits && tx_rx->rx_data[0] == 0xAF) {
-        FurryHalNfcTxRxContext tmp = *tx_rx;
-        tmp.tx_data[0] = 0xAF;
-        tmp.tx_bits = 8;
-        if(!furry_hal_nfc_tx_rx(&tmp, 1000)) {
-            return false;
-        }
-        part_len_bytes = tmp.rx_bits / 8;
-        if(part_len_bytes > FURRY_HAL_NFC_DATA_BUFF_SIZE - tx_rx->rx_bits / 8) {
-            FURI_LOG_W(TAG, "Overrun rx buf");
-            return false;
-        }
-        if(part_len_bytes == 0) {
-            FURI_LOG_W(TAG, "Empty 0xAF response");
-            return false;
-        }
-        memcpy(tx_rx->rx_data + tx_rx->rx_bits / 8, tmp.rx_data + 1, part_len_bytes - 1);
-        tx_rx->rx_data[0] = tmp.rx_data[0];
-        tx_rx->rx_bits += 8 * (part_len_bytes - 1);
-    }
-
-    return true;
-}
-
-void furry_hal_nfc_sleep() {
-    rfalNfcDeactivate(false);
-    rfalLowPowerModeStart();
-}
-
-FurryHalNfcReturn furry_hal_nfc_ll_set_mode(
-    FurryHalNfcMode mode,
-    FurryHalNfcBitrate txBR,
-    FurryHalNfcBitrate rxBR) {
-    return rfalSetMode((rfalMode)mode, (rfalBitRate)txBR, (rfalBitRate)rxBR);
-}
-
-void furry_hal_nfc_ll_set_error_handling(FurryHalNfcErrorHandling eHandling) {
-    rfalSetErrorHandling((rfalEHandling)eHandling);
-}
-
-void furry_hal_nfc_ll_set_guard_time(uint32_t cycles) {
-    rfalSetGT(cycles);
-}
-
-void furry_hal_nfc_ll_set_fdt_listen(uint32_t cycles) {
-    rfalSetFDTListen(cycles);
-}
-
-void furry_hal_nfc_ll_set_fdt_poll(uint32_t FDTPoll) {
-    rfalSetFDTPoll(FDTPoll);
-}
-
-void furry_hal_nfc_ll_txrx_on() {
-    st25r3916TxRxOn();
-}
-
-void furry_hal_nfc_ll_txrx_off() {
-    st25r3916TxRxOff();
-}
-
-FurryHalNfcReturn furry_hal_nfc_ll_txrx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    return rfalTransceiveBlockingTxRx(txBuf, txBufLen, rxBuf, rxBufLen, actLen, flags, fwt);
-}
-
-FurryHalNfcReturn furry_hal_nfc_ll_txrx_bits(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt) {
-    return rfalTransceiveBitsBlockingTxRx(txBuf, txBufLen, rxBuf, rxBufLen, actLen, flags, fwt);
-}
-
-void furry_hal_nfc_ll_poll() {
-    rfalWorker();
-}
-
-void furry_hal_nfc_field_detect_start() {
-    st25r3916WriteRegister(
-        ST25R3916_REG_OP_CONTROL,
-        ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_en_fd_mask);
-    st25r3916WriteRegister(ST25R3916_REG_MODE, ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om0);
-}
-
-bool furry_hal_nfc_field_is_present() {
-    return st25r3916CheckReg(
-        ST25R3916_REG_AUX_DISPLAY,
-        ST25R3916_REG_AUX_DISPLAY_efd_o,
-        ST25R3916_REG_AUX_DISPLAY_efd_o);
-}

esubghz_chat/lib/nfclegacy/furi_hal_nfc.h

@@ -1,438 +0,0 @@
-/**
- * @file furry_hal_nfc.h
- * NFC HAL API
- */
-
-#pragma once
-
-#include "ST25RFAL002/st_errno.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "ST25RFAL002/include/rfal_nfc.h"
-#include "protocols/nfca.h"
-
-#define FURRY_HAL_NFC_UID_MAX_LEN 10
-#define FURRY_HAL_NFC_DATA_BUFF_SIZE (512)
-#define FURRY_HAL_NFC_PARITY_BUFF_SIZE (FURRY_HAL_NFC_DATA_BUFF_SIZE / 8)
-
-#define FURRY_HAL_NFC_TXRX_DEFAULT                                                   \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_AUTO | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_REMV | \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_REMV | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_AUTO)
-
-#define FURRY_HAL_NFC_TX_DEFAULT_RX_NO_CRC                                           \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_AUTO | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP | \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_REMV | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_AUTO)
-
-#define FURRY_HAL_NFC_TXRX_WITH_PAR                                                    \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP | \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_KEEP | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_AUTO)
-
-#define FURRY_HAL_NFC_TXRX_RAW                                                         \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_KEEP | \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_KEEP | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_NONE)
-
-#define FURRY_HAL_NFC_TX_RAW_RX_DEFAULT                                                \
-    ((uint32_t)RFAL_TXRX_FLAGS_CRC_TX_MANUAL | (uint32_t)RFAL_TXRX_FLAGS_CRC_RX_REMV | \
-     (uint32_t)RFAL_TXRX_FLAGS_PAR_RX_REMV | (uint32_t)RFAL_TXRX_FLAGS_PAR_TX_NONE)
-
-typedef enum {
-    FurryHalNfcTxRxTypeDefault,
-    FurryHalNfcTxRxTypeRxNoCrc,
-    FurryHalNfcTxRxTypeRxKeepPar,
-    FurryHalNfcTxRxTypeRaw,
-    FurryHalNfcTxRxTypeRxRaw,
-    FurryHalNfcTxRxTransparent,
-} FurryHalNfcTxRxType;
-
-typedef bool (*FurryHalNfcEmulateCallback)(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len,
-    uint32_t* flags,
-    void* context);
-
-typedef enum {
-    FurryHalNfcTypeA,
-    FurryHalNfcTypeB,
-    FurryHalNfcTypeF,
-    FurryHalNfcTypeV,
-} FurryHalNfcType;
-
-typedef enum {
-    FurryHalNfcInterfaceRf,
-    FurryHalNfcInterfaceIsoDep,
-    FurryHalNfcInterfaceNfcDep,
-} FurryHalNfcInterface;
-
-typedef struct {
-    FurryHalNfcType type;
-    FurryHalNfcInterface interface;
-    uint8_t uid_len;
-    uint8_t uid[10];
-    uint32_t cuid;
-    uint8_t atqa[2];
-    uint8_t sak;
-} FurryHalNfcDevData;
-
-typedef void (
-    *FurryHalNfcTxRxSniffCallback)(uint8_t* data, uint16_t bits, bool crc_dropped, void* context);
-
-typedef struct {
-    uint8_t tx_data[FURRY_HAL_NFC_DATA_BUFF_SIZE];
-    uint8_t tx_parity[FURRY_HAL_NFC_PARITY_BUFF_SIZE];
-    uint16_t tx_bits;
-    uint8_t rx_data[FURRY_HAL_NFC_DATA_BUFF_SIZE];
-    uint8_t rx_parity[FURRY_HAL_NFC_PARITY_BUFF_SIZE];
-    uint16_t rx_bits;
-    FurryHalNfcTxRxType tx_rx_type;
-    NfcaSignal* nfca_signal;
-
-    FurryHalNfcTxRxSniffCallback sniff_tx;
-    FurryHalNfcTxRxSniffCallback sniff_rx;
-    void* sniff_context;
-} FurryHalNfcTxRxContext;
-
-/** Init nfc
- */
-void furry_hal_nfc_init();
-
-/** Deinit nfc
- */
-void furry_hal_nfc_deinit();
-
-/** Check if nfc worker is busy
- *
- * @return     true if busy
- */
-bool furry_hal_nfc_is_busy();
-
-/** Check if nfc is initialized
- *
- * @return     true if initialized
- */
-bool furry_hal_nfc_is_init();
-
-/** NFC field on
- */
-void furry_hal_nfc_field_on();
-
-/** NFC field off
- */
-void furry_hal_nfc_field_off();
-
-/** NFC start sleep
- */
-void furry_hal_nfc_start_sleep();
-
-void furry_hal_nfc_stop_cmd();
-
-/** NFC stop sleep
- */
-void furry_hal_nfc_exit_sleep();
-
-/** NFC poll
- *
- * @param      dev_list    pointer to rfalNfcDevice buffer
- * @param      dev_cnt     pointer device count
- * @param      timeout     timeout in ms
- * @param      deactivate  deactivate flag
- *
- * @return     true on success
- */
-bool furry_hal_nfc_detect(FurryHalNfcDevData* nfc_data, uint32_t timeout);
-
-/** Activate NFC-A tag
- *
- * @param      timeout      timeout in ms
- * @param      cuid         pointer to 32bit uid
- *
- * @return     true on succeess
- */
-bool furry_hal_nfc_activate_nfca(uint32_t timeout, uint32_t* cuid);
-
-/** NFC listen
- *
- * @param      uid                 pointer to uid buffer
- * @param      uid_len             uid length
- * @param      atqa                pointer to atqa
- * @param      sak                 sak
- * @param      activate_after_sak  activate after sak flag
- * @param      timeout             timeout in ms
- *
- * @return     true on success
- */
-bool furry_hal_nfc_listen(
-    uint8_t* uid,
-    uint8_t uid_len,
-    uint8_t* atqa,
-    uint8_t sak,
-    bool activate_after_sak,
-    uint32_t timeout);
-
-/** Start Target Listen mode
- * @note RFAL free implementation
- *
- * @param       nfc_data            FurryHalNfcDevData instance
- */
-void furry_hal_nfc_listen_start(FurryHalNfcDevData* nfc_data);
-
-/** Read data in Target Listen mode
- * @note Must be called only after furry_hal_nfc_listen_start()
- *
- * @param       tx_rx               FurryHalNfcTxRxContext instance
- * @param       timeout_ms          timeout im ms
- *
- * @return      true on not empty receive
- */
-bool furry_hal_nfc_listen_rx(FurryHalNfcTxRxContext* tx_rx, uint32_t timeout_ms);
-
-/** Set Target in Sleep state */
-void furry_hal_nfc_listen_sleep();
-
-/** Emulate NFC-A Target
- * @note RFAL based implementation
- *
- * @param       uid                 NFC-A UID
- * @param       uid_len             NFC-A UID length
- * @param       atqa                NFC-A ATQA
- * @param       sak                 NFC-A SAK
- * @param       callback            FurryHalNfcEmulateCallback instance
- * @param       context             pointer to context for callback
- * @param       timeout             timeout in ms
- *
- * @return      true on success
- */
-bool furry_hal_nfc_emulate_nfca(
-    uint8_t* uid,
-    uint8_t uid_len,
-    uint8_t* atqa,
-    uint8_t sak,
-    FurryHalNfcEmulateCallback callback,
-    void* context,
-    uint32_t timeout);
-
-/** NFC data exchange
- *
- * @param       tx_rx_ctx   FurryHalNfcTxRxContext instance
- *
- * @return      true on success
- */
-bool furry_hal_nfc_tx_rx(FurryHalNfcTxRxContext* tx_rx, uint16_t timeout_ms);
-
-/** NFC data full exhange
- *
- * @param       tx_rx_ctx   FurryHalNfcTxRxContext instance
- *
- * @return      true on success
- */
-bool furry_hal_nfc_tx_rx_full(FurryHalNfcTxRxContext* tx_rx);
-
-/** NFC deactivate and start sleep
- */
-void furry_hal_nfc_sleep();
-
-void furry_hal_nfc_stop();
-
-/* Low level transport API, use it to implement your own transport layers */
-
-#define furry_hal_nfc_ll_ms2fc rfalConvMsTo1fc
-
-#define FURRY_HAL_NFC_LL_TXRX_FLAGS_CRC_TX_MANUAL RFAL_TXRX_FLAGS_CRC_TX_MANUAL
-#define FURRY_HAL_NFC_LL_TXRX_FLAGS_AGC_ON RFAL_TXRX_FLAGS_AGC_ON
-#define FURRY_HAL_NFC_LL_TXRX_FLAGS_PAR_RX_REMV RFAL_TXRX_FLAGS_PAR_RX_REMV
-#define FURRY_HAL_NFC_LL_TXRX_FLAGS_CRC_RX_KEEP RFAL_TXRX_FLAGS_CRC_RX_KEEP
-
-typedef enum {
-    FurryHalNfcReturnOk = 0, /*!< no error occurred */
-    FurryHalNfcReturnNomem = 1, /*!< not enough memory to perform the requested operation */
-    FurryHalNfcReturnBusy = 2, /*!< device or resource busy */
-    FurryHalNfcReturnIo = 3, /*!< generic IO error */
-    FurryHalNfcReturnTimeout = 4, /*!< error due to timeout */
-    FurryHalNfcReturnRequest =
-        5, /*!< invalid request or requested function can't be executed at the moment */
-    FurryHalNfcReturnNomsg = 6, /*!< No message of desired type */
-    FurryHalNfcReturnParam = 7, /*!< Parameter error */
-    FurryHalNfcReturnSystem = 8, /*!< System error */
-    FurryHalNfcReturnFraming = 9, /*!< Framing error */
-    FurryHalNfcReturnOverrun = 10, /*!< lost one or more received bytes */
-    FurryHalNfcReturnProto = 11, /*!< protocol error */
-    FurryHalNfcReturnInternal = 12, /*!< Internal Error */
-    FurryHalNfcReturnAgain = 13, /*!< Call again */
-    FurryHalNfcReturnMemCorrupt = 14, /*!< memory corruption */
-    FurryHalNfcReturnNotImplemented = 15, /*!< not implemented */
-    FurryHalNfcReturnPcCorrupt =
-        16, /*!< Program Counter has been manipulated or spike/noise trigger illegal operation */
-    FurryHalNfcReturnSend = 17, /*!< error sending*/
-    FurryHalNfcReturnIgnore = 18, /*!< indicates error detected but to be ignored */
-    FurryHalNfcReturnSemantic = 19, /*!< indicates error in state machine (unexpected cmd) */
-    FurryHalNfcReturnSyntax = 20, /*!< indicates error in state machine (unknown cmd) */
-    FurryHalNfcReturnCrc = 21, /*!< crc error */
-    FurryHalNfcReturnNotfound = 22, /*!< transponder not found */
-    FurryHalNfcReturnNotunique =
-        23, /*!< transponder not unique - more than one transponder in field */
-    FurryHalNfcReturnNotsupp = 24, /*!< requested operation not supported */
-    FurryHalNfcReturnWrite = 25, /*!< write error */
-    FurryHalNfcReturnFifo = 26, /*!< fifo over or underflow error */
-    FurryHalNfcReturnPar = 27, /*!< parity error */
-    FurryHalNfcReturnDone = 28, /*!< transfer has already finished */
-    FurryHalNfcReturnRfCollision =
-        29, /*!< collision error (Bit Collision or during RF Collision avoidance ) */
-    FurryHalNfcReturnHwOverrun = 30, /*!< lost one or more received bytes */
-    FurryHalNfcReturnReleaseReq = 31, /*!< device requested release */
-    FurryHalNfcReturnSleepReq = 32, /*!< device requested sleep */
-    FurryHalNfcReturnWrongState = 33, /*!< incorrent state for requested operation */
-    FurryHalNfcReturnMaxReruns = 34, /*!< blocking procedure reached maximum runs */
-    FurryHalNfcReturnDisabled = 35, /*!< operation aborted due to disabled configuration */
-    FurryHalNfcReturnHwMismatch = 36, /*!< expected hw do not match  */
-    FurryHalNfcReturnLinkLoss =
-        37, /*!< Other device's field didn't behave as expected: turned off by Initiator in Passive mode, or AP2P did not turn on field */
-    FurryHalNfcReturnInvalidHandle = 38, /*!< invalid or not initalized device handle */
-    FurryHalNfcReturnIncompleteByte = 40, /*!< Incomplete byte rcvd         */
-    FurryHalNfcReturnIncompleteByte01 = 41, /*!< Incomplete byte rcvd - 1 bit */
-    FurryHalNfcReturnIncompleteByte02 = 42, /*!< Incomplete byte rcvd - 2 bit */
-    FurryHalNfcReturnIncompleteByte03 = 43, /*!< Incomplete byte rcvd - 3 bit */
-    FurryHalNfcReturnIncompleteByte04 = 44, /*!< Incomplete byte rcvd - 4 bit */
-    FurryHalNfcReturnIncompleteByte05 = 45, /*!< Incomplete byte rcvd - 5 bit */
-    FurryHalNfcReturnIncompleteByte06 = 46, /*!< Incomplete byte rcvd - 6 bit */
-    FurryHalNfcReturnIncompleteByte07 = 47, /*!< Incomplete byte rcvd - 7 bit */
-} FurryHalNfcReturn;
-
-typedef enum {
-    FurryHalNfcModeNone = 0, /*!< No mode selected/defined */
-    FurryHalNfcModePollNfca = 1, /*!< Mode to perform as NFCA (ISO14443A) Poller (PCD) */
-    FurryHalNfcModePollNfcaT1t = 2, /*!< Mode to perform as NFCA T1T (Topaz) Poller (PCD) */
-    FurryHalNfcModePollNfcb = 3, /*!< Mode to perform as NFCB (ISO14443B) Poller (PCD) */
-    FurryHalNfcModePollBPrime = 4, /*!< Mode to perform as B' Calypso (Innovatron) (PCD) */
-    FurryHalNfcModePollBCts = 5, /*!< Mode to perform as CTS Poller (PCD) */
-    FurryHalNfcModePollNfcf = 6, /*!< Mode to perform as NFCF (FeliCa) Poller (PCD) */
-    FurryHalNfcModePollNfcv = 7, /*!< Mode to perform as NFCV (ISO15963) Poller (PCD) */
-    FurryHalNfcModePollPicopass = 8, /*!< Mode to perform as PicoPass / iClass Poller (PCD) */
-    FurryHalNfcModePollActiveP2p = 9, /*!< Mode to perform as Active P2P (ISO18092) Initiator  */
-    FurryHalNfcModeListenNfca = 10, /*!< Mode to perform as NFCA (ISO14443A) Listener (PICC) */
-    FurryHalNfcModeListenNfcb = 11, /*!< Mode to perform as NFCA (ISO14443B) Listener (PICC) */
-    FurryHalNfcModeListenNfcf = 12, /*!< Mode to perform as NFCA (ISO15963) Listener (PICC) */
-    FurryHalNfcModeListenActiveP2p = 13 /*!< Mode to perform as Active P2P (ISO18092) Target  */
-} FurryHalNfcMode;
-
-typedef enum {
-    FurryHalNfcBitrate106 = 0, /*!< Bit Rate 106 kbit/s (fc/128) */
-    FurryHalNfcBitrate212 = 1, /*!< Bit Rate 212 kbit/s (fc/64) */
-    FurryHalNfcBitrate424 = 2, /*!< Bit Rate 424 kbit/s (fc/32) */
-    FurryHalNfcBitrate848 = 3, /*!< Bit Rate 848 kbit/s (fc/16) */
-    FurryHalNfcBitrate1695 = 4, /*!< Bit Rate 1695 kbit/s (fc/8) */
-    FurryHalNfcBitrate3390 = 5, /*!< Bit Rate 3390 kbit/s (fc/4) */
-    FurryHalNfcBitrate6780 = 6, /*!< Bit Rate 6780 kbit/s (fc/2) */
-    FurryHalNfcBitrate13560 = 7, /*!< Bit Rate 13560 kbit/s (fc) */
-    FurryHalNfcBitrate52p97 = 0xEB, /*!< Bit Rate 52.97 kbit/s (fc/256) Fast Mode VICC->VCD */
-    FurryHalNfcBitrate26p48 =
-        0xEC, /*!< Bit Rate 26,48 kbit/s (fc/512) NFCV VICC->VCD & VCD->VICC 1of4 */
-    FurryHalNfcBitrate1p66 = 0xED, /*!< Bit Rate 1,66 kbit/s (fc/8192) NFCV VCD->VICC 1of256 */
-    FurryHalNfcBitrateKeep = 0xFF /*!< Value indicating to keep the same previous bit rate */
-} FurryHalNfcBitrate;
-
-FurryHalNfcReturn furry_hal_nfc_ll_set_mode(
-    FurryHalNfcMode mode,
-    FurryHalNfcBitrate txBR,
-    FurryHalNfcBitrate rxBR);
-
-#define FURRY_HAL_NFC_LL_GT_NFCA \
-    furry_hal_nfc_ll_ms2fc(5U) /*!< GTA  Digital 2.0  6.10.4.1 & B.2 */
-#define FURRY_HAL_NFC_LL_GT_NFCB \
-    furry_hal_nfc_ll_ms2fc(5U) /*!< GTB  Digital 2.0  7.9.4.1  & B.3 */
-#define FURRY_HAL_NFC_LL_GT_NFCF \
-    furry_hal_nfc_ll_ms2fc(20U) /*!< GTF  Digital 2.0  8.7.4.1  & B.4 */
-#define FURRY_HAL_NFC_LL_GT_NFCV \
-    furry_hal_nfc_ll_ms2fc(5U) /*!< GTV  Digital 2.0  9.7.5.1  & B.5 */
-#define FURRY_HAL_NFC_LL_GT_PICOPASS furry_hal_nfc_ll_ms2fc(1U) /*!< GT Picopass */
-#define FURRY_HAL_NFC_LL_GT_AP2P furry_hal_nfc_ll_ms2fc(5U) /*!< TIRFG  Ecma 340  11.1.1 */
-#define FURRY_HAL_NFC_LL_GT_AP2P_ADJUSTED \
-    furry_hal_nfc_ll_ms2fc(               \
-        5U +                              \
-        25U) /*!< Adjusted GT for greater interoperability (Sony XPERIA P, Nokia N9, Huawei P2) */
-
-void furry_hal_nfc_ll_set_guard_time(uint32_t cycles);
-
-typedef enum {
-    FurryHalNfcErrorHandlingNone = 0, /*!< No special error handling will be performed */
-    FurryHalNfcErrorHandlingNfc = 1, /*!< Error handling set to perform as NFC compliant device */
-    FurryHalNfcErrorHandlingEmvco =
-        2 /*!< Error handling set to perform as EMVCo compliant device */
-} FurryHalNfcErrorHandling;
-
-void furry_hal_nfc_ll_set_error_handling(FurryHalNfcErrorHandling eHandling);
-
-/* RFAL Frame Delay Time (FDT) Listen default values   */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCA_POLLER \
-    1172U /*!< FDTA,LISTEN,MIN (n=9) Last bit: Logic "1" - tnn,min/2 Digital 1.1  6.10 ;  EMV CCP Spec Book D v2.01  4.8.1.3 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCB_POLLER \
-    1008U /*!< TR0B,MIN         Digital 1.1  7.1.3 & A.3  ; EMV CCP Spec Book D v2.01  4.8.1.3 & Table A.5 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCF_POLLER \
-    2672U /*!< TR0F,LISTEN,MIN  Digital 1.1  8.7.1.1 & A.4 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCV_POLLER \
-    4310U /*!< FDTV,LISTEN,MIN  t1 min       Digital 2.1  B.5  ;  ISO15693-3 2009  9.1 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_PICOPASS_POLLER \
-    3400U /*!< ISO15693 t1 min - observed adjustment */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_AP2P_POLLER \
-    64U /*!< FDT AP2P No actual FDTListen is required as fields switch and collision avoidance */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCA_LISTENER 1172U /*!< FDTA,LISTEN,MIN  Digital 1.1  6.10 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCB_LISTENER \
-    1024U /*!< TR0B,MIN         Digital 1.1  7.1.3 & A.3  ;  EMV CCP Spec Book D v2.01  4.8.1.3 & Table A.5 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_NFCF_LISTENER \
-    2688U /*!< TR0F,LISTEN,MIN  Digital 2.1  8.7.1.1 & B.4 */
-#define FURRY_HAL_NFC_LL_FDT_LISTEN_AP2P_LISTENER \
-    64U /*!< FDT AP2P No actual FDTListen exists as fields switch and collision avoidance */
-
-void furry_hal_nfc_ll_set_fdt_listen(uint32_t cycles);
-
-/*  RFAL Frame Delay Time (FDT) Poll default values    */
-#define FURRY_HAL_NFC_LL_FDT_POLL_NFCA_POLLER \
-    6780U /*!< FDTA,POLL,MIN   Digital 1.1  6.10.3.1 & A.2 */
-#define FURRY_HAL_NFC_LL_FDT_POLL_NFCA_T1T_POLLER \
-    384U /*!< RRDDT1T,MIN,B1  Digital 1.1  10.7.1 & A.5 */
-#define FURRY_HAL_NFC_LL_FDT_POLL_NFCB_POLLER \
-    6780U /*!< FDTB,POLL,MIN = TR2B,MIN,DEFAULT Digital 1.1 7.9.3 & A.3  ;  EMVCo 3.0 FDTB,PCD,MIN  Table A.5 */
-#define FURRY_HAL_NFC_LL_FDT_POLL_NFCF_POLLER \
-    6800U /*!< FDTF,POLL,MIN   Digital 2.1  8.7.3 & B.4 */
-#define FURRY_HAL_NFC_LL_FDT_POLL_NFCV_POLLER 4192U /*!< FDTV,POLL  Digital 2.1  9.7.3.1  & B.5 */
-#define FURRY_HAL_NFC_LL_FDT_POLL_PICOPASS_POLLER 1790U /*!< FDT Max */
-#define FURRY_HAL_NFC_LL_FDT_POLL_AP2P_POLLER \
-    0U /*!< FDT AP2P No actual FDTPoll exists as fields switch and collision avoidance */
-
-void furry_hal_nfc_ll_set_fdt_poll(uint32_t FDTPoll);
-
-void furry_hal_nfc_ll_txrx_on();
-
-void furry_hal_nfc_ll_txrx_off();
-
-FurryHalNfcReturn furry_hal_nfc_ll_txrx(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-FurryHalNfcReturn furry_hal_nfc_ll_txrx_bits(
-    uint8_t* txBuf,
-    uint16_t txBufLen,
-    uint8_t* rxBuf,
-    uint16_t rxBufLen,
-    uint16_t* actLen,
-    uint32_t flags,
-    uint32_t fwt);
-
-void furry_hal_nfc_ll_poll();
-
-void furry_hal_nfc_field_detect_start();
-
-bool furry_hal_nfc_field_is_present();
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/helpers/mf_classic_dict.c

@@ -1,349 +0,0 @@
-#include "mf_classic_dict.h"
-
-#include <lib/toolbox/args.h>
-#include <lib/flipper_format/flipper_format.h>
-
-#define MF_CLASSIC_DICT_FLIPPER_PATH EXT_PATH("nfc/assets/mf_classic_dict.nfc")
-#define MF_CLASSIC_DICT_USER_PATH EXT_PATH("nfc/assets/mf_classic_dict_user.nfc")
-#define MF_CLASSIC_DICT_UNIT_TEST_PATH EXT_PATH("unit_tests/mf_classic_dict.nfc")
-
-#define TAG "MfClassicDict"
-
-#define NFC_MF_CLASSIC_KEY_LEN (13)
-
-struct MfClassicDict {
-    Stream* stream;
-    uint32_t total_keys;
-};
-
-bool mf_classic_dict_check_presence(MfClassicDictType dict_type) {
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-
-    bool dict_present = false;
-    if(dict_type == MfClassicDictTypeSystem) {
-        dict_present = storage_common_stat(storage, MF_CLASSIC_DICT_FLIPPER_PATH, NULL) == FSE_OK;
-    } else if(dict_type == MfClassicDictTypeUser) {
-        dict_present = storage_common_stat(storage, MF_CLASSIC_DICT_USER_PATH, NULL) == FSE_OK;
-    } else if(dict_type == MfClassicDictTypeUnitTest) {
-        dict_present = storage_common_stat(storage, MF_CLASSIC_DICT_UNIT_TEST_PATH, NULL) ==
-                       FSE_OK;
-    }
-
-    furi_record_close(RECORD_STORAGE);
-
-    return dict_present;
-}
-
-MfClassicDict* mf_classic_dict_alloc(MfClassicDictType dict_type) {
-    MfClassicDict* dict = malloc(sizeof(MfClassicDict));
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    dict->stream = buffered_file_stream_alloc(storage);
-    furi_record_close(RECORD_STORAGE);
-
-    bool dict_loaded = false;
-    do {
-        if(dict_type == MfClassicDictTypeSystem) {
-            if(!buffered_file_stream_open(
-                   dict->stream,
-                   MF_CLASSIC_DICT_FLIPPER_PATH,
-                   FSAM_READ_WRITE,
-                   FSOM_OPEN_EXISTING)) {
-                buffered_file_stream_close(dict->stream);
-                break;
-            }
-        } else if(dict_type == MfClassicDictTypeUser) {
-            if(!buffered_file_stream_open(
-                   dict->stream, MF_CLASSIC_DICT_USER_PATH, FSAM_READ_WRITE, FSOM_OPEN_ALWAYS)) {
-                buffered_file_stream_close(dict->stream);
-                break;
-            }
-        } else if(dict_type == MfClassicDictTypeUnitTest) {
-            if(!buffered_file_stream_open(
-                   dict->stream,
-                   MF_CLASSIC_DICT_UNIT_TEST_PATH,
-                   FSAM_READ_WRITE,
-                   FSOM_OPEN_ALWAYS)) {
-                buffered_file_stream_close(dict->stream);
-                break;
-            }
-        }
-
-        // Check for new line ending
-        if(!stream_eof(dict->stream)) {
-            if(!stream_seek(dict->stream, -1, StreamOffsetFromEnd)) break;
-            uint8_t last_char = 0;
-            if(stream_read(dict->stream, &last_char, 1) != 1) break;
-            if(last_char != '\n') {
-                FURI_LOG_D(TAG, "Adding new line ending");
-                if(stream_write_char(dict->stream, '\n') != 1) break;
-            }
-            if(!stream_rewind(dict->stream)) break;
-        }
-
-        // Read total amount of keys
-        FuriString* next_line;
-        next_line = furi_string_alloc();
-        while(true) {
-            if(!stream_read_line(dict->stream, next_line)) {
-                FURI_LOG_T(TAG, "No keys left in dict");
-                break;
-            }
-            FURI_LOG_T(
-                TAG,
-                "Read line: %s, len: %zu",
-                furi_string_get_cstr(next_line),
-                furi_string_size(next_line));
-            if(furi_string_get_char(next_line, 0) == '#') continue;
-            if(furi_string_size(next_line) != NFC_MF_CLASSIC_KEY_LEN) continue;
-            dict->total_keys++;
-        }
-        furi_string_free(next_line);
-        stream_rewind(dict->stream);
-
-        dict_loaded = true;
-        FURI_LOG_I(TAG, "Loaded dictionary with %lu keys", dict->total_keys);
-    } while(false);
-
-    if(!dict_loaded) {
-        buffered_file_stream_close(dict->stream);
-        free(dict);
-        dict = NULL;
-    }
-
-    return dict;
-}
-
-void mf_classic_dict_free(MfClassicDict* dict) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    buffered_file_stream_close(dict->stream);
-    stream_free(dict->stream);
-    free(dict);
-}
-
-static void mf_classic_dict_int_to_str(uint8_t* key_int, FuriString* key_str) {
-    furi_string_reset(key_str);
-    for(size_t i = 0; i < 6; i++) {
-        furi_string_cat_printf(key_str, "%02X", key_int[i]);
-    }
-}
-
-static void mf_classic_dict_str_to_int(FuriString* key_str, uint64_t* key_int) {
-    uint8_t key_byte_tmp;
-
-    *key_int = 0ULL;
-    for(uint8_t i = 0; i < 12; i += 2) {
-        args_char_to_hex(
-            furi_string_get_char(key_str, i), furi_string_get_char(key_str, i + 1), &key_byte_tmp);
-        *key_int |= (uint64_t)key_byte_tmp << (8 * (5 - i / 2));
-    }
-}
-
-uint32_t mf_classic_dict_get_total_keys(MfClassicDict* dict) {
-    furi_assert(dict);
-
-    return dict->total_keys;
-}
-
-bool mf_classic_dict_rewind(MfClassicDict* dict) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    return stream_rewind(dict->stream);
-}
-
-bool mf_classic_dict_get_next_key_str(MfClassicDict* dict, FuriString* key) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    bool key_read = false;
-    furi_string_reset(key);
-    while(!key_read) {
-        if(!stream_read_line(dict->stream, key)) break;
-        if(furi_string_get_char(key, 0) == '#') continue;
-        if(furi_string_size(key) != NFC_MF_CLASSIC_KEY_LEN) continue;
-        furi_string_left(key, 12);
-        key_read = true;
-    }
-
-    return key_read;
-}
-
-bool mf_classic_dict_get_next_key(MfClassicDict* dict, uint64_t* key) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* temp_key;
-    temp_key = furi_string_alloc();
-    bool key_read = mf_classic_dict_get_next_key_str(dict, temp_key);
-    if(key_read) {
-        mf_classic_dict_str_to_int(temp_key, key);
-    }
-    furi_string_free(temp_key);
-    return key_read;
-}
-
-bool mf_classic_dict_is_key_present_str(MfClassicDict* dict, FuriString* key) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* next_line;
-    next_line = furi_string_alloc();
-
-    bool key_found = false;
-    stream_rewind(dict->stream);
-    while(!key_found) { //-V654
-        if(!stream_read_line(dict->stream, next_line)) break;
-        if(furi_string_get_char(next_line, 0) == '#') continue;
-        if(furi_string_size(next_line) != NFC_MF_CLASSIC_KEY_LEN) continue;
-        furi_string_left(next_line, 12);
-        if(!furi_string_equal(key, next_line)) continue;
-        key_found = true;
-    }
-
-    furi_string_free(next_line);
-    return key_found;
-}
-
-bool mf_classic_dict_is_key_present(MfClassicDict* dict, uint8_t* key) {
-    FuriString* temp_key;
-
-    temp_key = furi_string_alloc();
-    mf_classic_dict_int_to_str(key, temp_key);
-    bool key_found = mf_classic_dict_is_key_present_str(dict, temp_key);
-    furi_string_free(temp_key);
-    return key_found;
-}
-
-bool mf_classic_dict_add_key_str(MfClassicDict* dict, FuriString* key) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    furi_string_cat_printf(key, "\n");
-
-    bool key_added = false;
-    do {
-        if(!stream_seek(dict->stream, 0, StreamOffsetFromEnd)) break;
-        if(!stream_insert_string(dict->stream, key)) break;
-        dict->total_keys++;
-        key_added = true;
-    } while(false);
-
-    furi_string_left(key, 12);
-    return key_added;
-}
-
-bool mf_classic_dict_add_key(MfClassicDict* dict, uint8_t* key) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* temp_key;
-    temp_key = furi_string_alloc();
-    mf_classic_dict_int_to_str(key, temp_key);
-    bool key_added = mf_classic_dict_add_key_str(dict, temp_key);
-
-    furi_string_free(temp_key);
-    return key_added;
-}
-
-bool mf_classic_dict_get_key_at_index_str(MfClassicDict* dict, FuriString* key, uint32_t target) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* next_line;
-    uint32_t index = 0;
-    next_line = furi_string_alloc();
-    furi_string_reset(key);
-
-    bool key_found = false;
-    while(!key_found) {
-        if(!stream_read_line(dict->stream, next_line)) break;
-        if(furi_string_get_char(next_line, 0) == '#') continue;
-        if(furi_string_size(next_line) != NFC_MF_CLASSIC_KEY_LEN) continue;
-        if(index++ != target) continue;
-        furi_string_set_n(key, next_line, 0, 12);
-        key_found = true;
-    }
-
-    furi_string_free(next_line);
-    return key_found;
-}
-
-bool mf_classic_dict_get_key_at_index(MfClassicDict* dict, uint64_t* key, uint32_t target) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* temp_key;
-    temp_key = furi_string_alloc();
-    bool key_found = mf_classic_dict_get_key_at_index_str(dict, temp_key, target);
-    if(key_found) {
-        mf_classic_dict_str_to_int(temp_key, key);
-    }
-    furi_string_free(temp_key);
-    return key_found;
-}
-
-bool mf_classic_dict_find_index_str(MfClassicDict* dict, FuriString* key, uint32_t* target) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* next_line;
-    next_line = furi_string_alloc();
-
-    bool key_found = false;
-    uint32_t index = 0;
-    stream_rewind(dict->stream);
-    while(!key_found) { //-V654
-        if(!stream_read_line(dict->stream, next_line)) break;
-        if(furi_string_get_char(next_line, 0) == '#') continue;
-        if(furi_string_size(next_line) != NFC_MF_CLASSIC_KEY_LEN) continue;
-        furi_string_left(next_line, 12);
-        if(!furi_string_equal(key, next_line)) continue;
-        key_found = true;
-        *target = index;
-    }
-
-    furi_string_free(next_line);
-    return key_found;
-}
-
-bool mf_classic_dict_find_index(MfClassicDict* dict, uint8_t* key, uint32_t* target) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* temp_key;
-    temp_key = furi_string_alloc();
-    mf_classic_dict_int_to_str(key, temp_key);
-    bool key_found = mf_classic_dict_find_index_str(dict, temp_key, target);
-
-    furi_string_free(temp_key);
-    return key_found;
-}
-
-bool mf_classic_dict_delete_index(MfClassicDict* dict, uint32_t target) {
-    furi_assert(dict);
-    furi_assert(dict->stream);
-
-    FuriString* next_line;
-    next_line = furi_string_alloc();
-    uint32_t index = 0;
-
-    bool key_removed = false;
-    stream_rewind(dict->stream);
-    while(!key_removed) {
-        if(!stream_read_line(dict->stream, next_line)) break;
-        if(furi_string_get_char(next_line, 0) == '#') continue;
-        if(furi_string_size(next_line) != NFC_MF_CLASSIC_KEY_LEN) continue;
-        if(index++ != target) continue;
-        stream_seek(dict->stream, -NFC_MF_CLASSIC_KEY_LEN, StreamOffsetFromCurrent);
-        if(!stream_delete(dict->stream, NFC_MF_CLASSIC_KEY_LEN)) break;
-        dict->total_keys--;
-        key_removed = true;
-    }
-
-    stream_rewind(dict->stream);
-
-    furi_string_free(next_line);
-    return key_removed;
-}

esubghz_chat/lib/nfclegacy/helpers/mf_classic_dict.h

@@ -1,107 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include <storage/storage.h>
-#include <lib/flipper_format/flipper_format.h>
-#include <lib/toolbox/stream/file_stream.h>
-#include <lib/toolbox/stream/buffered_file_stream.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    MfClassicDictTypeUser,
-    MfClassicDictTypeSystem,
-    MfClassicDictTypeUnitTest,
-} MfClassicDictType;
-
-typedef struct MfClassicDict MfClassicDict;
-
-bool mf_classic_dict_check_presence(MfClassicDictType dict_type);
-
-/** Allocate MfClassicDict instance
- *
- * @param[in]  dict_type  The dictionary type
- *
- * @return     MfClassicDict instance
- */
-MfClassicDict* mf_classic_dict_alloc(MfClassicDictType dict_type);
-
-/** Free MfClassicDict instance
- *
- * @param      dict  MfClassicDict instance
- */
-void mf_classic_dict_free(MfClassicDict* dict);
-
-/** Get total keys count
- *
- * @param      dict  MfClassicDict instance
- *
- * @return     total keys count
- */
-uint32_t mf_classic_dict_get_total_keys(MfClassicDict* dict);
-
-/** Rewind to the beginning
- *
- * @param      dict  MfClassicDict instance
- *
- * @return     true on success
- */
-bool mf_classic_dict_rewind(MfClassicDict* dict);
-
-bool mf_classic_dict_is_key_present(MfClassicDict* dict, uint8_t* key);
-
-bool mf_classic_dict_is_key_present_str(MfClassicDict* dict, FuriString* key);
-
-bool mf_classic_dict_get_next_key(MfClassicDict* dict, uint64_t* key);
-
-bool mf_classic_dict_get_next_key_str(MfClassicDict* dict, FuriString* key);
-
-/** Get key at target offset as uint64_t
- *
- * @param      dict    MfClassicDict instance
- * @param[out] key     Pointer to the uint64_t key
- * @param[in]  target  Target offset from current position
- *
- * @return     true on success
- */
-bool mf_classic_dict_get_key_at_index(MfClassicDict* dict, uint64_t* key, uint32_t target);
-
-/** Get key at target offset as FuriString*
- *
- * @param      dict    MfClassicDict instance
- * @param[out] key     Found key destination buffer
- * @param[in]  target  Target offset from current position
- *
- * @return     true on success
- */
-bool mf_classic_dict_get_key_at_index_str(MfClassicDict* dict, FuriString* key, uint32_t target);
-
-bool mf_classic_dict_add_key(MfClassicDict* dict, uint8_t* key);
-
-/** Add string representation of the key
- *
- * @param      dict  MfClassicDict instance
- * @param[in]  key   String representation of the key
- *
- * @return     true on success
- */
-bool mf_classic_dict_add_key_str(MfClassicDict* dict, FuriString* key);
-
-bool mf_classic_dict_find_index(MfClassicDict* dict, uint8_t* key, uint32_t* target);
-
-bool mf_classic_dict_find_index_str(MfClassicDict* dict, FuriString* key, uint32_t* target);
-
-/** Delete key at target offset
- *
- * @param      dict    MfClassicDict instance
- * @param[in]  target  Target offset from current position
- *
- * @return     true on success
- */
-bool mf_classic_dict_delete_index(MfClassicDict* dict, uint32_t target);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/helpers/mfkey32.c

@@ -1,228 +0,0 @@
-#include "mfkey32.h"
-
-#include <furi/furi.h>
-#include <storage/storage.h>
-#include <stream/stream.h>
-#include <stream/buffered_file_stream.h>
-#include <m-array.h>
-
-#include "../protocols/mifare_classic.h"
-#include "../protocols/nfc_util.h"
-
-#define TAG "Mfkey32"
-
-#define MFKEY32_LOGS_PATH EXT_PATH("nfc/.mfkey32.log")
-
-typedef enum {
-    Mfkey32StateIdle,
-    Mfkey32StateAuthReceived,
-    Mfkey32StateAuthNtSent,
-    Mfkey32StateAuthArNrReceived,
-} Mfkey32State;
-
-typedef struct {
-    uint32_t cuid;
-    uint8_t sector;
-    MfClassicKey key;
-    uint32_t nt0;
-    uint32_t nr0;
-    uint32_t ar0;
-    uint32_t nt1;
-    uint32_t nr1;
-    uint32_t ar1;
-} Mfkey32Params;
-
-ARRAY_DEF(Mfkey32Params, Mfkey32Params, M_POD_OPLIST);
-
-typedef struct {
-    uint8_t sector;
-    MfClassicKey key;
-    uint32_t nt;
-    uint32_t nr;
-    uint32_t ar;
-} Mfkey32Nonce;
-
-struct Mfkey32 {
-    Mfkey32State state;
-    Stream* file_stream;
-    Mfkey32Params_t params_arr;
-    Mfkey32Nonce nonce;
-    uint32_t cuid;
-    Mfkey32ParseDataCallback callback;
-    void* context;
-};
-
-Mfkey32* mfkey32_alloc(uint32_t cuid) {
-    Mfkey32* instance = malloc(sizeof(Mfkey32));
-    instance->cuid = cuid;
-    instance->state = Mfkey32StateIdle;
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    instance->file_stream = buffered_file_stream_alloc(storage);
-    if(!buffered_file_stream_open(
-           instance->file_stream, MFKEY32_LOGS_PATH, FSAM_WRITE, FSOM_OPEN_APPEND)) {
-        buffered_file_stream_close(instance->file_stream);
-        stream_free(instance->file_stream);
-        free(instance);
-        instance = NULL;
-    } else {
-        Mfkey32Params_init(instance->params_arr);
-    }
-
-    furi_record_close(RECORD_STORAGE);
-
-    return instance;
-}
-
-void mfkey32_free(Mfkey32* instance) {
-    furi_assert(instance != NULL);
-
-    Mfkey32Params_clear(instance->params_arr);
-    buffered_file_stream_close(instance->file_stream);
-    stream_free(instance->file_stream);
-    free(instance);
-}
-
-void mfkey32_set_callback(Mfkey32* instance, Mfkey32ParseDataCallback callback, void* context) {
-    furi_assert(instance);
-    furi_assert(callback);
-
-    instance->callback = callback;
-    instance->context = context;
-}
-
-static bool mfkey32_write_params(Mfkey32* instance, Mfkey32Params* params) {
-    FuriString* str = furi_string_alloc_printf(
-        "Sec %d key %c cuid %08lx nt0 %08lx nr0 %08lx ar0 %08lx nt1 %08lx nr1 %08lx ar1 %08lx\n",
-        params->sector,
-        params->key == MfClassicKeyA ? 'A' : 'B',
-        params->cuid,
-        params->nt0,
-        params->nr0,
-        params->ar0,
-        params->nt1,
-        params->nr1,
-        params->ar1);
-    bool write_success = stream_write_string(instance->file_stream, str);
-    furi_string_free(str);
-    return write_success;
-}
-
-static void mfkey32_add_params(Mfkey32* instance) {
-    Mfkey32Nonce* nonce = &instance->nonce;
-    bool nonce_added = false;
-    // Search if we partially collected params
-    if(Mfkey32Params_size(instance->params_arr)) {
-        Mfkey32Params_it_t it;
-        for(Mfkey32Params_it(it, instance->params_arr); !Mfkey32Params_end_p(it);
-            Mfkey32Params_next(it)) {
-            Mfkey32Params* params = Mfkey32Params_ref(it);
-            if((params->sector == nonce->sector) && (params->key == nonce->key)) {
-                params->nt1 = nonce->nt;
-                params->nr1 = nonce->nr;
-                params->ar1 = nonce->ar;
-                nonce_added = true;
-                FURI_LOG_I(
-                    TAG,
-                    "Params for sector %d key %c collected",
-                    params->sector,
-                    params->key == MfClassicKeyA ? 'A' : 'B');
-                // Write on sd card
-                if(mfkey32_write_params(instance, params)) {
-                    Mfkey32Params_remove(instance->params_arr, it);
-                    if(instance->callback) {
-                        instance->callback(Mfkey32EventParamCollected, instance->context);
-                    }
-                }
-            }
-        }
-    }
-    if(!nonce_added) {
-        Mfkey32Params params = {
-            .sector = nonce->sector,
-            .key = nonce->key,
-            .cuid = instance->cuid,
-            .nt0 = nonce->nt,
-            .nr0 = nonce->nr,
-            .ar0 = nonce->ar,
-        };
-        Mfkey32Params_push_back(instance->params_arr, params);
-    }
-}
-
-void mfkey32_process_data(
-    Mfkey32* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    furi_assert(instance);
-    furi_assert(data);
-
-    Mfkey32Nonce* nonce = &instance->nonce;
-    uint16_t data_len = len;
-    if((data_len > 3) && !crc_dropped) {
-        data_len -= 2;
-    }
-
-    bool data_processed = false;
-    if(instance->state == Mfkey32StateIdle) {
-        if(reader_to_tag) {
-            if((data[0] == 0x60) || (data[0] == 0x61)) {
-                nonce->key = data[0] == 0x60 ? MfClassicKeyA : MfClassicKeyB;
-                nonce->sector = mf_classic_get_sector_by_block(data[1]);
-                instance->state = Mfkey32StateAuthReceived;
-                data_processed = true;
-            }
-        }
-    } else if(instance->state == Mfkey32StateAuthReceived) {
-        if(!reader_to_tag) {
-            if(len == 4) {
-                nonce->nt = nfc_util_bytes2num(data, 4);
-                instance->state = Mfkey32StateAuthNtSent;
-                data_processed = true;
-            }
-        }
-    } else if(instance->state == Mfkey32StateAuthNtSent) {
-        if(reader_to_tag) {
-            if(len == 8) {
-                nonce->nr = nfc_util_bytes2num(data, 4);
-                nonce->ar = nfc_util_bytes2num(&data[4], 4);
-                mfkey32_add_params(instance);
-                instance->state = Mfkey32StateIdle;
-            }
-        }
-    }
-    if(!data_processed) {
-        instance->state = Mfkey32StateIdle;
-    }
-}
-
-uint16_t mfkey32_get_auth_sectors(FuriString* data_str) {
-    furi_assert(data_str);
-
-    uint16_t nonces_num = 0;
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    Stream* file_stream = buffered_file_stream_alloc(storage);
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    do {
-        if(!buffered_file_stream_open(
-               file_stream, MFKEY32_LOGS_PATH, FSAM_READ, FSOM_OPEN_EXISTING))
-            break;
-        while(true) {
-            if(!stream_read_line(file_stream, temp_str)) break;
-            size_t uid_pos = furi_string_search(temp_str, "cuid");
-            furi_string_left(temp_str, uid_pos);
-            furi_string_push_back(temp_str, '\n');
-            furi_string_cat(data_str, temp_str);
-            nonces_num++;
-        }
-    } while(false);
-
-    buffered_file_stream_close(file_stream);
-    stream_free(file_stream);
-    furi_string_free(temp_str);
-
-    return nonces_num;
-}

esubghz_chat/lib/nfclegacy/helpers/mfkey32.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "../protocols/mifare_classic.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct Mfkey32 Mfkey32;
-
-typedef enum {
-    Mfkey32EventParamCollected,
-} Mfkey32Event;
-
-typedef void (*Mfkey32ParseDataCallback)(Mfkey32Event event, void* context);
-
-Mfkey32* mfkey32_alloc(uint32_t cuid);
-
-void mfkey32_free(Mfkey32* instance);
-
-void mfkey32_process_data(
-    Mfkey32* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped);
-
-void mfkey32_set_callback(Mfkey32* instance, Mfkey32ParseDataCallback callback, void* context);
-
-uint16_t mfkey32_get_auth_sectors(FuriString* string);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/helpers/nfc_debug_log.c

@@ -1,71 +0,0 @@
-#include "nfc_debug_log.h"
-
-#include <storage/storage.h>
-#include <stream/buffered_file_stream.h>
-
-#define TAG "NfcDebugLog"
-
-#define NFC_DEBUG_PCAP_FILENAME EXT_PATH("nfc/debug.txt")
-
-struct NfcDebugLog {
-    Stream* file_stream;
-    FuriString* data_str;
-};
-
-NfcDebugLog* nfc_debug_log_alloc() {
-    NfcDebugLog* instance = malloc(sizeof(NfcDebugLog));
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    instance->file_stream = buffered_file_stream_alloc(storage);
-
-    if(!buffered_file_stream_open(
-           instance->file_stream, NFC_DEBUG_PCAP_FILENAME, FSAM_WRITE, FSOM_OPEN_APPEND)) {
-        buffered_file_stream_close(instance->file_stream);
-        stream_free(instance->file_stream);
-        instance->file_stream = NULL;
-    }
-
-    if(!instance->file_stream) {
-        free(instance);
-        instance = NULL;
-    } else {
-        instance->data_str = furi_string_alloc();
-    }
-    furi_record_close(RECORD_STORAGE);
-
-    return instance;
-}
-
-void nfc_debug_log_free(NfcDebugLog* instance) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-    furi_assert(instance->data_str);
-
-    buffered_file_stream_close(instance->file_stream);
-    stream_free(instance->file_stream);
-    furi_string_free(instance->data_str);
-
-    free(instance);
-}
-
-void nfc_debug_log_process_data(
-    NfcDebugLog* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-    furi_assert(instance->data_str);
-    furi_assert(data);
-    UNUSED(crc_dropped);
-
-    furi_string_printf(instance->data_str, "%lu %c:", furi_get_tick(), reader_to_tag ? 'R' : 'T');
-    uint16_t data_len = len;
-    for(size_t i = 0; i < data_len; i++) {
-        furi_string_cat_printf(instance->data_str, " %02x", data[i]);
-    }
-    furi_string_push_back(instance->data_str, '\n');
-
-    stream_write_string(instance->file_stream, instance->data_str);
-}

esubghz_chat/lib/nfclegacy/helpers/nfc_debug_log.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef struct NfcDebugLog NfcDebugLog;
-
-NfcDebugLog* nfc_debug_log_alloc();
-
-void nfc_debug_log_free(NfcDebugLog* instance);
-
-void nfc_debug_log_process_data(
-    NfcDebugLog* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped);

esubghz_chat/lib/nfclegacy/helpers/nfc_debug_pcap.c

@@ -1,128 +0,0 @@
-#include "nfc_debug_pcap.h"
-
-#include <storage/storage.h>
-#include <stream/buffered_file_stream.h>
-#include "../furi_hal_nfc.h"
-#include <furi_hal_rtc.h>
-
-#define TAG "NfcDebugPcap"
-
-#define PCAP_MAGIC 0xa1b2c3d4
-#define PCAP_MAJOR 2
-#define PCAP_MINOR 4
-#define DLT_ISO_14443 264
-
-#define DATA_PICC_TO_PCD 0xFF
-#define DATA_PCD_TO_PICC 0xFE
-#define DATA_PICC_TO_PCD_CRC_DROPPED 0xFB
-#define DATA_PCD_TO_PICC_CRC_DROPPED 0xFA
-
-#define NFC_DEBUG_PCAP_FILENAME EXT_PATH("nfc/debug.pcap")
-
-struct NfcDebugPcap {
-    Stream* file_stream;
-};
-
-static Stream* nfc_debug_pcap_open(Storage* storage) {
-    Stream* stream = NULL;
-    stream = buffered_file_stream_alloc(storage);
-    if(!buffered_file_stream_open(stream, NFC_DEBUG_PCAP_FILENAME, FSAM_WRITE, FSOM_OPEN_APPEND)) {
-        buffered_file_stream_close(stream);
-        stream_free(stream);
-        stream = NULL;
-    } else {
-        if(!stream_tell(stream)) {
-            struct {
-                uint32_t magic;
-                uint16_t major, minor;
-                uint32_t reserved[2];
-                uint32_t snaplen;
-                uint32_t link_type;
-            } __attribute__((__packed__)) pcap_hdr = {
-                .magic = PCAP_MAGIC,
-                .major = PCAP_MAJOR,
-                .minor = PCAP_MINOR,
-                .snaplen = FURRY_HAL_NFC_DATA_BUFF_SIZE,
-                .link_type = DLT_ISO_14443,
-            };
-            if(stream_write(stream, (uint8_t*)&pcap_hdr, sizeof(pcap_hdr)) != sizeof(pcap_hdr)) {
-                FURI_LOG_E(TAG, "Failed to write pcap header");
-                buffered_file_stream_close(stream);
-                stream_free(stream);
-                stream = NULL;
-            }
-        }
-    }
-    return stream;
-}
-
-NfcDebugPcap* nfc_debug_pcap_alloc() {
-    NfcDebugPcap* instance = malloc(sizeof(NfcDebugPcap));
-
-    Storage* storage = furi_record_open(RECORD_STORAGE);
-    instance->file_stream = nfc_debug_pcap_open(storage);
-    if(!instance->file_stream) {
-        free(instance);
-        instance = NULL;
-    }
-    furi_record_close(RECORD_STORAGE);
-
-    return instance;
-}
-
-void nfc_debug_pcap_free(NfcDebugPcap* instance) {
-    furi_assert(instance);
-    furi_assert(instance->file_stream);
-
-    buffered_file_stream_close(instance->file_stream);
-    stream_free(instance->file_stream);
-
-    free(instance);
-}
-
-void nfc_debug_pcap_process_data(
-    NfcDebugPcap* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    furi_assert(instance);
-    furi_assert(data);
-
-    uint8_t event = 0;
-    if(reader_to_tag) {
-        if(crc_dropped) {
-            event = DATA_PCD_TO_PICC_CRC_DROPPED;
-        } else {
-            event = DATA_PCD_TO_PICC;
-        }
-    } else {
-        if(crc_dropped) {
-            event = DATA_PICC_TO_PCD_CRC_DROPPED;
-        } else {
-            event = DATA_PICC_TO_PCD;
-        }
-    }
-
-    struct {
-        // https://wiki.wireshark.org/Development/LibpcapFileFormat#record-packet-header
-        uint32_t ts_sec;
-        uint32_t ts_usec;
-        uint32_t incl_len;
-        uint32_t orig_len;
-        // https://www.kaiser.cx/posts/pcap-iso14443/#_packet_data
-        uint8_t version;
-        uint8_t event;
-        uint16_t len;
-    } __attribute__((__packed__)) pkt_hdr = {
-        .ts_sec = furi_hal_rtc_get_timestamp(),
-        .ts_usec = 0,
-        .incl_len = len + 4,
-        .orig_len = len + 4,
-        .version = 0,
-        .event = event,
-        .len = len << 8 | len >> 8,
-    };
-    stream_write(instance->file_stream, (uint8_t*)&pkt_hdr, sizeof(pkt_hdr));
-    stream_write(instance->file_stream, data, len);
-}

esubghz_chat/lib/nfclegacy/helpers/nfc_debug_pcap.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef struct NfcDebugPcap NfcDebugPcap;
-
-NfcDebugPcap* nfc_debug_pcap_alloc();
-
-void nfc_debug_pcap_free(NfcDebugPcap* instance);
-
-void nfc_debug_pcap_process_data(
-    NfcDebugPcap* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped);

esubghz_chat/lib/nfclegacy/helpers/nfc_generators.c

@@ -1,548 +0,0 @@
-#include <furi_hal_random.h>
-#include "nfc_generators.h"
-
-#define NXP_MANUFACTURER_ID (0x04)
-
-static const uint8_t version_bytes_mf0ulx1[] = {0x00, 0x04, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03};
-static const uint8_t version_bytes_ntag21x[] = {0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x03};
-static const uint8_t version_bytes_ntag_i2c[] = {0x00, 0x04, 0x04, 0x05, 0x02, 0x00, 0x00, 0x03};
-static const uint8_t default_data_ntag203[] =
-    {0xE1, 0x10, 0x12, 0x00, 0x01, 0x03, 0xA0, 0x10, 0x44, 0x03, 0x00, 0xFE};
-static const uint8_t default_data_ntag213[] = {0x01, 0x03, 0xA0, 0x0C, 0x34, 0x03, 0x00, 0xFE};
-static const uint8_t default_data_ntag215_216[] = {0x03, 0x00, 0xFE};
-static const uint8_t default_data_ntag_i2c[] = {0xE1, 0x10, 0x00, 0x00, 0x03, 0x00, 0xFE};
-static const uint8_t default_config_ntag_i2c[] = {0x01, 0x00, 0xF8, 0x48, 0x08, 0x01, 0x00, 0x00};
-
-static void nfc_generate_common_start(NfcDeviceData* data) {
-    nfc_device_data_clear(data);
-}
-
-static void nfc_generate_mf_ul_uid(uint8_t* uid) {
-    uid[0] = NXP_MANUFACTURER_ID;
-    furi_hal_random_fill_buf(&uid[1], 6);
-    // I'm not sure how this is generated, but the upper nybble always seems to be 8
-    uid[6] &= 0x0F;
-    uid[6] |= 0x80;
-}
-
-static void nfc_generate_mf_classic_uid(uint8_t* uid, uint8_t length) {
-    uid[0] = NXP_MANUFACTURER_ID;
-    furi_hal_random_fill_buf(&uid[1], length - 1);
-}
-
-static void nfc_generate_mf_classic_block_0(
-    uint8_t* block,
-    uint8_t uid_len,
-    uint8_t sak,
-    uint8_t atqa0,
-    uint8_t atqa1) {
-    // Block length is always 16 bytes, and the UID can be either 4 or 7 bytes
-    furi_assert(uid_len == 4 || uid_len == 7);
-    furi_assert(block);
-
-    if(uid_len == 4) {
-        // Calculate BCC
-        block[uid_len] = 0;
-
-        for(int i = 0; i < uid_len; i++) {
-            block[uid_len] ^= block[i];
-        }
-    } else {
-        uid_len -= 1;
-    }
-
-    block[uid_len + 1] = sak;
-    block[uid_len + 2] = atqa0;
-    block[uid_len + 3] = atqa1;
-
-    for(int i = uid_len + 4; i < 16; i++) {
-        block[i] = 0xFF;
-    }
-}
-
-static void nfc_generate_mf_classic_sector_trailer(MfClassicData* data, uint8_t block) {
-    // All keys are set to FFFF FFFF FFFFh at chip delivery and the bytes 6, 7 and 8 are set to FF0780h.
-    MfClassicSectorTrailer* sec_tr = (MfClassicSectorTrailer*)data->block[block].value;
-    sec_tr->access_bits[0] = 0xFF;
-    sec_tr->access_bits[1] = 0x07;
-    sec_tr->access_bits[2] = 0x80;
-    sec_tr->access_bits[3] = 0x69; // Nice
-
-    memset(sec_tr->key_a, 0xff, sizeof(sec_tr->key_a));
-    memset(sec_tr->key_b, 0xff, sizeof(sec_tr->key_b));
-
-    mf_classic_set_block_read(data, block, &data->block[block]);
-    mf_classic_set_key_found(
-        data, mf_classic_get_sector_by_block(block), MfClassicKeyA, 0xFFFFFFFFFFFF);
-    mf_classic_set_key_found(
-        data, mf_classic_get_sector_by_block(block), MfClassicKeyB, 0xFFFFFFFFFFFF);
-}
-
-static void nfc_generate_mf_ul_common(NfcDeviceData* data) {
-    data->nfc_data.type = FurryHalNfcTypeA;
-    data->nfc_data.interface = FurryHalNfcInterfaceRf;
-    data->nfc_data.uid_len = 7;
-    nfc_generate_mf_ul_uid(data->nfc_data.uid);
-    data->nfc_data.atqa[0] = 0x44;
-    data->nfc_data.atqa[1] = 0x00;
-    data->nfc_data.sak = 0x00;
-    data->protocol = NfcDeviceProtocolMifareUl;
-}
-
-static void
-    nfc_generate_mf_classic_common(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
-    data->nfc_data.type = FurryHalNfcTypeA;
-    data->nfc_data.interface = FurryHalNfcInterfaceRf;
-    data->nfc_data.uid_len = uid_len;
-    data->nfc_data.atqa[0] = 0x44;
-    data->nfc_data.atqa[1] = 0x00;
-    data->nfc_data.sak = 0x08;
-    data->protocol = NfcDeviceProtocolMifareClassic;
-    data->mf_classic_data.type = type;
-}
-
-static void nfc_generate_calc_bcc(uint8_t* uid, uint8_t* bcc0, uint8_t* bcc1) {
-    *bcc0 = 0x88 ^ uid[0] ^ uid[1] ^ uid[2];
-    *bcc1 = uid[3] ^ uid[4] ^ uid[5] ^ uid[6];
-}
-
-static void nfc_generate_mf_ul_copy_uid_with_bcc(NfcDeviceData* data) {
-    MfUltralightData* mful = &data->mf_ul_data;
-    memcpy(mful->data, data->nfc_data.uid, 3);
-    memcpy(&mful->data[4], &data->nfc_data.uid[3], 4);
-    nfc_generate_calc_bcc(data->nfc_data.uid, &mful->data[3], &mful->data[8]);
-}
-
-static void nfc_generate_mf_ul_orig(NfcDeviceData* data) {
-    nfc_generate_common_start(data);
-    nfc_generate_mf_ul_common(data);
-
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeUnknown;
-    mful->data_size = 16 * 4;
-    mful->data_read = mful->data_size;
-    nfc_generate_mf_ul_copy_uid_with_bcc(data);
-    // TODO: what's internal byte on page 2?
-    memset(&mful->data[4 * 4], 0xFF, 4);
-}
-
-static void nfc_generate_mf_ul_ntag203(NfcDeviceData* data) {
-    nfc_generate_common_start(data);
-    nfc_generate_mf_ul_common(data);
-
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeNTAG203;
-    mful->data_size = 42 * 4;
-    mful->data_read = mful->data_size;
-    nfc_generate_mf_ul_copy_uid_with_bcc(data);
-    mful->data[9] = 0x48; // Internal byte
-    memcpy(&mful->data[3 * 4], default_data_ntag203, sizeof(default_data_ntag203));
-}
-
-static void nfc_generate_mf_ul_with_config_common(NfcDeviceData* data, uint8_t num_pages) {
-    nfc_generate_common_start(data);
-    nfc_generate_mf_ul_common(data);
-
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->data_size = num_pages * 4;
-    mful->data_read = mful->data_size;
-    nfc_generate_mf_ul_copy_uid_with_bcc(data);
-    uint16_t config_index = (num_pages - 4) * 4;
-    mful->data[config_index] = 0x04; // STRG_MOD_EN
-    mful->data[config_index + 3] = 0xFF; // AUTH0
-    mful->data[config_index + 5] = 0x05; // VCTID
-    memset(&mful->data[config_index + 8], 0xFF, 4); // Default PWD
-    if(num_pages > 20) mful->data[config_index - 1] = MF_UL_TEARING_FLAG_DEFAULT;
-}
-
-static void nfc_generate_mf_ul_ev1_common(NfcDeviceData* data, uint8_t num_pages) {
-    nfc_generate_mf_ul_with_config_common(data, num_pages);
-    MfUltralightData* mful = &data->mf_ul_data;
-    memcpy(&mful->version, version_bytes_mf0ulx1, sizeof(version_bytes_mf0ulx1));
-    for(size_t i = 0; i < 3; ++i) {
-        mful->tearing[i] = MF_UL_TEARING_FLAG_DEFAULT;
-    }
-    // TODO: what's internal byte on page 2?
-}
-
-static void nfc_generate_mf_ul_11(NfcDeviceData* data) {
-    nfc_generate_mf_ul_ev1_common(data, 20);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeUL11;
-    mful->version.prod_subtype = 0x01;
-    mful->version.storage_size = 0x0B;
-    mful->data[16 * 4] = 0x00; // Low capacitance version does not have STRG_MOD_EN
-}
-
-static void nfc_generate_mf_ul_h11(NfcDeviceData* data) {
-    nfc_generate_mf_ul_ev1_common(data, 20);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeUL11;
-    mful->version.prod_subtype = 0x02;
-    mful->version.storage_size = 0x0B;
-}
-
-static void nfc_generate_mf_ul_21(NfcDeviceData* data) {
-    nfc_generate_mf_ul_ev1_common(data, 41);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeUL21;
-    mful->version.prod_subtype = 0x01;
-    mful->version.storage_size = 0x0E;
-    mful->data[37 * 4] = 0x00; // Low capacitance version does not have STRG_MOD_EN
-}
-
-static void nfc_generate_mf_ul_h21(NfcDeviceData* data) {
-    nfc_generate_mf_ul_ev1_common(data, 41);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeUL21;
-    mful->version.prod_subtype = 0x02;
-    mful->version.storage_size = 0x0E;
-}
-
-static void nfc_generate_ntag21x_common(NfcDeviceData* data, uint8_t num_pages) {
-    nfc_generate_mf_ul_with_config_common(data, num_pages);
-    MfUltralightData* mful = &data->mf_ul_data;
-    memcpy(&mful->version, version_bytes_ntag21x, sizeof(version_bytes_mf0ulx1));
-    mful->data[9] = 0x48; // Internal byte
-    // Capability container
-    mful->data[12] = 0xE1;
-    mful->data[13] = 0x10;
-}
-
-static void nfc_generate_ntag213(NfcDeviceData* data) {
-    nfc_generate_ntag21x_common(data, 45);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeNTAG213;
-    mful->version.storage_size = 0x0F;
-    mful->data[14] = 0x12;
-    // Default contents
-    memcpy(&mful->data[16], default_data_ntag213, sizeof(default_data_ntag213));
-}
-
-static void nfc_generate_ntag215(NfcDeviceData* data) {
-    nfc_generate_ntag21x_common(data, 135);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeNTAG215;
-    mful->version.storage_size = 0x11;
-    mful->data[14] = 0x3E;
-    // Default contents
-    memcpy(&mful->data[16], default_data_ntag215_216, sizeof(default_data_ntag215_216));
-}
-
-static void nfc_generate_ntag216(NfcDeviceData* data) {
-    nfc_generate_ntag21x_common(data, 231);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = MfUltralightTypeNTAG216;
-    mful->version.storage_size = 0x13;
-    mful->data[14] = 0x6D;
-    // Default contents
-    memcpy(&mful->data[16], default_data_ntag215_216, sizeof(default_data_ntag215_216));
-}
-
-static void
-    nfc_generate_ntag_i2c_common(NfcDeviceData* data, MfUltralightType type, uint16_t num_pages) {
-    nfc_generate_common_start(data);
-    nfc_generate_mf_ul_common(data);
-
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->type = type;
-    memcpy(&mful->version, version_bytes_ntag_i2c, sizeof(version_bytes_ntag_i2c));
-    mful->data_size = num_pages * 4;
-    mful->data_read = mful->data_size;
-    memcpy(mful->data, data->nfc_data.uid, data->nfc_data.uid_len);
-    mful->data[7] = data->nfc_data.sak;
-    mful->data[8] = data->nfc_data.atqa[0];
-    mful->data[9] = data->nfc_data.atqa[1];
-
-    uint16_t config_register_page;
-    uint16_t session_register_page;
-
-    // Sync with mifare_ultralight.c
-    switch(type) {
-    case MfUltralightTypeNTAGI2C1K:
-        config_register_page = 227;
-        session_register_page = 229;
-        break;
-    case MfUltralightTypeNTAGI2C2K:
-        config_register_page = 481;
-        session_register_page = 483;
-        break;
-    case MfUltralightTypeNTAGI2CPlus1K:
-    case MfUltralightTypeNTAGI2CPlus2K:
-        config_register_page = 232;
-        session_register_page = 234;
-        break;
-    default:
-        furi_crash("Unknown MFUL");
-        break;
-    }
-
-    memcpy(
-        &mful->data[config_register_page * 4],
-        default_config_ntag_i2c,
-        sizeof(default_config_ntag_i2c));
-    memcpy(
-        &mful->data[session_register_page * 4],
-        default_config_ntag_i2c,
-        sizeof(default_config_ntag_i2c));
-}
-
-static void nfc_generate_ntag_i2c_1k(NfcDeviceData* data) {
-    nfc_generate_ntag_i2c_common(data, MfUltralightTypeNTAGI2C1K, 231);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->version.prod_ver_minor = 0x01;
-    mful->version.storage_size = 0x13;
-
-    memcpy(&mful->data[12], default_data_ntag_i2c, sizeof(default_data_ntag_i2c));
-    mful->data[14] = 0x6D; // Size of tag in CC
-}
-
-static void nfc_generate_ntag_i2c_2k(NfcDeviceData* data) {
-    nfc_generate_ntag_i2c_common(data, MfUltralightTypeNTAGI2C2K, 485);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->version.prod_ver_minor = 0x01;
-    mful->version.storage_size = 0x15;
-
-    memcpy(&mful->data[12], default_data_ntag_i2c, sizeof(default_data_ntag_i2c));
-    mful->data[14] = 0xEA; // Size of tag in CC
-}
-
-static void nfc_generate_ntag_i2c_plus_common(
-    NfcDeviceData* data,
-    MfUltralightType type,
-    uint16_t num_pages) {
-    nfc_generate_ntag_i2c_common(data, type, num_pages);
-
-    MfUltralightData* mful = &data->mf_ul_data;
-    uint16_t config_index = 227 * 4;
-    mful->data[config_index + 3] = 0xFF; // AUTH0
-    memset(&mful->data[config_index + 8], 0xFF, 4); // Default PWD
-}
-
-static void nfc_generate_ntag_i2c_plus_1k(NfcDeviceData* data) {
-    nfc_generate_ntag_i2c_plus_common(data, MfUltralightTypeNTAGI2CPlus1K, 236);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->version.prod_ver_minor = 0x02;
-    mful->version.storage_size = 0x13;
-}
-
-static void nfc_generate_ntag_i2c_plus_2k(NfcDeviceData* data) {
-    nfc_generate_ntag_i2c_plus_common(data, MfUltralightTypeNTAGI2CPlus2K, 492);
-    MfUltralightData* mful = &data->mf_ul_data;
-    mful->version.prod_ver_minor = 0x02;
-    mful->version.storage_size = 0x15;
-}
-
-void nfc_generate_mf_classic_ext(
-    NfcDeviceData* data,
-    uint8_t uid_len,
-    MfClassicType type,
-    bool random_uid,
-    uint8_t* uid) {
-    nfc_generate_common_start(data);
-    if(random_uid) {
-        nfc_generate_mf_classic_uid(data->mf_classic_data.block[0].value, uid_len);
-    } else {
-        memcpy(data->mf_classic_data.block[0].value, uid, uid_len);
-    }
-    nfc_generate_mf_classic_common(data, uid_len, type);
-
-    // Set the UID
-    if(random_uid) {
-        data->nfc_data.uid[0] = NXP_MANUFACTURER_ID;
-        for(int i = 1; i < uid_len; i++) {
-            data->nfc_data.uid[i] = data->mf_classic_data.block[0].value[i];
-        }
-    } else {
-        for(int i = 0; i < uid_len; i++) {
-            data->nfc_data.uid[i] = data->mf_classic_data.block[0].value[i];
-        }
-    }
-
-    MfClassicData* mfc = &data->mf_classic_data;
-    mf_classic_set_block_read(mfc, 0, &mfc->block[0]);
-
-    if(type == MfClassicType4k) {
-        // Set every block to 0xFF
-        for(uint16_t i = 1; i < 256; i += 1) {
-            if(mf_classic_is_sector_trailer(i)) {
-                nfc_generate_mf_classic_sector_trailer(mfc, i);
-            } else {
-                memset(&mfc->block[i].value, 0xFF, 16);
-            }
-            mf_classic_set_block_read(mfc, i, &mfc->block[i]);
-        }
-        // Set SAK to 18
-        data->nfc_data.sak = 0x18;
-    } else if(type == MfClassicType1k) {
-        // Set every block to 0xFF
-        for(uint16_t i = 1; i < MF_CLASSIC_1K_TOTAL_SECTORS_NUM * 4; i += 1) {
-            if(mf_classic_is_sector_trailer(i)) {
-                nfc_generate_mf_classic_sector_trailer(mfc, i);
-            } else {
-                memset(&mfc->block[i].value, 0xFF, 16);
-            }
-            mf_classic_set_block_read(mfc, i, &mfc->block[i]);
-        }
-        // Set SAK to 08
-        data->nfc_data.sak = 0x08;
-    } else if(type == MfClassicTypeMini) {
-        // Set every block to 0xFF
-        for(uint16_t i = 1; i < MF_MINI_TOTAL_SECTORS_NUM * 4; i += 1) {
-            if(mf_classic_is_sector_trailer(i)) {
-                nfc_generate_mf_classic_sector_trailer(mfc, i);
-            } else {
-                memset(&mfc->block[i].value, 0xFF, 16);
-            }
-            mf_classic_set_block_read(mfc, i, &mfc->block[i]);
-        }
-        // Set SAK to 09
-        data->nfc_data.sak = 0x09;
-    }
-
-    nfc_generate_mf_classic_block_0(
-        data->mf_classic_data.block[0].value,
-        uid_len,
-        data->nfc_data.sak,
-        data->nfc_data.atqa[0],
-        data->nfc_data.atqa[1]);
-
-    mfc->type = type;
-}
-
-void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
-    uint8_t uid = 0;
-    nfc_generate_mf_classic_ext(data, uid_len, type, true, &uid);
-}
-
-static void nfc_generate_mf_mini(NfcDeviceData* data) {
-    nfc_generate_mf_classic(data, 4, MfClassicTypeMini);
-}
-
-static void nfc_generate_mf_classic_1k_4b_uid(NfcDeviceData* data) {
-    nfc_generate_mf_classic(data, 4, MfClassicType1k);
-}
-
-static void nfc_generate_mf_classic_1k_7b_uid(NfcDeviceData* data) {
-    nfc_generate_mf_classic(data, 7, MfClassicType1k);
-}
-
-static void nfc_generate_mf_classic_4k_4b_uid(NfcDeviceData* data) {
-    nfc_generate_mf_classic(data, 4, MfClassicType4k);
-}
-
-static void nfc_generate_mf_classic_4k_7b_uid(NfcDeviceData* data) {
-    nfc_generate_mf_classic(data, 7, MfClassicType4k);
-}
-
-static const NfcGenerator mf_ul_generator = {
-    .name = "Mifare Ultralight",
-    .generator_func = nfc_generate_mf_ul_orig,
-};
-
-static const NfcGenerator mf_ul_11_generator = {
-    .name = "Mifare Ultralight EV1 11",
-    .generator_func = nfc_generate_mf_ul_11,
-};
-
-static const NfcGenerator mf_ul_h11_generator = {
-    .name = "Mifare Ultralight EV1 H11",
-    .generator_func = nfc_generate_mf_ul_h11,
-};
-
-static const NfcGenerator mf_ul_21_generator = {
-    .name = "Mifare Ultralight EV1 21",
-    .generator_func = nfc_generate_mf_ul_21,
-};
-
-static const NfcGenerator mf_ul_h21_generator = {
-    .name = "Mifare Ultralight EV1 H21",
-    .generator_func = nfc_generate_mf_ul_h21,
-};
-
-static const NfcGenerator ntag203_generator = {
-    .name = "NTAG203",
-    .generator_func = nfc_generate_mf_ul_ntag203,
-};
-
-static const NfcGenerator ntag213_generator = {
-    .name = "NTAG213",
-    .generator_func = nfc_generate_ntag213,
-};
-
-static const NfcGenerator ntag215_generator = {
-    .name = "NTAG215",
-    .generator_func = nfc_generate_ntag215,
-};
-
-static const NfcGenerator ntag216_generator = {
-    .name = "NTAG216",
-    .generator_func = nfc_generate_ntag216,
-};
-
-static const NfcGenerator ntag_i2c_1k_generator = {
-    .name = "NTAG I2C 1k",
-    .generator_func = nfc_generate_ntag_i2c_1k,
-};
-
-static const NfcGenerator ntag_i2c_2k_generator = {
-    .name = "NTAG I2C 2k",
-    .generator_func = nfc_generate_ntag_i2c_2k,
-};
-
-static const NfcGenerator ntag_i2c_plus_1k_generator = {
-    .name = "NTAG I2C Plus 1k",
-    .generator_func = nfc_generate_ntag_i2c_plus_1k,
-};
-
-static const NfcGenerator ntag_i2c_plus_2k_generator = {
-    .name = "NTAG I2C Plus 2k",
-    .generator_func = nfc_generate_ntag_i2c_plus_2k,
-};
-
-static const NfcGenerator mifare_mini_generator = {
-    .name = "Mifare Mini",
-    .generator_func = nfc_generate_mf_mini,
-};
-
-static const NfcGenerator mifare_classic_1k_4b_uid_generator = {
-    .name = "Mifare Classic 1k 4byte UID",
-    .generator_func = nfc_generate_mf_classic_1k_4b_uid,
-};
-
-static const NfcGenerator mifare_classic_1k_7b_uid_generator = {
-    .name = "Mifare Classic 1k 7byte UID",
-    .generator_func = nfc_generate_mf_classic_1k_7b_uid,
-};
-
-static const NfcGenerator mifare_classic_4k_4b_uid_generator = {
-    .name = "Mifare Classic 4k 4byte UID",
-    .generator_func = nfc_generate_mf_classic_4k_4b_uid,
-};
-
-static const NfcGenerator mifare_classic_4k_7b_uid_generator = {
-    .name = "Mifare Classic 4k 7byte UID",
-    .generator_func = nfc_generate_mf_classic_4k_7b_uid,
-};
-
-const NfcGenerator* const nfc_generators[] = {
-    &mf_ul_generator,
-    &mf_ul_11_generator,
-    &mf_ul_h11_generator,
-    &mf_ul_21_generator,
-    &mf_ul_h21_generator,
-    &ntag203_generator,
-    &ntag213_generator,
-    &ntag215_generator,
-    &ntag216_generator,
-    &ntag_i2c_1k_generator,
-    &ntag_i2c_2k_generator,
-    &ntag_i2c_plus_1k_generator,
-    &ntag_i2c_plus_2k_generator,
-    &mifare_mini_generator,
-    &mifare_classic_1k_4b_uid_generator,
-    &mifare_classic_1k_7b_uid_generator,
-    &mifare_classic_4k_4b_uid_generator,
-    &mifare_classic_4k_7b_uid_generator,
-    NULL,
-};

esubghz_chat/lib/nfclegacy/helpers/nfc_generators.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "../nfc_device.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*NfcGeneratorFunc)(NfcDeviceData* data);
-
-typedef struct {
-    const char* name;
-    NfcGeneratorFunc generator_func;
-} NfcGenerator;
-
-extern const NfcGenerator* const nfc_generators[];
-
-void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type);
-
-void nfc_generate_mf_classic_ext(
-    NfcDeviceData* data,
-    uint8_t uid_len,
-    MfClassicType type,
-    bool random_uid,
-    uint8_t* uid);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/helpers/reader_analyzer.c

@@ -1,265 +0,0 @@
-#include "reader_analyzer.h"
-#include "../protocols/nfc_util.h"
-#include "../protocols/mifare_classic.h"
-#include <m-array.h>
-
-#include "mfkey32.h"
-#include "nfc_debug_pcap.h"
-#include "nfc_debug_log.h"
-
-#define TAG "ReaderAnalyzer"
-
-#define READER_ANALYZER_MAX_BUFF_SIZE (1024)
-
-typedef struct {
-    bool reader_to_tag;
-    bool crc_dropped;
-    uint16_t len;
-} ReaderAnalyzerHeader;
-
-typedef enum {
-    ReaderAnalyzerNfcDataMfClassic,
-} ReaderAnalyzerNfcData;
-
-struct ReaderAnalyzer {
-    FurryHalNfcDevData nfc_data;
-
-    bool alive;
-    FuriStreamBuffer* stream;
-    FuriThread* thread;
-
-    ReaderAnalyzerParseDataCallback callback;
-    void* context;
-
-    ReaderAnalyzerMode mode;
-    Mfkey32* mfkey32;
-    NfcDebugLog* debug_log;
-    NfcDebugPcap* pcap;
-};
-
-const FurryHalNfcDevData reader_analyzer_nfc_data[] = {
-    [ReaderAnalyzerNfcDataMfClassic] =
-        {.sak = 0x08,
-         .atqa = {0x44, 0x00},
-         .interface = FurryHalNfcInterfaceRf,
-         .type = FurryHalNfcTypeA,
-         .uid_len = 7,
-         .uid = {0x04, 0x77, 0x70, 0x2A, 0x23, 0x4F, 0x80},
-         .cuid = 0x2A234F80},
-};
-
-void reader_analyzer_parse(ReaderAnalyzer* instance, uint8_t* buffer, size_t size) {
-    if(size < sizeof(ReaderAnalyzerHeader)) return;
-
-    size_t bytes_i = 0;
-    while(bytes_i < size) {
-        ReaderAnalyzerHeader* header = (ReaderAnalyzerHeader*)&buffer[bytes_i];
-        uint16_t len = header->len;
-        if(bytes_i + len > size) break;
-        bytes_i += sizeof(ReaderAnalyzerHeader);
-        if(instance->mfkey32) {
-            mfkey32_process_data(
-                instance->mfkey32,
-                &buffer[bytes_i],
-                len,
-                header->reader_to_tag,
-                header->crc_dropped);
-        }
-        if(instance->pcap) {
-            nfc_debug_pcap_process_data(
-                instance->pcap, &buffer[bytes_i], len, header->reader_to_tag, header->crc_dropped);
-        }
-        if(instance->debug_log) {
-            nfc_debug_log_process_data(
-                instance->debug_log,
-                &buffer[bytes_i],
-                len,
-                header->reader_to_tag,
-                header->crc_dropped);
-        }
-        bytes_i += len;
-    }
-}
-
-int32_t reader_analyzer_thread(void* context) {
-    ReaderAnalyzer* reader_analyzer = context;
-    uint8_t buffer[READER_ANALYZER_MAX_BUFF_SIZE] = {};
-
-    while(reader_analyzer->alive || !furi_stream_buffer_is_empty(reader_analyzer->stream)) {
-        size_t ret = furi_stream_buffer_receive(
-            reader_analyzer->stream, buffer, READER_ANALYZER_MAX_BUFF_SIZE, 50);
-        if(ret) {
-            reader_analyzer_parse(reader_analyzer, buffer, ret);
-        }
-    }
-
-    return 0;
-}
-
-ReaderAnalyzer* reader_analyzer_alloc() {
-    ReaderAnalyzer* instance = malloc(sizeof(ReaderAnalyzer));
-
-    instance->nfc_data = reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic];
-    instance->alive = false;
-    instance->stream =
-        furi_stream_buffer_alloc(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
-
-    instance->thread =
-        furi_thread_alloc_ex("ReaderAnalyzerWorker", 2048, reader_analyzer_thread, instance);
-    furi_thread_set_priority(instance->thread, FuriThreadPriorityLow);
-
-    return instance;
-}
-
-static void reader_analyzer_mfkey_callback(Mfkey32Event event, void* context) {
-    furi_assert(context);
-    ReaderAnalyzer* instance = context;
-
-    if(event == Mfkey32EventParamCollected) {
-        if(instance->callback) {
-            instance->callback(ReaderAnalyzerEventMfkeyCollected, instance->context);
-        }
-    }
-}
-
-void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode) {
-    furi_assert(instance);
-
-    furi_stream_buffer_reset(instance->stream);
-    if(mode & ReaderAnalyzerModeDebugLog) {
-        instance->debug_log = nfc_debug_log_alloc();
-    }
-    if(mode & ReaderAnalyzerModeMfkey) {
-        instance->mfkey32 = mfkey32_alloc(instance->nfc_data.cuid);
-        if(instance->mfkey32) {
-            mfkey32_set_callback(instance->mfkey32, reader_analyzer_mfkey_callback, instance);
-        }
-    }
-    if(mode & ReaderAnalyzerModeDebugPcap) {
-        instance->pcap = nfc_debug_pcap_alloc();
-    }
-
-    instance->alive = true;
-    furi_thread_start(instance->thread);
-}
-
-void reader_analyzer_stop(ReaderAnalyzer* instance) {
-    furi_assert(instance);
-
-    instance->alive = false;
-    furi_thread_join(instance->thread);
-
-    if(instance->debug_log) {
-        nfc_debug_log_free(instance->debug_log);
-        instance->debug_log = NULL;
-    }
-    if(instance->mfkey32) {
-        mfkey32_free(instance->mfkey32);
-        instance->mfkey32 = NULL;
-    }
-    if(instance->pcap) {
-        nfc_debug_pcap_free(instance->pcap);
-        instance->pcap = NULL;
-    }
-}
-
-void reader_analyzer_free(ReaderAnalyzer* instance) {
-    furi_assert(instance);
-
-    reader_analyzer_stop(instance);
-    furi_thread_free(instance->thread);
-    furi_stream_buffer_free(instance->stream);
-    free(instance);
-}
-
-void reader_analyzer_set_callback(
-    ReaderAnalyzer* instance,
-    ReaderAnalyzerParseDataCallback callback,
-    void* context) {
-    furi_assert(instance);
-    furi_assert(callback);
-
-    instance->callback = callback;
-    instance->context = context;
-}
-
-NfcProtocol
-    reader_analyzer_guess_protocol(ReaderAnalyzer* instance, uint8_t* buff_rx, uint16_t len) {
-    furi_assert(instance);
-    furi_assert(buff_rx);
-    UNUSED(len);
-    NfcProtocol protocol = NfcDeviceProtocolUnknown;
-
-    if((buff_rx[0] == 0x60) || (buff_rx[0] == 0x61)) {
-        protocol = NfcDeviceProtocolMifareClassic;
-    }
-
-    return protocol;
-}
-
-FurryHalNfcDevData* reader_analyzer_get_nfc_data(ReaderAnalyzer* instance) {
-    furi_assert(instance);
-    instance->nfc_data = reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic];
-    return &instance->nfc_data;
-}
-
-void reader_analyzer_set_nfc_data(ReaderAnalyzer* instance, FurryHalNfcDevData* nfc_data) {
-    furi_assert(instance);
-    furi_assert(nfc_data);
-
-    memcpy(&instance->nfc_data, nfc_data, sizeof(FurryHalNfcDevData));
-}
-
-static void reader_analyzer_write(
-    ReaderAnalyzer* instance,
-    uint8_t* data,
-    uint16_t len,
-    bool reader_to_tag,
-    bool crc_dropped) {
-    ReaderAnalyzerHeader header = {
-        .reader_to_tag = reader_to_tag, .crc_dropped = crc_dropped, .len = len};
-    size_t data_sent = 0;
-    data_sent = furi_stream_buffer_send(
-        instance->stream, &header, sizeof(ReaderAnalyzerHeader), FuriWaitForever);
-    if(data_sent != sizeof(ReaderAnalyzerHeader)) {
-        FURI_LOG_W(TAG, "Sent %zu out of %zu bytes", data_sent, sizeof(ReaderAnalyzerHeader));
-    }
-    data_sent = furi_stream_buffer_send(instance->stream, data, len, FuriWaitForever);
-    if(data_sent != len) {
-        FURI_LOG_W(TAG, "Sent %zu out of %u bytes", data_sent, len);
-    }
-}
-
-static void
-    reader_analyzer_write_rx(uint8_t* data, uint16_t bits, bool crc_dropped, void* context) {
-    UNUSED(crc_dropped);
-    ReaderAnalyzer* reader_analyzer = context;
-    uint16_t bytes = bits < 8 ? 1 : bits / 8;
-    reader_analyzer_write(reader_analyzer, data, bytes, false, crc_dropped);
-}
-
-static void
-    reader_analyzer_write_tx(uint8_t* data, uint16_t bits, bool crc_dropped, void* context) {
-    UNUSED(crc_dropped);
-    ReaderAnalyzer* reader_analyzer = context;
-    uint16_t bytes = bits < 8 ? 1 : bits / 8;
-    reader_analyzer_write(reader_analyzer, data, bytes, true, crc_dropped);
-}
-
-void reader_analyzer_prepare_tx_rx(
-    ReaderAnalyzer* instance,
-    FurryHalNfcTxRxContext* tx_rx,
-    bool is_picc) {
-    furi_assert(instance);
-    furi_assert(tx_rx);
-
-    if(is_picc) {
-        tx_rx->sniff_tx = reader_analyzer_write_rx;
-        tx_rx->sniff_rx = reader_analyzer_write_tx;
-    } else {
-        tx_rx->sniff_rx = reader_analyzer_write_rx;
-        tx_rx->sniff_tx = reader_analyzer_write_tx;
-    }
-
-    tx_rx->sniff_context = instance;
-}

esubghz_chat/lib/nfclegacy/helpers/reader_analyzer.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include "../nfc_device.h"
-
-typedef enum {
-    ReaderAnalyzerModeDebugLog = 0x01,
-    ReaderAnalyzerModeMfkey = 0x02,
-    ReaderAnalyzerModeDebugPcap = 0x04,
-} ReaderAnalyzerMode;
-
-typedef enum {
-    ReaderAnalyzerEventMfkeyCollected,
-} ReaderAnalyzerEvent;
-
-typedef struct ReaderAnalyzer ReaderAnalyzer;
-
-typedef void (*ReaderAnalyzerParseDataCallback)(ReaderAnalyzerEvent event, void* context);
-
-ReaderAnalyzer* reader_analyzer_alloc();
-
-void reader_analyzer_free(ReaderAnalyzer* instance);
-
-void reader_analyzer_set_callback(
-    ReaderAnalyzer* instance,
-    ReaderAnalyzerParseDataCallback callback,
-    void* context);
-
-void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode);
-
-void reader_analyzer_stop(ReaderAnalyzer* instance);
-
-NfcProtocol
-    reader_analyzer_guess_protocol(ReaderAnalyzer* instance, uint8_t* buff_rx, uint16_t len);
-
-FurryHalNfcDevData* reader_analyzer_get_nfc_data(ReaderAnalyzer* instance);
-
-void reader_analyzer_set_nfc_data(ReaderAnalyzer* instance, FurryHalNfcDevData* nfc_data);
-
-void reader_analyzer_prepare_tx_rx(
-    ReaderAnalyzer* instance,
-    FurryHalNfcTxRxContext* tx_rx,
-    bool is_picc);

esubghz_chat/lib/nfclegacy/nfc_device.c

@@ -1,895 +0,0 @@
-#include "nfc_device.h"
-#include "nfc_types.h"
-
-#include <lib/toolbox/path.h>
-#include <lib/toolbox/hex.h>
-#include "protocols/nfc_util.h"
-#include <flipper_format/flipper_format.h>
-
-#define TAG "NfcDevice"
-#define NFC_DEVICE_KEYS_FOLDER EXT_PATH("nfc/.cache")
-#define NFC_DEVICE_KEYS_EXTENSION ".keys"
-
-static const char* nfc_file_header = "Flipper NFC device";
-static const uint32_t nfc_file_version = 3;
-
-static const char* nfc_keys_file_header = "Flipper NFC keys";
-static const uint32_t nfc_keys_file_version = 1;
-
-// Protocols format versions
-static const uint32_t nfc_mifare_classic_data_format_version = 2;
-static const uint32_t nfc_mifare_ultralight_data_format_version = 1;
-
-NfcDevice* nfc_device_alloc() {
-    NfcDevice* nfc_dev = malloc(sizeof(NfcDevice));
-    nfc_dev->storage = furi_record_open(RECORD_STORAGE);
-    nfc_dev->dialogs = furi_record_open(RECORD_DIALOGS);
-    nfc_dev->load_path = furi_string_alloc();
-    nfc_dev->dev_data.parsed_data = furi_string_alloc();
-    nfc_dev->folder = furi_string_alloc();
-
-    return nfc_dev;
-}
-
-void nfc_device_free(NfcDevice* nfc_dev) {
-    furi_assert(nfc_dev);
-    nfc_device_clear(nfc_dev);
-    furi_record_close(RECORD_STORAGE);
-    furi_record_close(RECORD_DIALOGS);
-    furi_string_free(nfc_dev->load_path);
-    if(nfc_dev->dev_data.parsed_data != NULL) {
-        furi_string_free(nfc_dev->dev_data.parsed_data);
-    }
-    furi_string_free(nfc_dev->folder);
-    free(nfc_dev);
-}
-
-static void nfc_device_prepare_format_string(NfcDevice* dev, FuriString* format_string) {
-    if(dev->format == NfcDeviceSaveFormatUid) {
-        furi_string_set(format_string, "UID");
-    } else if(dev->format == NfcDeviceSaveFormatBankCard) {
-        furi_string_set(format_string, "Bank card");
-    } else if(dev->format == NfcDeviceSaveFormatMifareUl) {
-        furi_string_set(format_string, nfc_mf_ul_type(dev->dev_data.mf_ul_data.type, true));
-    } else if(dev->format == NfcDeviceSaveFormatMifareClassic) {
-        furi_string_set(format_string, "Mifare Classic");
-    } else if(dev->format == NfcDeviceSaveFormatMifareDesfire) {
-        furi_string_set(format_string, "Mifare DESFire");
-    } else if(dev->format == NfcDeviceSaveFormatNfcV) {
-        furi_string_set(format_string, "ISO15693");
-    } else {
-        furi_string_set(format_string, "Unknown");
-    }
-}
-
-static bool nfc_device_parse_format_string(NfcDevice* dev, FuriString* format_string) {
-    if(furi_string_start_with_str(format_string, "UID")) {
-        dev->format = NfcDeviceSaveFormatUid;
-        dev->dev_data.protocol = NfcDeviceProtocolUnknown;
-        return true;
-    }
-    if(furi_string_start_with_str(format_string, "Bank card")) {
-        dev->format = NfcDeviceSaveFormatBankCard;
-        dev->dev_data.protocol = NfcDeviceProtocolEMV;
-        return true;
-    }
-    // Check Mifare Ultralight types
-    for(MfUltralightType type = MfUltralightTypeUnknown; type < MfUltralightTypeNum; type++) {
-        if(furi_string_equal(format_string, nfc_mf_ul_type(type, true))) {
-            dev->format = NfcDeviceSaveFormatMifareUl;
-            dev->dev_data.protocol = NfcDeviceProtocolMifareUl;
-            dev->dev_data.mf_ul_data.type = type;
-            return true;
-        }
-    }
-    if(furi_string_start_with_str(format_string, "Mifare Classic")) {
-        dev->format = NfcDeviceSaveFormatMifareClassic;
-        dev->dev_data.protocol = NfcDeviceProtocolMifareClassic;
-        return true;
-    }
-    if(furi_string_start_with_str(format_string, "Mifare DESFire")) {
-        dev->format = NfcDeviceSaveFormatMifareDesfire;
-        dev->dev_data.protocol = NfcDeviceProtocolMifareDesfire;
-        return true;
-    }
-    if(furi_string_start_with_str(format_string, "ISO15693")) {
-        dev->format = NfcDeviceSaveFormatNfcV;
-        dev->dev_data.protocol = NfcDeviceProtocolNfcV;
-        return true;
-    }
-    return false;
-}
-
-static bool nfc_device_save_mifare_ul_data(FlipperFormat* file, NfcDevice* dev) {
-    bool saved = false;
-    MfUltralightData* data = &dev->dev_data.mf_ul_data;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    // Save Mifare Ultralight specific data
-    do {
-        if(!flipper_format_write_comment_cstr(file, "Mifare Ultralight specific data")) break;
-        if(!flipper_format_write_uint32(
-               file, "Data format version", &nfc_mifare_ultralight_data_format_version, 1))
-            break;
-        if(!flipper_format_write_hex(file, "Signature", data->signature, sizeof(data->signature)))
-            break;
-        if(!flipper_format_write_hex(
-               file, "Mifare version", (uint8_t*)&data->version, sizeof(data->version)))
-            break;
-        // Write conters and tearing flags data
-        bool counters_saved = true;
-        for(uint8_t i = 0; i < 3; i++) {
-            furi_string_printf(temp_str, "Counter %d", i);
-            if(!flipper_format_write_uint32(
-                   file, furi_string_get_cstr(temp_str), &data->counter[i], 1)) {
-                counters_saved = false;
-                break;
-            }
-            furi_string_printf(temp_str, "Tearing %d", i);
-            if(!flipper_format_write_hex(
-                   file, furi_string_get_cstr(temp_str), &data->tearing[i], 1)) {
-                counters_saved = false;
-                break;
-            }
-        }
-        if(!counters_saved) break;
-        // Write pages data
-        uint32_t pages_total = data->data_size / 4;
-        if(!flipper_format_write_uint32(file, "Pages total", &pages_total, 1)) break;
-        uint32_t pages_read = data->data_read / 4;
-        if(!flipper_format_write_uint32(file, "Pages read", &pages_read, 1)) break;
-        bool pages_saved = true;
-        for(uint16_t i = 0; i < data->data_size; i += 4) {
-            furi_string_printf(temp_str, "Page %d", i / 4);
-            if(!flipper_format_write_hex(file, furi_string_get_cstr(temp_str), &data->data[i], 4)) {
-                pages_saved = false;
-                break;
-            }
-        }
-        if(!pages_saved) break;
-
-        // Write authentication counter
-        uint32_t auth_counter = data->curr_authlim;
-        if(!flipper_format_write_uint32(file, "Failed authentication attempts", &auth_counter, 1))
-            break;
-
-        saved = true;
-    } while(false);
-
-    furi_string_free(temp_str);
-    return saved;
-}
-
-bool nfc_device_load_mifare_ul_data(FlipperFormat* file, NfcDevice* dev) {
-    bool parsed = false;
-    MfUltralightData* data = &dev->dev_data.mf_ul_data;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-    uint32_t data_format_version = 0;
-
-    do {
-        // Read Mifare Ultralight format version
-        if(!flipper_format_read_uint32(file, "Data format version", &data_format_version, 1)) {
-            if(!flipper_format_rewind(file)) break;
-        }
-
-        // Read signature
-        if(!flipper_format_read_hex(file, "Signature", data->signature, sizeof(data->signature)))
-            break;
-        // Read Mifare version
-        if(!flipper_format_read_hex(
-               file, "Mifare version", (uint8_t*)&data->version, sizeof(data->version)))
-            break;
-        // Read counters and tearing flags
-        bool counters_parsed = true;
-        for(uint8_t i = 0; i < 3; i++) {
-            furi_string_printf(temp_str, "Counter %d", i);
-            if(!flipper_format_read_uint32(
-                   file, furi_string_get_cstr(temp_str), &data->counter[i], 1)) {
-                counters_parsed = false;
-                break;
-            }
-            furi_string_printf(temp_str, "Tearing %d", i);
-            if(!flipper_format_read_hex(
-                   file, furi_string_get_cstr(temp_str), &data->tearing[i], 1)) {
-                counters_parsed = false;
-                break;
-            }
-        }
-        if(!counters_parsed) break;
-        // Read pages
-        uint32_t pages_total = 0;
-        if(!flipper_format_read_uint32(file, "Pages total", &pages_total, 1)) break;
-        uint32_t pages_read = 0;
-        if(data_format_version < nfc_mifare_ultralight_data_format_version) {
-            pages_read = pages_total;
-        } else {
-            if(!flipper_format_read_uint32(file, "Pages read", &pages_read, 1)) break;
-        }
-        data->data_size = pages_total * 4;
-        data->data_read = pages_read * 4;
-        if(data->data_size > MF_UL_MAX_DUMP_SIZE || data->data_read > MF_UL_MAX_DUMP_SIZE) break;
-        bool pages_parsed = true;
-        for(uint16_t i = 0; i < pages_total; i++) {
-            furi_string_printf(temp_str, "Page %d", i);
-            if(!flipper_format_read_hex(
-                   file, furi_string_get_cstr(temp_str), &data->data[i * 4], 4)) {
-                pages_parsed = false;
-                break;
-            }
-        }
-        if(!pages_parsed) break;
-
-        // Read authentication counter
-        uint32_t auth_counter;
-        if(!flipper_format_read_uint32(file, "Failed authentication attempts", &auth_counter, 1))
-            auth_counter = 0;
-        data->curr_authlim = auth_counter;
-
-        data->auth_success = mf_ul_is_full_capture(data);
-
-        parsed = true;
-    } while(false);
-
-    furi_string_free(temp_str);
-    return parsed;
-}
-
-static void nfc_device_write_mifare_classic_block(
-    FuriString* block_str,
-    MfClassicData* data,
-    uint8_t block_num) {
-    furi_string_reset(block_str);
-    bool is_sec_trailer = mf_classic_is_sector_trailer(block_num);
-    if(is_sec_trailer) {
-        uint8_t sector_num = mf_classic_get_sector_by_block(block_num);
-        MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, sector_num);
-        // Write key A
-        for(size_t i = 0; i < sizeof(sec_tr->key_a); i++) {
-            if(mf_classic_is_key_found(data, sector_num, MfClassicKeyA)) {
-                furi_string_cat_printf(block_str, "%02X ", sec_tr->key_a[i]);
-            } else {
-                furi_string_cat_printf(block_str, "?? ");
-            }
-        }
-        // Write Access bytes
-        for(size_t i = 0; i < MF_CLASSIC_ACCESS_BYTES_SIZE; i++) {
-            if(mf_classic_is_block_read(data, block_num)) {
-                furi_string_cat_printf(block_str, "%02X ", sec_tr->access_bits[i]);
-            } else {
-                furi_string_cat_printf(block_str, "?? ");
-            }
-        }
-        // Write key B
-        for(size_t i = 0; i < sizeof(sec_tr->key_b); i++) {
-            if(mf_classic_is_key_found(data, sector_num, MfClassicKeyB)) {
-                furi_string_cat_printf(block_str, "%02X ", sec_tr->key_b[i]);
-            } else {
-                furi_string_cat_printf(block_str, "?? ");
-            }
-        }
-    } else {
-        // Write data block
-        for(size_t i = 0; i < MF_CLASSIC_BLOCK_SIZE; i++) {
-            if(mf_classic_is_block_read(data, block_num)) {
-                furi_string_cat_printf(block_str, "%02X ", data->block[block_num].value[i]);
-            } else {
-                furi_string_cat_printf(block_str, "?? ");
-            }
-        }
-    }
-    furi_string_trim(block_str);
-}
-
-static bool nfc_device_save_mifare_classic_data(FlipperFormat* file, NfcDevice* dev) {
-    bool saved = false;
-    MfClassicData* data = &dev->dev_data.mf_classic_data;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-    uint16_t blocks = 0;
-
-    // Save Mifare Classic specific data
-    do {
-        if(!flipper_format_write_comment_cstr(file, "Mifare Classic specific data")) break;
-
-        if(data->type == MfClassicTypeMini) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "MINI")) break;
-            blocks = 20;
-        } else if(data->type == MfClassicType1k) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "1K")) break;
-            blocks = 64;
-        } else if(data->type == MfClassicType4k) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "4K")) break;
-            blocks = 256;
-        }
-        if(!flipper_format_write_uint32(
-               file, "Data format version", &nfc_mifare_classic_data_format_version, 1))
-            break;
-        if(!flipper_format_write_comment_cstr(
-               file, "Mifare Classic blocks, \'??\' means unknown data"))
-            break;
-        bool block_saved = true;
-        FuriString* block_str;
-        block_str = furi_string_alloc();
-        for(size_t i = 0; i < blocks; i++) {
-            furi_string_printf(temp_str, "Block %d", i);
-            nfc_device_write_mifare_classic_block(block_str, data, i);
-            if(!flipper_format_write_string(file, furi_string_get_cstr(temp_str), block_str)) {
-                block_saved = false;
-                break;
-            }
-        }
-        furi_string_free(block_str);
-        if(!block_saved) break;
-        saved = true;
-    } while(false);
-
-    furi_string_free(temp_str);
-    return saved;
-}
-
-static void nfc_device_load_mifare_classic_block(
-    FuriString* block_str,
-    MfClassicData* data,
-    uint8_t block_num) {
-    furi_string_trim(block_str);
-    MfClassicBlock block_tmp = {};
-    bool is_sector_trailer = mf_classic_is_sector_trailer(block_num);
-    uint8_t sector_num = mf_classic_get_sector_by_block(block_num);
-    uint16_t block_unknown_bytes_mask = 0;
-
-    furi_string_trim(block_str);
-    for(size_t i = 0; i < MF_CLASSIC_BLOCK_SIZE; i++) {
-        char hi = furi_string_get_char(block_str, 3 * i);
-        char low = furi_string_get_char(block_str, 3 * i + 1);
-        uint8_t byte = 0;
-        if(hex_char_to_uint8(hi, low, &byte)) {
-            block_tmp.value[i] = byte;
-        } else {
-            FURI_BIT_SET(block_unknown_bytes_mask, i);
-        }
-    }
-
-    if(block_unknown_bytes_mask == 0xffff) {
-        // All data is unknown, exit
-        return;
-    }
-
-    if(is_sector_trailer) {
-        MfClassicSectorTrailer* sec_tr_tmp = (MfClassicSectorTrailer*)&block_tmp;
-        // Load Key A
-        // Key A mask 0b0000000000111111 = 0x003f
-        if((block_unknown_bytes_mask & 0x003f) == 0) {
-            uint64_t key = nfc_util_bytes2num(sec_tr_tmp->key_a, sizeof(sec_tr_tmp->key_a));
-            mf_classic_set_key_found(data, sector_num, MfClassicKeyA, key);
-        }
-        // Load Access Bits
-        // Access bits mask 0b0000001111000000 = 0x03c0
-        if((block_unknown_bytes_mask & 0x03c0) == 0) {
-            mf_classic_set_block_read(data, block_num, &block_tmp);
-        }
-        // Load Key B
-        // Key B mask 0b1111110000000000 = 0xfc00
-        if((block_unknown_bytes_mask & 0xfc00) == 0) {
-            uint64_t key = nfc_util_bytes2num(sec_tr_tmp->key_b, sizeof(sec_tr_tmp->key_b));
-            mf_classic_set_key_found(data, sector_num, MfClassicKeyB, key);
-        }
-    } else {
-        if(block_unknown_bytes_mask == 0) {
-            mf_classic_set_block_read(data, block_num, &block_tmp);
-        }
-    }
-}
-
-static bool nfc_device_load_mifare_classic_data(FlipperFormat* file, NfcDevice* dev) {
-    bool parsed = false;
-    MfClassicData* data = &dev->dev_data.mf_classic_data;
-    FuriString* temp_str;
-    uint32_t data_format_version = 0;
-    temp_str = furi_string_alloc();
-    uint16_t data_blocks = 0;
-    memset(data, 0, sizeof(MfClassicData));
-
-    do {
-        // Read Mifare Classic type
-        if(!flipper_format_read_string(file, "Mifare Classic type", temp_str)) break;
-        if(!furi_string_cmp(temp_str, "MINI")) {
-            data->type = MfClassicTypeMini;
-            data_blocks = 20;
-        } else if(!furi_string_cmp(temp_str, "1K")) {
-            data->type = MfClassicType1k;
-            data_blocks = 64;
-        } else if(!furi_string_cmp(temp_str, "4K")) {
-            data->type = MfClassicType4k;
-            data_blocks = 256;
-        } else {
-            break;
-        }
-
-        bool old_format = false;
-        // Read Mifare Classic format version
-        if(!flipper_format_read_uint32(file, "Data format version", &data_format_version, 1)) {
-            // Load unread sectors with zero keys access for backward compatibility
-            if(!flipper_format_rewind(file)) break;
-            old_format = true;
-        } else {
-            if(data_format_version < nfc_mifare_classic_data_format_version) {
-                old_format = true;
-            }
-        }
-
-        // Read Mifare Classic blocks
-        bool block_read = true;
-        FuriString* block_str;
-        block_str = furi_string_alloc();
-        for(size_t i = 0; i < data_blocks; i++) {
-            furi_string_printf(temp_str, "Block %d", i);
-            if(!flipper_format_read_string(file, furi_string_get_cstr(temp_str), block_str)) {
-                block_read = false;
-                break;
-            }
-            nfc_device_load_mifare_classic_block(block_str, data, i);
-        }
-        furi_string_free(block_str);
-        if(!block_read) break;
-
-        // Set keys and blocks as unknown for backward compatibility
-        if(old_format) {
-            data->key_a_mask = 0ULL;
-            data->key_b_mask = 0ULL;
-            memset(data->block_read_mask, 0, sizeof(data->block_read_mask));
-        }
-
-        parsed = true;
-    } while(false);
-
-    furi_string_free(temp_str);
-    return parsed;
-}
-
-static void nfc_device_get_key_cache_file_path(NfcDevice* dev, FuriString* file_path) {
-    uint8_t* uid = dev->dev_data.nfc_data.uid;
-    uint8_t uid_len = dev->dev_data.nfc_data.uid_len;
-    furi_string_set(file_path, NFC_DEVICE_KEYS_FOLDER "/");
-    for(size_t i = 0; i < uid_len; i++) {
-        furi_string_cat_printf(file_path, "%02X", uid[i]);
-    }
-    furi_string_cat_printf(file_path, NFC_DEVICE_KEYS_EXTENSION);
-}
-
-static bool nfc_device_save_mifare_classic_keys(NfcDevice* dev) {
-    FlipperFormat* file = flipper_format_file_alloc(dev->storage);
-    MfClassicData* data = &dev->dev_data.mf_classic_data;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    nfc_device_get_key_cache_file_path(dev, temp_str);
-    bool save_success = false;
-    do {
-        if(!storage_simply_mkdir(dev->storage, NFC_DEVICE_KEYS_FOLDER)) break;
-        if(!storage_simply_remove(dev->storage, furi_string_get_cstr(temp_str))) break;
-        if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break;
-        if(!flipper_format_write_header_cstr(file, nfc_keys_file_header, nfc_keys_file_version))
-            break;
-        if(data->type == MfClassicTypeMini) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "MINI")) break;
-        } else if(data->type == MfClassicType1k) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "1K")) break;
-        } else if(data->type == MfClassicType4k) {
-            if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "4K")) break;
-        }
-        if(!flipper_format_write_hex_uint64(file, "Key A map", &data->key_a_mask, 1)) break;
-        if(!flipper_format_write_hex_uint64(file, "Key B map", &data->key_b_mask, 1)) break;
-        uint8_t sector_num = mf_classic_get_total_sectors_num(data->type);
-        bool key_save_success = true;
-        for(size_t i = 0; (i < sector_num) && (key_save_success); i++) {
-            MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, i);
-            if(FURI_BIT(data->key_a_mask, i)) {
-                furi_string_printf(temp_str, "Key A sector %d", i);
-                key_save_success = flipper_format_write_hex(
-                    file, furi_string_get_cstr(temp_str), sec_tr->key_a, 6);
-            }
-            if(!key_save_success) break;
-            if(FURI_BIT(data->key_b_mask, i)) {
-                furi_string_printf(temp_str, "Key B sector %d", i);
-                key_save_success = flipper_format_write_hex(
-                    file, furi_string_get_cstr(temp_str), sec_tr->key_b, 6);
-            }
-        }
-        save_success = key_save_success;
-    } while(false);
-
-    flipper_format_free(file);
-    furi_string_free(temp_str);
-    return save_success;
-}
-
-bool nfc_device_load_key_cache(NfcDevice* dev) {
-    furi_assert(dev);
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    MfClassicData* data = &dev->dev_data.mf_classic_data;
-    nfc_device_get_key_cache_file_path(dev, temp_str);
-    FlipperFormat* file = flipper_format_file_alloc(dev->storage);
-
-    bool load_success = false;
-    do {
-        if(storage_common_stat(dev->storage, furi_string_get_cstr(temp_str), NULL) != FSE_OK)
-            break;
-        if(!flipper_format_file_open_existing(file, furi_string_get_cstr(temp_str))) break;
-        uint32_t version = 0;
-        if(!flipper_format_read_header(file, temp_str, &version)) break;
-        if(furi_string_cmp_str(temp_str, nfc_keys_file_header)) break;
-        if(version != nfc_keys_file_version) break;
-        if(!flipper_format_read_string(file, "Mifare Classic type", temp_str)) break;
-        if(!furi_string_cmp(temp_str, "MINI")) {
-            data->type = MfClassicTypeMini;
-        } else if(!furi_string_cmp(temp_str, "1K")) {
-            data->type = MfClassicType1k;
-        } else if(!furi_string_cmp(temp_str, "4K")) {
-            data->type = MfClassicType4k;
-        } else {
-            break;
-        }
-        if(!flipper_format_read_hex_uint64(file, "Key A map", &data->key_a_mask, 1)) break;
-        if(!flipper_format_read_hex_uint64(file, "Key B map", &data->key_b_mask, 1)) break;
-        uint8_t sectors = mf_classic_get_total_sectors_num(data->type);
-        bool key_read_success = true;
-        for(size_t i = 0; (i < sectors) && (key_read_success); i++) {
-            MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, i);
-            if(FURI_BIT(data->key_a_mask, i)) {
-                furi_string_printf(temp_str, "Key A sector %d", i);
-                key_read_success = flipper_format_read_hex(
-                    file, furi_string_get_cstr(temp_str), sec_tr->key_a, 6);
-            }
-            if(!key_read_success) break;
-            if(FURI_BIT(data->key_b_mask, i)) {
-                furi_string_printf(temp_str, "Key B sector %d", i);
-                key_read_success = flipper_format_read_hex(
-                    file, furi_string_get_cstr(temp_str), sec_tr->key_b, 6);
-            }
-        }
-        load_success = key_read_success;
-    } while(false);
-
-    furi_string_free(temp_str);
-    flipper_format_free(file);
-
-    return load_success;
-}
-
-void nfc_device_set_name(NfcDevice* dev, const char* name) {
-    furi_assert(dev);
-
-    strlcpy(dev->dev_name, name, NFC_DEV_NAME_MAX_LEN);
-}
-
-static void nfc_device_get_path_without_ext(FuriString* orig_path, FuriString* shadow_path) {
-    // TODO: this won't work if there is ".nfc" anywhere in the path other than
-    // at the end
-    size_t ext_start = furi_string_search(orig_path, NFC_APP_FILENAME_EXTENSION);
-    furi_string_set_n(shadow_path, orig_path, 0, ext_start);
-}
-
-static void nfc_device_get_shadow_path(FuriString* orig_path, FuriString* shadow_path) {
-    nfc_device_get_path_without_ext(orig_path, shadow_path);
-    furi_string_cat_printf(shadow_path, "%s", NFC_APP_SHADOW_EXTENSION);
-}
-
-static void nfc_device_get_folder_from_path(FuriString* path, FuriString* folder) {
-    size_t last_slash = furi_string_search_rchar(path, '/');
-    if(last_slash == FURI_STRING_FAILURE) {
-        // No slashes in the path, treat the whole path as a folder
-        furi_string_set(folder, path);
-    } else {
-        furi_string_set_n(folder, path, 0, last_slash);
-    }
-}
-
-bool nfc_device_save(NfcDevice* dev, const char* dev_name) {
-    return false;
-    furi_assert(dev);
-
-    bool saved = false;
-    FlipperFormat* file = flipper_format_file_alloc(dev->storage);
-    FurryHalNfcDevData* data = &dev->dev_data.nfc_data;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-
-    do {
-        // Create directory if necessary
-        FuriString* folder = furi_string_alloc();
-        // Get folder from filename (filename is in the form of "folder/filename.nfc", so the folder is "folder/")
-        furi_string_set(temp_str, dev_name);
-        // Get folder from filename
-        nfc_device_get_folder_from_path(temp_str, folder);
-        FURI_LOG_I("Nfc", "Saving to folder %s", furi_string_get_cstr(folder));
-        if(!storage_simply_mkdir(dev->storage, furi_string_get_cstr(folder))) {
-            FURI_LOG_E("Nfc", "Failed to create folder %s", furi_string_get_cstr(folder));
-            break;
-        }
-        furi_string_free(folder);
-        // First remove nfc device file if it was saved
-        // Open file
-        if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break;
-        // Write header
-        if(!flipper_format_write_header_cstr(file, nfc_file_header, nfc_file_version)) break;
-        // Write nfc device type
-        if(!flipper_format_write_comment_cstr(
-               file, "Nfc device type can be UID, Mifare Ultralight, Mifare Classic or ISO15693"))
-            break;
-        nfc_device_prepare_format_string(dev, temp_str);
-        if(!flipper_format_write_string(file, "Device type", temp_str)) break;
-        // Write UID
-        if(!flipper_format_write_comment_cstr(file, "UID is common for all formats")) break;
-        if(!flipper_format_write_hex(file, "UID", data->uid, data->uid_len)) break;
-
-        if(dev->format != NfcDeviceSaveFormatNfcV) {
-            // Write ATQA, SAK
-            if(!flipper_format_write_comment_cstr(file, "ISO14443 specific fields")) break;
-            // Save ATQA in MSB order for correct companion apps display
-            uint8_t atqa[2] = {data->atqa[1], data->atqa[0]};
-            if(!flipper_format_write_hex(file, "ATQA", atqa, 2)) break;
-            if(!flipper_format_write_hex(file, "SAK", &data->sak, 1)) break;
-        }
-
-        // Save more data if necessary
-        if(dev->format == NfcDeviceSaveFormatMifareUl) {
-            if(!nfc_device_save_mifare_ul_data(file, dev)) break;
-        } else if(dev->format == NfcDeviceSaveFormatMifareClassic) {
-            // Save data
-            if(!nfc_device_save_mifare_classic_data(file, dev)) break;
-            // Save keys cache
-            if(!nfc_device_save_mifare_classic_keys(dev)) break;
-        }
-        saved = true;
-    } while(0);
-
-    if(!saved) { //-V547
-        dialog_message_show_storage_error(dev->dialogs, "Can not save\nkey file");
-    }
-    furi_string_free(temp_str);
-    flipper_format_free(file);
-    return saved;
-}
-
-bool nfc_device_save_shadow(NfcDevice* dev, const char* path) {
-    return false;
-    dev->shadow_file_exist = true;
-    // Replace extension from .nfc to .shd if necessary
-    FuriString* orig_path = furi_string_alloc();
-    furi_string_set_str(orig_path, path);
-    FuriString* shadow_path = furi_string_alloc();
-    nfc_device_get_shadow_path(orig_path, shadow_path);
-
-    bool file_saved = nfc_device_save(dev, furi_string_get_cstr(shadow_path));
-    furi_string_free(orig_path);
-    furi_string_free(shadow_path);
-
-    return file_saved;
-}
-
-static bool nfc_device_load_data(NfcDevice* dev, FuriString* path, bool show_dialog) {
-    bool parsed = false;
-    FlipperFormat* file = flipper_format_file_alloc(dev->storage);
-    FurryHalNfcDevData* data = &dev->dev_data.nfc_data;
-    uint32_t data_cnt = 0;
-    FuriString* temp_str;
-    temp_str = furi_string_alloc();
-    bool deprecated_version = false;
-
-    // Version 2 of file format had ATQA bytes swapped
-    uint32_t version_with_lsb_atqa = 2;
-
-    if(dev->loading_cb) {
-        dev->loading_cb(dev->loading_cb_ctx, true);
-    }
-
-    do {
-        // Check existence of shadow file
-        nfc_device_get_shadow_path(path, temp_str);
-        dev->shadow_file_exist =
-            storage_common_stat(dev->storage, furi_string_get_cstr(temp_str), NULL) == FSE_OK;
-        // Open shadow file if it exists. If not - open original
-        if(dev->shadow_file_exist) {
-            if(!flipper_format_file_open_existing(file, furi_string_get_cstr(temp_str))) break;
-        } else {
-            if(!flipper_format_file_open_existing(file, furi_string_get_cstr(path))) break;
-        }
-        // Read and verify file header
-        uint32_t version = 0;
-        if(!flipper_format_read_header(file, temp_str, &version)) break;
-        if(furi_string_cmp_str(temp_str, nfc_file_header)) break;
-        if(version != nfc_file_version) {
-            if(version < version_with_lsb_atqa) {
-                deprecated_version = true;
-                break;
-            }
-        }
-        // Read Nfc device type
-        if(!flipper_format_read_string(file, "Device type", temp_str)) break;
-        if(!nfc_device_parse_format_string(dev, temp_str)) break;
-        // Read and parse UID, ATQA and SAK
-        if(!flipper_format_get_value_count(file, "UID", &data_cnt)) break;
-        if(!(data_cnt == 4 || data_cnt == 7 || data_cnt == 8)) break;
-        data->uid_len = data_cnt;
-        if(!flipper_format_read_hex(file, "UID", data->uid, data->uid_len)) break;
-        if(dev->format != NfcDeviceSaveFormatNfcV) {
-            if(version == version_with_lsb_atqa) {
-                if(!flipper_format_read_hex(file, "ATQA", data->atqa, 2)) break;
-            } else {
-                uint8_t atqa[2] = {};
-                if(!flipper_format_read_hex(file, "ATQA", atqa, 2)) break;
-                data->atqa[0] = atqa[1];
-                data->atqa[1] = atqa[0];
-            }
-            if(!flipper_format_read_hex(file, "SAK", &data->sak, 1)) break;
-        }
-        // Load CUID
-        uint8_t* cuid_start = data->uid;
-        if(data->uid_len == 7) {
-            cuid_start = &data->uid[3];
-        }
-        data->cuid = (cuid_start[0] << 24) | (cuid_start[1] << 16) | (cuid_start[2] << 8) |
-                     (cuid_start[3]);
-        // Parse other data
-        if(dev->format == NfcDeviceSaveFormatMifareUl) {
-            if(!nfc_device_load_mifare_ul_data(file, dev)) break;
-        } else if(dev->format == NfcDeviceSaveFormatMifareClassic) {
-            if(!nfc_device_load_mifare_classic_data(file, dev)) break;
-        }
-        parsed = true;
-    } while(false);
-
-    if(dev->loading_cb) {
-        dev->loading_cb(dev->loading_cb_ctx, false);
-    }
-
-    if((!parsed) && (show_dialog)) {
-        if(deprecated_version) {
-            dialog_message_show_storage_error(dev->dialogs, "File format deprecated");
-        } else {
-            dialog_message_show_storage_error(dev->dialogs, "Can not parse\nfile");
-        }
-    }
-
-    furi_string_free(temp_str);
-    flipper_format_free(file);
-    return parsed;
-}
-
-bool nfc_device_load(NfcDevice* dev, const char* file_path, bool show_dialog) {
-    furi_assert(dev);
-    furi_assert(file_path);
-
-    // Load device data
-    furi_string_set(dev->load_path, file_path);
-    bool dev_load = nfc_device_load_data(dev, dev->load_path, show_dialog);
-    if(dev_load) {
-        // Set device name
-        FuriString* filename;
-        filename = furi_string_alloc();
-        path_extract_filename_no_ext(file_path, filename);
-        nfc_device_set_name(dev, furi_string_get_cstr(filename));
-        furi_string_free(filename);
-    }
-
-    return dev_load;
-}
-
-void nfc_device_data_clear(NfcDeviceData* dev_data) {
-    if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
-        memset(&dev_data->mf_classic_data, 0, sizeof(MfClassicData));
-    } else if(dev_data->protocol == NfcDeviceProtocolMifareUl) {
-        mf_ul_reset(&dev_data->mf_ul_data);
-    }
-
-    memset(&dev_data->nfc_data, 0, sizeof(FurryHalNfcDevData));
-    dev_data->protocol = NfcDeviceProtocolUnknown;
-    if(dev_data->parsed_data != NULL) {
-        furi_string_reset(dev_data->parsed_data);
-    }
-}
-
-void nfc_device_clear(NfcDevice* dev) {
-    furi_assert(dev);
-
-    nfc_device_set_name(dev, "");
-    nfc_device_data_clear(&dev->dev_data);
-    dev->format = NfcDeviceSaveFormatUid;
-    furi_string_reset(dev->load_path);
-}
-
-bool nfc_device_delete(NfcDevice* dev, bool use_load_path) {
-    furi_assert(dev);
-
-    bool deleted = false;
-    FuriString* file_path;
-    file_path = furi_string_alloc();
-
-    do {
-        // Delete original file
-        if(use_load_path && !furi_string_empty(dev->load_path)) {
-            furi_string_set(file_path, dev->load_path);
-        } else {
-            furi_string_printf(
-                file_path,
-                "%s/%s%s",
-                furi_string_get_cstr(dev->folder),
-                dev->dev_name,
-                NFC_APP_FILENAME_EXTENSION);
-        }
-        if(!storage_simply_remove(dev->storage, furi_string_get_cstr(file_path))) break;
-        // Delete shadow file if it exists
-        if(dev->shadow_file_exist) {
-            if(use_load_path && !furi_string_empty(dev->load_path)) {
-                nfc_device_get_shadow_path(dev->load_path, file_path);
-            } else {
-                furi_string_printf(
-                    file_path,
-                    "%s/%s%s",
-                    furi_string_get_cstr(dev->folder),
-                    dev->dev_name,
-                    NFC_APP_SHADOW_EXTENSION);
-            }
-            if(!storage_simply_remove(dev->storage, furi_string_get_cstr(file_path))) break;
-        }
-        deleted = true;
-    } while(0);
-
-    if(!deleted) {
-        dialog_message_show_storage_error(dev->dialogs, "Can not remove file");
-    }
-
-    furi_string_free(file_path);
-    return deleted;
-}
-
-bool nfc_device_restore(NfcDevice* dev, bool use_load_path) {
-    furi_assert(dev);
-    furi_assert(dev->shadow_file_exist);
-
-    bool restored = false;
-    FuriString* path;
-
-    path = furi_string_alloc();
-
-    do {
-        if(use_load_path && !furi_string_empty(dev->load_path)) {
-            nfc_device_get_shadow_path(dev->load_path, path);
-        } else {
-            furi_string_printf(
-                path,
-                "%s/%s%s",
-                furi_string_get_cstr(dev->folder),
-                dev->dev_name,
-                NFC_APP_SHADOW_EXTENSION);
-        }
-        if(!storage_simply_remove(dev->storage, furi_string_get_cstr(path))) break;
-        dev->shadow_file_exist = false;
-        if(use_load_path && !furi_string_empty(dev->load_path)) {
-            furi_string_set(path, dev->load_path);
-        } else {
-            furi_string_printf(
-                path,
-                "%s/%s%s",
-                furi_string_get_cstr(dev->folder),
-                dev->dev_name,
-                NFC_APP_FILENAME_EXTENSION);
-        }
-        if(!nfc_device_load_data(dev, path, true)) break;
-        restored = true;
-    } while(0);
-
-    furi_string_free(path);
-    return restored;
-}
-
-void nfc_device_set_loading_callback(NfcDevice* dev, NfcLoadingCallback callback, void* context) {
-    furi_assert(dev);
-
-    dev->loading_cb = callback;
-    dev->loading_cb_ctx = context;
-}

esubghz_chat/lib/nfclegacy/nfc_device.h

@@ -1,120 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <storage/storage.h>
-#include <dialogs/dialogs.h>
-
-#include "./furi_hal_nfc.h"
-#include "helpers/mf_classic_dict.h"
-#include "protocols/mifare_ultralight.h"
-#include "protocols/mifare_classic.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define NFC_DEV_NAME_MAX_LEN 22
-#define NFC_READER_DATA_MAX_SIZE 64
-#define NFC_DICT_KEY_BATCH_SIZE 10
-
-#define NFC_APP_FILENAME_PREFIX "NFC"
-#define NFC_APP_FILENAME_EXTENSION ".nfc"
-#define NFC_APP_SHADOW_EXTENSION ".shd"
-
-typedef void (*NfcLoadingCallback)(void* context, bool state);
-
-typedef enum {
-    NfcDeviceProtocolUnknown,
-    NfcDeviceProtocolEMV,
-    NfcDeviceProtocolMifareUl,
-    NfcDeviceProtocolMifareClassic,
-    NfcDeviceProtocolMifareDesfire,
-    NfcDeviceProtocolNfcV
-} NfcProtocol;
-
-typedef enum {
-    NfcDeviceSaveFormatUid,
-    NfcDeviceSaveFormatBankCard,
-    NfcDeviceSaveFormatMifareUl,
-    NfcDeviceSaveFormatMifareClassic,
-    NfcDeviceSaveFormatMifareDesfire,
-    NfcDeviceSaveFormatNfcV,
-} NfcDeviceSaveFormat;
-
-typedef struct {
-    uint8_t data[NFC_READER_DATA_MAX_SIZE];
-    uint16_t size;
-} NfcReaderRequestData;
-
-typedef struct {
-    MfClassicDict* dict;
-    uint8_t current_sector;
-} NfcMfClassicDictAttackData;
-
-typedef enum {
-    NfcReadModeAuto,
-    NfcReadModeMfClassic,
-    NfcReadModeMfUltralight,
-    NfcReadModeMfDesfire,
-    NfcReadModeEMV,
-    NfcReadModeNFCA,
-} NfcReadMode;
-
-typedef struct {
-    FurryHalNfcDevData nfc_data;
-    NfcProtocol protocol;
-    NfcReadMode read_mode;
-    union {
-        NfcReaderRequestData reader_data;
-        NfcMfClassicDictAttackData mf_classic_dict_attack_data;
-        MfUltralightAuth mf_ul_auth;
-    };
-    union {
-        MfUltralightData mf_ul_data;
-        MfClassicData mf_classic_data;
-    };
-    FuriString* parsed_data;
-} NfcDeviceData;
-
-typedef struct {
-    Storage* storage;
-    DialogsApp* dialogs;
-    NfcDeviceData dev_data;
-    char dev_name[NFC_DEV_NAME_MAX_LEN + 1];
-    FuriString* load_path;
-    FuriString* folder;
-    NfcDeviceSaveFormat format;
-    bool shadow_file_exist;
-
-    NfcLoadingCallback loading_cb;
-    void* loading_cb_ctx;
-} NfcDevice;
-
-NfcDevice* nfc_device_alloc();
-
-void nfc_device_free(NfcDevice* nfc_dev);
-
-void nfc_device_set_name(NfcDevice* dev, const char* name);
-
-bool nfc_device_save(NfcDevice* dev, const char* dev_name);
-
-bool nfc_device_save_shadow(NfcDevice* dev, const char* dev_name);
-
-bool nfc_device_load(NfcDevice* dev, const char* file_path, bool show_dialog);
-
-bool nfc_device_load_key_cache(NfcDevice* dev);
-
-void nfc_device_data_clear(NfcDeviceData* dev);
-
-void nfc_device_clear(NfcDevice* dev);
-
-bool nfc_device_delete(NfcDevice* dev, bool use_load_path);
-
-bool nfc_device_restore(NfcDevice* dev, bool use_load_path);
-
-void nfc_device_set_loading_callback(NfcDevice* dev, NfcLoadingCallback callback, void* context);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/nfc_types.c

@@ -1,69 +0,0 @@
-#include "nfc_types.h"
-
-const char* nfc_get_dev_type(FurryHalNfcType type) {
-    if(type == FurryHalNfcTypeA) {
-        return "NFC-A";
-    } else if(type == FurryHalNfcTypeB) {
-        return "NFC-B";
-    } else if(type == FurryHalNfcTypeF) {
-        return "NFC-F";
-    } else if(type == FurryHalNfcTypeV) {
-        return "NFC-V";
-    } else {
-        return "Unknown";
-    }
-}
-
-const char* nfc_guess_protocol(NfcProtocol protocol) {
-    if(protocol == NfcDeviceProtocolEMV) {
-        return "EMV bank card";
-    } else if(protocol == NfcDeviceProtocolMifareUl) {
-        return "Mifare Ultral/NTAG";
-    } else if(protocol == NfcDeviceProtocolMifareClassic) {
-        return "Mifare Classic";
-    } else if(protocol == NfcDeviceProtocolMifareDesfire) {
-        return "Mifare DESFire";
-    } else {
-        return "Unrecognized";
-    }
-}
-
-const char* nfc_mf_ul_type(MfUltralightType type, bool full_name) {
-    if(type == MfUltralightTypeNTAG213) {
-        return "NTAG213";
-    } else if(type == MfUltralightTypeNTAG215) {
-        return "NTAG215";
-    } else if(type == MfUltralightTypeNTAG216) {
-        return "NTAG216";
-    } else if(type == MfUltralightTypeNTAGI2C1K) {
-        return "NTAG I2C 1K";
-    } else if(type == MfUltralightTypeNTAGI2C2K) {
-        return "NTAG I2C 2K";
-    } else if(type == MfUltralightTypeNTAGI2CPlus1K) {
-        return "NTAG I2C Plus 1K";
-    } else if(type == MfUltralightTypeNTAGI2CPlus2K) {
-        return "NTAG I2C Plus 2K";
-    } else if(type == MfUltralightTypeNTAG203) {
-        return "NTAG203";
-    } else if(type == MfUltralightTypeULC) {
-        return "Mifare Ultralight C";
-    } else if(type == MfUltralightTypeUL11 && full_name) {
-        return "Mifare Ultralight 11";
-    } else if(type == MfUltralightTypeUL21 && full_name) {
-        return "Mifare Ultralight 21";
-    } else {
-        return "Mifare Ultralight";
-    }
-}
-
-const char* nfc_mf_classic_type(MfClassicType type) {
-    if(type == MfClassicTypeMini) {
-        return "Mifare Mini 0.3K";
-    } else if(type == MfClassicType1k) {
-        return "Mifare Classic 1K";
-    } else if(type == MfClassicType4k) {
-        return "Mifare Classic 4K";
-    } else {
-        return "Mifare Classic";
-    }
-}

esubghz_chat/lib/nfclegacy/nfc_types.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "nfc_device.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-const char* nfc_get_dev_type(FurryHalNfcType type);
-
-const char* nfc_guess_protocol(NfcProtocol protocol);
-
-const char* nfc_mf_ul_type(MfUltralightType type, bool full_name);
-
-const char* nfc_mf_classic_type(MfClassicType type);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/nfc_worker.c

@@ -1,971 +0,0 @@
-#include "nfc_worker_i.h"
-#include <furi_hal_rtc.h>
-
-#include "ST25RFAL002/platform.h"
-
-#define TAG "NfcWorker"
-
-/***************************** NFC Worker API *******************************/
-
-NfcWorker* nfc_worker_alloc() {
-    NfcWorker* nfc_worker = malloc(sizeof(NfcWorker));
-
-    // Worker thread attributes
-    nfc_worker->thread = furi_thread_alloc_ex("NfcWorker", 8192, nfc_worker_task, nfc_worker);
-
-    nfc_worker->callback = NULL;
-    nfc_worker->context = NULL;
-    nfc_worker->storage = furi_record_open(RECORD_STORAGE);
-
-    // Initialize rfal
-    while(furry_hal_nfc_is_busy()) {
-        furi_delay_ms(10);
-    }
-    nfc_worker_change_state(nfc_worker, NfcWorkerStateReady);
-
-    nfc_worker->reader_analyzer = reader_analyzer_alloc(nfc_worker->storage);
-
-    return nfc_worker;
-}
-
-void nfc_worker_free(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-
-    furi_thread_free(nfc_worker->thread);
-
-    furi_record_close(RECORD_STORAGE);
-
-    reader_analyzer_free(nfc_worker->reader_analyzer);
-
-    free(nfc_worker);
-}
-
-NfcWorkerState nfc_worker_get_state(NfcWorker* nfc_worker) {
-    return nfc_worker->state;
-}
-
-void nfc_worker_start(
-    NfcWorker* nfc_worker,
-    NfcWorkerState state,
-    NfcDeviceData* dev_data,
-    NfcWorkerCallback callback,
-    void* context) {
-    furi_check(nfc_worker);
-    //furi_check(dev_data);
-    while(furry_hal_nfc_is_busy()) {
-        furi_delay_ms(10);
-    }
-    furry_hal_nfc_deinit();
-    furry_hal_nfc_init();
-
-    nfc_worker->callback = callback;
-    nfc_worker->context = context;
-    nfc_worker->dev_data = dev_data;
-    nfc_worker_change_state(nfc_worker, state);
-    furi_thread_start(nfc_worker->thread);
-}
-
-void nfc_worker_stop(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->thread);
-    if(furi_thread_get_state(nfc_worker->thread) != FuriThreadStateStopped) {
-        furry_hal_nfc_stop();
-        nfc_worker_change_state(nfc_worker, NfcWorkerStateStop);
-        furi_thread_join(nfc_worker->thread);
-    }
-}
-
-void nfc_worker_change_state(NfcWorker* nfc_worker, NfcWorkerState state) {
-    nfc_worker->state = state;
-}
-
-/***************************** NFC Worker Thread *******************************/
-
-int32_t nfc_worker_task(void* context) {
-    NfcWorker* nfc_worker = context;
-
-    furry_hal_nfc_exit_sleep();
-
-    if(nfc_worker->state == NfcWorkerStateRead) {
-        if(nfc_worker->dev_data->read_mode == NfcReadModeAuto) {
-            nfc_worker_read(nfc_worker);
-        } else {
-            nfc_worker_read_type(nfc_worker);
-        }
-    } else if(nfc_worker->state == NfcWorkerStateUidEmulate) {
-        nfc_worker_emulate_uid(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfUltralightEmulate) {
-        nfc_worker_emulate_mf_ultralight(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfClassicEmulate) {
-        nfc_worker_emulate_mf_classic(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfClassicWrite) {
-        nfc_worker_write_mf_classic(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfClassicUpdate) {
-        nfc_worker_update_mf_classic(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateReadMfUltralightReadAuth) {
-        nfc_worker_mf_ultralight_read_auth(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
-        nfc_worker_mf_classic_dict_attack(nfc_worker);
-    } else if(nfc_worker->state == NfcWorkerStateAnalyzeReader) {
-        nfc_worker_analyze_reader(nfc_worker);
-    }
-    furry_hal_nfc_sleep();
-    nfc_worker_change_state(nfc_worker, NfcWorkerStateReady);
-
-    return 0;
-}
-
-static bool nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker, FurryHalNfcTxRxContext* tx_rx) {
-    bool read_success = false;
-    MfUltralightReader reader = {};
-    MfUltralightData data = {};
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_prepare_tx_rx(nfc_worker->reader_analyzer, tx_rx, false);
-        reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeDebugLog);
-    }
-
-    do {
-        furry_hal_nfc_sleep();
-
-        // Otherwise, try to read as usual
-        if(!furry_hal_nfc_detect(&nfc_worker->dev_data->nfc_data, 200)) break;
-        if(!mf_ul_read_card(tx_rx, &reader, &data)) break;
-        // Copy data
-        nfc_worker->dev_data->mf_ul_data = data;
-        read_success = true;
-    } while(false);
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_stop(nfc_worker->reader_analyzer);
-    }
-
-    return read_success;
-}
-
-static bool nfc_worker_read_mf_classic(NfcWorker* nfc_worker, FurryHalNfcTxRxContext* tx_rx) {
-    furi_assert(nfc_worker->callback);
-    bool read_success = false;
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_prepare_tx_rx(nfc_worker->reader_analyzer, tx_rx, false);
-        reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeDebugLog);
-    }
-
-    do {
-        // Try to read card with key cache
-        FURI_LOG_I(TAG, "Search for key cache ...");
-        if(nfc_worker->callback(NfcWorkerEventReadMfClassicLoadKeyCache, nfc_worker->context)) {
-            FURI_LOG_I(TAG, "Load keys cache success. Start reading");
-            uint8_t sectors_read =
-                mf_classic_update_card(tx_rx, &nfc_worker->dev_data->mf_classic_data);
-            uint8_t sectors_total =
-                mf_classic_get_total_sectors_num(nfc_worker->dev_data->mf_classic_data.type);
-            FURI_LOG_I(TAG, "Read %d sectors out of %d total", sectors_read, sectors_total);
-            read_success = mf_classic_is_card_read(&nfc_worker->dev_data->mf_classic_data);
-        }
-    } while(false);
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_stop(nfc_worker->reader_analyzer);
-    }
-    return read_success;
-}
-
-static bool nfc_worker_read_nfca(NfcWorker* nfc_worker, FurryHalNfcTxRxContext* tx_rx) {
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-
-    bool card_read = false;
-    furry_hal_nfc_sleep();
-    if(mf_ul_check_card_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak)) {
-        FURI_LOG_I(TAG, "Mifare Ultralight / NTAG detected");
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareUl;
-        card_read = nfc_worker_read_mf_ultralight(nfc_worker, tx_rx);
-    } else if(mf_classic_check_card_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak)) {
-        FURI_LOG_I(TAG, "Mifare Classic detected");
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareClassic;
-        nfc_worker->dev_data->mf_classic_data.type =
-            mf_classic_get_classic_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak);
-        card_read = nfc_worker_read_mf_classic(nfc_worker, tx_rx);
-    } else if(nfc_data->interface == FurryHalNfcInterfaceIsoDep) {
-        FURI_LOG_I(TAG, "ISO14443-4 card detected");
-
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolUnknown;
-
-        card_read = true;
-    } else {
-        nfc_worker->dev_data->protocol = NfcDeviceProtocolUnknown;
-        card_read = true;
-    }
-
-    return card_read;
-}
-
-void nfc_worker_read(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    nfc_device_data_clear(nfc_worker->dev_data);
-    NfcDeviceData* dev_data = nfc_worker->dev_data;
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FurryHalNfcTxRxContext tx_rx = {};
-    NfcWorkerEvent event = 0;
-    bool card_not_detected_notified = false;
-
-    while(nfc_worker->state == NfcWorkerStateRead) {
-        if(furry_hal_nfc_detect(nfc_data, 300)) {
-            // Process first found device
-            nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-            card_not_detected_notified = false;
-            if(nfc_data->type == FurryHalNfcTypeA) {
-                if(nfc_worker_read_nfca(nfc_worker, &tx_rx)) {
-                    if(dev_data->protocol == NfcDeviceProtocolMifareUl) {
-                        event = NfcWorkerEventReadMfUltralight;
-                        break;
-                    } else if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
-                        event = NfcWorkerEventReadMfClassicDone;
-                        break;
-                    } else if(dev_data->protocol == NfcDeviceProtocolMifareDesfire) {
-                        event = NfcWorkerEventReadMfDesfire;
-                        break;
-                    } else if(dev_data->protocol == NfcDeviceProtocolEMV) {
-                        event = NfcWorkerEventReadBankCard;
-                        break;
-                    } else if(dev_data->protocol == NfcDeviceProtocolUnknown) {
-                        event = NfcWorkerEventReadUidNfcA;
-                        break;
-                    }
-                } else {
-                    if(dev_data->protocol == NfcDeviceProtocolMifareClassic) {
-                        event = NfcWorkerEventReadMfClassicDictAttackRequired;
-                        break;
-                    }
-                }
-            } else if(nfc_data->type == FurryHalNfcTypeB) {
-                event = NfcWorkerEventReadUidNfcB;
-                break;
-            } else if(nfc_data->type == FurryHalNfcTypeF) {
-                event = NfcWorkerEventReadUidNfcF;
-                break;
-            }
-        } else {
-            if(!card_not_detected_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_not_detected_notified = true;
-            }
-        }
-        furry_hal_nfc_sleep();
-        furi_delay_ms(100);
-    }
-    // Notify caller and exit
-    if(event > NfcWorkerEventReserved) {
-        nfc_worker->callback(event, nfc_worker->context);
-    }
-}
-
-void nfc_worker_read_type(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    NfcReadMode read_mode = nfc_worker->dev_data->read_mode;
-    nfc_device_data_clear(nfc_worker->dev_data);
-    NfcDeviceData* dev_data = nfc_worker->dev_data;
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FurryHalNfcTxRxContext tx_rx = {};
-    NfcWorkerEvent event = 0;
-    bool card_not_detected_notified = false;
-
-    while(nfc_worker->state == NfcWorkerStateRead) {
-        if(furry_hal_nfc_detect(nfc_data, 300)) {
-            FURI_LOG_D(TAG, "Card detected");
-            furry_hal_nfc_sleep();
-            // Process first found device
-            nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-            card_not_detected_notified = false;
-            if(nfc_data->type == FurryHalNfcTypeA) {
-                if(read_mode == NfcReadModeMfClassic) {
-                    nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareClassic;
-                    nfc_worker->dev_data->mf_classic_data.type = mf_classic_get_classic_type(
-                        nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak);
-                    if(nfc_worker_read_mf_classic(nfc_worker, &tx_rx)) {
-                        FURI_LOG_D(TAG, "Card read");
-                        dev_data->protocol = NfcDeviceProtocolMifareClassic;
-                        event = NfcWorkerEventReadMfClassicDone;
-                        break;
-                    } else {
-                        FURI_LOG_D(TAG, "Card read failed");
-                        dev_data->protocol = NfcDeviceProtocolMifareClassic;
-                        event = NfcWorkerEventReadMfClassicDictAttackRequired;
-                        break;
-                    }
-                } else if(read_mode == NfcReadModeMfUltralight) {
-                    FURI_LOG_I(TAG, "Mifare Ultralight / NTAG");
-                    nfc_worker->dev_data->protocol = NfcDeviceProtocolMifareUl;
-                    if(nfc_worker_read_mf_ultralight(nfc_worker, &tx_rx)) {
-                        event = NfcWorkerEventReadMfUltralight;
-                        break;
-                    }
-                } else if(read_mode == NfcReadModeNFCA) {
-                    nfc_worker->dev_data->protocol = NfcDeviceProtocolUnknown;
-                    event = NfcWorkerEventReadUidNfcA;
-                    break;
-                }
-            }
-        } else {
-            if(!card_not_detected_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_not_detected_notified = true;
-            }
-        }
-        furry_hal_nfc_sleep();
-        furi_delay_ms(100);
-    }
-    // Notify caller and exit
-    if(event > NfcWorkerEventReserved) {
-        nfc_worker->callback(event, nfc_worker->context);
-    }
-}
-
-void nfc_worker_emulate_uid(NfcWorker* nfc_worker) {
-    FurryHalNfcTxRxContext tx_rx = {};
-    FurryHalNfcDevData* data = &nfc_worker->dev_data->nfc_data;
-    NfcReaderRequestData* reader_data = &nfc_worker->dev_data->reader_data;
-
-    // TODO add support for RATS
-    // Need to save ATS to support ISO-14443A-4 emulation
-
-    while(nfc_worker->state == NfcWorkerStateUidEmulate) {
-        if(furry_hal_nfc_listen(data->uid, data->uid_len, data->atqa, data->sak, false, 100)) {
-            if(furry_hal_nfc_tx_rx(&tx_rx, 100)) {
-                reader_data->size = tx_rx.rx_bits / 8;
-                if(reader_data->size > 0) {
-                    memcpy(reader_data->data, tx_rx.rx_data, reader_data->size);
-                    if(nfc_worker->callback) {
-                        nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                    }
-                }
-            } else {
-                FURI_LOG_E(TAG, "Failed to get reader commands");
-            }
-        }
-    }
-}
-
-void nfc_worker_mf_ultralight_auth_received_callback(MfUltralightAuth auth, void* context) {
-    furi_assert(context);
-
-    NfcWorker* nfc_worker = context;
-    nfc_worker->dev_data->mf_ul_auth = auth;
-    if(nfc_worker->callback) {
-        nfc_worker->callback(NfcWorkerEventMfUltralightPwdAuth, nfc_worker->context);
-    }
-}
-
-void nfc_worker_emulate_mf_ultralight(NfcWorker* nfc_worker) {
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    MfUltralightEmulator emulator = {};
-    mf_ul_prepare_emulation(&emulator, &nfc_worker->dev_data->mf_ul_data);
-
-    // TODO rework with reader analyzer
-    emulator.auth_received_callback = nfc_worker_mf_ultralight_auth_received_callback;
-    emulator.context = nfc_worker;
-
-    rfal_platform_spi_acquire();
-
-    while(nfc_worker->state == NfcWorkerStateMfUltralightEmulate) {
-        mf_ul_reset_emulation(&emulator, true);
-        furry_hal_nfc_emulate_nfca(
-            nfc_data->uid,
-            nfc_data->uid_len,
-            nfc_data->atqa,
-            nfc_data->sak,
-            mf_ul_prepare_emulation_response,
-            &emulator,
-            5000);
-        // Check if data was modified
-        if(emulator.data_changed) {
-            nfc_worker->dev_data->mf_ul_data = emulator.data;
-            if(nfc_worker->callback) {
-                nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-            }
-            emulator.data_changed = false;
-        }
-    }
-
-    rfal_platform_spi_release();
-}
-
-static bool nfc_worker_mf_get_b_key_from_sector_trailer(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint16_t sector,
-    uint64_t key,
-    uint64_t* found_key) {
-    // Some access conditions allow reading B key via A key
-
-    uint8_t block = mf_classic_get_sector_trailer_block_num_by_sector(sector);
-
-    Crypto1 crypto = {};
-    MfClassicBlock block_tmp = {};
-    MfClassicAuthContext auth_context = {.sector = sector, .key_a = MF_CLASSIC_NO_KEY, .key_b = 0};
-
-    furry_hal_nfc_sleep();
-
-    if(mf_classic_auth_attempt(tx_rx, &crypto, &auth_context, key)) {
-        if(mf_classic_read_block(tx_rx, &crypto, block, &block_tmp)) {
-            *found_key = nfc_util_bytes2num(&block_tmp.value[10], sizeof(uint8_t) * 6);
-
-            return *found_key;
-        }
-    }
-
-    return false;
-}
-
-static void nfc_worker_mf_classic_key_attack(
-    NfcWorker* nfc_worker,
-    uint64_t key,
-    FurryHalNfcTxRxContext* tx_rx,
-    uint16_t start_sector) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    bool card_found_notified = true;
-    bool card_removed_notified = false;
-
-    MfClassicData* data = &nfc_worker->dev_data->mf_classic_data;
-    NfcMfClassicDictAttackData* dict_attack_data =
-        &nfc_worker->dev_data->mf_classic_dict_attack_data;
-    uint32_t total_sectors = mf_classic_get_total_sectors_num(data->type);
-
-    furi_assert(start_sector < total_sectors);
-
-    nfc_worker->callback(NfcWorkerEventKeyAttackStart, nfc_worker->context);
-
-    // Check every sector's A and B keys with the given key
-    for(size_t i = start_sector; i < total_sectors; i++) {
-        nfc_worker->callback(NfcWorkerEventKeyAttackNextSector, nfc_worker->context);
-        dict_attack_data->current_sector = i;
-        furry_hal_nfc_sleep();
-        if(furry_hal_nfc_activate_nfca(200, NULL)) {
-            furry_hal_nfc_sleep();
-            if(!card_found_notified) {
-                nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                card_found_notified = true;
-                card_removed_notified = false;
-            }
-            uint8_t block_num = mf_classic_get_sector_trailer_block_num_by_sector(i);
-            if(mf_classic_is_sector_read(data, i)) continue;
-            if(!mf_classic_is_key_found(data, i, MfClassicKeyA)) {
-                FURI_LOG_D(TAG, "Trying A key for sector %d, key: %012llX", i, key);
-                if(mf_classic_authenticate(tx_rx, block_num, key, MfClassicKeyA)) {
-                    mf_classic_set_key_found(data, i, MfClassicKeyA, key);
-                    FURI_LOG_D(TAG, "Key A found: %012llX", key);
-                    nfc_worker->callback(NfcWorkerEventFoundKeyA, nfc_worker->context);
-
-                    uint64_t found_key;
-                    if(nfc_worker_mf_get_b_key_from_sector_trailer(tx_rx, i, key, &found_key)) {
-                        FURI_LOG_D(TAG, "Found B key via reading sector %d", i);
-                        mf_classic_set_key_found(data, i, MfClassicKeyB, found_key);
-
-                        if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
-                            nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
-                        }
-                    }
-                }
-                furry_hal_nfc_sleep();
-            }
-            if(!mf_classic_is_key_found(data, i, MfClassicKeyB)) {
-                FURI_LOG_D(TAG, "Trying B key for sector %d, key: %012llX", i, key);
-                if(mf_classic_authenticate(tx_rx, block_num, key, MfClassicKeyB)) {
-                    mf_classic_set_key_found(data, i, MfClassicKeyB, key);
-                    FURI_LOG_D(TAG, "Key B found: %012llX", key);
-                    nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
-                }
-            }
-
-            if(mf_classic_is_sector_read(data, i)) continue;
-            mf_classic_read_sector(tx_rx, data, i);
-        } else {
-            if(!card_removed_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_removed_notified = true;
-                card_found_notified = false;
-            }
-        }
-        if(nfc_worker->state != NfcWorkerStateMfClassicDictAttack) break;
-    }
-    nfc_worker->callback(NfcWorkerEventKeyAttackStop, nfc_worker->context);
-}
-
-void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    MfClassicData* data = &nfc_worker->dev_data->mf_classic_data;
-    NfcMfClassicDictAttackData* dict_attack_data =
-        &nfc_worker->dev_data->mf_classic_dict_attack_data;
-    uint32_t total_sectors = mf_classic_get_total_sectors_num(data->type);
-    uint64_t key = 0;
-    uint64_t prev_key = 0;
-    FurryHalNfcTxRxContext tx_rx = {};
-    bool card_found_notified = true;
-    bool card_removed_notified = false;
-
-    // Load dictionary
-    MfClassicDict* dict = dict_attack_data->dict;
-    if(!dict) {
-        FURI_LOG_E(TAG, "Dictionary not found");
-        nfc_worker->callback(NfcWorkerEventNoDictFound, nfc_worker->context);
-        return;
-    }
-
-    FURI_LOG_D(
-        TAG, "Start Dictionary attack, Key Count %lu", mf_classic_dict_get_total_keys(dict));
-    for(size_t i = 0; i < total_sectors; i++) {
-        FURI_LOG_I(TAG, "Sector %d", i);
-        nfc_worker->callback(NfcWorkerEventNewSector, nfc_worker->context);
-        uint8_t block_num = mf_classic_get_sector_trailer_block_num_by_sector(i);
-        if(mf_classic_is_sector_read(data, i)) continue;
-        if(mf_classic_is_key_found(data, i, MfClassicKeyA) &&
-           mf_classic_is_key_found(data, i, MfClassicKeyB))
-            continue;
-        uint16_t key_index = 0;
-        while(mf_classic_dict_get_next_key(dict, &key)) {
-            FURI_LOG_T(TAG, "Key %d", key_index);
-            if(++key_index % NFC_DICT_KEY_BATCH_SIZE == 0) {
-                nfc_worker->callback(NfcWorkerEventNewDictKeyBatch, nfc_worker->context);
-            }
-            furry_hal_nfc_sleep();
-            uint32_t cuid;
-            if(furry_hal_nfc_activate_nfca(200, &cuid)) {
-                bool deactivated = false;
-                if(!card_found_notified) {
-                    nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                    card_found_notified = true;
-                    card_removed_notified = false;
-                    nfc_worker_mf_classic_key_attack(nfc_worker, prev_key, &tx_rx, i);
-                    deactivated = true;
-                }
-                FURI_LOG_D(TAG, "Try to auth to sector %d with key %012llX", i, key);
-                if(!mf_classic_is_key_found(data, i, MfClassicKeyA)) {
-                    if(mf_classic_authenticate_skip_activate(
-                           &tx_rx, block_num, key, MfClassicKeyA, !deactivated, cuid)) {
-                        mf_classic_set_key_found(data, i, MfClassicKeyA, key);
-                        FURI_LOG_D(TAG, "Key A found: %012llX", key);
-                        nfc_worker->callback(NfcWorkerEventFoundKeyA, nfc_worker->context);
-
-                        uint64_t found_key;
-                        if(nfc_worker_mf_get_b_key_from_sector_trailer(
-                               &tx_rx, i, key, &found_key)) {
-                            FURI_LOG_D(TAG, "Found B key via reading sector %d", i);
-                            mf_classic_set_key_found(data, i, MfClassicKeyB, found_key);
-
-                            if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
-                                nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
-                            }
-
-                            nfc_worker_mf_classic_key_attack(nfc_worker, found_key, &tx_rx, i + 1);
-                            break;
-                        }
-                        nfc_worker_mf_classic_key_attack(nfc_worker, key, &tx_rx, i + 1);
-                    }
-                    furry_hal_nfc_sleep();
-                    deactivated = true;
-                } else {
-                    // If the key A is marked as found and matches the searching key, invalidate it
-                    MfClassicSectorTrailer* sec_trailer =
-                        mf_classic_get_sector_trailer_by_sector(data, i);
-
-                    uint8_t current_key[6];
-                    nfc_util_num2bytes(key, 6, current_key);
-
-                    if(mf_classic_is_key_found(data, i, MfClassicKeyA) &&
-                       memcmp(sec_trailer->key_a, current_key, 6) == 0) {
-                        if(!mf_classic_authenticate_skip_activate(
-                               &tx_rx, block_num, key, MfClassicKeyA, !deactivated, cuid)) {
-                            mf_classic_set_key_not_found(data, i, MfClassicKeyA);
-                            FURI_LOG_D(TAG, "Key %dA not found in attack", i);
-                        }
-                    }
-                    furry_hal_nfc_sleep();
-                    deactivated = true;
-                }
-                if(!mf_classic_is_key_found(data, i, MfClassicKeyB)) {
-                    if(mf_classic_authenticate_skip_activate(
-                           &tx_rx, block_num, key, MfClassicKeyB, !deactivated, cuid)) { //-V547
-                        FURI_LOG_D(TAG, "Key B found: %012llX", key);
-                        mf_classic_set_key_found(data, i, MfClassicKeyB, key);
-                        nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
-                        nfc_worker_mf_classic_key_attack(nfc_worker, key, &tx_rx, i + 1);
-                    }
-                    deactivated = true; //-V1048
-                } else {
-                    // If the key B is marked as found and matches the searching key, invalidate it
-                    MfClassicSectorTrailer* sec_trailer =
-                        mf_classic_get_sector_trailer_by_sector(data, i);
-
-                    uint8_t current_key[6];
-                    nfc_util_num2bytes(key, 6, current_key);
-
-                    if(mf_classic_is_key_found(data, i, MfClassicKeyB) &&
-                       memcmp(sec_trailer->key_b, current_key, 6) == 0) {
-                        if(!mf_classic_authenticate_skip_activate(
-                               &tx_rx, block_num, key, MfClassicKeyB, !deactivated, cuid)) { //-V547
-                            mf_classic_set_key_not_found(data, i, MfClassicKeyB);
-                            FURI_LOG_D(TAG, "Key %dB not found in attack", i);
-                        }
-                        furry_hal_nfc_sleep();
-                        deactivated = true; //-V1048
-                    }
-                }
-                if(mf_classic_is_key_found(data, i, MfClassicKeyA) &&
-                   mf_classic_is_key_found(data, i, MfClassicKeyB))
-                    break;
-                if(nfc_worker->state != NfcWorkerStateMfClassicDictAttack) break;
-            } else {
-                if(!card_removed_notified) {
-                    nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                    card_removed_notified = true;
-                    card_found_notified = false;
-                }
-                if(nfc_worker->state != NfcWorkerStateMfClassicDictAttack) break;
-            }
-            prev_key = key;
-        }
-        if(nfc_worker->state != NfcWorkerStateMfClassicDictAttack) break;
-        mf_classic_read_sector(&tx_rx, data, i);
-        mf_classic_dict_rewind(dict);
-    }
-    if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
-        nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-    } else {
-        nfc_worker->callback(NfcWorkerEventAborted, nfc_worker->context);
-    }
-}
-
-void nfc_worker_emulate_mf_classic(NfcWorker* nfc_worker) {
-    FurryHalNfcTxRxContext tx_rx = {};
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    MfClassicEmulator emulator = {
-        .cuid = nfc_util_bytes2num(&nfc_data->uid[nfc_data->uid_len - 4], 4),
-        .data = nfc_worker->dev_data->mf_classic_data,
-        .data_changed = false,
-    };
-    NfcaSignal* nfca_signal = nfca_signal_alloc();
-    tx_rx.nfca_signal = nfca_signal;
-
-    rfal_platform_spi_acquire();
-
-    furry_hal_nfc_listen_start(nfc_data);
-    while(nfc_worker->state == NfcWorkerStateMfClassicEmulate) { //-V1044
-        if(furry_hal_nfc_listen_rx(&tx_rx, 300)) {
-            if(!mf_classic_emulator(&emulator, &tx_rx, false)) {
-                furry_hal_nfc_listen_start(nfc_data);
-            }
-        }
-    }
-    if(emulator.data_changed) {
-        nfc_worker->dev_data->mf_classic_data = emulator.data;
-        if(nfc_worker->callback) {
-            nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-        }
-        emulator.data_changed = false;
-    }
-
-    nfca_signal_free(nfca_signal);
-
-    rfal_platform_spi_release();
-}
-
-void nfc_worker_write_mf_classic(NfcWorker* nfc_worker) {
-    FurryHalNfcTxRxContext tx_rx = {};
-    bool card_found_notified = false;
-    FurryHalNfcDevData nfc_data = {};
-    MfClassicData* src_data = &nfc_worker->dev_data->mf_classic_data;
-    MfClassicData dest_data = *src_data;
-
-    while(nfc_worker->state == NfcWorkerStateMfClassicWrite) {
-        if(furry_hal_nfc_detect(&nfc_data, 200)) {
-            if(!card_found_notified) {
-                nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                card_found_notified = true;
-            }
-            furry_hal_nfc_sleep();
-
-            FURI_LOG_I(TAG, "Check low level nfc data");
-            if(memcmp(&nfc_data, &nfc_worker->dev_data->nfc_data, sizeof(FurryHalNfcDevData)) !=
-               0) {
-                FURI_LOG_E(TAG, "Wrong card");
-                nfc_worker->callback(NfcWorkerEventWrongCard, nfc_worker->context);
-                break;
-            }
-
-            FURI_LOG_I(TAG, "Check mf classic type");
-            MfClassicType type =
-                mf_classic_get_classic_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak);
-            if(type != nfc_worker->dev_data->mf_classic_data.type) {
-                FURI_LOG_E(TAG, "Wrong mf classic type");
-                nfc_worker->callback(NfcWorkerEventWrongCard, nfc_worker->context);
-                break;
-            }
-
-            // Set blocks not read
-            mf_classic_set_sector_data_not_read(&dest_data);
-            FURI_LOG_I(TAG, "Updating card sectors");
-            uint8_t total_sectors = mf_classic_get_total_sectors_num(type);
-            bool write_success = true;
-            for(uint8_t i = 0; i < total_sectors; i++) {
-                FURI_LOG_I(TAG, "Reading sector %d", i);
-                mf_classic_read_sector(&tx_rx, &dest_data, i);
-                bool old_data_read = mf_classic_is_sector_data_read(src_data, i);
-                bool new_data_read = mf_classic_is_sector_data_read(&dest_data, i);
-                if(old_data_read != new_data_read) {
-                    FURI_LOG_E(TAG, "Failed to update sector %d", i);
-                    write_success = false;
-                    break;
-                }
-                if(nfc_worker->state != NfcWorkerStateMfClassicWrite) break;
-                if(!mf_classic_write_sector(&tx_rx, &dest_data, src_data, i)) {
-                    FURI_LOG_E(TAG, "Failed to write %d sector", i);
-                    write_success = false;
-                    break;
-                }
-            }
-            if(nfc_worker->state != NfcWorkerStateMfClassicWrite) break;
-            if(write_success) {
-                nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                break;
-            } else {
-                nfc_worker->callback(NfcWorkerEventFail, nfc_worker->context);
-                break;
-            }
-
-        } else {
-            if(card_found_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_found_notified = false;
-            }
-        }
-        furi_delay_ms(300);
-    }
-}
-
-void nfc_worker_update_mf_classic(NfcWorker* nfc_worker) {
-    FurryHalNfcTxRxContext tx_rx = {};
-    bool card_found_notified = false;
-    FurryHalNfcDevData nfc_data = {};
-    MfClassicData* old_data = &nfc_worker->dev_data->mf_classic_data;
-    MfClassicData new_data = *old_data;
-
-    while(nfc_worker->state == NfcWorkerStateMfClassicUpdate) {
-        if(furry_hal_nfc_detect(&nfc_data, 200)) {
-            if(!card_found_notified) {
-                nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                card_found_notified = true;
-            }
-            furry_hal_nfc_sleep();
-
-            FURI_LOG_I(TAG, "Check low level nfc data");
-            if(memcmp(&nfc_data, &nfc_worker->dev_data->nfc_data, sizeof(FurryHalNfcDevData)) !=
-               0) {
-                FURI_LOG_E(TAG, "Low level nfc data mismatch");
-                nfc_worker->callback(NfcWorkerEventWrongCard, nfc_worker->context);
-                break;
-            }
-
-            FURI_LOG_I(TAG, "Check MF classic type");
-            MfClassicType type =
-                mf_classic_get_classic_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak);
-            if(type != nfc_worker->dev_data->mf_classic_data.type) {
-                FURI_LOG_E(TAG, "MF classic type mismatch");
-                nfc_worker->callback(NfcWorkerEventWrongCard, nfc_worker->context);
-                break;
-            }
-
-            // Set blocks not read
-            mf_classic_set_sector_data_not_read(&new_data);
-            FURI_LOG_I(TAG, "Updating card sectors");
-            uint8_t total_sectors = mf_classic_get_total_sectors_num(type);
-            bool update_success = true;
-            for(uint8_t i = 0; i < total_sectors; i++) {
-                FURI_LOG_I(TAG, "Reading sector %d", i);
-                mf_classic_read_sector(&tx_rx, &new_data, i);
-                bool old_data_read = mf_classic_is_sector_data_read(old_data, i);
-                bool new_data_read = mf_classic_is_sector_data_read(&new_data, i);
-                if(old_data_read != new_data_read) {
-                    FURI_LOG_E(TAG, "Failed to update sector %d", i);
-                    update_success = false;
-                    break;
-                }
-                if(nfc_worker->state != NfcWorkerStateMfClassicUpdate) break;
-            }
-            if(nfc_worker->state != NfcWorkerStateMfClassicUpdate) break;
-
-            // Check updated data
-            if(update_success) {
-                *old_data = new_data;
-                nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                break;
-            }
-        } else {
-            if(card_found_notified) {
-                nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-                card_found_notified = false;
-            }
-        }
-        furi_delay_ms(300);
-    }
-}
-
-void nfc_worker_mf_ultralight_read_auth(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    MfUltralightData* data = &nfc_worker->dev_data->mf_ul_data;
-    FurryHalNfcDevData* nfc_data = &nfc_worker->dev_data->nfc_data;
-    FurryHalNfcTxRxContext tx_rx = {};
-    MfUltralightReader reader = {};
-    mf_ul_reset(data);
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_prepare_tx_rx(nfc_worker->reader_analyzer, &tx_rx, true);
-        reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeDebugLog);
-    }
-
-    uint32_t key = 0;
-    uint16_t pack = 0;
-    while(nfc_worker->state == NfcWorkerStateReadMfUltralightReadAuth) {
-        furry_hal_nfc_sleep();
-        if(furry_hal_nfc_detect(nfc_data, 300) && nfc_data->type == FurryHalNfcTypeA) {
-            if(mf_ul_check_card_type(nfc_data->atqa[0], nfc_data->atqa[1], nfc_data->sak)) {
-                nfc_worker->callback(NfcWorkerEventCardDetected, nfc_worker->context);
-                if(data->auth_method == MfUltralightAuthMethodManual ||
-                   data->auth_method == MfUltralightAuthMethodAuto) {
-                    nfc_worker->callback(NfcWorkerEventMfUltralightPassKey, nfc_worker->context);
-                    key = nfc_util_bytes2num(data->auth_key, 4);
-                } else if(data->auth_method == MfUltralightAuthMethodAmeebo) {
-                    key = mf_ul_pwdgen_amiibo(nfc_data);
-                } else if(data->auth_method == MfUltralightAuthMethodXiaomi) {
-                    key = mf_ul_pwdgen_xiaomi(nfc_data);
-                } else {
-                    FURI_LOG_E(TAG, "Incorrect auth method");
-                    break;
-                }
-
-                data->auth_success = mf_ultralight_authenticate(&tx_rx, key, &pack);
-
-                if(!data->auth_success) {
-                    // Reset card
-                    furry_hal_nfc_sleep();
-                    if(!furry_hal_nfc_activate_nfca(300, NULL)) {
-                        nfc_worker->callback(NfcWorkerEventFail, nfc_worker->context);
-                        break;
-                    }
-                }
-
-                mf_ul_read_card(&tx_rx, &reader, data);
-                if(data->auth_success) {
-                    MfUltralightConfigPages* config_pages = mf_ultralight_get_config_pages(data);
-                    if(config_pages != NULL) {
-                        config_pages->auth_data.pwd.value = REVERSE_BYTES_U32(key);
-                        config_pages->auth_data.pack.value = pack;
-                    }
-                    nfc_worker->callback(NfcWorkerEventSuccess, nfc_worker->context);
-                    break;
-                } else {
-                    nfc_worker->callback(NfcWorkerEventFail, nfc_worker->context);
-                    break;
-                }
-            } else {
-                nfc_worker->callback(NfcWorkerEventWrongCardDetected, nfc_worker->context);
-                furi_delay_ms(10);
-            }
-        } else {
-            nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
-            furi_delay_ms(10);
-        }
-    }
-
-    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
-        reader_analyzer_stop(nfc_worker->reader_analyzer);
-    }
-}
-
-static void nfc_worker_reader_analyzer_callback(ReaderAnalyzerEvent event, void* context) {
-    furi_assert(context);
-    NfcWorker* nfc_worker = context;
-
-    if((nfc_worker->state == NfcWorkerStateAnalyzeReader) &&
-       (event == ReaderAnalyzerEventMfkeyCollected)) {
-        if(nfc_worker->callback) {
-            nfc_worker->callback(NfcWorkerEventDetectReaderMfkeyCollected, nfc_worker->context);
-        }
-    }
-}
-
-void nfc_worker_analyze_reader(NfcWorker* nfc_worker) {
-    furi_assert(nfc_worker);
-    furi_assert(nfc_worker->callback);
-
-    FurryHalNfcTxRxContext tx_rx = {};
-
-    ReaderAnalyzer* reader_analyzer = nfc_worker->reader_analyzer;
-    FurryHalNfcDevData* nfc_data = NULL;
-    if(nfc_worker->dev_data->protocol == NfcDeviceProtocolMifareClassic) {
-        nfc_data = &nfc_worker->dev_data->nfc_data;
-        reader_analyzer_set_nfc_data(reader_analyzer, nfc_data);
-    } else {
-        nfc_data = reader_analyzer_get_nfc_data(reader_analyzer);
-    }
-    MfClassicEmulator emulator = {
-        .cuid = nfc_util_bytes2num(&nfc_data->uid[nfc_data->uid_len - 4], 4),
-        .data = nfc_worker->dev_data->mf_classic_data,
-        .data_changed = false,
-    };
-    NfcaSignal* nfca_signal = nfca_signal_alloc();
-    tx_rx.nfca_signal = nfca_signal;
-    reader_analyzer_prepare_tx_rx(reader_analyzer, &tx_rx, true);
-    reader_analyzer_start(nfc_worker->reader_analyzer, ReaderAnalyzerModeMfkey);
-    reader_analyzer_set_callback(reader_analyzer, nfc_worker_reader_analyzer_callback, nfc_worker);
-
-    rfal_platform_spi_acquire();
-
-    FURI_LOG_D(TAG, "Start reader analyzer");
-
-    uint8_t reader_no_data_received_cnt = 0;
-    bool reader_no_data_notified = true;
-
-    while(nfc_worker->state == NfcWorkerStateAnalyzeReader) {
-        furry_hal_nfc_listen_start(nfc_data);
-        if(furry_hal_nfc_listen_rx(&tx_rx, 300)) {
-            if(reader_no_data_notified) {
-                nfc_worker->callback(NfcWorkerEventDetectReaderDetected, nfc_worker->context);
-            }
-            reader_no_data_received_cnt = 0;
-            reader_no_data_notified = false;
-            NfcProtocol protocol =
-                reader_analyzer_guess_protocol(reader_analyzer, tx_rx.rx_data, tx_rx.rx_bits / 8);
-            if(protocol == NfcDeviceProtocolMifareClassic) {
-                if(!mf_classic_emulator(&emulator, &tx_rx, true)) {
-                    furry_hal_nfc_listen_start(nfc_data);
-                }
-            }
-        } else {
-            reader_no_data_received_cnt++;
-            if(!reader_no_data_notified && (reader_no_data_received_cnt > 5)) {
-                nfc_worker->callback(NfcWorkerEventDetectReaderLost, nfc_worker->context);
-                reader_no_data_received_cnt = 0;
-                reader_no_data_notified = true;
-            }
-            FURI_LOG_D(TAG, "No data from reader");
-            continue;
-        }
-        furi_delay_ms(1);
-    }
-
-    rfal_platform_spi_release();
-
-    reader_analyzer_stop(nfc_worker->reader_analyzer);
-
-    nfca_signal_free(nfca_signal);
-}

esubghz_chat/lib/nfclegacy/nfc_worker.h

@@ -1,109 +0,0 @@
-#pragma once
-
-#include "nfc_device.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct NfcWorker NfcWorker;
-
-typedef enum {
-    // Init states
-    NfcWorkerStateNone,
-    NfcWorkerStateReady,
-    // Main worker states
-    NfcWorkerStateRead,
-    NfcWorkerStateUidEmulate,
-    NfcWorkerStateMfUltralightEmulate,
-    NfcWorkerStateMfClassicEmulate,
-    NfcWorkerStateMfClassicWrite,
-    NfcWorkerStateMfClassicUpdate,
-    NfcWorkerStateReadMfUltralightReadAuth,
-    NfcWorkerStateMfClassicDictAttack,
-    NfcWorkerStateAnalyzeReader,
-    NfcWorkerStateNfcVEmulate,
-    NfcWorkerStateNfcVUnlock,
-    NfcWorkerStateNfcVUnlockAndSave,
-    NfcWorkerStateNfcVSniff,
-    // Debug
-    NfcWorkerStateEmulateApdu,
-    NfcWorkerStateField,
-    // Transition
-    NfcWorkerStateStop,
-} NfcWorkerState;
-
-typedef enum {
-    // Reserve first 50 events for application events
-    NfcWorkerEventReserved = 50,
-
-    // Nfc read events
-    NfcWorkerEventReadUidNfcB,
-    NfcWorkerEventReadUidNfcV,
-    NfcWorkerEventReadUidNfcF,
-    NfcWorkerEventReadUidNfcA,
-    NfcWorkerEventReadMfUltralight,
-    NfcWorkerEventReadMfDesfire,
-    NfcWorkerEventReadMfClassicDone,
-    NfcWorkerEventReadMfClassicLoadKeyCache,
-    NfcWorkerEventReadMfClassicDictAttackRequired,
-    NfcWorkerEventReadBankCard,
-    NfcWorkerEventReadNfcV,
-
-    // Nfc worker common events
-    NfcWorkerEventSuccess,
-    NfcWorkerEventFail,
-    NfcWorkerEventAborted,
-    NfcWorkerEventCardDetected,
-    NfcWorkerEventNoCardDetected,
-    NfcWorkerEventWrongCardDetected,
-
-    // Read Mifare Classic events
-    NfcWorkerEventNoDictFound,
-    NfcWorkerEventNewSector,
-    NfcWorkerEventNewDictKeyBatch,
-    NfcWorkerEventFoundKeyA,
-    NfcWorkerEventFoundKeyB,
-    NfcWorkerEventKeyAttackStart,
-    NfcWorkerEventKeyAttackStop,
-    NfcWorkerEventKeyAttackNextSector,
-
-    // Write Mifare Classic events
-    NfcWorkerEventWrongCard,
-
-    // Detect Reader events
-    NfcWorkerEventDetectReaderDetected,
-    NfcWorkerEventDetectReaderLost,
-    NfcWorkerEventDetectReaderMfkeyCollected,
-
-    // Mifare Ultralight events
-    NfcWorkerEventMfUltralightPassKey, // NFC worker requesting manual key
-    NfcWorkerEventMfUltralightPwdAuth, // Reader sent auth command
-    NfcWorkerEventNfcVPassKey, // NFC worker requesting manual key
-    NfcWorkerEventNfcVCommandExecuted,
-    NfcWorkerEventNfcVContentChanged,
-} NfcWorkerEvent;
-
-typedef bool (*NfcWorkerCallback)(NfcWorkerEvent event, void* context);
-
-NfcWorker* nfc_worker_alloc();
-
-NfcWorkerState nfc_worker_get_state(NfcWorker* nfc_worker);
-
-void nfc_worker_free(NfcWorker* nfc_worker);
-
-void nfc_worker_start(
-    NfcWorker* nfc_worker,
-    NfcWorkerState state,
-    NfcDeviceData* dev_data,
-    NfcWorkerCallback callback,
-    void* context);
-
-void nfc_worker_stop(NfcWorker* nfc_worker);
-void nfc_worker_nfcv_unlock(NfcWorker* nfc_worker);
-void nfc_worker_nfcv_emulate(NfcWorker* nfc_worker);
-void nfc_worker_nfcv_sniff(NfcWorker* nfc_worker);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/nfc_worker_i.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include "nfc_worker.h"
-
-#include <furi.h>
-#include <lib/toolbox/stream/file_stream.h>
-
-#include "protocols/nfc_util.h"
-#include "protocols/mifare_common.h"
-#include "protocols/mifare_ultralight.h"
-#include "protocols/mifare_classic.h"
-#include "protocols/nfca.h"
-#include "helpers/reader_analyzer.h"
-
-struct NfcWorker {
-    FuriThread* thread;
-    Storage* storage;
-    Stream* dict_stream;
-
-    NfcDeviceData* dev_data;
-
-    NfcWorkerCallback callback;
-    void* context;
-
-    NfcWorkerState state;
-
-    ReaderAnalyzer* reader_analyzer;
-};
-
-void nfc_worker_change_state(NfcWorker* nfc_worker, NfcWorkerState state);
-
-int32_t nfc_worker_task(void* context);
-
-void nfc_worker_read(NfcWorker* nfc_worker);
-
-void nfc_worker_read_type(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_uid(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_mf_ultralight(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_mf_classic(NfcWorker* nfc_worker);
-
-void nfc_worker_write_mf_classic(NfcWorker* nfc_worker);
-
-void nfc_worker_update_mf_classic(NfcWorker* nfc_worker);
-
-void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker);
-
-void nfc_worker_mf_ultralight_read_auth(NfcWorker* nfc_worker);
-
-void nfc_worker_mf_ul_auth_attack(NfcWorker* nfc_worker);
-
-void nfc_worker_emulate_apdu(NfcWorker* nfc_worker);
-
-void nfc_worker_analyze_reader(NfcWorker* nfc_worker);

esubghz_chat/lib/nfclegacy/protocols/crypto1.c

@@ -1,128 +0,0 @@
-#include "crypto1.h"
-#include "nfc_util.h"
-#include <furi.h>
-
-// Algorithm from https://github.com/RfidResearchGroup/proxmark3.git
-
-#define SWAPENDIAN(x) \
-    ((x) = ((x) >> 8 & 0xff00ff) | ((x)&0xff00ff) << 8, (x) = (x) >> 16 | (x) << 16)
-#define LF_POLY_ODD (0x29CE5C)
-#define LF_POLY_EVEN (0x870804)
-
-#define BEBIT(x, n) FURI_BIT(x, (n) ^ 24)
-
-void crypto1_reset(Crypto1* crypto1) {
-    furi_assert(crypto1);
-    crypto1->even = 0;
-    crypto1->odd = 0;
-}
-
-void crypto1_init(Crypto1* crypto1, uint64_t key) {
-    furi_assert(crypto1);
-    crypto1->even = 0;
-    crypto1->odd = 0;
-    for(int8_t i = 47; i > 0; i -= 2) {
-        crypto1->odd = crypto1->odd << 1 | FURI_BIT(key, (i - 1) ^ 7);
-        crypto1->even = crypto1->even << 1 | FURI_BIT(key, i ^ 7);
-    }
-}
-
-uint32_t crypto1_filter(uint32_t in) {
-    uint32_t out = 0;
-    out = 0xf22c0 >> (in & 0xf) & 16;
-    out |= 0x6c9c0 >> (in >> 4 & 0xf) & 8;
-    out |= 0x3c8b0 >> (in >> 8 & 0xf) & 4;
-    out |= 0x1e458 >> (in >> 12 & 0xf) & 2;
-    out |= 0x0d938 >> (in >> 16 & 0xf) & 1;
-    return FURI_BIT(0xEC57E80A, out);
-}
-
-uint8_t crypto1_bit(Crypto1* crypto1, uint8_t in, int is_encrypted) {
-    furi_assert(crypto1);
-    uint8_t out = crypto1_filter(crypto1->odd);
-    uint32_t feed = out & (!!is_encrypted);
-    feed ^= !!in;
-    feed ^= LF_POLY_ODD & crypto1->odd;
-    feed ^= LF_POLY_EVEN & crypto1->even;
-    crypto1->even = crypto1->even << 1 | (nfc_util_even_parity32(feed));
-
-    FURI_SWAP(crypto1->odd, crypto1->even);
-    return out;
-}
-
-uint8_t crypto1_byte(Crypto1* crypto1, uint8_t in, int is_encrypted) {
-    furi_assert(crypto1);
-    uint8_t out = 0;
-    for(uint8_t i = 0; i < 8; i++) {
-        out |= crypto1_bit(crypto1, FURI_BIT(in, i), is_encrypted) << i;
-    }
-    return out;
-}
-
-uint32_t crypto1_word(Crypto1* crypto1, uint32_t in, int is_encrypted) {
-    furi_assert(crypto1);
-    uint32_t out = 0;
-    for(uint8_t i = 0; i < 32; i++) {
-        out |= crypto1_bit(crypto1, BEBIT(in, i), is_encrypted) << (24 ^ i);
-    }
-    return out;
-}
-
-uint32_t prng_successor(uint32_t x, uint32_t n) {
-    SWAPENDIAN(x);
-    while(n--) x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31;
-
-    return SWAPENDIAN(x);
-}
-
-void crypto1_decrypt(
-    Crypto1* crypto,
-    uint8_t* encrypted_data,
-    uint16_t encrypted_data_bits,
-    uint8_t* decrypted_data) {
-    furi_assert(crypto);
-    furi_assert(encrypted_data);
-    furi_assert(decrypted_data);
-
-    if(encrypted_data_bits < 8) {
-        uint8_t decrypted_byte = 0;
-        decrypted_byte |= (crypto1_bit(crypto, 0, 0) ^ FURI_BIT(encrypted_data[0], 0)) << 0;
-        decrypted_byte |= (crypto1_bit(crypto, 0, 0) ^ FURI_BIT(encrypted_data[0], 1)) << 1;
-        decrypted_byte |= (crypto1_bit(crypto, 0, 0) ^ FURI_BIT(encrypted_data[0], 2)) << 2;
-        decrypted_byte |= (crypto1_bit(crypto, 0, 0) ^ FURI_BIT(encrypted_data[0], 3)) << 3;
-        decrypted_data[0] = decrypted_byte;
-    } else {
-        for(size_t i = 0; i < encrypted_data_bits / 8; i++) {
-            decrypted_data[i] = crypto1_byte(crypto, 0, 0) ^ encrypted_data[i];
-        }
-    }
-}
-
-void crypto1_encrypt(
-    Crypto1* crypto,
-    uint8_t* keystream,
-    uint8_t* plain_data,
-    uint16_t plain_data_bits,
-    uint8_t* encrypted_data,
-    uint8_t* encrypted_parity) {
-    furi_assert(crypto);
-    furi_assert(plain_data);
-    furi_assert(encrypted_data);
-    furi_assert(encrypted_parity);
-
-    if(plain_data_bits < 8) {
-        encrypted_data[0] = 0;
-        for(size_t i = 0; i < plain_data_bits; i++) {
-            encrypted_data[0] |= (crypto1_bit(crypto, 0, 0) ^ FURI_BIT(plain_data[0], i)) << i;
-        }
-    } else {
-        memset(encrypted_parity, 0, plain_data_bits / 8 + 1);
-        for(uint8_t i = 0; i < plain_data_bits / 8; i++) {
-            encrypted_data[i] = crypto1_byte(crypto, keystream ? keystream[i] : 0, 0) ^
-                                plain_data[i];
-            encrypted_parity[i / 8] |=
-                (((crypto1_filter(crypto->odd) ^ nfc_util_odd_parity8(plain_data[i])) & 0x01)
-                 << (7 - (i & 0x0007)));
-        }
-    }
-}

esubghz_chat/lib/nfclegacy/protocols/crypto1.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-    uint32_t odd;
-    uint32_t even;
-} Crypto1;
-
-void crypto1_reset(Crypto1* crypto1);
-
-void crypto1_init(Crypto1* crypto1, uint64_t key);
-
-uint8_t crypto1_bit(Crypto1* crypto1, uint8_t in, int is_encrypted);
-
-uint8_t crypto1_byte(Crypto1* crypto1, uint8_t in, int is_encrypted);
-
-uint32_t crypto1_word(Crypto1* crypto1, uint32_t in, int is_encrypted);
-
-uint32_t crypto1_filter(uint32_t in);
-
-uint32_t prng_successor(uint32_t x, uint32_t n);
-
-void crypto1_decrypt(
-    Crypto1* crypto,
-    uint8_t* encrypted_data,
-    uint16_t encrypted_data_bits,
-    uint8_t* decrypted_data);
-
-void crypto1_encrypt(
-    Crypto1* crypto,
-    uint8_t* keystream,
-    uint8_t* plain_data,
-    uint16_t plain_data_bits,
-    uint8_t* encrypted_data,
-    uint8_t* encrypted_parity);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/protocols/mifare_classic.c

@@ -1,1627 +0,0 @@
-#include "mifare_classic.h"
-#include "nfca.h"
-#include "nfc_util.h"
-#include <furi_hal_rtc.h>
-
-// Algorithm from https://github.com/RfidResearchGroup/proxmark3.git
-
-#define TAG "MfClassic"
-
-#define MF_CLASSIC_ACK_CMD 0xAU
-#define MF_CLASSIC_NACK_BUF_VALID_CMD 0x0U
-#define MF_CLASSIC_NACK_BUF_INVALID_CMD 0x4U
-#define MF_CLASSIC_AUTH_KEY_A_CMD 0x60U
-#define MF_CLASSIC_AUTH_KEY_B_CMD 0x61U
-#define MF_CLASSIC_READ_BLOCK_CMD 0x30U
-#define MF_CLASSIC_WRITE_BLOCK_CMD 0xA0U
-#define MF_CLASSIC_TRANSFER_CMD 0xB0U
-#define MF_CLASSIC_DECREMENT_CMD 0xC0U
-#define MF_CLASSIC_INCREMENT_CMD 0xC1U
-#define MF_CLASSIC_RESTORE_CMD 0xC2U
-
-const char* mf_classic_get_type_str(MfClassicType type) {
-    if(type == MfClassicTypeMini) {
-        return "MIFARE Mini 0.3K";
-    } else if(type == MfClassicType1k) {
-        return "MIFARE Classic 1K";
-    } else if(type == MfClassicType4k) {
-        return "MIFARE Classic 4K";
-    } else {
-        return "Unknown";
-    }
-}
-
-static uint8_t mf_classic_get_first_block_num_of_sector(uint8_t sector) {
-    furi_assert(sector < 40);
-    if(sector < 32) {
-        return sector * 4;
-    } else {
-        return 32 * 4 + (sector - 32) * 16;
-    }
-}
-
-uint8_t mf_classic_get_sector_trailer_block_num_by_sector(uint8_t sector) {
-    furi_assert(sector < 40);
-    if(sector < 32) {
-        return sector * 4 + 3;
-    } else {
-        return 32 * 4 + (sector - 32) * 16 + 15;
-    }
-}
-
-uint8_t mf_classic_get_sector_by_block(uint8_t block) {
-    if(block < 128) {
-        return (block | 0x03) / 4;
-    } else {
-        return 32 + ((block | 0xf) - 32 * 4) / 16;
-    }
-}
-
-static uint8_t mf_classic_get_blocks_num_in_sector(uint8_t sector) {
-    furi_assert(sector < 40);
-    return sector < 32 ? 4 : 16;
-}
-
-uint8_t mf_classic_get_sector_trailer_num_by_block(uint8_t block) {
-    if(block < 128) {
-        return block | 0x03;
-    } else {
-        return block | 0x0f;
-    }
-}
-
-bool mf_classic_is_sector_trailer(uint8_t block) {
-    return block == mf_classic_get_sector_trailer_num_by_block(block);
-}
-
-MfClassicSectorTrailer*
-    mf_classic_get_sector_trailer_by_sector(MfClassicData* data, uint8_t sector) {
-    furi_assert(data);
-    uint8_t sec_tr_block_num = mf_classic_get_sector_trailer_block_num_by_sector(sector);
-    return (MfClassicSectorTrailer*)data->block[sec_tr_block_num].value;
-}
-
-uint8_t mf_classic_get_total_sectors_num(MfClassicType type) {
-    if(type == MfClassicTypeMini) {
-        return MF_MINI_TOTAL_SECTORS_NUM;
-    } else if(type == MfClassicType1k) {
-        return MF_CLASSIC_1K_TOTAL_SECTORS_NUM;
-    } else if(type == MfClassicType4k) {
-        return MF_CLASSIC_4K_TOTAL_SECTORS_NUM;
-    } else {
-        return 0;
-    }
-}
-
-uint16_t mf_classic_get_total_block_num(MfClassicType type) {
-    if(type == MfClassicTypeMini) {
-        return 20;
-    } else if(type == MfClassicType1k) {
-        return 64;
-    } else if(type == MfClassicType4k) {
-        return 256;
-    } else {
-        return 0;
-    }
-}
-
-bool mf_classic_is_block_read(MfClassicData* data, uint8_t block_num) {
-    furi_assert(data);
-
-    return (FURI_BIT(data->block_read_mask[block_num / 32], block_num % 32) == 1);
-}
-
-void mf_classic_set_block_read(MfClassicData* data, uint8_t block_num, MfClassicBlock* block_data) {
-    furi_assert(data);
-
-    if(mf_classic_is_sector_trailer(block_num)) {
-        memcpy(&data->block[block_num].value[6], &block_data->value[6], 4);
-    } else {
-        memcpy(data->block[block_num].value, block_data->value, MF_CLASSIC_BLOCK_SIZE);
-    }
-    FURI_BIT_SET(data->block_read_mask[block_num / 32], block_num % 32);
-}
-
-bool mf_classic_is_sector_data_read(MfClassicData* data, uint8_t sector_num) {
-    furi_assert(data);
-
-    uint8_t first_block = mf_classic_get_first_block_num_of_sector(sector_num);
-    uint8_t total_blocks = mf_classic_get_blocks_num_in_sector(sector_num);
-    bool data_read = true;
-    for(size_t i = first_block; i < first_block + total_blocks; i++) {
-        data_read &= mf_classic_is_block_read(data, i);
-    }
-
-    return data_read;
-}
-
-void mf_classic_set_sector_data_not_read(MfClassicData* data) {
-    furi_assert(data);
-    memset(data->block_read_mask, 0, sizeof(data->block_read_mask));
-}
-
-bool mf_classic_is_key_found(MfClassicData* data, uint8_t sector_num, MfClassicKey key_type) {
-    furi_assert(data);
-
-    bool key_found = false;
-    if(key_type == MfClassicKeyA) {
-        key_found = (FURI_BIT(data->key_a_mask, sector_num) == 1);
-    } else if(key_type == MfClassicKeyB) {
-        key_found = (FURI_BIT(data->key_b_mask, sector_num) == 1);
-    }
-
-    return key_found;
-}
-
-void mf_classic_set_key_found(
-    MfClassicData* data,
-    uint8_t sector_num,
-    MfClassicKey key_type,
-    uint64_t key) {
-    furi_assert(data);
-
-    uint8_t key_arr[6] = {};
-    MfClassicSectorTrailer* sec_trailer =
-        mf_classic_get_sector_trailer_by_sector(data, sector_num);
-    nfc_util_num2bytes(key, 6, key_arr);
-    if(key_type == MfClassicKeyA) {
-        memcpy(sec_trailer->key_a, key_arr, sizeof(sec_trailer->key_a));
-        FURI_BIT_SET(data->key_a_mask, sector_num);
-    } else if(key_type == MfClassicKeyB) {
-        memcpy(sec_trailer->key_b, key_arr, sizeof(sec_trailer->key_b));
-        FURI_BIT_SET(data->key_b_mask, sector_num);
-    }
-}
-
-void mf_classic_set_key_not_found(MfClassicData* data, uint8_t sector_num, MfClassicKey key_type) {
-    furi_assert(data);
-
-    if(key_type == MfClassicKeyA) {
-        FURI_BIT_CLEAR(data->key_a_mask, sector_num);
-    } else if(key_type == MfClassicKeyB) {
-        FURI_BIT_CLEAR(data->key_b_mask, sector_num);
-    }
-}
-
-bool mf_classic_is_sector_read(MfClassicData* data, uint8_t sector_num) {
-    furi_assert(data);
-
-    bool sector_read = false;
-    do {
-        if(!mf_classic_is_key_found(data, sector_num, MfClassicKeyA)) break;
-        if(!mf_classic_is_key_found(data, sector_num, MfClassicKeyB)) break;
-        uint8_t start_block = mf_classic_get_first_block_num_of_sector(sector_num);
-        uint8_t total_blocks = mf_classic_get_blocks_num_in_sector(sector_num);
-        uint8_t block_read = true;
-        for(size_t i = start_block; i < start_block + total_blocks; i++) {
-            block_read = mf_classic_is_block_read(data, i);
-            if(!block_read) break;
-        }
-        sector_read = block_read;
-    } while(false);
-
-    return sector_read;
-}
-
-void mf_classic_get_read_sectors_and_keys(
-    MfClassicData* data,
-    uint8_t* sectors_read,
-    uint8_t* keys_found) {
-    furi_assert(data);
-    furi_assert(sectors_read);
-    furi_assert(keys_found);
-
-    *sectors_read = 0;
-    *keys_found = 0;
-    uint8_t sectors_total = mf_classic_get_total_sectors_num(data->type);
-    for(size_t i = 0; i < sectors_total; i++) {
-        if(mf_classic_is_key_found(data, i, MfClassicKeyA)) {
-            *keys_found += 1;
-        }
-        if(mf_classic_is_key_found(data, i, MfClassicKeyB)) {
-            *keys_found += 1;
-        }
-        uint8_t first_block = mf_classic_get_first_block_num_of_sector(i);
-        uint8_t total_blocks_in_sec = mf_classic_get_blocks_num_in_sector(i);
-        bool blocks_read = true;
-        for(size_t j = first_block; j < first_block + total_blocks_in_sec; j++) {
-            blocks_read = mf_classic_is_block_read(data, j);
-            if(!blocks_read) break;
-        }
-        if(blocks_read) {
-            *sectors_read += 1;
-        }
-    }
-}
-
-bool mf_classic_is_card_read(MfClassicData* data) {
-    furi_assert(data);
-
-    uint8_t sectors_total = mf_classic_get_total_sectors_num(data->type);
-    uint8_t sectors_read = 0;
-    uint8_t keys_found = 0;
-    mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
-    bool card_read = (sectors_read == sectors_total) && (keys_found == sectors_total * 2);
-
-    return card_read;
-}
-
-bool mf_classic_is_allowed_access_sector_trailer(
-    MfClassicData* data,
-    uint8_t block_num,
-    MfClassicKey key,
-    MfClassicAction action) {
-    uint8_t* sector_trailer = data->block[block_num].value;
-    uint8_t AC = ((sector_trailer[7] >> 5) & 0x04) | ((sector_trailer[8] >> 2) & 0x02) |
-                 ((sector_trailer[8] >> 7) & 0x01);
-    switch(action) {
-    case MfClassicActionKeyARead: {
-        return false;
-    }
-    case MfClassicActionKeyAWrite:
-    case MfClassicActionKeyBWrite: {
-        return (
-            (key == MfClassicKeyA && (AC == 0x00 || AC == 0x01)) ||
-            (key == MfClassicKeyB && (AC == 0x04 || AC == 0x03)));
-    }
-    case MfClassicActionKeyBRead: {
-        return (key == MfClassicKeyA && (AC == 0x00 || AC == 0x02 || AC == 0x01));
-    }
-    case MfClassicActionACRead: {
-        return (
-            (key == MfClassicKeyA) ||
-            (key == MfClassicKeyB && !(AC == 0x00 || AC == 0x02 || AC == 0x01)));
-    }
-    case MfClassicActionACWrite: {
-        return (
-            (key == MfClassicKeyA && (AC == 0x01)) ||
-            (key == MfClassicKeyB && (AC == 0x03 || AC == 0x05)));
-    }
-    default:
-        return false;
-    }
-    return true;
-}
-
-bool mf_classic_is_allowed_access_data_block(
-    MfClassicData* data,
-    uint8_t block_num,
-    MfClassicKey key,
-    MfClassicAction action) {
-    uint8_t* sector_trailer =
-        data->block[mf_classic_get_sector_trailer_num_by_block(block_num)].value;
-
-    if(block_num == 0 && action == MfClassicActionDataWrite) {
-        return false;
-    }
-
-    uint8_t sector_block;
-    if(block_num <= 128) {
-        sector_block = block_num & 0x03;
-    } else {
-        sector_block = (block_num & 0x0f) / 5;
-    }
-
-    uint8_t AC;
-    switch(sector_block) {
-    case 0x00: {
-        AC = ((sector_trailer[7] >> 2) & 0x04) | ((sector_trailer[8] << 1) & 0x02) |
-             ((sector_trailer[8] >> 4) & 0x01);
-        break;
-    }
-    case 0x01: {
-        AC = ((sector_trailer[7] >> 3) & 0x04) | ((sector_trailer[8] >> 0) & 0x02) |
-             ((sector_trailer[8] >> 5) & 0x01);
-        break;
-    }
-    case 0x02: {
-        AC = ((sector_trailer[7] >> 4) & 0x04) | ((sector_trailer[8] >> 1) & 0x02) |
-             ((sector_trailer[8] >> 6) & 0x01);
-        break;
-    }
-    default:
-        return false;
-    }
-
-    switch(action) {
-    case MfClassicActionDataRead: {
-        return (
-            (key == MfClassicKeyA && !(AC == 0x03 || AC == 0x05 || AC == 0x07)) ||
-            (key == MfClassicKeyB && !(AC == 0x07)));
-    }
-    case MfClassicActionDataWrite: {
-        return (
-            (key == MfClassicKeyA && (AC == 0x00)) ||
-            (key == MfClassicKeyB && (AC == 0x00 || AC == 0x04 || AC == 0x06 || AC == 0x03)));
-    }
-    case MfClassicActionDataInc: {
-        return (
-            (key == MfClassicKeyA && (AC == 0x00)) ||
-            (key == MfClassicKeyB && (AC == 0x00 || AC == 0x06)));
-    }
-    case MfClassicActionDataDec: {
-        return (
-            (key == MfClassicKeyA && (AC == 0x00 || AC == 0x06 || AC == 0x01)) ||
-            (key == MfClassicKeyB && (AC == 0x00 || AC == 0x06 || AC == 0x01)));
-    }
-    default:
-        return false;
-    }
-
-    return false;
-}
-
-static bool mf_classic_is_allowed_access(
-    MfClassicEmulator* emulator,
-    uint8_t block_num,
-    MfClassicKey key,
-    MfClassicAction action) {
-    if(mf_classic_is_sector_trailer(block_num)) {
-        return mf_classic_is_allowed_access_sector_trailer(
-            &emulator->data, block_num, key, action);
-    } else {
-        return mf_classic_is_allowed_access_data_block(&emulator->data, block_num, key, action);
-    }
-}
-
-bool mf_classic_is_value_block(MfClassicData* data, uint8_t block_num) {
-    // Check if key A can write, if it can, it's transport configuration, not data block
-    return !mf_classic_is_allowed_access_data_block(
-               data, block_num, MfClassicKeyA, MfClassicActionDataWrite) &&
-           (mf_classic_is_allowed_access_data_block(
-                data, block_num, MfClassicKeyB, MfClassicActionDataInc) ||
-            mf_classic_is_allowed_access_data_block(
-                data, block_num, MfClassicKeyB, MfClassicActionDataDec));
-}
-
-bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    UNUSED(ATQA1);
-    if((ATQA0 == 0x44 || ATQA0 == 0x04) &&
-       (SAK == 0x08 || SAK == 0x88 || SAK == 0x09 || SAK == 0x89)) {
-        return true;
-    } else if((ATQA0 == 0x01) && (ATQA1 == 0x0F) && (SAK == 0x01)) {
-        //skylanders support
-        return true;
-    } else if(
-        ((ATQA0 == 0x42 || ATQA0 == 0x02) && (SAK == 0x18)) ||
-        ((ATQA0 == 0x02 || ATQA0 == 0x04 || ATQA0 == 0x08) && (SAK == 0x38))) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-MfClassicType mf_classic_get_classic_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    UNUSED(ATQA1);
-    if((ATQA0 == 0x44 || ATQA0 == 0x04)) {
-        if((SAK == 0x08 || SAK == 0x88)) {
-            return MfClassicType1k;
-        } else if((SAK == 0x38)) {
-            return MfClassicType4k;
-        } else if((SAK == 0x09 || SAK == 0x89)) {
-            return MfClassicTypeMini;
-        }
-    } else if((ATQA0 == 0x01) && (ATQA1 == 0x0F) && (SAK == 0x01)) {
-        //skylanders support
-        return MfClassicType1k;
-    } else if(
-        ((ATQA0 == 0x42 || ATQA0 == 0x02) && (SAK == 0x18)) ||
-        ((ATQA0 == 0x02 || ATQA0 == 0x08) && (SAK == 0x38))) {
-        return MfClassicType4k;
-    }
-    return MfClassicType1k;
-}
-
-void mf_classic_reader_add_sector(
-    MfClassicReader* reader,
-    uint8_t sector,
-    uint64_t key_a,
-    uint64_t key_b) {
-    furi_assert(reader);
-    furi_assert(sector < MF_CLASSIC_SECTORS_MAX);
-    furi_assert((key_a != MF_CLASSIC_NO_KEY) || (key_b != MF_CLASSIC_NO_KEY));
-
-    if(reader->sectors_to_read < MF_CLASSIC_SECTORS_MAX) {
-        reader->sector_reader[reader->sectors_to_read].key_a = key_a;
-        reader->sector_reader[reader->sectors_to_read].key_b = key_b;
-        reader->sector_reader[reader->sectors_to_read].sector_num = sector;
-        reader->sectors_to_read++;
-    }
-}
-
-bool mf_classic_block_to_value(const uint8_t* block, int32_t* value, uint8_t* addr) {
-    uint32_t v = *(uint32_t*)&block[0];
-    uint32_t v_inv = *(uint32_t*)&block[4];
-    uint32_t v1 = *(uint32_t*)&block[8];
-
-    bool val_checks =
-        ((v == v1) && (v == ~v_inv) && (block[12] == (~block[13] & 0xFF)) &&
-         (block[14] == (~block[15] & 0xFF)) && (block[12] == block[14]));
-    if(value) {
-        *value = (int32_t)v;
-    }
-    if(addr) {
-        *addr = block[12];
-    }
-    return val_checks;
-}
-
-void mf_classic_value_to_block(int32_t value, uint8_t addr, uint8_t* block) {
-    uint32_t v_inv = ~((uint32_t)value);
-
-    memcpy(block, &value, 4); //-V1086
-    memcpy(block + 4, &v_inv, 4); //-V1086
-    memcpy(block + 8, &value, 4); //-V1086
-
-    block[12] = addr;
-    block[13] = ~addr & 0xFF;
-    block[14] = addr;
-    block[15] = ~addr & 0xFF;
-}
-
-void mf_classic_auth_init_context(MfClassicAuthContext* auth_ctx, uint8_t sector) {
-    furi_assert(auth_ctx);
-    auth_ctx->sector = sector;
-    auth_ctx->key_a = MF_CLASSIC_NO_KEY;
-    auth_ctx->key_b = MF_CLASSIC_NO_KEY;
-}
-
-static bool mf_classic_auth(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint32_t block,
-    uint64_t key,
-    MfClassicKey key_type,
-    Crypto1* crypto,
-    bool skip_activate,
-    uint32_t cuid) {
-    bool auth_success = false;
-    memset(tx_rx->tx_data, 0, sizeof(tx_rx->tx_data));
-    memset(tx_rx->tx_parity, 0, sizeof(tx_rx->tx_parity));
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-
-    do {
-        if(!skip_activate && !furry_hal_nfc_activate_nfca(200, &cuid)) break;
-        if(key_type == MfClassicKeyA) {
-            tx_rx->tx_data[0] = MF_CLASSIC_AUTH_KEY_A_CMD;
-        } else {
-            tx_rx->tx_data[0] = MF_CLASSIC_AUTH_KEY_B_CMD;
-        }
-        tx_rx->tx_data[1] = block;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRxNoCrc;
-        tx_rx->tx_bits = 2 * 8;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 6)) break;
-
-        uint32_t nt = (uint32_t)nfc_util_bytes2num(tx_rx->rx_data, 4);
-        crypto1_init(crypto, key);
-        crypto1_word(crypto, nt ^ cuid, 0);
-        uint8_t nr[4] = {};
-        nfc_util_num2bytes(prng_successor(DWT->CYCCNT, 32), 4, nr);
-        for(uint8_t i = 0; i < 4; i++) {
-            tx_rx->tx_data[i] = crypto1_byte(crypto, nr[i], 0) ^ nr[i];
-            tx_rx->tx_parity[0] |=
-                (((crypto1_filter(crypto->odd) ^ nfc_util_odd_parity8(nr[i])) & 0x01) << (7 - i));
-        }
-        nt = prng_successor(nt, 32);
-        for(uint8_t i = 4; i < 8; i++) {
-            nt = prng_successor(nt, 8);
-            tx_rx->tx_data[i] = crypto1_byte(crypto, 0x00, 0) ^ (nt & 0xff);
-            tx_rx->tx_parity[0] |=
-                (((crypto1_filter(crypto->odd) ^ nfc_util_odd_parity8(nt & 0xff)) & 0x01)
-                 << (7 - i));
-        }
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-        tx_rx->tx_bits = 8 * 8;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 6)) break;
-        if(tx_rx->rx_bits == 32) {
-            crypto1_word(crypto, 0, 0);
-            auth_success = true;
-        }
-    } while(false);
-
-    return auth_success;
-}
-
-bool mf_classic_authenticate(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t block_num,
-    uint64_t key,
-    MfClassicKey key_type) {
-    furi_assert(tx_rx);
-
-    Crypto1 crypto = {};
-    bool key_found = mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, false, 0);
-    furry_hal_nfc_sleep();
-    return key_found;
-}
-
-bool mf_classic_authenticate_skip_activate(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t block_num,
-    uint64_t key,
-    MfClassicKey key_type,
-    bool skip_activate,
-    uint32_t cuid) {
-    furi_assert(tx_rx);
-
-    Crypto1 crypto = {};
-    bool key_found =
-        mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, skip_activate, cuid);
-    furry_hal_nfc_sleep();
-    return key_found;
-}
-
-bool mf_classic_auth_attempt(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    MfClassicAuthContext* auth_ctx,
-    uint64_t key) {
-    furi_assert(tx_rx);
-    furi_assert(auth_ctx);
-    bool found_key = false;
-    bool need_halt = (auth_ctx->key_a == MF_CLASSIC_NO_KEY) &&
-                     (auth_ctx->key_b == MF_CLASSIC_NO_KEY);
-
-    if(auth_ctx->key_a == MF_CLASSIC_NO_KEY) {
-        // Try AUTH with key A
-        if(mf_classic_auth(
-               tx_rx,
-               mf_classic_get_sector_trailer_block_num_by_sector(auth_ctx->sector),
-               key,
-               MfClassicKeyA,
-               crypto,
-               false,
-               0)) {
-            auth_ctx->key_a = key;
-            found_key = true;
-        }
-    }
-
-    if(need_halt) {
-        furry_hal_nfc_sleep();
-    }
-
-    if(auth_ctx->key_b == MF_CLASSIC_NO_KEY) {
-        // Try AUTH with key B
-        if(mf_classic_auth(
-               tx_rx,
-               mf_classic_get_sector_trailer_block_num_by_sector(auth_ctx->sector),
-               key,
-               MfClassicKeyB,
-               crypto,
-               false,
-               0)) {
-            auth_ctx->key_b = key;
-            found_key = true;
-        }
-    }
-
-    return found_key;
-}
-
-bool mf_classic_read_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    MfClassicBlock* block) {
-    furi_assert(tx_rx);
-    furi_assert(crypto);
-    furi_assert(block);
-
-    bool read_block_success = false;
-    uint8_t plain_cmd[4] = {MF_CLASSIC_READ_BLOCK_CMD, block_num, 0x00, 0x00};
-    nfca_append_crc16(plain_cmd, 2);
-
-    crypto1_encrypt(
-        crypto, NULL, plain_cmd, sizeof(plain_cmd) * 8, tx_rx->tx_data, tx_rx->tx_parity);
-    tx_rx->tx_bits = sizeof(plain_cmd) * 8;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-
-    if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-        if(tx_rx->rx_bits == 8 * (MF_CLASSIC_BLOCK_SIZE + 2)) {
-            uint8_t block_received[MF_CLASSIC_BLOCK_SIZE + 2];
-            crypto1_decrypt(crypto, tx_rx->rx_data, tx_rx->rx_bits, block_received);
-            uint16_t crc_calc = nfca_get_crc16(block_received, MF_CLASSIC_BLOCK_SIZE);
-            uint16_t crc_received = (block_received[MF_CLASSIC_BLOCK_SIZE + 1] << 8) |
-                                    block_received[MF_CLASSIC_BLOCK_SIZE];
-            if(crc_received != crc_calc) {
-                FURI_LOG_E(
-                    TAG,
-                    "Incorrect CRC while reading block %d. Expected %04X, Received %04X",
-                    block_num,
-                    crc_received,
-                    crc_calc);
-            } else {
-                memcpy(block->value, block_received, MF_CLASSIC_BLOCK_SIZE);
-                read_block_success = true;
-            }
-        }
-    }
-    return read_block_success;
-}
-
-void mf_classic_read_sector(FurryHalNfcTxRxContext* tx_rx, MfClassicData* data, uint8_t sec_num) {
-    furi_assert(tx_rx);
-    furi_assert(data);
-
-    furry_hal_nfc_sleep();
-    bool key_a_found = mf_classic_is_key_found(data, sec_num, MfClassicKeyA);
-    bool key_b_found = mf_classic_is_key_found(data, sec_num, MfClassicKeyB);
-    uint8_t start_block = mf_classic_get_first_block_num_of_sector(sec_num);
-    uint8_t total_blocks = mf_classic_get_blocks_num_in_sector(sec_num);
-    MfClassicBlock block_tmp = {};
-    uint64_t key = 0;
-    MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, sec_num);
-    Crypto1 crypto = {};
-
-    uint8_t blocks_read = 0;
-    do {
-        if(!key_a_found) break;
-        FURI_LOG_D(TAG, "Try to read blocks with key A");
-        key = nfc_util_bytes2num(sec_tr->key_a, sizeof(sec_tr->key_a));
-        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyA, &crypto, false, 0)) {
-            mf_classic_set_key_not_found(data, sec_num, MfClassicKeyA);
-            FURI_LOG_D(TAG, "Key %dA not found in read", sec_num);
-            break;
-        }
-
-        for(size_t i = start_block; i < start_block + total_blocks; i++) {
-            if(!mf_classic_is_block_read(data, i)) {
-                if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
-                    mf_classic_set_block_read(data, i, &block_tmp);
-                    blocks_read++;
-                } else if(i > start_block) {
-                    // Try to re-auth to read block in case prevous block was protected from read
-                    furry_hal_nfc_sleep();
-                    if(!mf_classic_auth(tx_rx, i, key, MfClassicKeyA, &crypto, false, 0)) {
-                        mf_classic_set_key_not_found(data, sec_num, MfClassicKeyA);
-                        FURI_LOG_D(TAG, "Key %dA not found in read", sec_num);
-                        break;
-                    }
-                    if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
-                        mf_classic_set_block_read(data, i, &block_tmp);
-                        blocks_read++;
-                    }
-                }
-            } else {
-                blocks_read++;
-            }
-        }
-        FURI_LOG_D(TAG, "Read %d blocks out of %d", blocks_read, total_blocks);
-    } while(false);
-    do {
-        if(blocks_read == total_blocks) break;
-        if(!key_b_found) break;
-        if(key_a_found) {
-            furry_hal_nfc_sleep();
-        }
-        FURI_LOG_D(TAG, "Try to read blocks with key B");
-        key = nfc_util_bytes2num(sec_tr->key_b, sizeof(sec_tr->key_b));
-        if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyB, &crypto, false, 0)) {
-            mf_classic_set_key_not_found(data, sec_num, MfClassicKeyB);
-            FURI_LOG_D(TAG, "Key %dB not found in read", sec_num);
-            break;
-        }
-
-        for(size_t i = start_block; i < start_block + total_blocks; i++) {
-            if(!mf_classic_is_block_read(data, i)) {
-                if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
-                    mf_classic_set_block_read(data, i, &block_tmp);
-                    blocks_read++;
-                } else if(i > start_block) {
-                    // Try to re-auth to read block in case prevous block was protected from read
-                    furry_hal_nfc_sleep();
-                    if(!mf_classic_auth(tx_rx, i, key, MfClassicKeyB, &crypto, false, 0)) {
-                        mf_classic_set_key_not_found(data, sec_num, MfClassicKeyB);
-                        FURI_LOG_D(TAG, "Key %dB not found in read", sec_num);
-                        break;
-                    }
-                    if(mf_classic_read_block(tx_rx, &crypto, i, &block_tmp)) {
-                        mf_classic_set_block_read(data, i, &block_tmp);
-                        blocks_read++;
-                    }
-                }
-            } else {
-                blocks_read++;
-            }
-        }
-        FURI_LOG_D(TAG, "Read %d blocks out of %d", blocks_read, total_blocks);
-    } while(false);
-}
-
-static bool mf_classic_read_sector_with_reader(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    MfClassicSectorReader* sector_reader,
-    MfClassicSector* sector) {
-    furi_assert(tx_rx);
-    furi_assert(sector_reader);
-    furi_assert(sector);
-
-    uint64_t key;
-    MfClassicKey key_type;
-    uint8_t first_block;
-    bool sector_read = false;
-
-    furry_hal_nfc_sleep();
-    do {
-        // Activate card
-        first_block = mf_classic_get_first_block_num_of_sector(sector_reader->sector_num);
-        if(sector_reader->key_a != MF_CLASSIC_NO_KEY) {
-            key = sector_reader->key_a;
-            key_type = MfClassicKeyA;
-        } else if(sector_reader->key_b != MF_CLASSIC_NO_KEY) {
-            key = sector_reader->key_b;
-            key_type = MfClassicKeyB;
-        } else {
-            break;
-        }
-
-        // Auth to first block in sector
-        if(!mf_classic_auth(tx_rx, first_block, key, key_type, crypto, false, 0)) {
-            // Set key to MF_CLASSIC_NO_KEY to prevent further attempts
-            if(key_type == MfClassicKeyA) {
-                sector_reader->key_a = MF_CLASSIC_NO_KEY;
-            } else {
-                sector_reader->key_b = MF_CLASSIC_NO_KEY;
-            }
-            break;
-        }
-        sector->total_blocks = mf_classic_get_blocks_num_in_sector(sector_reader->sector_num);
-
-        // Read blocks
-        for(uint8_t i = 0; i < sector->total_blocks; i++) {
-            if(mf_classic_read_block(tx_rx, crypto, first_block + i, &sector->block[i])) continue;
-            if(i == 0) continue;
-            // Try to auth to read next block in case previous is locked
-            furry_hal_nfc_sleep();
-            if(!mf_classic_auth(tx_rx, first_block + i, key, key_type, crypto, false, 0)) continue;
-            mf_classic_read_block(tx_rx, crypto, first_block + i, &sector->block[i]);
-        }
-        // Save sector keys in last block
-        if(sector_reader->key_a != MF_CLASSIC_NO_KEY) {
-            nfc_util_num2bytes(
-                sector_reader->key_a, 6, &sector->block[sector->total_blocks - 1].value[0]);
-        }
-        if(sector_reader->key_b != MF_CLASSIC_NO_KEY) {
-            nfc_util_num2bytes(
-                sector_reader->key_b, 6, &sector->block[sector->total_blocks - 1].value[10]);
-        }
-
-        sector_read = true;
-    } while(false);
-
-    return sector_read;
-}
-
-uint8_t mf_classic_read_card(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicReader* reader,
-    MfClassicData* data) {
-    furi_assert(tx_rx);
-    furi_assert(reader);
-    furi_assert(data);
-
-    uint8_t sectors_read = 0;
-    data->type = reader->type;
-    data->key_a_mask = 0;
-    data->key_b_mask = 0;
-    MfClassicSector temp_sector = {};
-    for(uint8_t i = 0; i < reader->sectors_to_read; i++) {
-        if(mf_classic_read_sector_with_reader(
-               tx_rx, &reader->crypto, &reader->sector_reader[i], &temp_sector)) {
-            uint8_t first_block =
-                mf_classic_get_first_block_num_of_sector(reader->sector_reader[i].sector_num);
-            for(uint8_t j = 0; j < temp_sector.total_blocks; j++) {
-                mf_classic_set_block_read(data, first_block + j, &temp_sector.block[j]);
-            }
-            if(reader->sector_reader[i].key_a != MF_CLASSIC_NO_KEY) {
-                mf_classic_set_key_found(
-                    data,
-                    reader->sector_reader[i].sector_num,
-                    MfClassicKeyA,
-                    reader->sector_reader[i].key_a);
-            }
-            if(reader->sector_reader[i].key_b != MF_CLASSIC_NO_KEY) {
-                mf_classic_set_key_found(
-                    data,
-                    reader->sector_reader[i].sector_num,
-                    MfClassicKeyB,
-                    reader->sector_reader[i].key_b);
-            }
-            sectors_read++;
-        }
-    }
-
-    return sectors_read;
-}
-
-uint8_t mf_classic_update_card(FurryHalNfcTxRxContext* tx_rx, MfClassicData* data) {
-    furi_assert(tx_rx);
-    furi_assert(data);
-
-    uint8_t total_sectors = mf_classic_get_total_sectors_num(data->type);
-
-    for(size_t i = 0; i < total_sectors; i++) {
-        mf_classic_read_sector(tx_rx, data, i);
-    }
-    uint8_t sectors_read = 0;
-    uint8_t keys_found = 0;
-    mf_classic_get_read_sectors_and_keys(data, &sectors_read, &keys_found);
-    FURI_LOG_D(TAG, "Read %d sectors and %d keys", sectors_read, keys_found);
-
-    return sectors_read;
-}
-
-bool mf_classic_emulator(
-    MfClassicEmulator* emulator,
-    FurryHalNfcTxRxContext* tx_rx,
-    bool is_reader_analyzer) {
-    furi_assert(emulator);
-    furi_assert(tx_rx);
-    uint8_t plain_data[MF_CLASSIC_MAX_DATA_SIZE];
-    MfClassicKey access_key = MfClassicKeyA;
-    bool need_reset = false;
-    bool need_nack = false;
-    bool is_encrypted = false;
-    uint8_t sector = 0;
-
-    // Used for decrement and increment - copy to block on transfer
-    uint8_t transfer_buf[MF_CLASSIC_BLOCK_SIZE];
-    bool transfer_buf_valid = false;
-
-    // Process commands
-    while(!need_reset && !need_nack) { //-V654
-        memset(plain_data, 0, MF_CLASSIC_MAX_DATA_SIZE);
-        if(!is_encrypted) {
-            crypto1_reset(&emulator->crypto);
-            memcpy(plain_data, tx_rx->rx_data, tx_rx->rx_bits / 8);
-        } else {
-            if(!furry_hal_nfc_tx_rx(tx_rx, 300)) {
-                FURI_LOG_D(
-                    TAG,
-                    "Error in tx rx. Tx: %d bits, Rx: %d bits",
-                    tx_rx->tx_bits,
-                    tx_rx->rx_bits);
-                need_reset = true;
-                break;
-            }
-            crypto1_decrypt(&emulator->crypto, tx_rx->rx_data, tx_rx->rx_bits, plain_data);
-        }
-
-        // After increment, decrement or restore the only allowed command is transfer
-        uint8_t cmd = plain_data[0];
-        if(transfer_buf_valid && cmd != MF_CLASSIC_TRANSFER_CMD) {
-            need_nack = true;
-            break;
-        }
-
-        if(cmd == NFCA_CMD_HALT && plain_data[1] == 0x00) {
-            FURI_LOG_T(TAG, "Halt received");
-            need_reset = true;
-            break;
-        }
-
-        if(cmd == NFCA_CMD_RATS) {
-            // Mifare Classic doesn't support ATS, NACK it and start listening again
-            FURI_LOG_T(TAG, "RATS received");
-            need_nack = true;
-            break;
-        }
-
-        if(cmd == MF_CLASSIC_AUTH_KEY_A_CMD || cmd == MF_CLASSIC_AUTH_KEY_B_CMD) {
-            uint8_t block = plain_data[1];
-            uint64_t key = 0;
-            uint8_t sector_trailer_block = mf_classic_get_sector_trailer_num_by_block(block);
-            sector = mf_classic_get_sector_by_block(block);
-            MfClassicSectorTrailer* sector_trailer =
-                (MfClassicSectorTrailer*)emulator->data.block[sector_trailer_block].value;
-            if(cmd == MF_CLASSIC_AUTH_KEY_A_CMD) {
-                if(mf_classic_is_key_found(
-                       &emulator->data, mf_classic_get_sector_by_block(block), MfClassicKeyA) ||
-                   is_reader_analyzer) {
-                    key = nfc_util_bytes2num(sector_trailer->key_a, 6);
-                    access_key = MfClassicKeyA;
-                } else {
-                    FURI_LOG_D(TAG, "Key not known");
-                    need_nack = true;
-                    break;
-                }
-            } else {
-                if(mf_classic_is_key_found(
-                       &emulator->data, mf_classic_get_sector_by_block(block), MfClassicKeyB) ||
-                   is_reader_analyzer) {
-                    key = nfc_util_bytes2num(sector_trailer->key_b, 6);
-                    access_key = MfClassicKeyB;
-                } else {
-                    FURI_LOG_D(TAG, "Key not known");
-                    need_nack = true;
-                    break;
-                }
-            }
-
-            uint32_t nonce = prng_successor(DWT->CYCCNT, 32) ^ 0xAA;
-            uint8_t nt[4];
-            uint8_t nt_keystream[4];
-            nfc_util_num2bytes(nonce, 4, nt);
-            nfc_util_num2bytes(nonce ^ emulator->cuid, 4, nt_keystream);
-            crypto1_init(&emulator->crypto, key);
-            if(!is_encrypted) {
-                crypto1_word(&emulator->crypto, emulator->cuid ^ nonce, 0);
-                memcpy(tx_rx->tx_data, nt, sizeof(nt));
-                tx_rx->tx_parity[0] = 0;
-                nfc_util_odd_parity(tx_rx->tx_data, tx_rx->tx_parity, sizeof(nt));
-                tx_rx->tx_bits = sizeof(nt) * 8;
-                tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            } else {
-                crypto1_encrypt(
-                    &emulator->crypto,
-                    nt_keystream,
-                    nt,
-                    sizeof(nt) * 8,
-                    tx_rx->tx_data,
-                    tx_rx->tx_parity);
-                tx_rx->tx_bits = sizeof(nt) * 8;
-                tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            }
-
-            if(!furry_hal_nfc_tx_rx(tx_rx, 500)) {
-                FURI_LOG_E(TAG, "Error in NT exchange");
-                need_reset = true;
-                break;
-            }
-
-            if(tx_rx->rx_bits != 64) {
-                need_reset = true;
-                break;
-            }
-
-            uint32_t nr = nfc_util_bytes2num(tx_rx->rx_data, 4);
-            uint32_t ar = nfc_util_bytes2num(&tx_rx->rx_data[4], 4);
-
-            crypto1_word(&emulator->crypto, nr, 1);
-            uint32_t cardRr = ar ^ crypto1_word(&emulator->crypto, 0, 0);
-            if(cardRr != prng_successor(nonce, 64)) {
-                FURI_LOG_T(
-                    TAG,
-                    "Wrong AUTH on block %u! %08lX != %08lX",
-                    block,
-                    cardRr,
-                    prng_successor(nonce, 64));
-                // Don't send NACK, as the tag doesn't send it
-                need_reset = true;
-                break;
-            }
-
-            uint32_t ans = prng_successor(nonce, 96);
-            uint8_t response[4] = {};
-            nfc_util_num2bytes(ans, 4, response);
-            crypto1_encrypt(
-                &emulator->crypto,
-                NULL,
-                response,
-                sizeof(response) * 8,
-                tx_rx->tx_data,
-                tx_rx->tx_parity);
-            tx_rx->tx_bits = sizeof(response) * 8;
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-
-            is_encrypted = true;
-            continue;
-        }
-
-        if(!is_encrypted) {
-            FURI_LOG_T(TAG, "Invalid command before auth session established: %02X", cmd);
-            need_nack = true;
-            break;
-        }
-
-        // Mifare Classic commands always have block number after command
-        uint8_t block = plain_data[1];
-        if(mf_classic_get_sector_by_block(block) != sector) {
-            // Don't allow access to sectors other than authorized
-            FURI_LOG_T(
-                TAG,
-                "Trying to access block %u from not authorized sector (command: %02X)",
-                block,
-                cmd);
-            need_nack = true;
-            break;
-        }
-
-        switch(cmd) {
-        case MF_CLASSIC_READ_BLOCK_CMD: {
-            uint8_t block_data[MF_CLASSIC_BLOCK_SIZE + 2] = {};
-            memcpy(block_data, emulator->data.block[block].value, MF_CLASSIC_BLOCK_SIZE);
-            if(mf_classic_is_sector_trailer(block)) {
-                if(!mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionKeyARead)) {
-                    memset(block_data, 0, 6); //-V1086
-                }
-                if(!mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionKeyBRead)) {
-                    memset(&block_data[10], 0, 6);
-                }
-                if(!mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionACRead)) {
-                    memset(&block_data[6], 0, 4);
-                }
-            } else if(
-                !mf_classic_is_allowed_access(
-                    emulator, block, access_key, MfClassicActionDataRead) ||
-                !mf_classic_is_block_read(&emulator->data, block)) {
-                need_nack = true;
-                break;
-            }
-
-            nfca_append_crc16(block_data, 16);
-
-            crypto1_encrypt(
-                &emulator->crypto,
-                NULL,
-                block_data,
-                sizeof(block_data) * 8,
-                tx_rx->tx_data,
-                tx_rx->tx_parity);
-            tx_rx->tx_bits = (MF_CLASSIC_BLOCK_SIZE + 2) * 8;
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            break;
-        }
-
-        case MF_CLASSIC_WRITE_BLOCK_CMD: {
-            // Send ACK
-            uint8_t ack = MF_CLASSIC_ACK_CMD;
-            crypto1_encrypt(&emulator->crypto, NULL, &ack, 4, tx_rx->tx_data, tx_rx->tx_parity);
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            tx_rx->tx_bits = 4;
-
-            if(!furry_hal_nfc_tx_rx(tx_rx, 300)) {
-                need_reset = true;
-                break;
-            }
-
-            if(tx_rx->rx_bits != (MF_CLASSIC_BLOCK_SIZE + 2) * 8) {
-                need_reset = true;
-                break;
-            }
-
-            crypto1_decrypt(&emulator->crypto, tx_rx->rx_data, tx_rx->rx_bits, plain_data);
-            uint8_t block_data[MF_CLASSIC_BLOCK_SIZE] = {};
-            memcpy(block_data, emulator->data.block[block].value, MF_CLASSIC_BLOCK_SIZE);
-
-            if(!mf_classic_is_block_read(&emulator->data, block)) {
-                // Don't allow writing to the block for which we haven't read data yet
-                need_nack = true;
-                break;
-            }
-
-            if(mf_classic_is_sector_trailer(block)) {
-                if(mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionKeyAWrite)) {
-                    memcpy(block_data, plain_data, 6); //-V1086
-                }
-                if(mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionKeyBWrite)) {
-                    memcpy(&block_data[10], &plain_data[10], 6);
-                }
-                if(mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionACWrite)) {
-                    memcpy(&block_data[6], &plain_data[6], 4);
-                }
-            } else {
-                if(mf_classic_is_allowed_access(
-                       emulator, block, access_key, MfClassicActionDataWrite)) {
-                    memcpy(block_data, plain_data, MF_CLASSIC_BLOCK_SIZE);
-                } else {
-                    need_nack = true;
-                    break;
-                }
-            }
-
-            if(memcmp(block_data, emulator->data.block[block].value, MF_CLASSIC_BLOCK_SIZE) != 0) {
-                memcpy(emulator->data.block[block].value, block_data, MF_CLASSIC_BLOCK_SIZE);
-                emulator->data_changed = true;
-            }
-
-            // Send ACK
-            ack = MF_CLASSIC_ACK_CMD;
-            crypto1_encrypt(&emulator->crypto, NULL, &ack, 4, tx_rx->tx_data, tx_rx->tx_parity);
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            tx_rx->tx_bits = 4;
-            break;
-        }
-
-        case MF_CLASSIC_DECREMENT_CMD:
-        case MF_CLASSIC_INCREMENT_CMD:
-        case MF_CLASSIC_RESTORE_CMD: {
-            MfClassicAction action = (cmd == MF_CLASSIC_INCREMENT_CMD) ? MfClassicActionDataInc :
-                                                                         MfClassicActionDataDec;
-
-            if(!mf_classic_is_allowed_access(emulator, block, access_key, action)) {
-                need_nack = true;
-                break;
-            }
-
-            int32_t prev_value;
-            uint8_t addr;
-            if(!mf_classic_block_to_value(emulator->data.block[block].value, &prev_value, &addr)) {
-                need_nack = true;
-                break;
-            }
-
-            // Send ACK
-            uint8_t ack = MF_CLASSIC_ACK_CMD;
-            crypto1_encrypt(&emulator->crypto, NULL, &ack, 4, tx_rx->tx_data, tx_rx->tx_parity);
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            tx_rx->tx_bits = 4;
-
-            if(!furry_hal_nfc_tx_rx(tx_rx, 300)) {
-                need_reset = true;
-                break;
-            }
-
-            if(tx_rx->rx_bits != (sizeof(int32_t) + 2) * 8) {
-                need_reset = true;
-                break;
-            }
-
-            crypto1_decrypt(&emulator->crypto, tx_rx->rx_data, tx_rx->rx_bits, plain_data);
-            int32_t value = *(int32_t*)&plain_data[0];
-            if(value < 0) {
-                value = -value;
-            }
-            if(cmd == MF_CLASSIC_DECREMENT_CMD) {
-                value = -value;
-            } else if(cmd == MF_CLASSIC_RESTORE_CMD) {
-                value = 0;
-            }
-
-            mf_classic_value_to_block(prev_value + value, addr, transfer_buf);
-            transfer_buf_valid = true;
-            // Commands do not ACK
-            tx_rx->tx_bits = 0;
-            break;
-        }
-
-        case MF_CLASSIC_TRANSFER_CMD: {
-            if(!mf_classic_is_allowed_access(emulator, block, access_key, MfClassicActionDataDec)) {
-                need_nack = true;
-                break;
-            }
-            if(memcmp(transfer_buf, emulator->data.block[block].value, MF_CLASSIC_BLOCK_SIZE) !=
-               0) {
-                memcpy(emulator->data.block[block].value, transfer_buf, MF_CLASSIC_BLOCK_SIZE);
-                emulator->data_changed = true;
-            }
-            transfer_buf_valid = false;
-
-            uint8_t ack = MF_CLASSIC_ACK_CMD;
-            crypto1_encrypt(&emulator->crypto, NULL, &ack, 4, tx_rx->tx_data, tx_rx->tx_parity);
-            tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-            tx_rx->tx_bits = 4;
-            break;
-        }
-
-        default:
-            FURI_LOG_T(TAG, "Unknown command: %02X", cmd);
-            need_nack = true;
-            break;
-        }
-    }
-
-    if(need_nack && !need_reset) {
-        // Send NACK
-        uint8_t nack = transfer_buf_valid ? MF_CLASSIC_NACK_BUF_VALID_CMD :
-                                            MF_CLASSIC_NACK_BUF_INVALID_CMD;
-        if(is_encrypted) {
-            crypto1_encrypt(&emulator->crypto, NULL, &nack, 4, tx_rx->tx_data, tx_rx->tx_parity);
-        } else {
-            tx_rx->tx_data[0] = nack;
-        }
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTransparent;
-        tx_rx->tx_bits = 4;
-        furry_hal_nfc_tx_rx(tx_rx, 300);
-        need_reset = true;
-    }
-
-    return !need_reset;
-}
-
-void mf_classic_halt(FurryHalNfcTxRxContext* tx_rx, Crypto1* crypto) {
-    furi_assert(tx_rx);
-
-    uint8_t plain_data[4] = {NFCA_CMD_HALT, 0x00, 0x00, 0x00};
-
-    nfca_append_crc16(plain_data, 2);
-    if(crypto) {
-        crypto1_encrypt(
-            crypto, NULL, plain_data, sizeof(plain_data) * 8, tx_rx->tx_data, tx_rx->tx_parity);
-    } else {
-        memcpy(tx_rx->tx_data, plain_data, sizeof(plain_data));
-        nfc_util_odd_parity(tx_rx->tx_data, tx_rx->tx_parity, sizeof(plain_data));
-    }
-
-    tx_rx->tx_bits = sizeof(plain_data) * 8;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-    furry_hal_nfc_tx_rx(tx_rx, 50);
-}
-
-bool mf_classic_write_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    MfClassicBlock* src_block) {
-    furi_assert(tx_rx);
-    furi_assert(crypto);
-    furi_assert(src_block);
-
-    bool write_success = false;
-    uint8_t plain_data[MF_CLASSIC_BLOCK_SIZE + 2] = {};
-    uint8_t resp;
-
-    do {
-        // Send write command
-        plain_data[0] = MF_CLASSIC_WRITE_BLOCK_CMD;
-        plain_data[1] = block_num;
-        nfca_append_crc16(plain_data, 2);
-        crypto1_encrypt(crypto, NULL, plain_data, 4 * 8, tx_rx->tx_data, tx_rx->tx_parity);
-        tx_rx->tx_bits = 4 * 8;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            if(tx_rx->rx_bits == 4) {
-                crypto1_decrypt(crypto, tx_rx->rx_data, 4, &resp);
-                if(resp != 0x0A) {
-                    FURI_LOG_D(TAG, "NACK received on write cmd: %02X", resp);
-                    break;
-                }
-            } else {
-                FURI_LOG_D(TAG, "Not ACK received");
-                break;
-            }
-        } else {
-            FURI_LOG_D(TAG, "Failed to send write cmd");
-            break;
-        }
-
-        // Send data
-        memcpy(plain_data, src_block->value, MF_CLASSIC_BLOCK_SIZE);
-        nfca_append_crc16(plain_data, MF_CLASSIC_BLOCK_SIZE);
-        crypto1_encrypt(
-            crypto,
-            NULL,
-            plain_data,
-            (MF_CLASSIC_BLOCK_SIZE + 2) * 8,
-            tx_rx->tx_data,
-            tx_rx->tx_parity);
-        tx_rx->tx_bits = (MF_CLASSIC_BLOCK_SIZE + 2) * 8;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            if(tx_rx->rx_bits == 4) {
-                crypto1_decrypt(crypto, tx_rx->rx_data, 4, &resp);
-                if(resp != MF_CLASSIC_ACK_CMD) {
-                    FURI_LOG_D(TAG, "NACK received on sending data");
-                    break;
-                }
-            } else {
-                FURI_LOG_D(TAG, "Not ACK received");
-                break;
-            }
-        } else {
-            FURI_LOG_D(TAG, "Failed to send data");
-            break;
-        }
-
-        write_success = true;
-    } while(false);
-
-    return write_success;
-}
-
-bool mf_classic_auth_write_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicBlock* src_block,
-    uint8_t block_num,
-    MfClassicKey key_type,
-    uint64_t key) {
-    furi_assert(tx_rx);
-    furi_assert(src_block);
-
-    Crypto1 crypto = {};
-    bool write_success = false;
-
-    do {
-        furry_hal_nfc_sleep();
-        if(!mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, false, 0)) {
-            FURI_LOG_D(TAG, "Auth fail");
-            break;
-        }
-
-        if(!mf_classic_write_block(tx_rx, &crypto, block_num, src_block)) {
-            FURI_LOG_D(TAG, "Write fail");
-            break;
-        }
-        write_success = true;
-
-        mf_classic_halt(tx_rx, &crypto);
-    } while(false);
-
-    return write_success;
-}
-
-bool mf_classic_transfer(FurryHalNfcTxRxContext* tx_rx, Crypto1* crypto, uint8_t block_num) {
-    furi_assert(tx_rx);
-    furi_assert(crypto);
-
-    // Send transfer command
-    uint8_t plain_data[4] = {MF_CLASSIC_TRANSFER_CMD, block_num, 0, 0};
-    uint8_t resp = 0;
-    bool transfer_success = false;
-
-    nfca_append_crc16(plain_data, 2);
-    crypto1_encrypt(
-        crypto, NULL, plain_data, sizeof(plain_data) * 8, tx_rx->tx_data, tx_rx->tx_parity);
-    tx_rx->tx_bits = sizeof(plain_data) * 8;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-
-    do {
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            if(tx_rx->rx_bits == 4) {
-                crypto1_decrypt(crypto, tx_rx->rx_data, 4, &resp);
-                if(resp != 0x0A) {
-                    FURI_LOG_D(TAG, "NACK received on transfer cmd: %02X", resp);
-                    break;
-                }
-            } else {
-                FURI_LOG_D(TAG, "Not ACK received");
-                break;
-            }
-        } else {
-            FURI_LOG_D(TAG, "Failed to send transfer cmd");
-            break;
-        }
-
-        transfer_success = true;
-    } while(false);
-
-    return transfer_success;
-}
-
-bool mf_classic_value_cmd(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    uint8_t cmd,
-    int32_t d_value) {
-    furi_assert(tx_rx);
-    furi_assert(crypto);
-    furi_assert(
-        cmd == MF_CLASSIC_INCREMENT_CMD || cmd == MF_CLASSIC_DECREMENT_CMD ||
-        cmd == MF_CLASSIC_RESTORE_CMD);
-    furi_assert(d_value >= 0);
-
-    uint8_t plain_data[sizeof(d_value) + 2] = {};
-    uint8_t resp = 0;
-    bool success = false;
-
-    do {
-        // Send cmd
-        plain_data[0] = cmd;
-        plain_data[1] = block_num;
-        nfca_append_crc16(plain_data, 2);
-        crypto1_encrypt(crypto, NULL, plain_data, 4 * 8, tx_rx->tx_data, tx_rx->tx_parity);
-        tx_rx->tx_bits = 4 * 8;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            if(tx_rx->rx_bits == 4) {
-                crypto1_decrypt(crypto, tx_rx->rx_data, 4, &resp);
-                if(resp != 0x0A) {
-                    FURI_LOG_D(TAG, "NACK received on write cmd: %02X", resp);
-                    break;
-                }
-            } else {
-                FURI_LOG_D(TAG, "Not ACK received");
-                break;
-            }
-        } else {
-            FURI_LOG_D(TAG, "Failed to send write cmd");
-            break;
-        }
-
-        // Send data
-        memcpy(plain_data, &d_value, sizeof(d_value));
-        nfca_append_crc16(plain_data, sizeof(d_value));
-        crypto1_encrypt(
-            crypto, NULL, plain_data, (sizeof(d_value) + 2) * 8, tx_rx->tx_data, tx_rx->tx_parity);
-        tx_rx->tx_bits = (sizeof(d_value) + 2) * 8;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeRaw;
-        // inc, dec, restore do not ACK, but they do NACK
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            if(tx_rx->rx_bits == 4) {
-                crypto1_decrypt(crypto, tx_rx->rx_data, 4, &resp);
-                if(resp != 0x0A) {
-                    FURI_LOG_D(TAG, "NACK received on transfer cmd: %02X", resp);
-                    break;
-                }
-            } else {
-                FURI_LOG_D(TAG, "Not NACK received");
-                break;
-            }
-        }
-
-        success = true;
-
-    } while(false);
-
-    return success;
-}
-
-bool mf_classic_value_cmd_full(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicBlock* src_block,
-    uint8_t block_num,
-    MfClassicKey key_type,
-    uint64_t key,
-    int32_t d_value) {
-    furi_assert(tx_rx);
-    furi_assert(src_block);
-
-    Crypto1 crypto = {};
-    uint8_t cmd;
-    bool success = false;
-
-    if(d_value > 0) {
-        cmd = MF_CLASSIC_INCREMENT_CMD;
-    } else if(d_value < 0) {
-        cmd = MF_CLASSIC_DECREMENT_CMD;
-        d_value = -d_value;
-    } else {
-        cmd = MF_CLASSIC_RESTORE_CMD;
-    }
-
-    do {
-        furry_hal_nfc_sleep();
-        if(!mf_classic_auth(tx_rx, block_num, key, key_type, &crypto, false, 0)) {
-            FURI_LOG_D(TAG, "Value cmd auth fail");
-            break;
-        }
-        if(!mf_classic_value_cmd(tx_rx, &crypto, block_num, cmd, d_value)) {
-            FURI_LOG_D(TAG, "Value cmd inc/dec/res fail");
-            break;
-        }
-
-        if(!mf_classic_transfer(tx_rx, &crypto, block_num)) {
-            FURI_LOG_D(TAG, "Value cmd transfer fail");
-            break;
-        }
-
-        success = true;
-
-        // Send Halt
-        mf_classic_halt(tx_rx, &crypto);
-    } while(false);
-
-    return success;
-}
-
-bool mf_classic_write_sector(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicData* dest_data,
-    MfClassicData* src_data,
-    uint8_t sec_num) {
-    furi_assert(tx_rx);
-    furi_assert(dest_data);
-    furi_assert(src_data);
-
-    uint8_t first_block = mf_classic_get_first_block_num_of_sector(sec_num);
-    uint8_t total_blocks = mf_classic_get_blocks_num_in_sector(sec_num);
-    MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(dest_data, sec_num);
-    bool key_a_found = mf_classic_is_key_found(dest_data, sec_num, MfClassicKeyA);
-    bool key_b_found = mf_classic_is_key_found(dest_data, sec_num, MfClassicKeyB);
-
-    bool write_success = true;
-    for(size_t i = first_block; i < first_block + total_blocks; i++) {
-        // Compare blocks
-        if(memcmp(dest_data->block[i].value, src_data->block[i].value, MF_CLASSIC_BLOCK_SIZE) !=
-           0) {
-            if(mf_classic_is_value_block(dest_data, i)) {
-                bool key_a_inc_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyA, MfClassicActionDataInc);
-                bool key_b_inc_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyB, MfClassicActionDataInc);
-                bool key_a_dec_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyA, MfClassicActionDataDec);
-                bool key_b_dec_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyB, MfClassicActionDataDec);
-
-                int32_t src_value, dst_value;
-
-                mf_classic_block_to_value(src_data->block[i].value, &src_value, NULL);
-                mf_classic_block_to_value(dest_data->block[i].value, &dst_value, NULL);
-
-                int32_t diff = src_value - dst_value;
-
-                if(diff > 0) {
-                    if(key_a_found && key_a_inc_allowed) {
-                        FURI_LOG_I(TAG, "Incrementing block %d with key A by %ld", i, diff);
-                        uint64_t key = nfc_util_bytes2num(sec_tr->key_a, 6);
-                        if(!mf_classic_value_cmd_full(
-                               tx_rx, &src_data->block[i], i, MfClassicKeyA, key, diff)) {
-                            FURI_LOG_E(TAG, "Failed to increment block %d", i);
-                            write_success = false;
-                            break;
-                        }
-                    } else if(key_b_found && key_b_inc_allowed) {
-                        FURI_LOG_I(TAG, "Incrementing block %d with key B by %ld", i, diff);
-                        uint64_t key = nfc_util_bytes2num(sec_tr->key_b, 6);
-                        if(!mf_classic_value_cmd_full(
-                               tx_rx, &src_data->block[i], i, MfClassicKeyB, key, diff)) {
-                            FURI_LOG_E(TAG, "Failed to increment block %d", i);
-                            write_success = false;
-                            break;
-                        }
-                    } else {
-                        FURI_LOG_E(TAG, "Failed to increment block %d", i);
-                    }
-                } else if(diff < 0) {
-                    if(key_a_found && key_a_dec_allowed) {
-                        FURI_LOG_I(TAG, "Decrementing block %d with key A by %ld", i, -diff);
-                        uint64_t key = nfc_util_bytes2num(sec_tr->key_a, 6);
-                        if(!mf_classic_value_cmd_full(
-                               tx_rx, &src_data->block[i], i, MfClassicKeyA, key, diff)) {
-                            FURI_LOG_E(TAG, "Failed to decrement block %d", i);
-                            write_success = false;
-                            break;
-                        }
-                    } else if(key_b_found && key_b_dec_allowed) {
-                        FURI_LOG_I(TAG, "Decrementing block %d with key B by %ld", i, diff);
-                        uint64_t key = nfc_util_bytes2num(sec_tr->key_b, 6);
-                        if(!mf_classic_value_cmd_full(
-                               tx_rx, &src_data->block[i], i, MfClassicKeyB, key, diff)) {
-                            FURI_LOG_E(TAG, "Failed to decrement block %d", i);
-                            write_success = false;
-                            break;
-                        }
-                    } else {
-                        FURI_LOG_E(TAG, "Failed to decrement block %d", i);
-                    }
-                } else {
-                    FURI_LOG_E(TAG, "Value block %d address changed, cannot write it", i);
-                }
-            } else {
-                bool key_a_write_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyA, MfClassicActionDataWrite);
-                bool key_b_write_allowed = mf_classic_is_allowed_access_data_block(
-                    dest_data, i, MfClassicKeyB, MfClassicActionDataWrite);
-
-                if(key_a_found && key_a_write_allowed) {
-                    FURI_LOG_I(TAG, "Writing block %d with key A", i);
-                    uint64_t key = nfc_util_bytes2num(sec_tr->key_a, 6);
-                    if(!mf_classic_auth_write_block(
-                           tx_rx, &src_data->block[i], i, MfClassicKeyA, key)) {
-                        FURI_LOG_E(TAG, "Failed to write block %d", i);
-                        write_success = false;
-                        break;
-                    }
-                } else if(key_b_found && key_b_write_allowed) {
-                    FURI_LOG_I(TAG, "Writing block %d with key A", i);
-                    uint64_t key = nfc_util_bytes2num(sec_tr->key_b, 6);
-                    if(!mf_classic_auth_write_block(
-                           tx_rx, &src_data->block[i], i, MfClassicKeyB, key)) {
-                        FURI_LOG_E(TAG, "Failed to write block %d", i);
-                        write_success = false;
-                        break;
-                    }
-                } else {
-                    FURI_LOG_E(TAG, "Failed to find key with write access");
-                    write_success = false;
-                    break;
-                }
-            }
-        } else {
-            FURI_LOG_D(TAG, "Blocks %d are equal", i);
-        }
-    }
-
-    return write_success;
-}

esubghz_chat/lib/nfclegacy/protocols/mifare_classic.h

@@ -1,251 +0,0 @@
-#pragma once
-
-#include "../furi_hal_nfc.h"
-
-#include "crypto1.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MF_CLASSIC_BLOCK_SIZE (16)
-#define MF_CLASSIC_TOTAL_BLOCKS_MAX (256)
-#define MF_MINI_TOTAL_SECTORS_NUM (5)
-#define MF_CLASSIC_1K_TOTAL_SECTORS_NUM (16)
-#define MF_CLASSIC_4K_TOTAL_SECTORS_NUM (40)
-
-#define MF_CLASSIC_SECTORS_MAX (40)
-#define MF_CLASSIC_BLOCKS_IN_SECTOR_MAX (16)
-
-#define MF_CLASSIC_NO_KEY (0xFFFFFFFFFFFFFFFF)
-#define MF_CLASSIC_MAX_DATA_SIZE (16)
-#define MF_CLASSIC_KEY_SIZE (6)
-#define MF_CLASSIC_ACCESS_BYTES_SIZE (4)
-
-typedef enum {
-    MfClassicType1k,
-    MfClassicType4k,
-    MfClassicTypeMini,
-} MfClassicType;
-
-typedef enum {
-    MfClassicKeyA,
-    MfClassicKeyB,
-} MfClassicKey;
-
-typedef enum {
-    MfClassicActionDataRead,
-    MfClassicActionDataWrite,
-    MfClassicActionDataInc,
-    MfClassicActionDataDec,
-
-    MfClassicActionKeyARead,
-    MfClassicActionKeyAWrite,
-    MfClassicActionKeyBRead,
-    MfClassicActionKeyBWrite,
-    MfClassicActionACRead,
-    MfClassicActionACWrite,
-} MfClassicAction;
-
-typedef struct {
-    uint8_t value[MF_CLASSIC_BLOCK_SIZE];
-} MfClassicBlock;
-
-typedef struct {
-    uint8_t key_a[MF_CLASSIC_KEY_SIZE];
-    uint8_t access_bits[MF_CLASSIC_ACCESS_BYTES_SIZE];
-    uint8_t key_b[MF_CLASSIC_KEY_SIZE];
-} MfClassicSectorTrailer;
-
-typedef struct {
-    uint8_t total_blocks;
-    MfClassicBlock block[MF_CLASSIC_BLOCKS_IN_SECTOR_MAX];
-} MfClassicSector;
-
-typedef struct {
-    MfClassicType type;
-    uint32_t block_read_mask[MF_CLASSIC_TOTAL_BLOCKS_MAX / 32];
-    uint64_t key_a_mask;
-    uint64_t key_b_mask;
-    MfClassicBlock block[MF_CLASSIC_TOTAL_BLOCKS_MAX];
-} MfClassicData;
-
-typedef struct {
-    uint8_t sector;
-    uint64_t key_a;
-    uint64_t key_b;
-} MfClassicAuthContext;
-
-typedef struct {
-    uint8_t sector_num;
-    uint64_t key_a;
-    uint64_t key_b;
-} MfClassicSectorReader;
-
-typedef struct {
-    MfClassicType type;
-    Crypto1 crypto;
-    uint8_t sectors_to_read;
-    MfClassicSectorReader sector_reader[MF_CLASSIC_SECTORS_MAX];
-} MfClassicReader;
-
-typedef struct {
-    uint32_t cuid;
-    Crypto1 crypto;
-    MfClassicData data;
-    bool data_changed;
-} MfClassicEmulator;
-
-const char* mf_classic_get_type_str(MfClassicType type);
-
-bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK);
-
-MfClassicType mf_classic_get_classic_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK);
-
-uint8_t mf_classic_get_total_sectors_num(MfClassicType type);
-
-uint16_t mf_classic_get_total_block_num(MfClassicType type);
-
-uint8_t mf_classic_get_sector_trailer_block_num_by_sector(uint8_t sector);
-
-bool mf_classic_is_sector_trailer(uint8_t block);
-
-uint8_t mf_classic_get_sector_by_block(uint8_t block);
-
-bool mf_classic_is_allowed_access_sector_trailer(
-    MfClassicData* data,
-    uint8_t block_num,
-    MfClassicKey key,
-    MfClassicAction action);
-
-bool mf_classic_is_allowed_access_data_block(
-    MfClassicData* data,
-    uint8_t block_num,
-    MfClassicKey key,
-    MfClassicAction action);
-
-bool mf_classic_is_value_block(MfClassicData* data, uint8_t block_num);
-
-bool mf_classic_block_to_value(const uint8_t* block, int32_t* value, uint8_t* addr);
-
-void mf_classic_value_to_block(int32_t value, uint8_t addr, uint8_t* block);
-
-bool mf_classic_is_key_found(MfClassicData* data, uint8_t sector_num, MfClassicKey key_type);
-
-void mf_classic_set_key_found(
-    MfClassicData* data,
-    uint8_t sector_num,
-    MfClassicKey key_type,
-    uint64_t key);
-
-void mf_classic_set_key_not_found(MfClassicData* data, uint8_t sector_num, MfClassicKey key_type);
-
-bool mf_classic_is_block_read(MfClassicData* data, uint8_t block_num);
-
-void mf_classic_set_block_read(MfClassicData* data, uint8_t block_num, MfClassicBlock* block_data);
-
-bool mf_classic_is_sector_data_read(MfClassicData* data, uint8_t sector_num);
-
-void mf_classic_set_sector_data_not_read(MfClassicData* data);
-
-bool mf_classic_is_sector_read(MfClassicData* data, uint8_t sector_num);
-
-bool mf_classic_is_card_read(MfClassicData* data);
-
-void mf_classic_get_read_sectors_and_keys(
-    MfClassicData* data,
-    uint8_t* sectors_read,
-    uint8_t* keys_found);
-
-MfClassicSectorTrailer*
-    mf_classic_get_sector_trailer_by_sector(MfClassicData* data, uint8_t sector);
-
-void mf_classic_auth_init_context(MfClassicAuthContext* auth_ctx, uint8_t sector);
-
-bool mf_classic_authenticate(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t block_num,
-    uint64_t key,
-    MfClassicKey key_type);
-
-bool mf_classic_authenticate_skip_activate(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t block_num,
-    uint64_t key,
-    MfClassicKey key_type,
-    bool skip_activate,
-    uint32_t cuid);
-
-bool mf_classic_auth_attempt(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    MfClassicAuthContext* auth_ctx,
-    uint64_t key);
-
-void mf_classic_reader_add_sector(
-    MfClassicReader* reader,
-    uint8_t sector,
-    uint64_t key_a,
-    uint64_t key_b);
-
-bool mf_classic_read_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    MfClassicBlock* block);
-
-void mf_classic_read_sector(FurryHalNfcTxRxContext* tx_rx, MfClassicData* data, uint8_t sec_num);
-
-uint8_t mf_classic_read_card(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicReader* reader,
-    MfClassicData* data);
-
-uint8_t mf_classic_update_card(FurryHalNfcTxRxContext* tx_rx, MfClassicData* data);
-
-bool mf_classic_emulator(
-    MfClassicEmulator* emulator,
-    FurryHalNfcTxRxContext* tx_rx,
-    bool is_reader_analyzer);
-
-void mf_classic_halt(FurryHalNfcTxRxContext* tx_rx, Crypto1* crypto);
-
-bool mf_classic_write_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    MfClassicBlock* src_block);
-
-bool mf_classic_auth_write_block(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicBlock* src_block,
-    uint8_t block_num,
-    MfClassicKey key_type,
-    uint64_t key);
-
-bool mf_classic_transfer(FurryHalNfcTxRxContext* tx_rx, Crypto1* crypto, uint8_t block_num);
-
-bool mf_classic_value_cmd(
-    FurryHalNfcTxRxContext* tx_rx,
-    Crypto1* crypto,
-    uint8_t block_num,
-    uint8_t cmd,
-    int32_t d_value);
-
-bool mf_classic_value_cmd_full(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicBlock* src_block,
-    uint8_t block_num,
-    MfClassicKey key_type,
-    uint64_t key,
-    int32_t d_value);
-
-bool mf_classic_write_sector(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfClassicData* dest_data,
-    MfClassicData* src_data,
-    uint8_t sec_num);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/protocols/mifare_common.c

@@ -1,19 +0,0 @@
-#include "mifare_common.h"
-
-MifareType mifare_common_get_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    MifareType type = MifareTypeUnknown;
-
-    if((ATQA0 == 0x44) && (ATQA1 == 0x00) && (SAK == 0x00)) {
-        type = MifareTypeUltralight;
-    } else if(
-        ((ATQA0 == 0x44 || ATQA0 == 0x04) &&
-         (SAK == 0x08 || SAK == 0x88 || SAK == 0x09 || SAK == 0x89)) ||
-        ((ATQA0 == 0x42 || ATQA0 == 0x02) && (SAK == 0x18)) ||
-        ((ATQA0 == 0x01) && (ATQA1 == 0x0F) && (SAK == 0x01))) {
-        type = MifareTypeClassic;
-    } else if(ATQA0 == 0x44 && ATQA1 == 0x03 && SAK == 0x20) {
-        type = MifareTypeDesfire;
-    }
-
-    return type;
-}

esubghz_chat/lib/nfclegacy/protocols/mifare_common.h

@@ -1,12 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-typedef enum {
-    MifareTypeUnknown,
-    MifareTypeUltralight,
-    MifareTypeClassic,
-    MifareTypeDesfire,
-} MifareType;
-
-MifareType mifare_common_get_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK);

esubghz_chat/lib/nfclegacy/protocols/mifare_ultralight.c

@@ -1,1946 +0,0 @@
-#include <limits.h>
-#include <mbedtls/sha1.h>
-#include "mifare_ultralight.h"
-#include "nfc_util.h"
-#include <furi.h>
-#include "../furi_hal_nfc.h"
-
-#define TAG "MfUltralight"
-
-// Algorithms from: https://github.com/RfidResearchGroup/proxmark3/blob/0f6061c16f072372b7d4d381911f1542afbc3a69/common/generator.c#L110
-uint32_t mf_ul_pwdgen_xiaomi(FurryHalNfcDevData* data) {
-    uint8_t hash[20];
-    mbedtls_sha1(data->uid, data->uid_len, hash);
-
-    uint32_t pwd = 0;
-    pwd |= (hash[hash[0] % 20]) << 24;
-    pwd |= (hash[(hash[0] + 5) % 20]) << 16;
-    pwd |= (hash[(hash[0] + 13) % 20]) << 8;
-    pwd |= (hash[(hash[0] + 17) % 20]);
-
-    return pwd;
-}
-
-uint32_t mf_ul_pwdgen_amiibo(FurryHalNfcDevData* data) {
-    uint8_t* uid = data->uid;
-
-    uint32_t pwd = 0;
-    pwd |= (uid[1] ^ uid[3] ^ 0xAA) << 24;
-    pwd |= (uid[2] ^ uid[4] ^ 0x55) << 16;
-    pwd |= (uid[3] ^ uid[5] ^ 0xAA) << 8;
-    pwd |= uid[4] ^ uid[6] ^ 0x55;
-
-    return pwd;
-}
-
-bool mf_ul_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    if((ATQA0 == 0x44) && (ATQA1 == 0x00) && (SAK == 0x00)) {
-        return true;
-    }
-    return false;
-}
-
-void mf_ul_reset(MfUltralightData* data) {
-    furi_assert(data);
-    data->type = MfUltralightTypeUnknown;
-    memset(&data->version, 0, sizeof(MfUltralightVersion));
-    memset(data->signature, 0, sizeof(data->signature));
-    memset(data->counter, 0, sizeof(data->counter));
-    memset(data->tearing, 0, sizeof(data->tearing));
-    memset(data->data, 0, sizeof(data->data));
-    data->data_size = 0;
-    data->data_read = 0;
-    data->curr_authlim = 0;
-    data->auth_success = false;
-}
-
-static MfUltralightFeatures mf_ul_get_features(MfUltralightType type) {
-    switch(type) {
-    case MfUltralightTypeUL11:
-    case MfUltralightTypeUL21:
-        return MfUltralightSupportFastRead | MfUltralightSupportCompatWrite |
-               MfUltralightSupportReadCounter | MfUltralightSupportIncrCounter |
-               MfUltralightSupportAuth | MfUltralightSupportSignature |
-               MfUltralightSupportTearingFlags | MfUltralightSupportVcsl;
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        return MfUltralightSupportFastRead | MfUltralightSupportCompatWrite |
-               MfUltralightSupportReadCounter | MfUltralightSupportAuth |
-               MfUltralightSupportSignature | MfUltralightSupportSingleCounter |
-               MfUltralightSupportAsciiMirror;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2C2K:
-        return MfUltralightSupportFastRead | MfUltralightSupportSectorSelect;
-    case MfUltralightTypeNTAGI2CPlus1K:
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return MfUltralightSupportFastRead | MfUltralightSupportAuth |
-               MfUltralightSupportFastWrite | MfUltralightSupportSignature |
-               MfUltralightSupportSectorSelect;
-    case MfUltralightTypeNTAG203:
-        return MfUltralightSupportCompatWrite | MfUltralightSupportCounterInMemory;
-    case MfUltralightTypeULC:
-        return MfUltralightSupportCompatWrite | MfUltralightSupport3DesAuth;
-    default:
-        // Assumed original MFUL 512-bit
-        return MfUltralightSupportCompatWrite;
-    }
-}
-
-static void mf_ul_set_default_version(MfUltralightReader* reader, MfUltralightData* data) {
-    data->type = MfUltralightTypeUnknown;
-    reader->pages_to_read = 16;
-}
-
-static void mf_ul_set_version_ntag203(MfUltralightReader* reader, MfUltralightData* data) {
-    data->type = MfUltralightTypeNTAG203;
-    reader->pages_to_read = 42;
-}
-
-static void mf_ul_set_version_ulc(MfUltralightReader* reader, MfUltralightData* data) {
-    data->type = MfUltralightTypeULC;
-    reader->pages_to_read = 48;
-}
-
-bool mf_ultralight_read_version(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    bool version_read = false;
-
-    do {
-        FURI_LOG_D(TAG, "Reading version");
-        tx_rx->tx_data[0] = MF_UL_GET_VERSION_CMD;
-        tx_rx->tx_bits = 8;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits != 64) {
-            FURI_LOG_D(TAG, "Failed reading version");
-            mf_ul_set_default_version(reader, data);
-            furry_hal_nfc_sleep();
-            furry_hal_nfc_activate_nfca(300, NULL);
-            break;
-        }
-        MfUltralightVersion* version = (MfUltralightVersion*)tx_rx->rx_data;
-        data->version = *version;
-        if(version->storage_size == 0x0B || version->storage_size == 0x00) {
-            data->type = MfUltralightTypeUL11;
-            reader->pages_to_read = 20;
-        } else if(version->storage_size == 0x0E) {
-            data->type = MfUltralightTypeUL21;
-            reader->pages_to_read = 41;
-        } else if(version->storage_size == 0x0F) {
-            data->type = MfUltralightTypeNTAG213;
-            reader->pages_to_read = 45;
-        } else if(version->storage_size == 0x11) {
-            data->type = MfUltralightTypeNTAG215;
-            reader->pages_to_read = 135;
-        } else if(version->prod_subtype == 5 && version->prod_ver_major == 2) {
-            // NTAG I2C
-            bool known = false;
-            if(version->prod_ver_minor == 1) {
-                if(version->storage_size == 0x13) {
-                    data->type = MfUltralightTypeNTAGI2C1K;
-                    reader->pages_to_read = 231;
-                    known = true;
-                } else if(version->storage_size == 0x15) {
-                    data->type = MfUltralightTypeNTAGI2C2K;
-                    reader->pages_to_read = 485;
-                    known = true;
-                }
-            } else if(version->prod_ver_minor == 2) {
-                if(version->storage_size == 0x13) {
-                    data->type = MfUltralightTypeNTAGI2CPlus1K;
-                    reader->pages_to_read = 236;
-                    known = true;
-                } else if(version->storage_size == 0x15) {
-                    data->type = MfUltralightTypeNTAGI2CPlus2K;
-                    reader->pages_to_read = 492;
-                    known = true;
-                }
-            }
-
-            if(!known) {
-                mf_ul_set_default_version(reader, data);
-            }
-        } else if(version->storage_size == 0x13) {
-            data->type = MfUltralightTypeNTAG216;
-            reader->pages_to_read = 231;
-        } else {
-            mf_ul_set_default_version(reader, data);
-            break;
-        }
-        version_read = true;
-    } while(false);
-
-    reader->supported_features = mf_ul_get_features(data->type);
-    return version_read;
-}
-
-bool mf_ultralight_authenticate(FurryHalNfcTxRxContext* tx_rx, uint32_t key, uint16_t* pack) {
-    furi_assert(pack);
-    bool authenticated = false;
-
-    do {
-        FURI_LOG_D(TAG, "Authenticating");
-        tx_rx->tx_data[0] = MF_UL_PWD_AUTH;
-        nfc_util_num2bytes(key, 4, &tx_rx->tx_data[1]);
-        tx_rx->tx_bits = 40;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Tag did not respond to authentication");
-            break;
-        }
-
-        // PACK
-        if(tx_rx->rx_bits < 2 * 8) {
-            FURI_LOG_D(TAG, "Authentication failed");
-            break;
-        }
-
-        *pack = (tx_rx->rx_data[1] << 8) | tx_rx->rx_data[0];
-
-        FURI_LOG_I(TAG, "Auth success. Password: %08lX. PACK: %04X", key, *pack);
-        authenticated = true;
-    } while(false);
-
-    return authenticated;
-}
-
-static int16_t mf_ultralight_page_addr_to_tag_addr(uint8_t sector, uint8_t page) {
-    return sector * 256 + page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_1k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 226: sector 0
-    // 227 - 228: config registers
-    // 229 - 230: session registers
-
-    if(linear_address > 230) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 229) {
-        *sector = 3;
-        *valid_pages = 2 - (linear_address - 229);
-        return linear_address - 229 + 248;
-    } else if(linear_address >= 227) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 227);
-        return linear_address - 227 + 232;
-    } else {
-        *sector = 0;
-        *valid_pages = 227 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_2k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 255: sector 0
-    // 256 - 480: sector 1
-    // 481 - 482: config registers
-    // 483 - 484: session registers
-
-    if(linear_address > 484) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 483) {
-        *sector = 3;
-        *valid_pages = 2 - (linear_address - 483);
-        return linear_address - 483 + 248;
-    } else if(linear_address >= 481) {
-        *sector = 1;
-        *valid_pages = 2 - (linear_address - 481);
-        return linear_address - 481 + 232;
-    } else if(linear_address >= 256) {
-        *sector = 1;
-        *valid_pages = 225 - (linear_address - 256);
-        return linear_address - 256;
-    } else {
-        *sector = 0;
-        *valid_pages = 256 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_1k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 233: sector 0 + registers
-    // 234 - 235: session registers
-
-    if(linear_address > 235) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 234) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 234);
-        return linear_address - 234 + 236;
-    } else {
-        *sector = 0;
-        *valid_pages = 234 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_2k(
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    // 0 - 233: sector 0 + registers
-    // 234 - 235: session registers
-    // 236 - 491: sector 1
-
-    if(linear_address > 491) {
-        *valid_pages = 0;
-        return -1;
-    } else if(linear_address >= 236) {
-        *sector = 1;
-        *valid_pages = 256 - (linear_address - 236);
-        return linear_address - 236;
-    } else if(linear_address >= 234) {
-        *sector = 0;
-        *valid_pages = 2 - (linear_address - 234);
-        return linear_address - 234 + 236;
-    } else {
-        *sector = 0;
-        *valid_pages = 234 - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_lin_to_tag(
-    MfUltralightData* data,
-    MfUltralightReader* reader,
-    int16_t linear_address,
-    uint8_t* sector,
-    int16_t* valid_pages) {
-    switch(data->type) {
-    case MfUltralightTypeNTAGI2C1K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_1k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2C2K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_2k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus1K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_1k(linear_address, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return mf_ultralight_ntag_i2c_addr_lin_to_tag_plus_2k(linear_address, sector, valid_pages);
-
-    default:
-        *sector = 0xff;
-        *valid_pages = reader->pages_to_read - linear_address;
-        return linear_address;
-    }
-}
-
-static int16_t
-    mf_ultralight_ntag_i2c_addr_tag_to_lin_1k(uint8_t page, uint8_t sector, uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 226) {
-            *valid_pages = 227 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 232 && page <= 233) {
-            *valid_pages = 2 - (page - 232);
-            translated_page = page - 232 + 227;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 229;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t
-    mf_ultralight_ntag_i2c_addr_tag_to_lin_2k(uint8_t page, uint8_t sector, uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        *valid_pages = 256 - page;
-        translated_page = page;
-        valid = true;
-    } else if(sector == 1) {
-        if(page <= 224) {
-            *valid_pages = 225 - page;
-            translated_page = 256 + page;
-            valid = true;
-        } else if(page >= 232 && page <= 233) {
-            *valid_pages = 2 - (page - 232);
-            translated_page = page - 232 + 481;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 483;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_1k(
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 233) {
-            *valid_pages = 234 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 236 && page <= 237) {
-            *valid_pages = 2 - (page - 236);
-            translated_page = page - 236 + 234;
-            valid = true;
-        }
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 234;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_2k(
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    bool valid = false;
-    int16_t translated_page;
-    if(sector == 0) {
-        if(page <= 233) {
-            *valid_pages = 234 - page;
-            translated_page = page;
-            valid = true;
-        } else if(page >= 236 && page <= 237) {
-            *valid_pages = 2 - (page - 236);
-            translated_page = page - 236 + 234;
-            valid = true;
-        }
-    } else if(sector == 1) {
-        *valid_pages = 256 - page;
-        translated_page = page + 236;
-        valid = true;
-    } else if(sector == 3) {
-        if(page >= 248 && page <= 249) {
-            *valid_pages = 2 - (page - 248);
-            translated_page = page - 248 + 234;
-            valid = true;
-        }
-    }
-
-    if(!valid) {
-        *valid_pages = 0;
-        translated_page = -1;
-    }
-    return translated_page;
-}
-
-static int16_t mf_ultralight_ntag_i2c_addr_tag_to_lin(
-    MfUltralightData* data,
-    uint8_t page,
-    uint8_t sector,
-    uint16_t* valid_pages) {
-    switch(data->type) {
-    case MfUltralightTypeNTAGI2C1K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_1k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2C2K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_2k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus1K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_1k(page, sector, valid_pages);
-
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return mf_ultralight_ntag_i2c_addr_tag_to_lin_plus_2k(page, sector, valid_pages);
-
-    default:
-        *valid_pages = data->data_size / 4 - page;
-        return page;
-    }
-}
-
-MfUltralightConfigPages* mf_ultralight_get_config_pages(MfUltralightData* data) {
-    if(data->type >= MfUltralightTypeUL11 && data->type <= MfUltralightTypeNTAG216) {
-        return (MfUltralightConfigPages*)&data->data[data->data_size - 4 * 4];
-    } else if(
-        data->type >= MfUltralightTypeNTAGI2CPlus1K &&
-        data->type <= MfUltralightTypeNTAGI2CPlus2K) {
-        return (MfUltralightConfigPages*)&data->data[0xe3 * 4]; //-V641
-    } else {
-        return NULL;
-    }
-}
-
-static uint16_t mf_ultralight_calc_auth_count(MfUltralightData* data) {
-    if(mf_ul_get_features(data->type) & MfUltralightSupportAuth) {
-        MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-        uint16_t scaled_authlim = config->access.authlim;
-        // NTAG I2C Plus uses 2^AUTHLIM attempts rather than the direct number
-        if(scaled_authlim > 0 && data->type >= MfUltralightTypeNTAGI2CPlus1K &&
-           data->type <= MfUltralightTypeNTAGI2CPlus2K) {
-            scaled_authlim = 1 << scaled_authlim;
-        }
-        return scaled_authlim;
-    }
-
-    return 0;
-}
-
-// NTAG21x will NAK if NFC_CNT_EN unset, so preempt
-static bool mf_ultralight_should_read_counters(MfUltralightData* data) {
-    if(data->type < MfUltralightTypeNTAG213 || data->type > MfUltralightTypeNTAG216) return true;
-
-    MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-    return config->access.nfc_cnt_en;
-}
-
-static bool mf_ultralight_sector_select(FurryHalNfcTxRxContext* tx_rx, uint8_t sector) {
-    FURI_LOG_D(TAG, "Selecting sector %u", sector);
-    tx_rx->tx_data[0] = MF_UL_SECTOR_SELECT;
-    tx_rx->tx_data[1] = 0xff;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-    if(!furry_hal_nfc_tx_rx(tx_rx, 50)) {
-        FURI_LOG_D(TAG, "Failed to issue sector select command");
-        return false;
-    }
-
-    tx_rx->tx_data[0] = sector;
-    tx_rx->tx_data[1] = 0x00;
-    tx_rx->tx_data[2] = 0x00;
-    tx_rx->tx_data[3] = 0x00;
-    tx_rx->tx_bits = 32;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-    // This is NOT a typo! The tag ACKs by not sending a response within 1ms.
-    if(furry_hal_nfc_tx_rx(tx_rx, 20)) {
-        // TODO: what gets returned when an actual NAK is received?
-        FURI_LOG_D(TAG, "Sector %u select NAK'd", sector);
-        return false;
-    }
-
-    return true;
-}
-
-bool mf_ultralight_read_pages_direct(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t start_index,
-    uint8_t* data) {
-    FURI_LOG_D(TAG, "Reading pages %d - %d", start_index, start_index + 3);
-    tx_rx->tx_data[0] = MF_UL_READ_CMD;
-    tx_rx->tx_data[1] = start_index;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-    if(!furry_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits < 16 * 8) {
-        FURI_LOG_D(TAG, "Failed to read pages %d - %d", start_index, start_index + 3);
-        return false;
-    }
-    memcpy(data, tx_rx->rx_data, 16); //-V1086
-    return true;
-}
-
-bool mf_ultralight_read_pages(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    uint8_t pages_read_cnt = 0;
-    uint8_t curr_sector_index = 0xff;
-    reader->pages_read = 0;
-    for(size_t i = 0; i < reader->pages_to_read; i += pages_read_cnt) {
-        uint8_t tag_sector;
-        int16_t valid_pages;
-        int16_t tag_page = mf_ultralight_ntag_i2c_addr_lin_to_tag(
-            data, reader, (int16_t)i, &tag_sector, &valid_pages);
-
-        furi_assert(tag_page != -1);
-        if(curr_sector_index != tag_sector) {
-            if(!mf_ultralight_sector_select(tx_rx, tag_sector)) return false;
-            curr_sector_index = tag_sector;
-        }
-
-        FURI_LOG_D(
-            TAG, "Reading pages %zu - %zu", i, i + (valid_pages > 4 ? 4 : valid_pages) - 1U);
-        tx_rx->tx_data[0] = MF_UL_READ_CMD;
-        tx_rx->tx_data[1] = tag_page;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-
-        if(!furry_hal_nfc_tx_rx(tx_rx, 50) || tx_rx->rx_bits < 16 * 8) {
-            FURI_LOG_D(
-                TAG,
-                "Failed to read pages %zu - %zu",
-                i,
-                i + (valid_pages > 4 ? 4 : valid_pages) - 1U);
-            break;
-        }
-
-        if(valid_pages > 4) {
-            pages_read_cnt = 4;
-        } else {
-            pages_read_cnt = valid_pages;
-        }
-        reader->pages_read += pages_read_cnt;
-        memcpy(&data->data[i * 4], tx_rx->rx_data, pages_read_cnt * 4);
-    }
-    data->data_size = reader->pages_to_read * 4;
-    data->data_read = reader->pages_read * 4;
-
-    return reader->pages_read > 0;
-}
-
-bool mf_ultralight_fast_read_pages(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    uint8_t curr_sector_index = 0xff;
-    reader->pages_read = 0;
-    while(reader->pages_read < reader->pages_to_read) {
-        uint8_t tag_sector;
-        int16_t valid_pages;
-        int16_t tag_page = mf_ultralight_ntag_i2c_addr_lin_to_tag(
-            data, reader, reader->pages_read, &tag_sector, &valid_pages);
-
-        furi_assert(tag_page != -1);
-        if(curr_sector_index != tag_sector) {
-            if(!mf_ultralight_sector_select(tx_rx, tag_sector)) return false;
-            curr_sector_index = tag_sector;
-        }
-
-        FURI_LOG_D(
-            TAG, "Reading pages %d - %d", reader->pages_read, reader->pages_read + valid_pages - 1);
-        tx_rx->tx_data[0] = MF_UL_FAST_READ_CMD;
-        tx_rx->tx_data[1] = tag_page;
-        tx_rx->tx_data[2] = valid_pages - 1;
-        tx_rx->tx_bits = 24;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-        if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            memcpy(&data->data[reader->pages_read * 4], tx_rx->rx_data, valid_pages * 4);
-            reader->pages_read += valid_pages;
-            data->data_size = reader->pages_read * 4;
-        } else {
-            FURI_LOG_D(
-                TAG,
-                "Failed to read pages %d - %d",
-                reader->pages_read,
-                reader->pages_read + valid_pages - 1);
-            break;
-        }
-    }
-
-    return reader->pages_read == reader->pages_to_read;
-}
-
-bool mf_ultralight_read_signature(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    bool signature_read = false;
-
-    FURI_LOG_D(TAG, "Reading signature");
-    tx_rx->tx_data[0] = MF_UL_READ_SIG;
-    tx_rx->tx_data[1] = 0;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-    if(furry_hal_nfc_tx_rx(tx_rx, 50)) {
-        memcpy(data->signature, tx_rx->rx_data, sizeof(data->signature));
-        signature_read = true;
-    } else {
-        FURI_LOG_D(TAG, "Failed redaing signature");
-    }
-
-    return signature_read;
-}
-
-bool mf_ultralight_read_counters(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    uint8_t counter_read = 0;
-
-    FURI_LOG_D(TAG, "Reading counters");
-    bool is_single_counter = (mf_ul_get_features(data->type) & MfUltralightSupportSingleCounter) !=
-                             0;
-    for(size_t i = is_single_counter ? 2 : 0; i < 3; i++) {
-        tx_rx->tx_data[0] = MF_UL_READ_CNT;
-        tx_rx->tx_data[1] = i;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Failed to read %d counter", i);
-            break;
-        }
-        data->counter[i] = (tx_rx->rx_data[2] << 16) | (tx_rx->rx_data[1] << 8) |
-                           tx_rx->rx_data[0];
-        counter_read++;
-    }
-
-    return counter_read == (is_single_counter ? 1 : 3);
-}
-
-bool mf_ultralight_read_tearing_flags(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
-    uint8_t flag_read = 0;
-
-    FURI_LOG_D(TAG, "Reading tearing flags");
-    for(size_t i = 0; i < 3; i++) {
-        tx_rx->tx_data[0] = MF_UL_CHECK_TEARING;
-        tx_rx->tx_data[1] = i;
-        tx_rx->tx_bits = 16;
-        tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-        if(!furry_hal_nfc_tx_rx(tx_rx, 50)) {
-            FURI_LOG_D(TAG, "Failed to read %d tearing flag", i);
-            break;
-        }
-        data->tearing[i] = tx_rx->rx_data[0];
-        flag_read++;
-    }
-
-    return flag_read == 2;
-}
-
-static bool mf_ul_probe_3des_auth(FurryHalNfcTxRxContext* tx_rx) {
-    tx_rx->tx_data[0] = MF_UL_AUTHENTICATE_1;
-    tx_rx->tx_data[1] = 0;
-    tx_rx->tx_bits = 16;
-    tx_rx->tx_rx_type = FurryHalNfcTxRxTypeDefault;
-    bool rc = furry_hal_nfc_tx_rx(tx_rx, 50) && tx_rx->rx_bits == 9 * 8 &&
-              tx_rx->rx_data[0] == 0xAF;
-
-    // Reset just in case, we're not going to finish authenticating and need to if tag doesn't support auth
-    furry_hal_nfc_sleep();
-    furry_hal_nfc_activate_nfca(300, NULL);
-
-    return rc;
-}
-
-bool mf_ul_read_card(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data) {
-    furi_assert(tx_rx);
-    furi_assert(reader);
-    furi_assert(data);
-
-    bool card_read = false;
-
-    // Read Mifare Ultralight version
-    if(mf_ultralight_read_version(tx_rx, reader, data)) {
-        if(reader->supported_features & MfUltralightSupportSignature) {
-            // Read Signature
-            mf_ultralight_read_signature(tx_rx, data);
-        }
-    } else {
-        uint8_t dummy[16];
-        // No GET_VERSION command, check if AUTHENTICATE command available (detect UL C).
-        if(mf_ul_probe_3des_auth(tx_rx)) {
-            mf_ul_set_version_ulc(reader, data);
-        } else if(mf_ultralight_read_pages_direct(tx_rx, 41, dummy)) {
-            // No AUTHENTICATE, check for NTAG203 by reading last page (41)
-            mf_ul_set_version_ntag203(reader, data);
-        } else {
-            // We're really an original Mifare Ultralight, reset tag for safety
-            furry_hal_nfc_sleep();
-            furry_hal_nfc_activate_nfca(300, NULL);
-        }
-
-        reader->supported_features = mf_ul_get_features(data->type);
-    }
-
-    card_read = mf_ultralight_read_pages(tx_rx, reader, data);
-
-    if(card_read) {
-        if(reader->supported_features & MfUltralightSupportReadCounter &&
-           mf_ultralight_should_read_counters(data)) {
-            mf_ultralight_read_counters(tx_rx, data);
-        }
-        if(reader->supported_features & MfUltralightSupportTearingFlags) {
-            mf_ultralight_read_tearing_flags(tx_rx, data);
-        }
-        data->curr_authlim = 0;
-
-        if(reader->pages_read == reader->pages_to_read &&
-           reader->supported_features & MfUltralightSupportAuth && !data->auth_success) {
-            MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-            if(config->access.authlim == 0) {
-                // Attempt to auth with default PWD
-                uint16_t pack;
-                data->auth_success = mf_ultralight_authenticate(tx_rx, MF_UL_DEFAULT_PWD, &pack);
-                if(data->auth_success) {
-                    config->auth_data.pwd.value = MF_UL_DEFAULT_PWD;
-                    config->auth_data.pack.value = pack;
-                } else {
-                    furry_hal_nfc_sleep();
-                    furry_hal_nfc_activate_nfca(300, NULL);
-                }
-            }
-        }
-    }
-
-    if(reader->pages_read != reader->pages_to_read) {
-        if(reader->supported_features & MfUltralightSupportAuth) {
-            // Probably password protected, fix AUTH0 and PROT so before AUTH0
-            // can be written and since AUTH0 won't be readable, like on the
-            // original card
-            MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-            config->auth0 = reader->pages_read;
-            config->access.prot = true;
-        }
-    }
-
-    return card_read;
-}
-
-static void mf_ul_protect_auth_data_on_read_command_i2c(
-    uint8_t* tx_buff,
-    uint8_t start_page,
-    uint8_t end_page,
-    MfUltralightEmulator* emulator) {
-    if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K) {
-        // Blank out PWD and PACK
-        if(start_page <= 229 && end_page >= 229) {
-            uint16_t offset = (229 - start_page) * 4;
-            uint8_t count = 4;
-            if(end_page >= 230) count += 2;
-            memset(&tx_buff[offset], 0, count);
-        }
-
-        // Handle AUTH0 for sector 0
-        if(!emulator->auth_success) {
-            if(emulator->config_cache.access.prot) {
-                uint8_t auth0 = emulator->config_cache.auth0;
-                if(auth0 < end_page) {
-                    // start_page is always < auth0; otherwise is NAK'd already
-                    uint8_t page_offset = auth0 - start_page;
-                    uint8_t page_count = end_page - auth0;
-                    memset(&tx_buff[page_offset * 4], 0, page_count * 4);
-                }
-            }
-        }
-    }
-}
-
-static void mf_ul_ntag_i2c_fill_cross_area_read(
-    uint8_t* tx_buff,
-    uint8_t start_page,
-    uint8_t end_page,
-    MfUltralightEmulator* emulator) {
-    // For copying config or session registers in fast read
-    int16_t tx_page_offset;
-    int16_t data_page_offset;
-    uint8_t page_length;
-    bool apply = false;
-    MfUltralightType type = emulator->data.type;
-    if(emulator->curr_sector == 0) {
-        if(type == MfUltralightTypeNTAGI2C1K) {
-            if(start_page <= 233 && end_page >= 232) {
-                tx_page_offset = start_page - 232;
-                data_page_offset = 227;
-                page_length = 2;
-                apply = true;
-            }
-        } else if(type == MfUltralightTypeNTAGI2CPlus1K || type == MfUltralightTypeNTAGI2CPlus2K) {
-            if(start_page <= 237 && end_page >= 236) {
-                tx_page_offset = start_page - 236;
-                data_page_offset = 234;
-                page_length = 2;
-                apply = true;
-            }
-        }
-    } else if(emulator->curr_sector == 1) {
-        if(type == MfUltralightTypeNTAGI2C2K) {
-            if(start_page <= 233 && end_page >= 232) {
-                tx_page_offset = start_page - 232;
-                data_page_offset = 483;
-                page_length = 2;
-                apply = true;
-            }
-        }
-    }
-
-    if(apply) {
-        while(tx_page_offset < 0 && page_length > 0) { //-V614
-            ++tx_page_offset;
-            ++data_page_offset;
-            --page_length;
-        }
-        memcpy(
-            &tx_buff[tx_page_offset * 4],
-            &emulator->data.data[data_page_offset * 4],
-            page_length * 4);
-    }
-}
-
-static bool mf_ul_check_auth(MfUltralightEmulator* emulator, uint8_t start_page, bool is_write) {
-    if(!emulator->auth_success) {
-        if(start_page >= emulator->config_cache.auth0 &&
-           (emulator->config_cache.access.prot || is_write))
-            return false;
-    }
-
-    if(is_write && emulator->config_cache.access.cfglck) {
-        uint16_t config_start_page = emulator->page_num - 4;
-        if(start_page == config_start_page || start_page == config_start_page + 1) return false;
-    }
-
-    return true;
-}
-
-static bool mf_ul_ntag_i2c_plus_check_auth(
-    MfUltralightEmulator* emulator,
-    uint8_t start_page,
-    bool is_write) {
-    if(!emulator->auth_success) {
-        // Check NFC_PROT
-        if(emulator->curr_sector == 0 && (emulator->config_cache.access.prot || is_write)) {
-            if(start_page >= emulator->config_cache.auth0) return false;
-        } else if(emulator->curr_sector == 1) {
-            // We don't have to specifically check for type because this is done
-            // by address translator
-            uint8_t pt_i2c = emulator->data.data[231 * 4];
-            // Check 2K_PROT
-            if(pt_i2c & 0x08) return false;
-        }
-    }
-
-    if(emulator->curr_sector == 1) {
-        // Check NFC_DIS_SEC1
-        if(emulator->config_cache.access.nfc_dis_sec1) return false;
-    }
-
-    return true;
-}
-
-static int16_t mf_ul_get_dynamic_lock_page_addr(MfUltralightData* data) {
-    switch(data->type) {
-    case MfUltralightTypeNTAG203:
-        return 0x28;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        return data->data_size / 4 - 5;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-    case MfUltralightTypeNTAGI2CPlus2K:
-        return 0xe2;
-    case MfUltralightTypeNTAGI2C2K:
-        return 0x1e0;
-    default:
-        return -1; // No dynamic lock bytes
-    }
-}
-
-// Returns true if page not locked
-// write_page is tag address
-static bool mf_ul_check_lock(MfUltralightEmulator* emulator, int16_t write_page) {
-    if(write_page < 2) return false; // Page 0-1 is always locked
-    if(write_page == 2) return true; // Page 2 does not have a lock flag
-
-    // Check static lock bytes
-    if(write_page <= 15) {
-        uint16_t static_lock_bytes = emulator->data.data[10] | (emulator->data.data[11] << 8);
-        return (static_lock_bytes & (1 << write_page)) == 0;
-    }
-
-    // Check dynamic lock bytes
-
-    // Check max page
-    switch(emulator->data.type) {
-    case MfUltralightTypeNTAG203:
-        // Counter page can be locked and is after dynamic locks
-        if(write_page == 40) return true;
-        break;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-        if(write_page >= emulator->page_num - 5) return true;
-        break;
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-        if(write_page > 225) return true;
-        break;
-    case MfUltralightTypeNTAGI2C2K:
-        if(write_page > 479) return true;
-        break;
-    case MfUltralightTypeNTAGI2CPlus2K:
-        if(write_page >= 226 && write_page <= 255) return true;
-        if(write_page >= 512) return true;
-        break;
-    default:
-        furi_crash("Unknown MFUL");
-        return true;
-    }
-
-    int16_t dynamic_lock_index = mf_ul_get_dynamic_lock_page_addr(&emulator->data);
-    if(dynamic_lock_index == -1) return true;
-    // Run address through converter because NTAG I2C 2K is special
-    uint16_t valid_pages; // unused
-    dynamic_lock_index =
-        mf_ultralight_ntag_i2c_addr_tag_to_lin(
-            &emulator->data, dynamic_lock_index & 0xff, dynamic_lock_index >> 8, &valid_pages) *
-        4;
-
-    uint16_t dynamic_lock_bytes = emulator->data.data[dynamic_lock_index] |
-                                  (emulator->data.data[dynamic_lock_index + 1] << 8);
-    uint8_t shift;
-
-    switch(emulator->data.type) {
-    // low byte LSB range, MSB range
-    case MfUltralightTypeNTAG203:
-        if(write_page >= 16 && write_page <= 27) //-V560
-            shift = (write_page - 16) / 4 + 1;
-        else if(write_page >= 28 && write_page <= 39) //-V560
-            shift = (write_page - 28) / 4 + 5;
-        else if(write_page == 41)
-            shift = 12;
-        else {
-            furi_crash("Unknown MFUL");
-        }
-
-        break;
-    case MfUltralightTypeUL21:
-    case MfUltralightTypeNTAG213:
-        // 16-17, 30-31
-        shift = (write_page - 16) / 2;
-        break;
-    case MfUltralightTypeNTAG215:
-    case MfUltralightTypeNTAG216:
-    case MfUltralightTypeNTAGI2C1K:
-    case MfUltralightTypeNTAGI2CPlus1K:
-        // 16-31, 128-129
-        // 16-31, 128-143
-        shift = (write_page - 16) / 16;
-        break;
-    case MfUltralightTypeNTAGI2C2K:
-        // 16-47, 240-271
-        shift = (write_page - 16) / 32;
-        break;
-    case MfUltralightTypeNTAGI2CPlus2K:
-        // 16-47, 256-271
-        if(write_page >= 208 && write_page <= 225)
-            shift = 6;
-        else if(write_page >= 256 && write_page <= 271)
-            shift = 7;
-        else
-            shift = (write_page - 16) / 32;
-        break;
-    default:
-        furi_crash("Unknown MFUL");
-        break;
-    }
-
-    return (dynamic_lock_bytes & (1 << shift)) == 0;
-}
-
-static void mf_ul_make_ascii_mirror(MfUltralightEmulator* emulator, FuriString* str) {
-    // Locals to improve readability
-    uint8_t mirror_page = emulator->config->mirror_page;
-    uint8_t mirror_byte = emulator->config->mirror.mirror_byte;
-    MfUltralightMirrorConf mirror_conf = emulator->config_cache.mirror.mirror_conf;
-    uint16_t last_user_page_index = emulator->page_num - 6;
-    bool uid_printed = false;
-
-    if(mirror_conf == MfUltralightMirrorUid || mirror_conf == MfUltralightMirrorUidCounter) {
-        // UID range check
-        if(mirror_page < 4 || mirror_page > last_user_page_index - 3 ||
-           (mirror_page == last_user_page_index - 3 && mirror_byte > 2)) {
-            if(mirror_conf == MfUltralightMirrorUid) return;
-            // NTAG21x has the peculiar behavior when UID+counter selected, if UID does not fit but
-            // counter will fit, it will actually mirror the counter
-            furi_string_cat(str, "              ");
-        } else {
-            for(int i = 0; i < 3; ++i) {
-                furi_string_cat_printf(str, "%02X", emulator->data.data[i]);
-            }
-            // Skip BCC0
-            for(int i = 4; i < 8; ++i) {
-                furi_string_cat_printf(str, "%02X", emulator->data.data[i]);
-            }
-            uid_printed = true;
-        }
-
-        uint16_t next_byte_offset = mirror_page * 4 + mirror_byte + 14;
-        if(mirror_conf == MfUltralightMirrorUidCounter) ++next_byte_offset;
-        mirror_page = next_byte_offset / 4;
-        mirror_byte = next_byte_offset % 4;
-    }
-
-    if(mirror_conf == MfUltralightMirrorCounter || mirror_conf == MfUltralightMirrorUidCounter) {
-        // Counter is only printed if counter enabled
-        if(emulator->config_cache.access.nfc_cnt_en) {
-            // Counter protection check
-            if(emulator->config_cache.access.nfc_cnt_pwd_prot && !emulator->auth_success) return;
-            // Counter range check
-            if(mirror_page < 4) return;
-            if(mirror_page > last_user_page_index - 1) return;
-            if(mirror_page == last_user_page_index - 1 && mirror_byte > 2) return;
-
-            if(mirror_conf == MfUltralightMirrorUidCounter)
-                furi_string_cat(str, uid_printed ? "x" : " ");
-
-            furi_string_cat_printf(str, "%06lX", emulator->data.counter[2]);
-        }
-    }
-}
-
-static void mf_ul_increment_single_counter(MfUltralightEmulator* emulator) {
-    if(!emulator->read_counter_incremented && emulator->config_cache.access.nfc_cnt_en) {
-        if(emulator->data.counter[2] < 0xFFFFFF) {
-            ++emulator->data.counter[2];
-            emulator->data_changed = true;
-        }
-        emulator->read_counter_incremented = true;
-    }
-}
-
-static bool
-    mf_ul_emulate_ntag203_counter_write(MfUltralightEmulator* emulator, uint8_t* page_buff) {
-    // We'll reuse the existing counters for other NTAGs as staging
-    // Counter 0 stores original value, data is new value
-    uint32_t counter_value;
-    if(emulator->data.tearing[0] == MF_UL_TEARING_FLAG_DEFAULT) {
-        counter_value = emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] |
-                        (emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] << 8);
-    } else {
-        // We've had a reset here, so load from original value
-        counter_value = emulator->data.counter[0];
-    }
-    // Although the datasheet says increment by 0 is always possible, this is not the case on
-    // an actual tag. If the counter is at 0xFFFF, any writes are locked out.
-    if(counter_value == 0xFFFF) return false;
-    uint32_t increment = page_buff[0] | (page_buff[1] << 8);
-    if(counter_value == 0) {
-        counter_value = increment;
-    } else {
-        // Per datasheet specifying > 0x000F is supposed to NAK, but actual tag doesn't
-        increment &= 0x000F;
-        if(counter_value + increment > 0xFFFF) return false;
-        counter_value += increment;
-    }
-    // Commit to new value counter
-    emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] = (uint8_t)counter_value;
-    emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] = (uint8_t)(counter_value >> 8);
-    emulator->data.tearing[0] = MF_UL_TEARING_FLAG_DEFAULT;
-    if(counter_value == 0xFFFF) {
-        // Tag will lock out counter if final number is 0xFFFF, even if you try to roll it back
-        emulator->data.counter[1] = 0xFFFF;
-    }
-    emulator->data_changed = true;
-    return true;
-}
-
-static void mf_ul_emulate_write(
-    MfUltralightEmulator* emulator,
-    int16_t tag_addr,
-    int16_t write_page,
-    uint8_t* page_buff) {
-    // Assumption: all access checks have been completed
-
-    if(tag_addr == 2) {
-        // Handle static locks
-        uint16_t orig_static_locks = emulator->data.data[write_page * 4 + 2] |
-                                     (emulator->data.data[write_page * 4 + 3] << 8);
-        uint16_t new_static_locks = page_buff[2] | (page_buff[3] << 8);
-        if(orig_static_locks & 1) new_static_locks &= ~0x08;
-        if(orig_static_locks & 2) new_static_locks &= ~0xF0;
-        if(orig_static_locks & 4) new_static_locks &= 0xFF;
-        new_static_locks |= orig_static_locks;
-        page_buff[0] = emulator->data.data[write_page * 4];
-        page_buff[1] = emulator->data.data[write_page * 4 + 1];
-        page_buff[2] = new_static_locks & 0xff;
-        page_buff[3] = new_static_locks >> 8;
-    } else if(tag_addr == 3) {
-        // Handle OTP/capability container
-        *(uint32_t*)page_buff |= *(uint32_t*)&emulator->data.data[write_page * 4];
-    } else if(tag_addr == mf_ul_get_dynamic_lock_page_addr(&emulator->data)) {
-        // Handle dynamic locks
-        if(emulator->data.type == MfUltralightTypeNTAG203) {
-            // NTAG203 lock bytes are a bit different from the others
-            uint8_t orig_page_lock_byte = emulator->data.data[write_page * 4];
-            uint8_t orig_cnt_lock_byte = emulator->data.data[write_page * 4 + 1];
-            uint8_t new_page_lock_byte = page_buff[0];
-            uint8_t new_cnt_lock_byte = page_buff[1];
-
-            if(orig_page_lock_byte & 0x01) // Block lock bits 1-3
-                new_page_lock_byte &= ~0x0E;
-            if(orig_page_lock_byte & 0x10) // Block lock bits 5-7
-                new_page_lock_byte &= ~0xE0;
-            for(uint8_t i = 0; i < 4; ++i) {
-                if(orig_cnt_lock_byte & (1 << i)) // Block lock counter bit
-                    new_cnt_lock_byte &= ~(1 << (4 + i));
-            }
-
-            new_page_lock_byte |= orig_page_lock_byte;
-            new_cnt_lock_byte |= orig_cnt_lock_byte;
-            page_buff[0] = new_page_lock_byte;
-            page_buff[1] = new_cnt_lock_byte;
-        } else {
-            uint16_t orig_locks = emulator->data.data[write_page * 4] |
-                                  (emulator->data.data[write_page * 4 + 1] << 8);
-            uint8_t orig_block_locks = emulator->data.data[write_page * 4 + 2];
-            uint16_t new_locks = page_buff[0] | (page_buff[1] << 8);
-            uint8_t new_block_locks = page_buff[2];
-
-            int block_lock_count;
-            switch(emulator->data.type) {
-            case MfUltralightTypeUL21:
-                block_lock_count = 5;
-                break;
-            case MfUltralightTypeNTAG213:
-                block_lock_count = 6;
-                break;
-            case MfUltralightTypeNTAG215:
-                block_lock_count = 4;
-                break;
-            case MfUltralightTypeNTAG216:
-            case MfUltralightTypeNTAGI2C1K:
-            case MfUltralightTypeNTAGI2CPlus1K:
-                block_lock_count = 7;
-                break;
-            case MfUltralightTypeNTAGI2C2K:
-            case MfUltralightTypeNTAGI2CPlus2K:
-                block_lock_count = 8;
-                break;
-            default:
-                furi_crash("Unknown MFUL");
-                break;
-            }
-
-            for(int i = 0; i < block_lock_count; ++i) {
-                if(orig_block_locks & (1 << i)) new_locks &= ~(3 << (2 * i));
-            }
-
-            new_locks |= orig_locks;
-            new_block_locks |= orig_block_locks;
-
-            page_buff[0] = new_locks & 0xff;
-            page_buff[1] = new_locks >> 8;
-            page_buff[2] = new_block_locks;
-            if(emulator->data.type >= MfUltralightTypeUL21 && //-V1016
-               emulator->data.type <= MfUltralightTypeNTAG216)
-                page_buff[3] = MF_UL_TEARING_FLAG_DEFAULT;
-            else
-                page_buff[3] = 0;
-        }
-    }
-
-    memcpy(&emulator->data.data[write_page * 4], page_buff, 4);
-    emulator->data_changed = true;
-}
-
-bool mf_ul_emulation_supported(MfUltralightData* data) {
-    return data->type != MfUltralightTypeULC;
-}
-
-void mf_ul_reset_emulation(MfUltralightEmulator* emulator, bool is_power_cycle) {
-    emulator->comp_write_cmd_started = false;
-    emulator->sector_select_cmd_started = false;
-    emulator->curr_sector = 0;
-    emulator->ntag_i2c_plus_sector3_lockout = false;
-    emulator->auth_success = false;
-    if(is_power_cycle) {
-        if(emulator->config != NULL) emulator->config_cache = *emulator->config;
-
-        if(emulator->supported_features & MfUltralightSupportSingleCounter) {
-            emulator->read_counter_incremented = false;
-        }
-
-        if(emulator->data.type == MfUltralightTypeNTAG203) {
-            // Apply lockout if counter ever reached 0xFFFF
-            if(emulator->data.counter[1] == 0xFFFF) {
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] = 0xFF;
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] = 0xFF;
-            }
-            // Copy original counter value from data
-            emulator->data.counter[0] =
-                emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4] |
-                (emulator->data.data[MF_UL_NTAG203_COUNTER_PAGE * 4 + 1] << 8);
-        }
-    } else {
-        if(emulator->config != NULL) {
-            // ACCESS (less CFGLCK) and AUTH0 are updated when reactivated
-            // MIRROR_CONF is not; don't know about STRG_MOD_EN, but we're not using that anyway
-            emulator->config_cache.access.value = (emulator->config->access.value & 0xBF) |
-                                                  (emulator->config_cache.access.value & 0x40);
-            emulator->config_cache.auth0 = emulator->config->auth0;
-        }
-    }
-    if(emulator->data.type == MfUltralightTypeNTAG203) {
-        // Mark counter as dirty
-        emulator->data.tearing[0] = 0;
-    }
-}
-
-void mf_ul_prepare_emulation(MfUltralightEmulator* emulator, MfUltralightData* data) {
-    FURI_LOG_D(TAG, "Prepare emulation");
-    emulator->data = *data;
-    emulator->supported_features = mf_ul_get_features(data->type);
-    emulator->config = mf_ultralight_get_config_pages(&emulator->data);
-    emulator->page_num = emulator->data.data_size / 4;
-    emulator->data_changed = false;
-    memset(&emulator->auth_attempt, 0, sizeof(MfUltralightAuth));
-    mf_ul_reset_emulation(emulator, true);
-}
-
-bool mf_ul_prepare_emulation_response(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len,
-    uint32_t* data_type,
-    void* context) {
-    furi_assert(context);
-    MfUltralightEmulator* emulator = context;
-    uint16_t tx_bytes = 0;
-    uint16_t tx_bits = 0;
-    bool command_parsed = false;
-    bool send_ack = false;
-    bool respond_nothing = false;
-    bool reset_idle = false;
-
-#ifdef FURI_DEBUG
-    FuriString* debug_buf;
-    debug_buf = furi_string_alloc();
-    for(int i = 0; i < (buff_rx_len + 7) / 8; ++i) {
-        furi_string_cat_printf(debug_buf, "%02x ", buff_rx[i]);
-    }
-    furi_string_trim(debug_buf);
-    FURI_LOG_T(TAG, "Emu RX (%d): %s", buff_rx_len, furi_string_get_cstr(debug_buf));
-    furi_string_reset(debug_buf);
-#endif
-
-    // Check composite commands
-    if(emulator->comp_write_cmd_started) {
-        if(buff_rx_len == 16 * 8) {
-            if(emulator->data.type == MfUltralightTypeNTAG203 &&
-               emulator->comp_write_page_addr == MF_UL_NTAG203_COUNTER_PAGE) {
-                send_ack = mf_ul_emulate_ntag203_counter_write(emulator, buff_rx);
-                command_parsed = send_ack;
-            } else {
-                mf_ul_emulate_write(
-                    emulator,
-                    emulator->comp_write_page_addr,
-                    emulator->comp_write_page_addr,
-                    buff_rx);
-                send_ack = true;
-                command_parsed = true;
-            }
-        }
-        emulator->comp_write_cmd_started = false;
-    } else if(emulator->sector_select_cmd_started) {
-        if(buff_rx_len == 4 * 8) {
-            if(buff_rx[0] <= 0xFE) {
-                emulator->curr_sector = buff_rx[0] > 3 ? 0 : buff_rx[0];
-                emulator->ntag_i2c_plus_sector3_lockout = false;
-                command_parsed = true;
-                respond_nothing = true;
-                FURI_LOG_D(TAG, "Changing sector to %d", emulator->curr_sector);
-            }
-        }
-        emulator->sector_select_cmd_started = false;
-    } else if(buff_rx_len >= 8) {
-        uint8_t cmd = buff_rx[0];
-        if(cmd == MF_UL_GET_VERSION_CMD) {
-            if(emulator->data.type >= MfUltralightTypeUL11) {
-                if(buff_rx_len == 1 * 8) {
-                    tx_bytes = sizeof(emulator->data.version);
-                    memcpy(buff_tx, &emulator->data.version, tx_bytes);
-                    *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_READ_CMD) {
-            if(buff_rx_len == (1 + 1) * 8) {
-                int16_t start_page = buff_rx[1];
-                tx_bytes = 16;
-                if(emulator->data.type < MfUltralightTypeNTAGI2C1K) {
-                    if(start_page < emulator->page_num) {
-                        do {
-                            uint8_t copied_pages = 0;
-                            uint8_t src_page = start_page;
-                            uint8_t last_page_plus_one = start_page + 4;
-                            uint8_t pwd_page = emulator->page_num - 2;
-                            FuriString* ascii_mirror = NULL;
-                            size_t ascii_mirror_len = 0;
-                            const char* ascii_mirror_cptr = NULL;
-                            uint8_t ascii_mirror_curr_page = 0;
-                            uint8_t ascii_mirror_curr_byte = 0;
-                            if(last_page_plus_one > emulator->page_num)
-                                last_page_plus_one = emulator->page_num;
-                            if(emulator->supported_features & MfUltralightSupportAuth) {
-                                if(!mf_ul_check_auth(emulator, start_page, false)) break;
-                                if(!emulator->auth_success && emulator->config_cache.access.prot &&
-                                   emulator->config_cache.auth0 < last_page_plus_one)
-                                    last_page_plus_one = emulator->config_cache.auth0;
-                            }
-                            if(emulator->supported_features & MfUltralightSupportSingleCounter)
-                                mf_ul_increment_single_counter(emulator);
-                            if(emulator->supported_features & MfUltralightSupportAsciiMirror &&
-                               emulator->config_cache.mirror.mirror_conf !=
-                                   MfUltralightMirrorNone) {
-                                ascii_mirror_curr_byte = emulator->config->mirror.mirror_byte;
-                                ascii_mirror_curr_page = emulator->config->mirror_page;
-                                // Try to avoid wasting time making mirror if we won't copy it
-                                // Conservatively check with UID+counter mirror size
-                                if(last_page_plus_one > ascii_mirror_curr_page &&
-                                   start_page + 3 >= ascii_mirror_curr_page &&
-                                   start_page <= ascii_mirror_curr_page + 6) {
-                                    ascii_mirror = furi_string_alloc();
-                                    mf_ul_make_ascii_mirror(emulator, ascii_mirror);
-                                    ascii_mirror_len = furi_string_utf8_length(ascii_mirror);
-                                    ascii_mirror_cptr = furi_string_get_cstr(ascii_mirror);
-                                    // Move pointer to where it should be to start copying
-                                    if(ascii_mirror_len > 0 &&
-                                       ascii_mirror_curr_page < start_page &&
-                                       ascii_mirror_curr_byte != 0) {
-                                        uint8_t diff = 4 - ascii_mirror_curr_byte;
-                                        ascii_mirror_len -= diff;
-                                        ascii_mirror_cptr += diff;
-                                        ascii_mirror_curr_byte = 0;
-                                        ++ascii_mirror_curr_page;
-                                    }
-                                    while(ascii_mirror_len > 0 &&
-                                          ascii_mirror_curr_page < start_page) {
-                                        uint8_t diff = ascii_mirror_len > 4 ? 4 : ascii_mirror_len;
-                                        ascii_mirror_len -= diff;
-                                        ascii_mirror_cptr += diff;
-                                        ++ascii_mirror_curr_page;
-                                    }
-                                }
-                            }
-
-                            uint8_t* dest_ptr = buff_tx;
-                            while(copied_pages < 4) {
-                                // Copy page
-                                memcpy(dest_ptr, &emulator->data.data[src_page * 4], 4);
-
-                                // Note: don't have to worry about roll-over with ASCII mirror because
-                                // lowest valid page for it is 4, while roll-over will at best read
-                                // pages 0-2
-                                if(ascii_mirror_len > 0 && src_page == ascii_mirror_curr_page) {
-                                    // Copy ASCII mirror
-                                    size_t copy_len = 4 - ascii_mirror_curr_byte;
-                                    if(copy_len > ascii_mirror_len) copy_len = ascii_mirror_len;
-                                    for(size_t i = 0; i < copy_len; ++i) {
-                                        if(*ascii_mirror_cptr != ' ')
-                                            dest_ptr[ascii_mirror_curr_byte] =
-                                                (uint8_t)*ascii_mirror_cptr;
-                                        ++ascii_mirror_curr_byte;
-                                        ++ascii_mirror_cptr;
-                                    }
-                                    ascii_mirror_len -= copy_len;
-                                    // Don't care if this is inaccurate after ascii_mirror_len = 0
-                                    ascii_mirror_curr_byte = 0;
-                                    ++ascii_mirror_curr_page;
-                                }
-
-                                if(emulator->supported_features & MfUltralightSupportAuth) {
-                                    if(src_page == pwd_page || src_page == pwd_page + 1) {
-                                        // Blank out PWD and PACK pages
-                                        memset(dest_ptr, 0, 4);
-                                    }
-                                }
-
-                                dest_ptr += 4;
-                                ++copied_pages;
-                                ++src_page;
-                                if(src_page >= last_page_plus_one) src_page = 0;
-                            }
-                            if(ascii_mirror != NULL) {
-                                furi_string_free(ascii_mirror);
-                            }
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        } while(false);
-                    }
-                } else {
-                    uint16_t valid_pages;
-                    start_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                        &emulator->data, start_page, emulator->curr_sector, &valid_pages);
-                    if(start_page != -1) {
-                        if(emulator->data.type < MfUltralightTypeNTAGI2CPlus1K ||
-                           mf_ul_ntag_i2c_plus_check_auth(emulator, buff_rx[1], false)) {
-                            if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K &&
-                               emulator->curr_sector == 3 && valid_pages == 1) {
-                                // Rewind back a sector to match behavior on a real tag
-                                --start_page;
-                                ++valid_pages;
-                            }
-
-                            uint16_t copy_count = (valid_pages > 4 ? 4 : valid_pages) * 4;
-                            FURI_LOG_D(
-                                TAG,
-                                "NTAG I2C Emu: page valid, %02x:%02x -> %d, %d",
-                                emulator->curr_sector,
-                                buff_rx[1],
-                                start_page,
-                                valid_pages);
-                            memcpy(buff_tx, &emulator->data.data[start_page * 4], copy_count);
-                            // For NTAG I2C, there's no roll-over; remainder is filled by null bytes
-                            if(copy_count < tx_bytes)
-                                memset(&buff_tx[copy_count], 0, tx_bytes - copy_count);
-                            // Special case: NTAG I2C Plus sector 0 page 233 read crosses into page 236
-                            if(start_page == 233)
-                                memcpy(
-                                    &buff_tx[12], &emulator->data.data[(start_page + 1) * 4], 4);
-                            mf_ul_protect_auth_data_on_read_command_i2c(
-                                buff_tx, start_page, start_page + copy_count / 4 - 1, emulator);
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        }
-                    } else {
-                        FURI_LOG_D(
-                            TAG,
-                            "NTAG I2C Emu: page invalid, %02x:%02x",
-                            emulator->curr_sector,
-                            buff_rx[1]);
-                        if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K &&
-                           emulator->curr_sector == 3 &&
-                           !emulator->ntag_i2c_plus_sector3_lockout) {
-                            // NTAG I2C Plus has a weird behavior where if you read sector 3
-                            // at an invalid address, it responds with zeroes then locks
-                            // the read out, while if you read the mirrored session registers,
-                            // it returns both session registers on either pages
-                            memset(buff_tx, 0, tx_bytes);
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                            emulator->ntag_i2c_plus_sector3_lockout = true;
-                        }
-                    }
-                }
-                if(!command_parsed) tx_bytes = 0;
-            }
-        } else if(cmd == MF_UL_FAST_READ_CMD) {
-            if(emulator->supported_features & MfUltralightSupportFastRead) {
-                if(buff_rx_len == (1 + 2) * 8) {
-                    int16_t start_page = buff_rx[1];
-                    uint8_t end_page = buff_rx[2];
-                    if(start_page <= end_page) {
-                        tx_bytes = ((end_page + 1) - start_page) * 4;
-                        if(emulator->data.type < MfUltralightTypeNTAGI2C1K) {
-                            if((start_page < emulator->page_num) &&
-                               (end_page < emulator->page_num)) {
-                                do {
-                                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                                        // NAK if not authenticated and requested pages cross over AUTH0
-                                        if(!emulator->auth_success &&
-                                           emulator->config_cache.access.prot &&
-                                           (start_page >= emulator->config_cache.auth0 ||
-                                            end_page >= emulator->config_cache.auth0))
-                                            break;
-                                    }
-                                    if(emulator->supported_features &
-                                       MfUltralightSupportSingleCounter)
-                                        mf_ul_increment_single_counter(emulator);
-
-                                    // Copy requested pages
-                                    memcpy(
-                                        buff_tx, &emulator->data.data[start_page * 4], tx_bytes);
-
-                                    if(emulator->supported_features &
-                                           MfUltralightSupportAsciiMirror &&
-                                       emulator->config_cache.mirror.mirror_conf !=
-                                           MfUltralightMirrorNone) {
-                                        // Copy ASCII mirror
-                                        // Less stringent check here, because expecting FAST_READ to
-                                        // only be issued once rather than repeatedly
-                                        FuriString* ascii_mirror;
-                                        ascii_mirror = furi_string_alloc();
-                                        mf_ul_make_ascii_mirror(emulator, ascii_mirror);
-                                        size_t ascii_mirror_len =
-                                            furi_string_utf8_length(ascii_mirror);
-                                        const char* ascii_mirror_cptr =
-                                            furi_string_get_cstr(ascii_mirror);
-                                        int16_t mirror_start_offset =
-                                            (emulator->config->mirror_page - start_page) * 4 +
-                                            emulator->config->mirror.mirror_byte;
-                                        if(mirror_start_offset < 0) {
-                                            if(mirror_start_offset < -(int16_t)ascii_mirror_len) {
-                                                // Past ASCII mirror, don't copy
-                                                ascii_mirror_len = 0;
-                                            } else {
-                                                ascii_mirror_cptr += -mirror_start_offset;
-                                                ascii_mirror_len -= -mirror_start_offset;
-                                                mirror_start_offset = 0;
-                                            }
-                                        }
-                                        if(ascii_mirror_len > 0) {
-                                            int16_t mirror_end_offset =
-                                                mirror_start_offset + ascii_mirror_len;
-                                            if(mirror_end_offset > (end_page + 1) * 4) {
-                                                mirror_end_offset = (end_page + 1) * 4;
-                                                ascii_mirror_len =
-                                                    mirror_end_offset - mirror_start_offset;
-                                            }
-                                            for(size_t i = 0; i < ascii_mirror_len; ++i) {
-                                                if(*ascii_mirror_cptr != ' ')
-                                                    buff_tx[mirror_start_offset] =
-                                                        (uint8_t)*ascii_mirror_cptr;
-                                                ++mirror_start_offset;
-                                                ++ascii_mirror_cptr;
-                                            }
-                                        }
-                                        furi_string_free(ascii_mirror);
-                                    }
-
-                                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                                        // Clear PWD and PACK pages
-                                        uint8_t pwd_page = emulator->page_num - 2;
-                                        int16_t pwd_page_offset = pwd_page - start_page;
-                                        // PWD page
-                                        if(pwd_page_offset >= 0 && pwd_page <= end_page) {
-                                            memset(&buff_tx[pwd_page_offset * 4], 0, 4);
-                                            // PACK page
-                                            if(pwd_page + 1 <= end_page)
-                                                memset(&buff_tx[(pwd_page_offset + 1) * 4], 0, 4);
-                                        }
-                                    }
-                                    *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                                    command_parsed = true;
-                                } while(false);
-                            }
-                        } else {
-                            uint16_t valid_pages;
-                            start_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                                &emulator->data, start_page, emulator->curr_sector, &valid_pages);
-                            if(start_page != -1) {
-                                if(emulator->data.type < MfUltralightTypeNTAGI2CPlus1K ||
-                                   mf_ul_ntag_i2c_plus_check_auth(emulator, buff_rx[1], false)) {
-                                    uint16_t copy_count = tx_bytes;
-                                    if(copy_count > valid_pages * 4) copy_count = valid_pages * 4;
-                                    memcpy(
-                                        buff_tx, &emulator->data.data[start_page * 4], copy_count);
-                                    if(copy_count < tx_bytes)
-                                        memset(&buff_tx[copy_count], 0, tx_bytes - copy_count);
-                                    mf_ul_ntag_i2c_fill_cross_area_read(
-                                        buff_tx, buff_rx[1], buff_rx[2], emulator);
-                                    mf_ul_protect_auth_data_on_read_command_i2c(
-                                        buff_tx,
-                                        start_page,
-                                        start_page + copy_count / 4 - 1,
-                                        emulator);
-                                    *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                                    command_parsed = true;
-                                }
-                            }
-                        }
-                        if(!command_parsed) tx_bytes = 0;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_WRITE) {
-            if(buff_rx_len == (1 + 5) * 8) {
-                do {
-                    uint8_t orig_write_page = buff_rx[1];
-                    int16_t write_page = orig_write_page;
-                    uint16_t valid_pages; // unused
-                    write_page = mf_ultralight_ntag_i2c_addr_tag_to_lin(
-                        &emulator->data, write_page, emulator->curr_sector, &valid_pages);
-                    if(write_page == -1) // NTAG I2C range check
-                        break;
-                    else if(write_page < 2 || write_page >= emulator->page_num) // Other MFUL/NTAG range check
-                        break;
-
-                    if(emulator->supported_features & MfUltralightSupportAuth) {
-                        if(emulator->data.type >= MfUltralightTypeNTAGI2CPlus1K) {
-                            if(!mf_ul_ntag_i2c_plus_check_auth(emulator, orig_write_page, true))
-                                break;
-                        } else {
-                            if(!mf_ul_check_auth(emulator, orig_write_page, true)) break;
-                        }
-                    }
-                    int16_t tag_addr = mf_ultralight_page_addr_to_tag_addr(
-                        emulator->curr_sector, orig_write_page);
-                    if(!mf_ul_check_lock(emulator, tag_addr)) break;
-                    if(emulator->data.type == MfUltralightTypeNTAG203 &&
-                       orig_write_page == MF_UL_NTAG203_COUNTER_PAGE) {
-                        send_ack = mf_ul_emulate_ntag203_counter_write(emulator, &buff_rx[2]);
-                        command_parsed = send_ack;
-                    } else {
-                        mf_ul_emulate_write(emulator, tag_addr, write_page, &buff_rx[2]);
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                } while(false);
-            }
-        } else if(cmd == MF_UL_FAST_WRITE) {
-            if(emulator->supported_features & MfUltralightSupportFastWrite) {
-                if(buff_rx_len == (1 + 66) * 8) {
-                    if(buff_rx[1] == 0xF0 && buff_rx[2] == 0xFF) {
-                        // TODO: update when SRAM emulation implemented
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_COMP_WRITE) {
-            if(emulator->supported_features & MfUltralightSupportCompatWrite) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    uint8_t write_page = buff_rx[1];
-                    do {
-                        if(write_page < 2 || write_page >= emulator->page_num) break;
-                        if(emulator->supported_features & MfUltralightSupportAuth &&
-                           !mf_ul_check_auth(emulator, write_page, true))
-                            break;
-                        // Note we don't convert to tag addr here because there's only one sector
-                        if(!mf_ul_check_lock(emulator, write_page)) break;
-
-                        emulator->comp_write_cmd_started = true;
-                        emulator->comp_write_page_addr = write_page;
-                        send_ack = true;
-                        command_parsed = true;
-                    } while(false);
-                }
-            }
-        } else if(cmd == MF_UL_READ_CNT) {
-            if(emulator->supported_features & MfUltralightSupportReadCounter) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    do {
-                        uint8_t cnt_num = buff_rx[1];
-
-                        // NTAG21x checks
-                        if(emulator->supported_features & MfUltralightSupportSingleCounter) {
-                            if(cnt_num != 2) break; // Only counter 2 is available
-                            if(!emulator->config_cache.access.nfc_cnt_en)
-                                break; // NAK if counter not enabled
-                            if(emulator->config_cache.access.nfc_cnt_pwd_prot &&
-                               !emulator->auth_success)
-                                break;
-                        }
-
-                        if(cnt_num < 3) {
-                            buff_tx[0] = emulator->data.counter[cnt_num] & 0xFF;
-                            buff_tx[1] = (emulator->data.counter[cnt_num] >> 8) & 0xFF;
-                            buff_tx[2] = (emulator->data.counter[cnt_num] >> 16) & 0xFF;
-                            tx_bytes = 3;
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            command_parsed = true;
-                        }
-                    } while(false);
-                }
-            }
-        } else if(cmd == MF_UL_INC_CNT) {
-            if(emulator->supported_features & MfUltralightSupportIncrCounter) {
-                if(buff_rx_len == (1 + 5) * 8) {
-                    uint8_t cnt_num = buff_rx[1];
-                    uint32_t inc = (buff_rx[2] | (buff_rx[3] << 8) | (buff_rx[4] << 16));
-                    // TODO: can you increment by 0 when counter is at 0xffffff?
-                    if((cnt_num < 3) && (emulator->data.counter[cnt_num] != 0x00FFFFFF) &&
-                       (emulator->data.counter[cnt_num] + inc <= 0x00FFFFFF)) {
-                        emulator->data.counter[cnt_num] += inc;
-                        // We're RAM-backed, so tearing never happens
-                        emulator->data.tearing[cnt_num] = MF_UL_TEARING_FLAG_DEFAULT;
-                        emulator->data_changed = true;
-                        send_ack = true;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_PWD_AUTH) {
-            if(emulator->supported_features & MfUltralightSupportAuth) {
-                if(buff_rx_len == (1 + 4) * 8) {
-                    // Record password sent by PCD
-                    memcpy(
-                        emulator->auth_attempt.pwd.raw,
-                        &buff_rx[1],
-                        sizeof(emulator->auth_attempt.pwd.raw));
-                    emulator->auth_attempted = true;
-                    if(emulator->auth_received_callback) {
-                        emulator->auth_received_callback(
-                            emulator->auth_attempt, emulator->context);
-                    }
-
-                    uint16_t scaled_authlim = mf_ultralight_calc_auth_count(&emulator->data);
-                    if(scaled_authlim != 0 && emulator->data.curr_authlim >= scaled_authlim) {
-                        if(emulator->data.curr_authlim != UINT16_MAX) {
-                            // Handle case where AUTHLIM has been lowered or changed from 0
-                            emulator->data.curr_authlim = UINT16_MAX;
-                            emulator->data_changed = true;
-                        }
-                        // AUTHLIM reached, always fail
-                        buff_tx[0] = MF_UL_NAK_AUTHLIM_REACHED;
-                        tx_bits = 4;
-                        *data_type = FURRY_HAL_NFC_TX_RAW_RX_DEFAULT;
-                        mf_ul_reset_emulation(emulator, false);
-                        command_parsed = true;
-                    } else {
-                        if(memcmp(&buff_rx[1], emulator->config->auth_data.pwd.raw, 4) == 0) {
-                            // Correct password
-                            buff_tx[0] = emulator->config->auth_data.pack.raw[0];
-                            buff_tx[1] = emulator->config->auth_data.pack.raw[1];
-                            tx_bytes = 2;
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            emulator->auth_success = true;
-                            command_parsed = true;
-                            if(emulator->data.curr_authlim != 0) {
-                                // Reset current AUTHLIM
-                                emulator->data.curr_authlim = 0;
-                                emulator->data_changed = true;
-                            }
-                        } else if(!emulator->config->auth_data.pwd.value) {
-                            // Unknown password, pretend to be an Amiibo
-                            buff_tx[0] = 0x80;
-                            buff_tx[1] = 0x80;
-                            tx_bytes = 2;
-                            *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                            emulator->auth_success = true;
-                            command_parsed = true;
-                        } else {
-                            // Wrong password, increase negative verification count
-                            if(emulator->data.curr_authlim < UINT16_MAX) {
-                                ++emulator->data.curr_authlim;
-                                emulator->data_changed = true;
-                            }
-                            if(scaled_authlim != 0 &&
-                               emulator->data.curr_authlim >= scaled_authlim) {
-                                emulator->data.curr_authlim = UINT16_MAX;
-                                buff_tx[0] = MF_UL_NAK_AUTHLIM_REACHED;
-                                tx_bits = 4;
-                                *data_type = FURRY_HAL_NFC_TX_RAW_RX_DEFAULT;
-                                mf_ul_reset_emulation(emulator, false);
-                                command_parsed = true;
-                            } else {
-                                // Should delay here to slow brute forcing
-                            }
-                        }
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_READ_SIG) {
-            if(emulator->supported_features & MfUltralightSupportSignature) {
-                // Check 2nd byte = 0x00 - RFU
-                if(buff_rx_len == (1 + 1) * 8 && buff_rx[1] == 0x00) {
-                    tx_bytes = sizeof(emulator->data.signature);
-                    memcpy(buff_tx, emulator->data.signature, tx_bytes);
-                    *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_CHECK_TEARING) {
-            if(emulator->supported_features & MfUltralightSupportTearingFlags) {
-                if(buff_rx_len == (1 + 1) * 8) {
-                    uint8_t cnt_num = buff_rx[1];
-                    if(cnt_num < 3) {
-                        buff_tx[0] = emulator->data.tearing[cnt_num];
-                        tx_bytes = 1;
-                        *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                        command_parsed = true;
-                    }
-                }
-            }
-        } else if(cmd == MF_UL_HALT_START) {
-            reset_idle = true;
-            FURI_LOG_D(TAG, "Received HLTA");
-        } else if(cmd == MF_UL_SECTOR_SELECT) {
-            if(emulator->supported_features & MfUltralightSupportSectorSelect) {
-                if(buff_rx_len == (1 + 1) * 8 && buff_rx[1] == 0xFF) {
-                    // Send ACK
-                    emulator->sector_select_cmd_started = true;
-                    send_ack = true;
-                    command_parsed = true;
-                }
-            }
-        } else if(cmd == MF_UL_READ_VCSL) {
-            if(emulator->supported_features & MfUltralightSupportVcsl) {
-                if(buff_rx_len == (1 + 20) * 8) {
-                    buff_tx[0] = emulator->config_cache.vctid;
-                    tx_bytes = 1;
-                    *data_type = FURRY_HAL_NFC_TXRX_DEFAULT;
-                    command_parsed = true;
-                }
-            }
-        } else {
-            // NTAG203 appears to NAK instead of just falling off on invalid commands
-            if(emulator->data.type != MfUltralightTypeNTAG203) reset_idle = true;
-            FURI_LOG_D(TAG, "Received invalid command");
-        }
-    } else {
-        reset_idle = true;
-        FURI_LOG_D(TAG, "Received invalid buffer less than 8 bits in length");
-    }
-
-    if(reset_idle) {
-        mf_ul_reset_emulation(emulator, false);
-        tx_bits = 0;
-        command_parsed = true;
-    }
-
-    if(!command_parsed) {
-        // Send NACK
-        buff_tx[0] = MF_UL_NAK_INVALID_ARGUMENT;
-        tx_bits = 4;
-        *data_type = FURRY_HAL_NFC_TX_RAW_RX_DEFAULT;
-        // Every NAK should cause reset to IDLE
-        mf_ul_reset_emulation(emulator, false);
-    } else if(send_ack) {
-        buff_tx[0] = MF_UL_ACK;
-        tx_bits = 4;
-        *data_type = FURRY_HAL_NFC_TX_RAW_RX_DEFAULT;
-    }
-
-    if(respond_nothing) {
-        *buff_tx_len = UINT16_MAX;
-        *data_type = FURRY_HAL_NFC_TX_RAW_RX_DEFAULT;
-    } else {
-        // Return tx buffer size in bits
-        if(tx_bytes) {
-            tx_bits = tx_bytes * 8;
-        }
-        *buff_tx_len = tx_bits;
-    }
-
-#ifdef FURI_DEBUG
-    if(*buff_tx_len == UINT16_MAX) {
-        FURI_LOG_T(TAG, "Emu TX: no reply");
-    } else if(*buff_tx_len > 0) {
-        int count = (*buff_tx_len + 7) / 8;
-        for(int i = 0; i < count; ++i) {
-            furi_string_cat_printf(debug_buf, "%02x ", buff_tx[i]);
-        }
-        furi_string_trim(debug_buf);
-        FURI_LOG_T(TAG, "Emu TX (%d): %s", *buff_tx_len, furi_string_get_cstr(debug_buf));
-        furi_string_free(debug_buf);
-    } else {
-        FURI_LOG_T(TAG, "Emu TX: HALT");
-    }
-#endif
-
-    return tx_bits > 0;
-}
-
-bool mf_ul_is_full_capture(MfUltralightData* data) {
-    if(data->data_read != data->data_size) return false;
-
-    // Having read all the pages doesn't mean that we've got everything.
-    // By default PWD is 0xFFFFFFFF, but if read back it is always 0x00000000,
-    // so a default read on an auth-supported NTAG is never complete.
-    if(!(mf_ul_get_features(data->type) & MfUltralightSupportAuth)) return true;
-    MfUltralightConfigPages* config = mf_ultralight_get_config_pages(data);
-    return config->auth_data.pwd.value != 0 || config->auth_data.pack.value != 0;
-}

esubghz_chat/lib/nfclegacy/protocols/mifare_ultralight.h

@@ -1,269 +0,0 @@
-#pragma once
-
-#include "../furi_hal_nfc.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Largest tag is NTAG I2C Plus 2K, both data sectors plus SRAM
-#define MF_UL_MAX_DUMP_SIZE ((238 + 256 + 16) * 4)
-
-#define MF_UL_TEARING_FLAG_DEFAULT (0xBD)
-
-#define MF_UL_HALT_START (0x50)
-#define MF_UL_GET_VERSION_CMD (0x60)
-#define MF_UL_READ_CMD (0x30)
-#define MF_UL_FAST_READ_CMD (0x3A)
-#define MF_UL_WRITE (0xA2)
-#define MF_UL_FAST_WRITE (0xA6)
-#define MF_UL_COMP_WRITE (0xA0)
-#define MF_UL_READ_CNT (0x39)
-#define MF_UL_INC_CNT (0xA5)
-#define MF_UL_AUTHENTICATE_1 (0x1A)
-#define MF_UL_PWD_AUTH (0x1B)
-#define MF_UL_READ_SIG (0x3C)
-#define MF_UL_CHECK_TEARING (0x3E)
-#define MF_UL_READ_VCSL (0x4B)
-#define MF_UL_SECTOR_SELECT (0xC2)
-
-#define MF_UL_ACK (0xa)
-#define MF_UL_NAK_INVALID_ARGUMENT (0x0)
-#define MF_UL_NAK_AUTHLIM_REACHED (0x4)
-
-#define MF_UL_NTAG203_COUNTER_PAGE (41)
-
-#define MF_UL_DEFAULT_PWD (0xFFFFFFFF)
-
-typedef enum {
-    MfUltralightAuthMethodManual,
-    MfUltralightAuthMethodAmeebo,
-    MfUltralightAuthMethodXiaomi,
-    MfUltralightAuthMethodAuto,
-} MfUltralightAuthMethod;
-
-// Important: order matters; some features are based on positioning in this enum
-typedef enum {
-    MfUltralightTypeUnknown,
-    MfUltralightTypeNTAG203,
-    MfUltralightTypeULC,
-    // Below have config pages and GET_VERSION support
-    MfUltralightTypeUL11,
-    MfUltralightTypeUL21,
-    MfUltralightTypeNTAG213,
-    MfUltralightTypeNTAG215,
-    MfUltralightTypeNTAG216,
-    // Below also have sector select
-    // NTAG I2C's *does not* have regular config pages, so it's a bit of an odd duck
-    MfUltralightTypeNTAGI2C1K,
-    MfUltralightTypeNTAGI2C2K,
-    // NTAG I2C Plus has stucture expected from NTAG21x
-    MfUltralightTypeNTAGI2CPlus1K,
-    MfUltralightTypeNTAGI2CPlus2K,
-
-    // Keep last for number of types calculation
-    MfUltralightTypeNum,
-} MfUltralightType;
-
-typedef enum {
-    MfUltralightSupportNone = 0,
-    MfUltralightSupportFastRead = 1 << 0,
-    MfUltralightSupportTearingFlags = 1 << 1,
-    MfUltralightSupportReadCounter = 1 << 2,
-    MfUltralightSupportIncrCounter = 1 << 3,
-    MfUltralightSupportSignature = 1 << 4,
-    MfUltralightSupportFastWrite = 1 << 5,
-    MfUltralightSupportCompatWrite = 1 << 6,
-    MfUltralightSupportAuth = 1 << 7,
-    MfUltralightSupportVcsl = 1 << 8,
-    MfUltralightSupportSectorSelect = 1 << 9,
-    // NTAG21x only has counter 2
-    MfUltralightSupportSingleCounter = 1 << 10,
-    // ASCII mirror is not a command, but handy to have as a flag
-    MfUltralightSupportAsciiMirror = 1 << 11,
-    // NTAG203 counter that's in memory rather than through a command
-    MfUltralightSupportCounterInMemory = 1 << 12,
-    MfUltralightSupport3DesAuth = 1 << 13,
-} MfUltralightFeatures;
-
-typedef enum {
-    MfUltralightMirrorNone,
-    MfUltralightMirrorUid,
-    MfUltralightMirrorCounter,
-    MfUltralightMirrorUidCounter,
-} MfUltralightMirrorConf;
-
-typedef struct {
-    uint8_t header;
-    uint8_t vendor_id;
-    uint8_t prod_type;
-    uint8_t prod_subtype;
-    uint8_t prod_ver_major;
-    uint8_t prod_ver_minor;
-    uint8_t storage_size;
-    uint8_t protocol_type;
-} MfUltralightVersion;
-
-typedef struct {
-    uint8_t sn0[3];
-    uint8_t btBCC0;
-    uint8_t sn1[4];
-    uint8_t btBCC1;
-    uint8_t internal;
-    uint8_t lock[2];
-    uint8_t otp[4];
-} MfUltralightManufacturerBlock;
-
-typedef struct {
-    MfUltralightType type;
-    MfUltralightVersion version;
-    uint8_t signature[32];
-    uint32_t counter[3];
-    uint8_t tearing[3];
-    MfUltralightAuthMethod auth_method;
-    uint8_t auth_key[4];
-    bool auth_success;
-    uint16_t curr_authlim;
-    uint16_t data_size;
-    uint8_t data[MF_UL_MAX_DUMP_SIZE];
-    uint16_t data_read;
-} MfUltralightData;
-
-typedef struct __attribute__((packed)) {
-    union {
-        uint8_t raw[4];
-        uint32_t value;
-    } pwd;
-    union {
-        uint8_t raw[2];
-        uint16_t value;
-    } pack;
-} MfUltralightAuth;
-
-// Common configuration pages for MFUL EV1, NTAG21x, and NTAG I2C Plus
-typedef struct __attribute__((packed)) {
-    union {
-        uint8_t value;
-        struct {
-            uint8_t rfui1 : 2;
-            bool strg_mod_en : 1;
-            bool rfui2 : 1;
-            uint8_t mirror_byte : 2;
-            MfUltralightMirrorConf mirror_conf : 2;
-        };
-    } mirror;
-    uint8_t rfui1;
-    uint8_t mirror_page;
-    uint8_t auth0;
-    union {
-        uint8_t value;
-        struct {
-            uint8_t authlim : 3;
-            bool nfc_cnt_pwd_prot : 1;
-            bool nfc_cnt_en : 1;
-            bool nfc_dis_sec1 : 1; // NTAG I2C Plus only
-            bool cfglck : 1;
-            bool prot : 1;
-        };
-    } access;
-    uint8_t vctid;
-    uint8_t rfui2[2];
-    MfUltralightAuth auth_data;
-    uint8_t rfui3[2];
-} MfUltralightConfigPages;
-
-typedef struct {
-    uint16_t pages_to_read;
-    int16_t pages_read;
-    MfUltralightFeatures supported_features;
-} MfUltralightReader;
-
-// TODO rework with reader analyzer
-typedef void (*MfUltralightAuthReceivedCallback)(MfUltralightAuth auth, void* context);
-
-typedef struct {
-    MfUltralightData data;
-    MfUltralightConfigPages* config;
-    // Most config values don't apply until power cycle, so cache config pages
-    // for correct behavior
-    MfUltralightConfigPages config_cache;
-    MfUltralightFeatures supported_features;
-    uint16_t page_num;
-    bool data_changed;
-    bool comp_write_cmd_started;
-    uint8_t comp_write_page_addr;
-    bool auth_success;
-    uint8_t curr_sector;
-    bool sector_select_cmd_started;
-    bool ntag_i2c_plus_sector3_lockout;
-    bool read_counter_incremented;
-    bool auth_attempted;
-    MfUltralightAuth auth_attempt;
-
-    // TODO rework with reader analyzer
-    MfUltralightAuthReceivedCallback auth_received_callback;
-    void* context;
-} MfUltralightEmulator;
-
-void mf_ul_reset(MfUltralightData* data);
-
-bool mf_ul_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK);
-
-bool mf_ultralight_read_version(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data);
-
-bool mf_ultralight_read_pages_direct(
-    FurryHalNfcTxRxContext* tx_rx,
-    uint8_t start_index,
-    uint8_t* data);
-
-bool mf_ultralight_read_pages(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data);
-
-bool mf_ultralight_fast_read_pages(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data);
-
-bool mf_ultralight_read_signature(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data);
-
-bool mf_ultralight_read_counters(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data);
-
-bool mf_ultralight_read_tearing_flags(FurryHalNfcTxRxContext* tx_rx, MfUltralightData* data);
-
-bool mf_ultralight_authenticate(FurryHalNfcTxRxContext* tx_rx, uint32_t key, uint16_t* pack);
-
-MfUltralightConfigPages* mf_ultralight_get_config_pages(MfUltralightData* data);
-
-bool mf_ul_read_card(
-    FurryHalNfcTxRxContext* tx_rx,
-    MfUltralightReader* reader,
-    MfUltralightData* data);
-
-bool mf_ul_emulation_supported(MfUltralightData* data);
-
-void mf_ul_reset_emulation(MfUltralightEmulator* emulator, bool is_power_cycle);
-
-void mf_ul_prepare_emulation(MfUltralightEmulator* emulator, MfUltralightData* data);
-
-bool mf_ul_prepare_emulation_response(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len,
-    uint32_t* data_type,
-    void* context);
-
-uint32_t mf_ul_pwdgen_amiibo(FurryHalNfcDevData* data);
-
-uint32_t mf_ul_pwdgen_xiaomi(FurryHalNfcDevData* data);
-
-bool mf_ul_is_full_capture(MfUltralightData* data);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/protocols/nfc_util.c

@@ -1,70 +0,0 @@
-#include "nfc_util.h"
-
-#include <furi.h>
-
-static const uint8_t nfc_util_odd_byte_parity[256] = {
-    1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
-    1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,
-    1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
-    0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,
-    1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-    0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0,
-    0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1,
-    0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
-    1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1};
-
-void nfc_util_num2bytes(uint64_t src, uint8_t len, uint8_t* dest) {
-    furi_assert(dest);
-    furi_assert(len <= 8);
-
-    while(len--) {
-        dest[len] = (uint8_t)src;
-        src >>= 8;
-    }
-}
-
-uint64_t nfc_util_bytes2num(const uint8_t* src, uint8_t len) {
-    furi_assert(src);
-    furi_assert(len <= 8);
-
-    uint64_t res = 0;
-    while(len--) {
-        res = (res << 8) | (*src);
-        src++;
-    }
-    return res;
-}
-
-uint8_t nfc_util_even_parity32(uint32_t data) {
-    // data ^= data >> 16;
-    // data ^= data >> 8;
-    // return !nfc_util_odd_byte_parity[data];
-    return (__builtin_parity(data) & 0xFF);
-}
-
-uint8_t nfc_util_odd_parity8(uint8_t data) {
-    return nfc_util_odd_byte_parity[data];
-}
-
-void nfc_util_odd_parity(const uint8_t* src, uint8_t* dst, uint8_t len) {
-    furi_assert(src);
-    furi_assert(dst);
-
-    uint8_t parity = 0;
-    uint8_t bit = 0;
-    while(len--) {
-        parity |= nfc_util_odd_parity8(*src) << (7 - bit); // parity is MSB first
-        bit++;
-        if(bit == 8) {
-            *dst = parity;
-            dst++;
-            parity = 0;
-            bit = 0;
-        }
-        src++;
-    }
-
-    if(bit) {
-        *dst = parity;
-    }
-}

esubghz_chat/lib/nfclegacy/protocols/nfc_util.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void nfc_util_num2bytes(uint64_t src, uint8_t len, uint8_t* dest);
-
-uint64_t nfc_util_bytes2num(const uint8_t* src, uint8_t len);
-
-uint8_t nfc_util_even_parity32(uint32_t data);
-
-uint8_t nfc_util_odd_parity8(uint8_t data);
-
-void nfc_util_odd_parity(const uint8_t* src, uint8_t* dst, uint8_t len);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/nfclegacy/protocols/nfca.c

@@ -1,140 +0,0 @@
-#include "nfca.h"
-#include <string.h>
-#include <stdio.h>
-#include <furi.h>
-
-#define NFCA_CRC_INIT (0x6363)
-
-#define NFCA_F_SIG (13560000.0)
-#define T_SIG 7374 //73.746ns*100
-#define T_SIG_x8 58992 //T_SIG*8
-#define T_SIG_x8_x8 471936 //T_SIG*8*8
-#define T_SIG_x8_x9 530928 //T_SIG*8*9
-
-#define NFCA_SIGNAL_MAX_EDGES (1350)
-
-typedef struct {
-    uint8_t cmd;
-    uint8_t param;
-} nfca_cmd_rats;
-
-static uint8_t nfca_default_ats[] = {0x05, 0x78, 0x80, 0x80, 0x00};
-
-static uint8_t nfca_halt_req[] = {NFCA_CMD_HALT, 0x00};
-
-uint16_t nfca_get_crc16(uint8_t* buff, uint16_t len) {
-    uint16_t crc = NFCA_CRC_INIT;
-    uint8_t byte = 0;
-
-    for(uint8_t i = 0; i < len; i++) {
-        byte = buff[i];
-        byte ^= (uint8_t)(crc & 0xff);
-        byte ^= byte << 4;
-        crc = (crc >> 8) ^ (((uint16_t)byte) << 8) ^ (((uint16_t)byte) << 3) ^
-              (((uint16_t)byte) >> 4);
-    }
-
-    return crc;
-}
-
-void nfca_append_crc16(uint8_t* buff, uint16_t len) {
-    uint16_t crc = nfca_get_crc16(buff, len);
-    buff[len] = (uint8_t)crc;
-    buff[len + 1] = (uint8_t)(crc >> 8);
-}
-
-bool nfca_emulation_handler(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len) {
-    bool halt = false;
-    uint8_t rx_bytes = buff_rx_len / 8;
-
-    if(rx_bytes == sizeof(nfca_halt_req) && !memcmp(buff_rx, nfca_halt_req, rx_bytes)) {
-        halt = true;
-    } else if(rx_bytes == sizeof(nfca_cmd_rats) && buff_rx[0] == NFCA_CMD_RATS) {
-        memcpy(buff_tx, nfca_default_ats, sizeof(nfca_default_ats));
-        *buff_tx_len = sizeof(nfca_default_ats) * 8;
-    }
-
-    return halt;
-}
-
-static void nfca_add_bit(DigitalSignal* signal, bool bit) {
-    if(bit) {
-        signal->start_level = true;
-        for(size_t i = 0; i < 7; i++) {
-            signal->edge_timings[i] = T_SIG_x8;
-        }
-        signal->edge_timings[7] = T_SIG_x8_x9;
-        signal->edge_cnt = 8;
-    } else {
-        signal->start_level = false;
-        signal->edge_timings[0] = T_SIG_x8_x8;
-        for(size_t i = 1; i < 9; i++) {
-            signal->edge_timings[i] = T_SIG_x8;
-        }
-        signal->edge_cnt = 9;
-    }
-}
-
-static void nfca_add_byte(NfcaSignal* nfca_signal, uint8_t byte, bool parity) {
-    for(uint8_t i = 0; i < 8; i++) {
-        if(byte & (1 << i)) {
-            digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-        } else {
-            digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-        }
-    }
-    if(parity) {
-        digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-    } else {
-        digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-    }
-}
-
-NfcaSignal* nfca_signal_alloc() {
-    NfcaSignal* nfca_signal = malloc(sizeof(NfcaSignal));
-    nfca_signal->one = digital_signal_alloc(10);
-    nfca_signal->zero = digital_signal_alloc(10);
-    nfca_add_bit(nfca_signal->one, true);
-    nfca_add_bit(nfca_signal->zero, false);
-    nfca_signal->tx_signal = digital_signal_alloc(NFCA_SIGNAL_MAX_EDGES);
-
-    return nfca_signal;
-}
-
-void nfca_signal_free(NfcaSignal* nfca_signal) {
-    furi_assert(nfca_signal);
-
-    digital_signal_free(nfca_signal->one);
-    digital_signal_free(nfca_signal->zero);
-    digital_signal_free(nfca_signal->tx_signal);
-    free(nfca_signal);
-}
-
-void nfca_signal_encode(NfcaSignal* nfca_signal, uint8_t* data, uint16_t bits, uint8_t* parity) {
-    furi_assert(nfca_signal);
-    furi_assert(data);
-    furi_assert(parity);
-
-    nfca_signal->tx_signal->edge_cnt = 0;
-    nfca_signal->tx_signal->start_level = true;
-    // Start of frame
-    digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-
-    if(bits < 8) {
-        for(size_t i = 0; i < bits; i++) {
-            if(FURI_BIT(data[0], i)) {
-                digital_signal_append(nfca_signal->tx_signal, nfca_signal->one);
-            } else {
-                digital_signal_append(nfca_signal->tx_signal, nfca_signal->zero);
-            }
-        }
-    } else {
-        for(size_t i = 0; i < bits / 8; i++) {
-            nfca_add_byte(nfca_signal, data[i], parity[i / 8] & (1 << (7 - (i & 0x07))));
-        }
-    }
-}

esubghz_chat/lib/nfclegacy/protocols/nfca.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#include "../digital_signal/digital_signal.h"
-
-#define NFCA_CMD_RATS (0xE0U)
-#define NFCA_CMD_HALT (0x50U)
-
-typedef struct {
-    DigitalSignal* one;
-    DigitalSignal* zero;
-    DigitalSignal* tx_signal;
-} NfcaSignal;
-
-uint16_t nfca_get_crc16(uint8_t* buff, uint16_t len);
-
-void nfca_append_crc16(uint8_t* buff, uint16_t len);
-
-bool nfca_emulation_handler(
-    uint8_t* buff_rx,
-    uint16_t buff_rx_len,
-    uint8_t* buff_tx,
-    uint16_t* buff_tx_len);
-
-NfcaSignal* nfca_signal_alloc();
-
-void nfca_signal_free(NfcaSignal* nfca_signal);
-
-void nfca_signal_encode(NfcaSignal* nfca_signal, uint8_t* data, uint16_t bits, uint8_t* parity);

esubghz_chat/lib/nfclegacy/pulse_reader/pulse_reader.c

@@ -1,236 +0,0 @@
-#include "pulse_reader.h"
-
-#include <limits.h>
-#include <furi.h>
-#include <furi_hal.h>
-#include <furi_hal_gpio.h>
-
-#include <stm32wbxx_ll_dma.h>
-#include <stm32wbxx_ll_dmamux.h>
-#include <stm32wbxx_ll_tim.h>
-#include <stm32wbxx_ll_exti.h>
-
-struct PulseReader {
-    uint32_t* timer_buffer;
-    uint32_t* gpio_buffer;
-    uint32_t size;
-    uint32_t pos;
-    uint32_t timer_value;
-    uint32_t gpio_value;
-    uint32_t gpio_mask;
-    uint32_t unit_multiplier;
-    uint32_t unit_divider;
-    uint32_t bit_time;
-    uint32_t dma_channel;
-    const GpioPin* gpio;
-    GpioPull pull;
-    LL_DMA_InitTypeDef dma_config_timer;
-    LL_DMA_InitTypeDef dma_config_gpio;
-};
-
-#define GPIO_PIN_MAP(pin, prefix)               \
-    (((pin) == (LL_GPIO_PIN_0))  ? prefix##0 :  \
-     ((pin) == (LL_GPIO_PIN_1))  ? prefix##1 :  \
-     ((pin) == (LL_GPIO_PIN_2))  ? prefix##2 :  \
-     ((pin) == (LL_GPIO_PIN_3))  ? prefix##3 :  \
-     ((pin) == (LL_GPIO_PIN_4))  ? prefix##4 :  \
-     ((pin) == (LL_GPIO_PIN_5))  ? prefix##5 :  \
-     ((pin) == (LL_GPIO_PIN_6))  ? prefix##6 :  \
-     ((pin) == (LL_GPIO_PIN_7))  ? prefix##7 :  \
-     ((pin) == (LL_GPIO_PIN_8))  ? prefix##8 :  \
-     ((pin) == (LL_GPIO_PIN_9))  ? prefix##9 :  \
-     ((pin) == (LL_GPIO_PIN_10)) ? prefix##10 : \
-     ((pin) == (LL_GPIO_PIN_11)) ? prefix##11 : \
-     ((pin) == (LL_GPIO_PIN_12)) ? prefix##12 : \
-     ((pin) == (LL_GPIO_PIN_13)) ? prefix##13 : \
-     ((pin) == (LL_GPIO_PIN_14)) ? prefix##14 : \
-                                   prefix##15)
-
-#define GET_DMAMUX_EXTI_LINE(pin) GPIO_PIN_MAP(pin, LL_DMAMUX_REQ_GEN_EXTI_LINE)
-
-PulseReader* pulse_reader_alloc(const GpioPin* gpio, uint32_t size) {
-    PulseReader* signal = malloc(sizeof(PulseReader));
-    signal->timer_buffer = malloc(size * sizeof(uint32_t));
-    signal->gpio_buffer = malloc(size * sizeof(uint32_t));
-    signal->dma_channel = LL_DMA_CHANNEL_4;
-    signal->gpio = gpio;
-    signal->pull = GpioPullNo;
-    signal->size = size;
-    signal->timer_value = 0;
-    signal->pos = 0;
-
-    pulse_reader_set_timebase(signal, PulseReaderUnit64MHz);
-    pulse_reader_set_bittime(signal, 1);
-
-    signal->dma_config_timer.Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
-    signal->dma_config_timer.PeriphOrM2MSrcAddress = (uint32_t) & (TIM2->CNT);
-    signal->dma_config_timer.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    signal->dma_config_timer.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    signal->dma_config_timer.MemoryOrM2MDstAddress = (uint32_t)signal->timer_buffer;
-    signal->dma_config_timer.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    signal->dma_config_timer.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    signal->dma_config_timer.Mode = LL_DMA_MODE_CIRCULAR;
-    signal->dma_config_timer.PeriphRequest =
-        LL_DMAMUX_REQ_GENERATOR0; /* executes LL_DMA_SetPeriphRequest */
-    signal->dma_config_timer.Priority = LL_DMA_PRIORITY_VERYHIGH;
-
-    signal->dma_config_gpio.Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
-    signal->dma_config_gpio.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
-    signal->dma_config_gpio.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
-    signal->dma_config_gpio.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
-    signal->dma_config_gpio.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
-    signal->dma_config_gpio.Mode = LL_DMA_MODE_CIRCULAR;
-    signal->dma_config_gpio.PeriphRequest =
-        LL_DMAMUX_REQ_GENERATOR0; /* executes LL_DMA_SetPeriphRequest */
-    signal->dma_config_gpio.Priority = LL_DMA_PRIORITY_VERYHIGH;
-
-    return signal;
-}
-
-void pulse_reader_set_timebase(PulseReader* signal, PulseReaderUnit unit) {
-    switch(unit) {
-    case PulseReaderUnit64MHz:
-        signal->unit_multiplier = 1;
-        signal->unit_divider = 1;
-        break;
-    case PulseReaderUnitPicosecond:
-        signal->unit_multiplier = 15625;
-        signal->unit_divider = 1;
-        break;
-    case PulseReaderUnitNanosecond:
-        signal->unit_multiplier = 15625;
-        signal->unit_divider = 1000;
-        break;
-    case PulseReaderUnitMicrosecond:
-        signal->unit_multiplier = 15625;
-        signal->unit_divider = 1000000;
-        break;
-    }
-}
-
-void pulse_reader_set_bittime(PulseReader* signal, uint32_t bit_time) {
-    signal->bit_time = bit_time;
-}
-
-void pulse_reader_set_pull(PulseReader* signal, GpioPull pull) {
-    signal->pull = pull;
-}
-
-void pulse_reader_free(PulseReader* signal) {
-    furi_assert(signal);
-
-    free(signal->timer_buffer);
-    free(signal->gpio_buffer);
-    free(signal);
-}
-
-uint32_t pulse_reader_samples(PulseReader* signal) {
-    uint32_t dma_pos = signal->size - (uint32_t)LL_DMA_GetDataLength(DMA1, signal->dma_channel);
-
-    return ((signal->pos + signal->size) - dma_pos) % signal->size;
-}
-
-void pulse_reader_stop(PulseReader* signal) {
-    LL_DMA_DisableChannel(DMA1, signal->dma_channel);
-    LL_DMA_DisableChannel(DMA1, signal->dma_channel + 1);
-    LL_DMAMUX_DisableRequestGen(NULL, LL_DMAMUX_REQ_GEN_0);
-    LL_TIM_DisableCounter(TIM2);
-    furi_hal_bus_disable(FuriHalBusTIM2);
-    furi_hal_gpio_init_simple(signal->gpio, GpioModeAnalog);
-}
-
-void pulse_reader_start(PulseReader* signal) {
-    /* configure DMA to read from a timer peripheral */
-    signal->dma_config_timer.NbData = signal->size;
-
-    signal->dma_config_gpio.PeriphOrM2MSrcAddress = (uint32_t) & (signal->gpio->port->IDR);
-    signal->dma_config_gpio.MemoryOrM2MDstAddress = (uint32_t)signal->gpio_buffer;
-    signal->dma_config_gpio.NbData = signal->size;
-
-    furi_hal_bus_enable(FuriHalBusTIM2);
-
-    /* start counter */
-    LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);
-    LL_TIM_SetClockDivision(TIM2, LL_TIM_CLOCKDIVISION_DIV1);
-    LL_TIM_SetPrescaler(TIM2, 0);
-    LL_TIM_SetAutoReload(TIM2, 0xFFFFFFFF);
-    LL_TIM_SetCounter(TIM2, 0);
-    LL_TIM_EnableCounter(TIM2);
-
-    /* generator 0 gets fed by EXTI_LINEn */
-    LL_DMAMUX_SetRequestSignalID(
-        NULL, LL_DMAMUX_REQ_GEN_0, GET_DMAMUX_EXTI_LINE(signal->gpio->pin));
-    /* trigger on rising edge of the interrupt */
-    LL_DMAMUX_SetRequestGenPolarity(NULL, LL_DMAMUX_REQ_GEN_0, LL_DMAMUX_REQ_GEN_POL_RISING);
-    /* now enable request generation again */
-    LL_DMAMUX_EnableRequestGen(NULL, LL_DMAMUX_REQ_GEN_0);
-
-    /* we need the EXTI to be configured as interrupt generating line, but no ISR registered */
-    furi_hal_gpio_init_ex(
-        signal->gpio, GpioModeInterruptRiseFall, signal->pull, GpioSpeedVeryHigh, GpioAltFnUnused);
-
-    /* capture current timer */
-    signal->pos = 0;
-    signal->timer_value = TIM2->CNT;
-    signal->gpio_mask = signal->gpio->pin;
-    signal->gpio_value = signal->gpio->port->IDR & signal->gpio_mask;
-
-    /* now set up DMA with these settings */
-    LL_DMA_Init(DMA1, signal->dma_channel, &signal->dma_config_timer);
-    LL_DMA_Init(DMA1, signal->dma_channel + 1, &signal->dma_config_gpio);
-    LL_DMA_EnableChannel(DMA1, signal->dma_channel);
-    LL_DMA_EnableChannel(DMA1, signal->dma_channel + 1);
-}
-
-uint32_t pulse_reader_receive(PulseReader* signal, int timeout_us) {
-    uint32_t start_time = DWT->CYCCNT;
-    uint32_t timeout_ticks = timeout_us * (F_TIM2 / 1000000);
-
-    do {
-        /* get the DMA's next write position by reading "remaining length" register */
-        uint32_t dma_pos =
-            signal->size - (uint32_t)LL_DMA_GetDataLength(DMA1, signal->dma_channel);
-
-        /* the DMA has advanced in the ringbuffer */
-        if(dma_pos != signal->pos) {
-            uint32_t delta = signal->timer_buffer[signal->pos] - signal->timer_value;
-            uint32_t last_gpio_value = signal->gpio_value;
-
-            signal->gpio_value = signal->gpio_buffer[signal->pos];
-
-            /* check if the GPIO really toggled. if not, we lost an edge :( */
-            if(((last_gpio_value ^ signal->gpio_value) & signal->gpio_mask) != signal->gpio_mask) {
-                signal->gpio_value ^= signal->gpio_mask;
-                return PULSE_READER_LOST_EDGE;
-            }
-            signal->timer_value = signal->timer_buffer[signal->pos];
-
-            signal->pos++;
-            signal->pos %= signal->size;
-
-            uint32_t delta_unit = 0;
-
-            /* probably larger values, so choose a wider data type */
-            if(signal->unit_divider > 1) {
-                delta_unit =
-                    (uint32_t)((uint64_t)delta * (uint64_t)signal->unit_multiplier / signal->unit_divider);
-            } else {
-                delta_unit = delta * signal->unit_multiplier;
-            }
-
-            /* if to be scaled to bit times, save a few instructions. should be faster */
-            if(signal->bit_time > 1) {
-                return (delta_unit + signal->bit_time / 2) / signal->bit_time;
-            }
-
-            return delta_unit;
-        }
-
-        /* check for timeout */
-        uint32_t elapsed = DWT->CYCCNT - start_time;
-
-        if(elapsed > timeout_ticks) {
-            return PULSE_READER_NO_EDGE;
-        }
-    } while(true);
-}

esubghz_chat/lib/nfclegacy/pulse_reader/pulse_reader.h

@@ -1,122 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdbool.h>
-
-#include <furi_hal_gpio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define PULSE_READER_NO_EDGE (0xFFFFFFFFUL)
-#define PULSE_READER_LOST_EDGE (0xFFFFFFFEUL)
-#define F_TIM2 (64000000UL)
-
-/**
- * unit of the edge durations to return
- */
-typedef enum {
-    PulseReaderUnit64MHz,
-    PulseReaderUnitPicosecond,
-    PulseReaderUnitNanosecond,
-    PulseReaderUnitMicrosecond,
-} PulseReaderUnit;
-
-/* using an anonymous type */
-typedef struct PulseReader PulseReader;
-
-/** Allocate a PulseReader object
- *
- * Allocates memory for a ringbuffer and initalizes the object
- *
- * @param[in]  gpio        the GPIO to use. will get configured as input.
- * @param[in]  size        number of edges to buffer
- */
-PulseReader* pulse_reader_alloc(const GpioPin* gpio, uint32_t size);
-
-/** Free a PulseReader object
- *
- * Frees all memory of the given object
- *
- * @param[in]  signal      previously allocated PulseReader object.
- */
-void pulse_reader_free(PulseReader* signal);
-
-/** Start signal capturing
- *
- * Initializes DMA1, TIM2 and DMAMUX_REQ_GEN_0 to automatically capture timer values.
- * Ensure that interrupts are always enabled, as the used EXTI line is handled as one.
- *
- * @param[in]  signal      previously allocated PulseReader object.
- */
-void pulse_reader_start(PulseReader* signal);
-
-/** Stop signal capturing
- *
- * Frees DMA1, TIM2 and DMAMUX_REQ_GEN_0
- *
- * @param[in]  signal      previously allocated PulseReader object.
- */
-void pulse_reader_stop(PulseReader* signal);
-
-/** Recevie a sample from ringbuffer
- *
- * Waits for the specified time until a new edge gets detected.
- * If not configured otherwise, the pulse duration will be in picosecond resolution.
- * If a bittime was configured, the return value will contain the properly rounded
- * number of bit times measured.
- *
- * @param[in]  signal      previously allocated PulseReader object.
- * @param[in]  timeout_us  time to wait for a signal [µs]
- *
- * @returns the scaled value of the pulse duration
- */
-uint32_t pulse_reader_receive(PulseReader* signal, int timeout_us);
-
-/** Get available samples
- *
- * Get the number of available samples in the ringbuffer
- *
- * @param[in]  signal  previously allocated PulseReader object.
- *
- * @returns the number of samples in buffer
- */
-uint32_t pulse_reader_samples(PulseReader* signal);
-
-/** Set timebase
- *
- * Set the timebase to be used when returning pulse duration.
- *
- * @param[in]  signal  previously allocated PulseReader object.
- * @param[in]  unit  PulseReaderUnit64MHz or PulseReaderUnitPicosecond
- */
-void pulse_reader_set_timebase(PulseReader* signal, PulseReaderUnit unit);
-
-/** Set bit time
- *
- * Set the number of timebase units per bit.
- * When set, the pulse_reader_receive() will return an already rounded
- * bit count value instead of the raw duration.
- *
- * Set to 1 to return duration again.
- *
- * @param[in]  signal    previously allocated PulseReader object.
- * @param[in]  bit_time
- */
-void pulse_reader_set_bittime(PulseReader* signal, uint32_t bit_time);
-
-/** Set GPIO pull direction
- *
- * Some GPIOs need pulldown, others don't. By default the
- * pull direction is GpioPullNo.
- *
- * @param[in]  signal    previously allocated PulseReader object.
- * @param[in]  pull      GPIO pull direction
- */
-void pulse_reader_set_pull(PulseReader* signal, GpioPull pull);
-
-#ifdef __cplusplus
-}
-#endif

esubghz_chat/lib/parity/parity.c

@@ -1,71 +0,0 @@
-#include "parity.h"
-
-uint32_t __paritysi2(uint32_t a) {
-    uint32_t x = (uint32_t)a;
-    x ^= x >> 16;
-    x ^= x >> 8;
-    x ^= x >> 4;
-    return (0x6996 >> (x & 0xF)) & 1;
-}
-
-static const uint8_t g_odd_byte_parity[256] = {
-    1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
-    1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,
-    1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1,
-    0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,
-    1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,
-    0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0,
-    0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1,
-    0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
-    1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1};
-
-#define ODD_PARITY8(x) \
-    { g_odd_byte_parity[x] }
-#define EVEN_PARITY8(x) \
-    { !g_odd_byte_parity[x] }
-
-uint8_t oddparity8(const uint8_t x) {
-    return g_odd_byte_parity[x];
-}
-
-uint8_t evenparity8(const uint8_t x) {
-    return !g_odd_byte_parity[x];
-}
-
-uint8_t evenparity16(uint16_t x) {
-#if !defined __GNUC__
-    x ^= x >> 8;
-    return EVEN_PARITY8(x);
-#else
-    return (__builtin_parity(x) & 0xFF);
-#endif
-}
-
-uint8_t oddparity16(uint16_t x) {
-#if !defined __GNUC__
-    x ^= x >> 8;
-    return ODD_PARITY8(x);
-#else
-    return !__builtin_parity(x);
-#endif
-}
-
-uint8_t evenparity32(uint32_t x) {
-#if !defined __GNUC__
-    x ^= x >> 16;
-    x ^= x >> 8;
-    return EVEN_PARITY8(x);
-#else
-    return (__builtin_parity(x) & 0xFF);
-#endif
-}
-
-uint8_t oddparity32(uint32_t x) {
-#if !defined __GNUC__
-    x ^= x >> 16;
-    x ^= x >> 8;
-    return ODD_PARITY8(x);
-#else
-    return !__builtin_parity(x);
-#endif
-}

esubghz_chat/lib/parity/parity.h

@@ -1,10 +0,0 @@
-#include "stdint.h"
-
-uint8_t oddparity8(const uint8_t x);
-uint8_t evenparity8(const uint8_t x);
-
-uint8_t evenparity16(uint16_t x);
-uint8_t oddparity16(uint16_t x);
-
-uint8_t evenparity32(uint32_t x);
-uint8_t oddparity32(uint32_t x);

esubghz_chat/scenes/esubghz_chat_key_display.c

@@ -88,7 +88,7 @@ void scene_on_enter_key_display(void* context) {
     dialog_ex_set_left_button_text(state->key_display, "Back");
 
     if(state->encrypted) {
-        dialog_ex_set_center_button_text(state->key_display, "Share");
+        // dialog_ex_set_center_button_text(state->key_display, "Share");
     }
 
     dialog_ex_set_result_callback(state->key_display, key_display_result_cb);
@@ -119,11 +119,11 @@ bool scene_on_event_key_display(void* context, SceneManagerEvent event) {
             consumed = true;
             break;
 
-        /* open key sharing popup */
-        case ESubGhzChatEvent_KeyDisplayShare:
-            scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeySharePopup);
-            consumed = true;
-            break;
+            /* open key sharing popup */
+            // case ESubGhzChatEvent_KeyDisplayShare:
+            //     scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeySharePopup);
+            //     consumed = true;
+            //     break;
         }
         break;
 

esubghz_chat/scenes/esubghz_chat_key_menu.c

@@ -5,7 +5,7 @@ typedef enum {
     ESubGhzChatKeyMenuItems_Password,
     ESubGhzChatKeyMenuItems_HexKey,
     ESubGhzChatKeyMenuItems_GenKey,
-    ESubGhzChatKeyMenuItems_ReadKeyFromNfc,
+    // ESubGhzChatKeyMenuItems_ReadKeyFromNfc,
 } ESubGhzChatKeyMenuItems;
 
 static void key_menu_cb(void* context, uint32_t index) {
@@ -52,10 +52,10 @@ static void key_menu_cb(void* context, uint32_t index) {
         view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_KeyMenuGenKey);
         break;
 
-    case ESubGhzChatKeyMenuItems_ReadKeyFromNfc:
-        view_dispatcher_send_custom_event(
-            state->view_dispatcher, ESubGhzChatEvent_KeyMenuReadKeyFromNfc);
-        break;
+        // case ESubGhzChatKeyMenuItems_ReadKeyFromNfc:
+        //     view_dispatcher_send_custom_event(
+        //         state->view_dispatcher, ESubGhzChatEvent_KeyMenuReadKeyFromNfc);
+        //     break;
 
     default:
         break;
@@ -98,13 +98,13 @@ void scene_on_enter_key_menu(void* context) {
         ESubGhzChatKeyMenuItems_GenKey,
         key_menu_cb,
         state);
-    menu_add_item(
-        state->menu,
-        "Read Key from NFC",
-        &I_Nfc_14px,
-        ESubGhzChatKeyMenuItems_ReadKeyFromNfc,
-        key_menu_cb,
-        state);
+    // menu_add_item(
+    //     state->menu,
+    //     "Read Key from NFC",
+    //     &I_Nfc_14px,
+    //     ESubGhzChatKeyMenuItems_ReadKeyFromNfc,
+    //     key_menu_cb,
+    //     state);
 
     view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Menu);
 }
@@ -140,11 +140,11 @@ bool scene_on_event_key_menu(void* context, SceneManagerEvent event) {
             consumed = true;
             break;
 
-        /* switch to hex key read scene */
-        case ESubGhzChatEvent_KeyMenuReadKeyFromNfc:
-            scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
-            consumed = true;
-            break;
+            /* switch to hex key read scene */
+            // case ESubGhzChatEvent_KeyMenuReadKeyFromNfc:
+            //     scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
+            //     consumed = true;
+            //     break;
         }
 
         break;

esubghz_chat/scenes/esubghz_chat_key_read_popup.c

@@ -1,268 +1,273 @@
-#include "../esubghz_chat_i.h"
-#include "../helpers/nfc_helpers.h"
-#include <machine/endian.h>
-
-typedef enum {
-    KeyReadPopupState_Idle,
-    KeyReadPopupState_Detecting,
-    KeyReadPopupState_Reading,
-    KeyReadPopupState_Fail,
-    KeyReadPopupState_Success,
-} KeyReadPopupState;
-
-static bool read_worker_cb(NfcWorkerEvent event, void* context) {
-    furi_assert(context);
-    ESubGhzChatState* state = context;
-
-    view_dispatcher_send_custom_event(state->view_dispatcher, event);
-
-    return true;
-}
-
-static void key_read_popup_timeout_cb(void* context) {
-    furi_assert(context);
-    ESubGhzChatState* state = context;
-
-    uint32_t cur_state =
-        scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
-
-    /* done displaying our failure */
-    if(cur_state == KeyReadPopupState_Fail) {
-        view_dispatcher_send_custom_event(
-            state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupFailed);
-        /* done displaying our success */
-    } else if(cur_state == KeyReadPopupState_Success) {
-        view_dispatcher_send_custom_event(
-            state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupSucceeded);
-    }
-}
-
-struct ReplayDictNfcReaderContext {
-    uint8_t* cur;
-    uint8_t* max;
-};
-
-static bool replay_dict_nfc_reader(uint64_t* run_id, uint32_t* counter, void* context) {
-    struct ReplayDictNfcReaderContext* ctx = (struct ReplayDictNfcReaderContext*)context;
-
-    if(ctx->cur + sizeof(struct ReplayDictNfcEntry) > ctx->max) {
-        return false;
-    }
-
-    struct ReplayDictNfcEntry* entry = (struct ReplayDictNfcEntry*)ctx->cur;
-    *run_id = entry->run_id;
-    *counter = __ntohl(entry->counter);
-
-    ctx->cur += sizeof(struct ReplayDictNfcEntry);
-
-    return true;
-}
-
-static bool key_read_popup_handle_key_read(ESubGhzChatState* state) {
-    NfcDeviceData* dev_data = state->nfc_dev_data;
-
-    /* check for config pages */
-    if(dev_data->mf_ul_data.data_read < NFC_CONFIG_PAGES * 4) {
-        return false;
-    }
-
-    size_t data_read = dev_data->mf_ul_data.data_read - (NFC_CONFIG_PAGES * 4);
-
-    /* check if key was transmitted */
-    if(data_read < KEY_BITS / 8) {
-        return false;
-    }
-
-    /* initiate the crypto context */
-    bool ret = crypto_ctx_set_key(
-        state->crypto_ctx, dev_data->mf_ul_data.data, state->name_prefix, furi_get_tick());
-
-    /* cleanup */
-    crypto_explicit_bzero(dev_data->mf_ul_data.data, KEY_BITS / 8);
-
-    if(!ret) {
-        crypto_ctx_clear(state->crypto_ctx);
-        return false;
-    }
-
-    /* read the frequency */
-    if(data_read >= (KEY_BITS / 8) + sizeof(struct FreqNfcEntry)) {
-        struct FreqNfcEntry* freq_entry =
-            (struct FreqNfcEntry*)(dev_data->mf_ul_data.data + (KEY_BITS / 8));
-        state->frequency = __ntohl(freq_entry->frequency);
-    }
-
-    /* read the replay dict */
-    struct ReplayDictNfcReaderContext rd_ctx = {
-        .cur = dev_data->mf_ul_data.data + (KEY_BITS / 8) + sizeof(struct FreqNfcEntry),
-        .max =
-            dev_data->mf_ul_data.data + (data_read < NFC_MAX_BYTES ? data_read : NFC_MAX_BYTES)};
-
-    crypto_ctx_read_replay_dict(state->crypto_ctx, replay_dict_nfc_reader, &rd_ctx);
-
-    /* set encrypted flag */
-    state->encrypted = true;
-
-    return true;
-}
-
-static void key_read_popup_set_state(ESubGhzChatState* state, KeyReadPopupState new_state) {
-    uint32_t cur_state =
-        scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
-    if(cur_state == new_state) {
-        return;
-    }
-
-    if(new_state == KeyReadPopupState_Detecting) {
-        popup_reset(state->nfc_popup);
-        popup_disable_timeout(state->nfc_popup);
-        popup_set_text(state->nfc_popup, "Tap Flipper\n to sender", 97, 24, AlignCenter, AlignTop);
-        popup_set_icon(state->nfc_popup, 0, 8, &I_NFC_manual_60x50);
-        notification_message(state->notification, &sequence_blink_start_cyan);
-    } else if(new_state == KeyReadPopupState_Reading) {
-        popup_reset(state->nfc_popup);
-        popup_disable_timeout(state->nfc_popup);
-        popup_set_header(
-            state->nfc_popup,
-            "Reading key\nDon't "
-            "move...",
-            85,
-            24,
-            AlignCenter,
-            AlignTop);
-        popup_set_icon(state->nfc_popup, 12, 23, &I_Loading_24);
-        notification_message(state->notification, &sequence_blink_start_yellow);
-    } else if(new_state == KeyReadPopupState_Fail) {
-        nfc_worker_stop(state->nfc_worker);
-
-        popup_reset(state->nfc_popup);
-        popup_set_header(state->nfc_popup, "Failure!", 64, 2, AlignCenter, AlignTop);
-        popup_set_text(state->nfc_popup, "Failed\nto read\nkey.", 78, 16, AlignLeft, AlignTop);
-        popup_set_icon(state->nfc_popup, 14, 10, &I_dolph_cry_49x54);
-
-        popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS);
-        popup_set_context(state->nfc_popup, state);
-        popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb);
-        popup_enable_timeout(state->nfc_popup);
-
-        notification_message(state->notification, &sequence_blink_stop);
-    } else if(new_state == KeyReadPopupState_Success) {
-        nfc_worker_stop(state->nfc_worker);
-
-        popup_reset(state->nfc_popup);
-        popup_set_header(state->nfc_popup, "Key\nread!", 13, 22, AlignLeft, AlignBottom);
-        popup_set_icon(state->nfc_popup, 36, 5, &I_DolphinDone_80x58);
-
-        popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS);
-        popup_set_context(state->nfc_popup, state);
-        popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb);
-        popup_enable_timeout(state->nfc_popup);
-
-        notification_message(state->notification, &sequence_success);
-        notification_message(state->notification, &sequence_blink_stop);
-    }
-
-    scene_manager_set_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup, new_state);
-
-    view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_NfcPopup);
-}
-
-/* Prepares the key share read scene. */
-void scene_on_enter_key_read_popup(void* context) {
-    FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_read_popup");
-
-    furi_assert(context);
-    ESubGhzChatState* state = context;
-
-    key_read_popup_set_state(state, KeyReadPopupState_Detecting);
-
-    nfc_worker_start(
-        state->nfc_worker, NfcWorkerStateRead, state->nfc_dev_data, read_worker_cb, state);
-}
-
-/* Handles scene manager events for the key read popup scene. */
-bool scene_on_event_key_read_popup(void* context, SceneManagerEvent event) {
-    FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_read_popup");
-
-    furi_assert(context);
-    ESubGhzChatState* state = context;
-
-    bool consumed = false;
-
-    switch(event.type) {
-    case SceneManagerEventTypeCustom:
-        switch(event.event) {
-        /* card detected */
-        case NfcWorkerEventCardDetected:
-            key_read_popup_set_state(state, KeyReadPopupState_Reading);
-            consumed = true;
-            break;
-
-        /* no card detected */
-        case NfcWorkerEventNoCardDetected:
-            key_read_popup_set_state(state, KeyReadPopupState_Detecting);
-            consumed = true;
-            break;
-
-        /* key probably read */
-        case NfcWorkerEventReadMfUltralight:
-            if(key_read_popup_handle_key_read(state)) {
-                key_read_popup_set_state(state, KeyReadPopupState_Success);
-            } else {
-                key_read_popup_set_state(state, KeyReadPopupState_Fail);
-            }
-            consumed = true;
-            break;
-
-        /* close the popup and go back */
-        case ESubGhzChatEvent_KeyReadPopupFailed:
-            if(!scene_manager_previous_scene(state->scene_manager)) {
-                view_dispatcher_stop(state->view_dispatcher);
-            }
-            consumed = true;
-            break;
-
-        /* success, go to frequency input */
-        case ESubGhzChatEvent_KeyReadPopupSucceeded:
-            scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_FreqInput);
-            consumed = true;
-            break;
-
-        /* something else happend, treat as failure */
-        default:
-            key_read_popup_set_state(state, KeyReadPopupState_Fail);
-            consumed = true;
-            break;
-        }
-
-        break;
-
-    default:
-        consumed = false;
-        break;
-    }
-
-    return consumed;
-}
-
-/* Cleans up the key read popup scene. */
-void scene_on_exit_key_read_popup(void* context) {
-    FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_read_popup");
-
-    furi_assert(context);
-    ESubGhzChatState* state = context;
-
-    popup_reset(state->nfc_popup);
-    scene_manager_set_scene_state(
-        state->scene_manager, ESubGhzChatScene_KeyReadPopup, KeyReadPopupState_Idle);
-
-    notification_message(state->notification, &sequence_blink_stop);
-
-    nfc_worker_stop(state->nfc_worker);
-
-    crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8);
-    /*if(state->nfc_dev_data->parsed_data != NULL) {
-        furi_string_free(state->nfc_dev_data->parsed_data);
-    }*/
-    //memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData));
-}
+// #include "../esubghz_chat_i.h"
+// #include "../helpers/nfc_helpers.h"
+
+// typedef enum {
+//     KeyReadPopupState_Idle,
+//     KeyReadPopupState_Detecting,
+//     KeyReadPopupState_Reading,
+//     KeyReadPopupState_Fail,
+//     KeyReadPopupState_Success,
+// } KeyReadPopupState;
+
+// static bool read_worker_cb(NfcWorkerEvent event, void* context) {
+//     furi_assert(context);
+//     ESubGhzChatState* state = context;
+
+//     view_dispatcher_send_custom_event(state->view_dispatcher, event);
+
+//     return true;
+// }
+
+// static void key_read_popup_timeout_cb(void* context) {
+//     furi_assert(context);
+//     ESubGhzChatState* state = context;
+
+//     uint32_t cur_state =
+//         scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
+
+//     /* done displaying our failure */
+//     if(cur_state == KeyReadPopupState_Fail) {
+//         view_dispatcher_send_custom_event(
+//             state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupFailed);
+//         /* done displaying our success */
+//     } else if(cur_state == KeyReadPopupState_Success) {
+//         view_dispatcher_send_custom_event(
+//             state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupSucceeded);
+//     }
+// }
+
+// struct ReplayDictNfcReaderContext {
+//     uint8_t* cur;
+//     uint8_t* max;
+// };
+
+// static bool replay_dict_nfc_reader(uint64_t* run_id, uint32_t* counter, void* context) {
+//     struct ReplayDictNfcReaderContext* ctx = (struct ReplayDictNfcReaderContext*)context;
+
+//     if(ctx->cur + sizeof(struct ReplayDictNfcEntry) > ctx->max) {
+//         return false;
+//     }
+
+//     struct ReplayDictNfcEntry* entry = (struct ReplayDictNfcEntry*)ctx->cur;
+//     *run_id = entry->run_id;
+//     *counter = __ntohl(entry->counter);
+
+//     ctx->cur += sizeof(struct ReplayDictNfcEntry);
+
+//     return true;
+// }
+
+// static bool key_read_popup_handle_key_read(ESubGhzChatState* state) {
+//     NfcDeviceData* dev_data = state->nfc_dev_data;
+
+//     /* check for config pages */
+//     if(dev_data->mf_ul_data.data_read < NFC_CONFIG_PAGES * 4) {
+//         return false;
+//     }
+
+//     size_t data_read = dev_data->mf_ul_data.data_read - (NFC_CONFIG_PAGES * 4);
+
+//     /* check if key was transmitted */
+//     if(data_read < KEY_BITS / 8) {
+//         return false;
+//     }
+
+//     /* initiate the crypto context */
+//     bool ret = crypto_ctx_set_key(
+//         state->crypto_ctx, dev_data->mf_ul_data.data, state->name_prefix, furi_get_tick());
+
+//     /* cleanup */
+//     crypto_explicit_bzero(dev_data->mf_ul_data.data, KEY_BITS / 8);
+
+//     if(!ret) {
+//         crypto_ctx_clear(state->crypto_ctx);
+//         return false;
+//     }
+
+//     /* read the frequency */
+//     if(data_read >= (KEY_BITS / 8) + sizeof(struct FreqNfcEntry)) {
+//         struct FreqNfcEntry* freq_entry =
+//             (struct FreqNfcEntry*)(dev_data->mf_ul_data.data + (KEY_BITS / 8));
+//         state->frequency = __ntohl(freq_entry->frequency);
+//     }
+
+//     /* read the replay dict */
+//     struct ReplayDictNfcReaderContext rd_ctx = {
+//         .cur = dev_data->mf_ul_data.data + (KEY_BITS / 8) + sizeof(struct FreqNfcEntry),
+//         .max =
+//             dev_data->mf_ul_data.data + (data_read < NFC_MAX_BYTES ? data_read : NFC_MAX_BYTES)};
+
+//     crypto_ctx_read_replay_dict(state->crypto_ctx, replay_dict_nfc_reader, &rd_ctx);
+
+//     /* set encrypted flag */
+//     state->encrypted = true;
+
+//     return true;
+// }
+
+// static void key_read_popup_set_state(ESubGhzChatState* state, KeyReadPopupState new_state) {
+//     uint32_t cur_state =
+//         scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup);
+//     if(cur_state == new_state) {
+//         return;
+//     }
+
+//     if(new_state == KeyReadPopupState_Detecting) {
+//         popup_reset(state->nfc_popup);
+//         popup_disable_timeout(state->nfc_popup);
+//         popup_set_text(state->nfc_popup, "Tap Flipper\n to sender", 97, 24, AlignCenter, AlignTop);
+//         popup_set_icon(state->nfc_popup, 0, 8, &I_NFC_manual_60x50);
+//         notification_message(state->notification, &sequence_blink_start_cyan);
+//     } else if(new_state == KeyReadPopupState_Reading) {
+//         popup_reset(state->nfc_popup);
+//         popup_disable_timeout(state->nfc_popup);
+//         popup_set_header(
+//             state->nfc_popup,
+//             "Reading key\nDon't "
+//             "move...",
+//             85,
+//             24,
+//             AlignCenter,
+//             AlignTop);
+//         popup_set_icon(state->nfc_popup, 12, 23, &I_Loading_24);
+//         notification_message(state->notification, &sequence_blink_start_yellow);
+//     } else if(new_state == KeyReadPopupState_Fail) {
+//         nfc_worker_stop(state->nfc_worker);
+
+//         popup_reset(state->nfc_popup);
+//         popup_set_header(state->nfc_popup, "Failure!", 64, 2, AlignCenter, AlignTop);
+//         popup_set_text(state->nfc_popup, "Failed\nto read\nkey.", 78, 16, AlignLeft, AlignTop);
+//         popup_set_icon(state->nfc_popup, 14, 10, &I_dolph_cry_49x54);
+
+//         popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS);
+//         popup_set_context(state->nfc_popup, state);
+//         popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb);
+//         popup_enable_timeout(state->nfc_popup);
+
+//         notification_message(state->notification, &sequence_blink_stop);
+//     } else if(new_state == KeyReadPopupState_Success) {
+//         nfc_worker_stop(state->nfc_worker);
+
+//         popup_reset(state->nfc_popup);
+//         popup_set_header(state->nfc_popup, "Key\nread!", 13, 22, AlignLeft, AlignBottom);
+//         popup_set_icon(state->nfc_popup, 36, 5, &I_DolphinDone_80x58);
+
+//         popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS);
+//         popup_set_context(state->nfc_popup, state);
+//         popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb);
+//         popup_enable_timeout(state->nfc_popup);
+
+//         notification_message(state->notification, &sequence_success);
+//         notification_message(state->notification, &sequence_blink_stop);
+//     }
+
+//     scene_manager_set_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup, new_state);
+
+//     view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_NfcPopup);
+// }
+
+// /* Prepares the key share read scene. */
+// void scene_on_enter_key_read_popup(void* context) {
+//     FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_read_popup");
+
+//     furi_assert(context);
+//     ESubGhzChatState* state = context;
+
+//     key_read_popup_set_state(state, KeyReadPopupState_Detecting);
+
+//     state->nfc_dev_data->parsed_data = furi_string_alloc();
+//     if(state->nfc_dev_data->parsed_data == NULL) {
+//         /* can't do anything here, crash */
+//         furi_check(0);
+//     }
+
+//     nfc_worker_start(
+//         state->nfc_worker, NfcWorkerStateRead, state->nfc_dev_data, read_worker_cb, state);
+// }
+
+// /* Handles scene manager events for the key read popup scene. */
+// bool scene_on_event_key_read_popup(void* context, SceneManagerEvent event) {
+//     FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_read_popup");
+
+//     furi_assert(context);
+//     ESubGhzChatState* state = context;
+
+//     bool consumed = false;
+
+//     switch(event.type) {
+//     case SceneManagerEventTypeCustom:
+//         switch(event.event) {
+//         /* card detected */
+//         case NfcWorkerEventCardDetected:
+//             key_read_popup_set_state(state, KeyReadPopupState_Reading);
+//             consumed = true;
+//             break;
+
+//         /* no card detected */
+//         case NfcWorkerEventNoCardDetected:
+//             key_read_popup_set_state(state, KeyReadPopupState_Detecting);
+//             consumed = true;
+//             break;
+
+//         /* key probably read */
+//         case NfcWorkerEventReadMfUltralight:
+//             if(key_read_popup_handle_key_read(state)) {
+//                 key_read_popup_set_state(state, KeyReadPopupState_Success);
+//             } else {
+//                 key_read_popup_set_state(state, KeyReadPopupState_Fail);
+//             }
+//             consumed = true;
+//             break;
+
+//         /* close the popup and go back */
+//         case ESubGhzChatEvent_KeyReadPopupFailed:
+//             if(!scene_manager_previous_scene(state->scene_manager)) {
+//                 view_dispatcher_stop(state->view_dispatcher);
+//             }
+//             consumed = true;
+//             break;
+
+//         /* success, go to frequency input */
+//         case ESubGhzChatEvent_KeyReadPopupSucceeded:
+//             scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_FreqInput);
+//             consumed = true;
+//             break;
+
+//         /* something else happend, treat as failure */
+//         default:
+//             key_read_popup_set_state(state, KeyReadPopupState_Fail);
+//             consumed = true;
+//             break;
+//         }
+
+//         break;
+
+//     default:
+//         consumed = false;
+//         break;
+//     }
+
+//     return consumed;
+// }
+
+// /* Cleans up the key read popup scene. */
+// void scene_on_exit_key_read_popup(void* context) {
+//     FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_read_popup");
+
+//     furi_assert(context);
+//     ESubGhzChatState* state = context;
+
+//     popup_reset(state->nfc_popup);
+//     scene_manager_set_scene_state(
+//         state->scene_manager, ESubGhzChatScene_KeyReadPopup, KeyReadPopupState_Idle);
+
+//     notification_message(state->notification, &sequence_blink_stop);
+
+//     nfc_worker_stop(state->nfc_worker);
+
+//     crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8);
+//     if(state->nfc_dev_data->parsed_data != NULL) {
+//         furi_string_free(state->nfc_dev_data->parsed_data);
+//     }
+//     memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData));
+// }