2021-10-18 01:54:19 +03:00
/**
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* 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 "rfal_nfc.h"
# include "utils.h"
# 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 ; /* Decices 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 opration 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 ;
}
}
/*******************************************************************************/
2021-12-21 15:33:17 +03:00
ReturnCode rfalNfcDataExchangeStart ( uint8_t * txData , uint16_t txDataLen , uint8_t * * rxData , uint16_t * * rvdLen , uint32_t fwt , uint32_t flags )
2021-10-18 01:54:19 +03:00
{
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 :
2021-12-21 15:33:17 +03:00
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 ;
}
2021-10-18 01:54:19 +03:00
* 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 succesfully 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 succesfull 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 ;
/* Supress 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 ;
/* Supress 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 ;
/* Supress 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 perfomed (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 ;
/* Supress 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 ;
}
