/****************************************************************************** * \attention * *

© COPYRIGHT 2020 STMicroelectronics

* * 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.
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.
* Additionally few specific Transceive methods are available to cope with the * specifics of these particular operations. * * The most common interfaces are: *
rfalInitialize() *
rfalSetFDTPoll() *
rfalSetFDTListen() *
rfalSetGT() *
rfalSetBitRate() *
rfalSetMode() *
rfalFieldOnAndStartGT() *
rfalFieldOff() *
rfalStartTransceive() *
rfalGetTransceiveStatus() *
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 "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_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_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); /*! Callback to be executed after a Transceive */ typedef void (* rfalPostTxRxCallback)(void); /*******************************************************************************/ /* 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 ); /*! ***************************************************************************** * \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 ); /***************************************************************************** * 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 */ /** * @} * * @} * * @} */