phFriNfc_TopazMap.c - Android社区 - https://www.androidos.net.cn/

/*
 * Copyright (C) 2010 NXP Semiconductors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*!
* \file  phFriNfc_TopazMap.c
* \brief NFC Ndef Mapping For Remote Devices.
*
* Project: NFC-FRI
*
* $Date: Mon Dec 13 14:14:14 2010 $
* $Author: ing02260 $
* $Revision: 1.23 $
* $Aliases:  $
*
*/

#include <phFriNfc_NdefMap.h>
#include <phFriNfc_TopazMap.h>
#include <phFriNfc_MapTools.h>
#include <phFriNfc_OvrHal.h>

#ifndef PH_FRINFC_MAP_TOPAZ_DISABLED
/*! \ingroup grp_file_attributes
*  \name NDEF Mapping
*
* File: \ref phFriNfcNdefMap.c
*
*/
/*@{*/
#define PHFRINFCTOPAZMAP_FILEREVISION "$Revision: 1.23 $"
#define PHFRINFCTOPAZMAP_FILEALIASES  "$Aliases:  $"
/*@}*/
/****************** Start of macros ********************/
/* Below MACRO is used for the WRITE error scenario, 
    in case PN544 returns error for any WRITE, then 
    read the written block and byte number, to check the data 
    written to the card is correct or not 
*/
/* #define TOPAZ_RF_ERROR_WORKAROUND */

#ifdef FRINFC_READONLY_NDEF

#define CC_BLOCK_NUMBER                                         (0x01U)
    #define LOCK_BLOCK_NUMBER                                       (0x0EU)

#define LOCK0_BYTE_NUMBER                                       (0x00U)
    #define LOCK0_BYTE_VALUE                                        (0xFFU)

#define LOCK1_BYTE_NUMBER                                       (0x01U)
    #define LOCK1_BYTE_VALUE                                        (0x7FU)

#define CC_RWA_BYTE_NUMBER                                      (0x03U)
    #define CC_READ_ONLY_VALUE                                      (0x0FU)

#endif /* #ifdef FRINFC_READONLY_NDEF */

#ifdef TOPAZ_RF_ERROR_WORKAROUND

/* Below MACROs are added for the error returned from HAL, if the 
        below error has occured during the WRITE, then read the error 
        returned blocks to confirm */
    #define FRINFC_RF_TIMEOUT_89                                    (0x89U)
    #define FRINFC_RF_TIMEOUT_90                                    (0x90U)

/* State specific to read after the RF ERROR for the WRITE */
    #define PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ                     (0x0FU)

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */

/****************** End of macros ********************/

/*!
* \name Topaz Mapping - Helper Functions
*
*/
/*@{*/

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall read 8 bytes 
*  from the card.
*/
static NFCSTATUS phFriNfc_Tpz_H_RdBytes(phFriNfc_NdefMap_t *NdefMap,
                                        uint16_t             BlockNo,
                                        uint16_t             ByteNo);
 
/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process 
* read id command
*/
static NFCSTATUS phFriNfc_Tpz_H_ProReadID(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process 
* read all command
*/
static NFCSTATUS phFriNfc_Tpz_H_ProReadAll(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function depends on
* function called by the user
*/
static NFCSTATUS phFriNfc_Tpz_H_CallNxtOp(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function checks the CC 
* bytes
*/
static NFCSTATUS phFriNfc_Tpz_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function finds 
* NDEF TLV
*/
static NFCSTATUS phFriNfc_Tpz_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function writes a 
* byte into the card
*/
static NFCSTATUS phFriNfc_Tpz_H_WrAByte(phFriNfc_NdefMap_t *NdefMap,
                                        uint16_t             BlockNo,
                                        uint16_t             ByteNo,
                                        uint8_t              ByteVal
                                        );

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process the 
* NMN write 
*/
static NFCSTATUS phFriNfc_Tpz_H_ProWrNMN(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function writes the length field of
* the NDEF TLV
*/
static NFCSTATUS phFriNfc_Tpz_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function updates length field 
* of the NDEF TLV after complete write.
*/
static NFCSTATUS phFriNfc_Tpz_H_WrLByte(phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function copies the card data
*  to the user buffer
*/
static NFCSTATUS phFriNfc_Tpz_H_CpDataToUsrBuf( phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process the 
* written data
*/
static NFCSTATUS phFriNfc_Tpz_H_ProWrUsrData( phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function checks the block 
* number is correct or not
*/
static void phFriNfc_Tpz_H_BlkChk(phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function writes the 0th 
* byte of block 1 has Zero
*/
static NFCSTATUS phFriNfc_Tpz_H_WrByte0ValE1(phFriNfc_NdefMap_t   *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function calls the 
* completion routine
*/
static void phFriNfc_Tpz_H_Complete(phFriNfc_NdefMap_t  *NdefMap,
                                    NFCSTATUS           Status);

/*!
* \brief \copydoc page_ovr Helper function for Topaz check ndef. This function checks 
* the CC byte in check ndef function
*/
static NFCSTATUS phFriNfc_Tpz_H_ChkCCinChkNdef(phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz check ndef. This function checks 
* the lock bits and set a card state
*/
static void phFriNfc_Tpz_H_ChkLockBits(phFriNfc_NdefMap_t  *NdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function writes CC bytes or 
* type of the TLV
*/
static NFCSTATUS phFriNfc_Tpz_H_WrCCorTLV(phFriNfc_NdefMap_t  *NdefMap);

#ifdef TOPAZ_RF_ERROR_WORKAROUND

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function checks the written  
* value after the 
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_CheckWrittenData (
    phFriNfc_NdefMap_t          *psNdefMap,
    uint8_t                     state_rf_error);

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function checks the written 
* CC bytes are correct
*/
static NFCSTATUS phFriNfc_Tpz_H_ProCCTLV(phFriNfc_NdefMap_t  *NdefMap);
/*@}*/
void phFriNfc_TopazMap_H_Reset(phFriNfc_NdefMap_t        *NdefMap)
{
    /* Initialising the Topaz structure variable */
    NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_INVALID_OPE;
    NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
    NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
    NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_VAL0;
    (void)memset(NdefMap->TopazContainer.ReadBuffer, PH_FRINFC_TOPAZ_VAL0, 
                sizeof(NdefMap->TopazContainer.ReadBuffer));
    NdefMap->TopazContainer.ReadWriteCompleteFlag = PH_FRINFC_TOPAZ_FLAG0;
    NdefMap->TopazContainer.RemainingSize = PH_FRINFC_TOPAZ_VAL0;
    (void)memset(NdefMap->TopazContainer.UID, PH_FRINFC_TOPAZ_VAL0, 
                sizeof(NdefMap->TopazContainer.UID));
    NdefMap->TopazContainer.Cur_RW_Index=0;
    NdefMap->TopazContainer.ByteRWFrmCard =0;
}

/*!
* \brief Check whether a particular Remote Device is NDEF compliant.
*
* The function checks whether the peer device is NDEF compliant.
*
* \param[in] NdefMap Pointer to a valid instance of the \ref phFriNfc_NdefMap_t 
*                    structure describing the component context.
*
* \retval  NFCSTATUS_PENDING   The action has been successfully triggered.
* \retval  Others              An error has occurred.
*
*/

NFCSTATUS phFriNfc_TopazMap_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
        NFCSTATUS_INVALID_PARAMETER);
    if ( NdefMap != NULL)
    {
        /* Update the previous operation */
        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
        /* Update the CR index to know from which operation completion 
        routine has to be called */
        NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;
        NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
        NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;

/* Set card state */
        NdefMap->CardType = PH_FRINFC_NDEFMAP_TOPAZ_CARD;

/* Change the state to Check Ndef Compliant */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READID;
        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;

#ifdef TOPAZ_RAW_SUPPORT
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;  
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READID;        
#else        
#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_RID;   
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRid;
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        
        Result = phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
            NdefMap->TopazContainer.ByteNumber);
    }
    return Result;    
}

#ifdef FRINFC_READONLY_NDEF

NFCSTATUS 
phFriNfc_TopazMap_ConvertToReadOnly (
    phFriNfc_NdefMap_t          *NdefMap)
{
    NFCSTATUS               result = NFCSTATUS_SUCCESS;

result = phFriNfc_Tpz_H_WrAByte (NdefMap, CC_BLOCK_NUMBER, 
                                    CC_RWA_BYTE_NUMBER, CC_READ_ONLY_VALUE);

if (NFCSTATUS_PENDING == PHNFCSTATUS(result))
    {
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_CC_BYTE;
    }
    return result;
}

#endif /* #ifdef FRINFC_READONLY_NDEF */

/*!
* \brief Initiates Reading of NDEF information from the Remote Device.
*
* The function initiates the reading of NDEF information from a Remote Device.
* It performs a reset of the state and starts the action (state machine).
* A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
* has been triggered.
*/
NFCSTATUS phFriNfc_TopazMap_RdNdef( phFriNfc_NdefMap_t                  *NdefMap,
                                        uint8_t                         *PacketData,
                                        uint32_t                        *PacketDataLength,
                                        uint8_t                         Offset)
{
    NFCSTATUS               Result =    NFCSTATUS_SUCCESS;

/* Copy user buffer to the context */
    NdefMap->ApduBuffer = PacketData;
    /* Copy user length to the context */
    NdefMap->ApduBufferSize = *PacketDataLength;
    /* Update the user memory size to a context variable */
    NdefMap->NumOfBytesRead = PacketDataLength;
    /* Number of bytes read from the card is zero. 
    This variable returns the number of bytes read 
    from the card. */
    *NdefMap->NumOfBytesRead = PH_FRINFC_TOPAZ_VAL0;
    /* Index to know the length read */
    NdefMap->ApduBuffIndex = PH_FRINFC_TOPAZ_VAL0;    
    /* Store the offset in the context */
    NdefMap->Offset = Offset;
    /* Update the CR index to know from which operation completion 
    routine has to be called */
    NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;

if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == 
        PH_FRINFC_NDEFMAP_WRITE_OPE))
    {
        /* If previous operation is not read then the read shall 
        start from BEGIN */
        NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
        /* Initialise current block and byte number */
        NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
        NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
        /* State has to be changed */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
        NdefMap->TopazContainer.ReadWriteCompleteFlag = 
            PH_FRINFC_TOPAZ_FLAG0;
        /* Topaz command = READALL */
#ifdef TOPAZ_RAW_SUPPORT
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
#else

#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;        
#endif

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    }
    
    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
    /* Offset = Current, but the read has reached the End of Card */
    if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
        (NdefMap->TopazContainer.ReadWriteCompleteFlag == 
        PH_FRINFC_TOPAZ_FLAG1))
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 
    }
    else
    {
        /* if the offset is begin then call READALL else copy the data 
        from the user buffer */
        Result = ((Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
            phFriNfc_Tpz_H_RdBytes(NdefMap,
            NdefMap->TopazContainer.CurrentBlock,
            NdefMap->TopazContainer.ByteNumber):
        phFriNfc_Tpz_H_CpDataToUsrBuf(NdefMap));
    }

return Result;
}

/*!
* \brief Initiates Writing of NDEF information to the Remote Device.
*
* The function initiates the writing of NDEF information to a Remote Device.
* It performs a reset of the state and starts the action (state machine).
* A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
* has been triggered.
*/
NFCSTATUS phFriNfc_TopazMap_WrNdef( phFriNfc_NdefMap_t     *NdefMap,
                                   uint8_t                 *PacketData,
                                   uint32_t                *PacketDataLength,
                                   uint8_t                 Offset)
{
    NFCSTATUS                   Result =    NFCSTATUS_SUCCESS;
    uint8_t TempByteVal = 0;
    /* Copy user buffer to the context */
    NdefMap->ApduBuffer = PacketData;
    /* Copy user length to the context */
    NdefMap->ApduBufferSize = *PacketDataLength;
    /* Index to know the length written */
    NdefMap->ApduBuffIndex = PH_FRINFC_TOPAZ_VAL0;
    /* Update the user memory size to a context variable */
    NdefMap->WrNdefPacketLength = PacketDataLength;
    /* Number of bytes written to the card is zero. 
    This variable returns the number of bytes written 
    to the card. */
    *NdefMap->WrNdefPacketLength = PH_FRINFC_TOPAZ_VAL0;
    /* Update the CR index to know from which operation completion 
    routine has to be called */
    NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
    /* Store the offset in the context */
    NdefMap->Offset = Offset;

if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || 
        (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))
    {
        NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
        /* Initialise current block and byte number */
        NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
        NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
        /* State has to be changed */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
        /* Topaz command = READALL */

#ifdef TOPAZ_RAW_SUPPORT
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
#else
#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;
#endif
#endif  /* #ifdef TOPAZ_RAW_SUPPORT */      
        NdefMap->TopazContainer.ReadWriteCompleteFlag = 
            PH_FRINFC_TOPAZ_FLAG0;
        NdefMap->TopazContainer.RemainingSize = NdefMap->CardMemSize;        
        TempByteVal = NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1];
    }
    else
    {
        /* State has to be changed */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
        /* copy the user data to write into the card */
        TempByteVal = NdefMap->ApduBuffer[NdefMap->ApduBuffIndex];
    }

/* Update the previous operation to write operation */
    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
    if((Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
        (NdefMap->TopazContainer.ReadWriteCompleteFlag == 
        PH_FRINFC_TOPAZ_FLAG1))
    {
        /* Offset = Current, but the read has reached the End of Card */
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 
    }
    else
    {
        /* Check the block */
        phFriNfc_Tpz_H_BlkChk(NdefMap);
        /* if offset is begin then call READALL else start writing */
        Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
            phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
            NdefMap->TopazContainer.ByteNumber):
            phFriNfc_Tpz_H_WrAByte(NdefMap, NdefMap->TopazContainer.CurrentBlock,
            NdefMap->TopazContainer.ByteNumber,TempByteVal));
    }

return Result;
}

/*!
* \brief Completion Routine, Processing function, needed to avoid long blocking.
* \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion
*       Routine in order to be able to notify the component that an I/O has finished and data are
*       ready to be processed.
*
*/

void phFriNfc_TopazMap_Process( void       *Context,
                               NFCSTATUS   Status)
{

phFriNfc_NdefMap_t              *psNdefMap = NULL;

#ifdef TOPAZ_RF_ERROR_WORKAROUND

static uint8_t                  rf_error_state = 0;

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
#ifdef FRINFC_READONLY_NDEF
    static uint8_t                  written_lock_byte = 0;
#endif /* #ifdef FRINFC_READONLY_NDEF */

psNdefMap = (phFriNfc_NdefMap_t *)Context;

if ((Status & PHNFCSTBLOWER) == (NFCSTATUS_SUCCESS & PHNFCSTBLOWER))
    {
        switch (psNdefMap->State)
        {
#ifdef FRINFC_READONLY_NDEF
            case PH_FRINFC_TOPAZ_STATE_WR_CC_BYTE:
            {
                if((CC_READ_ONLY_VALUE == *psNdefMap->SendRecvBuf)  
                    && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
                {
                    written_lock_byte = 0;
#ifdef TOPAZ_RAW_SUPPORT
                    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;
#else
#ifdef PH_HAL4_ENABLE
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;
#else
                    psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;
#endif /* #ifdef PH_HAL4_ENABLE */
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                    Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, LOCK_BLOCK_NUMBER, 
                                                    LOCK0_BYTE_NUMBER);

if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
                    {
                        psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_LOCK0_BYTE;
                    }
                }
                else
                {
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                        NFCSTATUS_INVALID_RECEIVE_LENGTH);
                }
                break;
            }

case PH_FRINFC_TOPAZ_STATE_RD_LOCK0_BYTE:
            {
                if (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength)
                {
                    Status = phFriNfc_Tpz_H_WrAByte (psNdefMap, LOCK_BLOCK_NUMBER, 
                                                LOCK0_BYTE_NUMBER, 
                                                LOCK0_BYTE_VALUE);

if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
                    {
                        psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_LOCK0_BYTE;
                    }
                }
                break;
            }

case PH_FRINFC_TOPAZ_STATE_WR_LOCK0_BYTE:
            {
                if((LOCK0_BYTE_VALUE == *psNdefMap->SendRecvBuf)  
                    && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
                {
#ifdef TOPAZ_RAW_SUPPORT
                    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;
#else
#ifdef PH_HAL4_ENABLE
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;
#else
                    psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;
#endif /* #ifdef PH_HAL4_ENABLE */
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                    Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, LOCK_BLOCK_NUMBER, 
                                                    LOCK1_BYTE_NUMBER);

if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
                    {
                        psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_LOCK1_BYTE;
                    }
                }
                else
                {
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                        NFCSTATUS_INVALID_RECEIVE_LENGTH);
                }
            }

case PH_FRINFC_TOPAZ_STATE_RD_LOCK1_BYTE:
            {
                if (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength)
                {
                    written_lock_byte = (uint8_t)(*psNdefMap->SendRecvBuf | LOCK1_BYTE_VALUE);
                    Status = phFriNfc_Tpz_H_WrAByte (psNdefMap, LOCK_BLOCK_NUMBER, 
                                                LOCK1_BYTE_NUMBER, 
                                                written_lock_byte);

if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
                    {
                        psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_LOCK1_BYTE;
                    }
                }
                break;
            }

case PH_FRINFC_TOPAZ_STATE_WR_LOCK1_BYTE:
            {
                if((written_lock_byte == *psNdefMap->SendRecvBuf)  
                    && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
                {
                    written_lock_byte = 0;
                    /* Do nothing */
                }
                else
                {
                    written_lock_byte = 0;
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                        NFCSTATUS_INVALID_RECEIVE_LENGTH);
                }
            }
#endif /* #ifdef FRINFC_READONLY_NDEF */
            case PH_FRINFC_TOPAZ_STATE_WRITE:
            {
                Status = phFriNfc_Tpz_H_ProWrUsrData (psNdefMap);
                break;
            }

case PH_FRINFC_TOPAZ_STATE_READID:
            {
                Status = phFriNfc_Tpz_H_ProReadID (psNdefMap);
                break;
            }

case PH_FRINFC_TOPAZ_STATE_READALL:
            {
                Status = phFriNfc_Tpz_H_ProReadAll (psNdefMap);
                break;
            }

case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
            {
                Status = phFriNfc_Tpz_H_ProWrNMN (psNdefMap);
                break;
            }

case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
            {
                Status = phFriNfc_Tpz_H_ProWrTLV (psNdefMap);
                break;
            }

case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
            {
                Status = phFriNfc_Tpz_H_ProCCTLV (psNdefMap);
                break;
            }

#ifdef TOPAZ_RF_ERROR_WORKAROUND

case PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ:
            {
                Status = phFriNfc_Tpz_H_CheckWrittenData (psNdefMap, 
                                                        rf_error_state);
                break;
            }

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */

default:
            {
                Status = PHNFCSTVAL (CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_DEVICE_REQUEST);
                break;
            }
        }
    }
    else
    {
#ifdef TOPAZ_RF_ERROR_WORKAROUND

if ((FRINFC_RF_TIMEOUT_89 == PHNFCSTATUS (Status)) || 
            (FRINFC_RF_TIMEOUT_90 == PHNFCSTATUS (Status)) || 
            (NFCSTATUS_RF_TIMEOUT == PHNFCSTATUS (Status)))
        {
            uint8_t             byte_number = 0;
            uint8_t             block_number = 0;

rf_error_state = psNdefMap->State;

#ifdef TOPAZ_RAW_SUPPORT

*psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;

#else

#ifdef PH_HAL4_ENABLE

psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;

#else

psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;

#endif /* #ifdef PH_HAL4_ENABLE */

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

/* Update the state variable to the new work around state*/
            psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ;

/* Switch is used to know, if the error occured during WRITE or READ */
            switch (rf_error_state)
            {
                case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
                {                    
                    /* Block and byte number is updated for NMN */
                    byte_number = PH_FRINFC_TOPAZ_VAL0;
                    block_number = PH_FRINFC_TOPAZ_VAL1;
                    break;
                }

case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
                {
                    /* Get the L field of the TLV block */
                    block_number = (uint8_t)(((psNdefMap->TLVStruct.NdefTLVByte + 
                                        PH_FRINFC_TOPAZ_VAL1) > 
                                        PH_FRINFC_TOPAZ_VAL7)?
                                        (psNdefMap->TLVStruct.NdefTLVBlock + 
                                        PH_FRINFC_TOPAZ_VAL1):
                                        psNdefMap->TLVStruct.NdefTLVBlock);
                    /* Get the L byte */
                    byte_number = (uint8_t)((psNdefMap->TLVStruct.NdefTLVByte + 
                                        PH_FRINFC_TOPAZ_VAL1) % 
                                        PH_FRINFC_TOPAZ_VAL8);
                    break;
                }

case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
                {
                    switch (psNdefMap->TopazContainer.InternalState)
                    {
                        case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
                        {
                            /* Block and byte number is updated for the CC byte 0 */
                            block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
                            byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL0;
                            break;
                        }

case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
                        {
                            /* Block and byte number is updated for the CC byte 1 */
                            block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
                            byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
                            break;
                        }

case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
                        {
                            /* Block and byte number is updated for the CC byte 2 */
                            block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
                            byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL2;
                            break;
                        }

case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
                        {
                            /* Block and byte number is updated for the CC byte 3 */
                            block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
                            byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL3;
                            break;
                        }

case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
                        {
                            /* Block and byte number is updated for the Type field of the TLV */
                            block_number = psNdefMap->TLVStruct.NdefTLVBlock;
                            byte_number = (uint8_t)psNdefMap->TLVStruct.NdefTLVByte;
                            break;
                        }

default:
                        {
                            /* Do nothing */
                            break;
                        }
                    } /* switch (psNdefMap->TopazContainer.InternalState) */
                    break;
                }

case PH_FRINFC_TOPAZ_STATE_WRITE:                
                {
                    /* Block and byte number is updated for the written error data */                    
                    block_number = psNdefMap->TopazContainer.CurrentBlock;
                    byte_number = psNdefMap->TopazContainer.ByteNumber;                  
                    break;
                }

default:
                {
                    /* Error occured is not during WRITE, so update 
                        state variable to the previous state */
                    psNdefMap->State = rf_error_state;
                    break;
                }
            } /* switch (rf_error_state) */

/* The below check is added, to know if the error is for 
            the WRITE or READ scenario, 
            If the error is for READ, then state variable is not updated
            If the error is for WRITE, then state variable is updated with 
            PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ value */
            if (PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ == psNdefMap->State)
            {
                /* Read the data with the updated block and byte number */
                Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, block_number, 
                                                byte_number);
            }
        }

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
    }

/* Call Completion Routine, if Status != PENDING */
    if (NFCSTATUS_PENDING != Status)
    {
        phFriNfc_Tpz_H_Complete(psNdefMap, Status);
    }
}

#ifdef TOPAZ_RF_ERROR_WORKAROUND

static 
NFCSTATUS 
phFriNfc_Tpz_H_CheckWrittenData (
    phFriNfc_NdefMap_t          *psNdefMap,
    uint8_t                     state_rf_error)
{
    NFCSTATUS   result = NFCSTATUS_SUCCESS;

switch (state_rf_error)
    {
        case PH_FRINFC_TOPAZ_STATE_WRITE:
        {
            result = phFriNfc_Tpz_H_ProWrUsrData (psNdefMap);
            break;
        }

case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
        {
            result = phFriNfc_Tpz_H_ProWrNMN (psNdefMap);
            break;
        }

case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
        {
            result = phFriNfc_Tpz_H_ProWrTLV (psNdefMap);
            break;
        }

case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
        {
            result = phFriNfc_Tpz_H_ProCCTLV (psNdefMap);
            break;
        }

default:
        {
            break;
        }
    }

return result;
}

#endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */

static NFCSTATUS phFriNfc_Tpz_H_RdBytes(phFriNfc_NdefMap_t *NdefMap,
                                        uint16_t             BlockNo,
                                        uint16_t            ByteNo)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
#ifdef TOPAZ_RAW_SUPPORT
    uint8_t index = 0;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

/* set the data for additional data exchange*/
    NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
    NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
    NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;

NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazMap_Process;
    NdefMap->MapCompletionInfo.Context = NdefMap;

*NdefMap->SendRecvLength = NdefMap->TempReceiveLength;

/* Depending on the jewel command, the send length is decided */
#ifdef TOPAZ_RAW_SUPPORT
    switch(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0])
#else
    switch(NdefMap->Cmd.JewelCmd)
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    {

#ifdef TOPAZ_RAW_SUPPORT
    case PH_FRINFC_TOPAZ_CMD_READID:
#else
#ifdef PH_HAL4_ENABLE
    case phHal_eJewel_RID:
#else
    case phHal_eJewelCmdListJewelRid:
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

#ifdef TOPAZ_RAW_SUPPORT
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
        /*Copy command to  Send Buffer*/
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0]  = PH_FRINFC_TOPAZ_CMD_READID;
        index ++;

/*Copy UID of the tag to  Send Buffer*/
        (void)memset(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1]),
        0x00,(0x06));
        index = index + 0x06;

/* Update the length of the command buffer*/
        NdefMap->SendLength = index;
#else
        /* For READ ID and READ ALL, send length is 0 */
        NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        break;

#ifdef TOPAZ_RAW_SUPPORT
    case PH_FRINFC_TOPAZ_CMD_READALL:
#else
#ifdef PH_HAL4_ENABLE
    case phHal_eJewel_ReadAll:  
#else
    case phHal_eJewelCmdListJewelReadAll:
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

/*Copy 0x00 to Send Buffer*/
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 0x00;
        index ++;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 0x00;
        index ++;

/*Copy UID of the tag to  Send Buffer*/
        (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL3]),
        &(NdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid),
        TOPAZ_UID_LENGTH_FOR_READ_WRITE);

index = (uint8_t)(index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);

/* Update the length of the command buffer*/
        NdefMap->SendLength = index;
#else
       /* For READ ID and READ ALL, send length is 0 */
        NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        break;

#ifdef TOPAZ_RAW_SUPPORT
    case PH_FRINFC_TOPAZ_CMD_READ:
#else
#ifdef PH_HAL4_ENABLE
    case phHal_eJewel_Read1:
#else
    case phHal_eJewelCmdListJewelRead1:
#endif

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

/*Copy Address to  Send Buffer*/
        /* Calculate send length 
        7 | 6   5   4   3 | 2   1   0 | 
        |    block no   |  byte no  | 
        */
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 
                (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) + 
                ByteNo);
        index ++;
        /*Copy 0x00 to  Send Buffer*/
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 0x00;
        index ++;

/* Update the length of the command buffer*/
        NdefMap->SendLength = index;
#else
        /* Calculate send length 
        7 | 6   5   4   3 | 2   1   0 | 
        |    block no   |  byte no  | 
        */
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = 
                (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) + 
                ByteNo);
        NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL1;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        
        break;
#ifdef TOPAZ_RAW_SUPPORT
#else
#ifdef PH_HAL4_ENABLE
    case phHal_eJewel_Read:
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 104;
        NdefMap->SendLength = 3;
    break;
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

default:
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_INVALID_DEVICE_REQUEST);
    }

if(Result == NFCSTATUS_SUCCESS)
    {
        /* Call the Overlapped HAL Transceive function */ 
        Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,
                                                &NdefMap->MapCompletionInfo,
                                                NdefMap->psRemoteDevInfo,
                                                NdefMap->Cmd,
                                                &NdefMap->psDepAdditionalInfo,
                                                NdefMap->SendRecvBuf,
                                                NdefMap->SendLength,
                                                NdefMap->SendRecvBuf,
                                                NdefMap->SendRecvLength);
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_WrAByte(phFriNfc_NdefMap_t *NdefMap,
                                        uint16_t             BlockNo,
                                        uint16_t             ByteNo,
                                        uint8_t              ByteVal
                                        )
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint8_t     index = 0;

PHNFC_UNUSED_VARIABLE(ByteVal);
    /* set the data for additional data exchange*/
    NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
    NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
    NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;

NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazMap_Process;
    NdefMap->MapCompletionInfo.Context = NdefMap;

*NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
    /* Command used to write 1 byte */
#ifdef TOPAZ_RAW_SUPPORT
    NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
#else
#ifdef PH_HAL4_ENABLE
    NdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#else
    NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelWriteErase1;
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

#ifdef TOPAZ_RAW_SUPPORT
    /*Copy command to Send Buffer*/
    NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0]  = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
    index ++;

/*Copy Address to  Send Buffer*/
    /* Calculate send length 
    7 | 6   5   4   3 | 2   1   0 | 
    |    block no   |  byte no  | 
    */
    NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 
            (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) + 
            ByteNo);
    index ++;
    /*Copy Data byte to Send Buffer*/
    NdefMap->SendRecvBuf[index] = ByteVal;
    index ++;

/*Copy UID of the tag to  Send Buffer*/
    (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL3]),
      &(NdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid),
      TOPAZ_UID_LENGTH_FOR_READ_WRITE);
    index = (uint8_t)(index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);

/* Update the length of the command buffer*/
    NdefMap->SendLength = index;

#else
    /* Depending on the jewel command, the send length is decided */
    /* Calculate send length 
    7 | 6   5   4   3 | 2   1   0 | 
    |    block no   |  byte no  | 
    */
    NdefMap->SendRecvBuf[index] = 
                        (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) + 
                        ByteNo);
    index ++;
    NdefMap->SendRecvBuf[index] = ByteVal;
    index ++;
    NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL2;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

/* Call the Overlapped HAL Transceive function */ 
    Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,
                                            &NdefMap->MapCompletionInfo,
                                            NdefMap->psRemoteDevInfo,
                                            NdefMap->Cmd,
                                            &NdefMap->psDepAdditionalInfo,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendLength,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendRecvLength);

return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProReadID(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    
    if(((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] & 
        PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_HEADROM0_VAL) && 
        (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL6))
    {
        /* Copy UID to the context, Used when the READ ALL command is used */
        (void)memcpy(NdefMap->TopazContainer.UID, 
            &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
            PH_FRINFC_TOPAZ_VAL4);

/* State has to be changed */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
        /* Topaz command = READALL */
#ifdef TOPAZ_RAW_SUPPORT
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
        NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
#else 
#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;
#endif
#endif /* #ifdef TOPAZ_RAW_SUPPORT */ 
    
        /* Read all bytes from the card */
        Result = phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
            NdefMap->TopazContainer.ByteNumber);
    }

return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProReadAll(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    int32_t     memcompare = PH_FRINFC_TOPAZ_VAL0;
    
    /* Compare the UID of READ ALL command with the stored UID */
#ifdef PH_HAL4_ENABLE
    if ((NdefMap->TopazContainer.UID[0] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2]) &&
        (NdefMap->TopazContainer.UID[1] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 1]) &&
        (NdefMap->TopazContainer.UID[2] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 2]) &&
        (NdefMap->TopazContainer.UID[3] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 3]))
    {
        memcompare = PH_FRINFC_TOPAZ_VAL0;
    }
    else
    {
        memcompare = PH_FRINFC_TOPAZ_VAL1;
    }
#else
    memcompare = memcmp(NdefMap->TopazContainer.UID, 
        &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
        PH_FRINFC_TOPAZ_VAL4);  
#endif /* #ifdef PH_HAL4_ENABLE */

if(((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] & 
        PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_HEADROM0_VAL) && 
        (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_READALL_RESP) && 
        (memcompare == PH_FRINFC_TOPAZ_VAL0))
    {
        /* Copy 96 bytes from the read/write memory space */
        (void)memcpy(NdefMap->TopazContainer.ReadBuffer, 
            &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL10],
            PH_FRINFC_TOPAZ_TOTAL_RWBYTES);

/* Check the lock bits and set the card state */
        phFriNfc_Tpz_H_ChkLockBits(NdefMap);

Result = phFriNfc_Tpz_H_CallNxtOp(NdefMap);
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_CallNxtOp(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    /* Depending on the operation (check, read or write ndef), process the  
    read data */
    switch(NdefMap->PrevOperation)
    {
    case PH_FRINFC_NDEFMAP_CHECK_OPE:
        /* Check the capabilty container values, according 
        to the spec */
        Result = phFriNfc_Tpz_H_ChkCCinChkNdef(NdefMap);

if (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)
        {
            /* Check the spec version */
            Result = phFriNfc_Tpz_H_ChkSpcVer( NdefMap,
                NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL1]);
            /*  Check the CC header size: Only valid ones are
            0x0C for 96 bytes. */
            if ((Result == NFCSTATUS_SUCCESS) && 
                ( NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL2] <=  
                PH_FRINFC_TOPAZ_CC_BYTE2_MAX))
            {
                Result = phFriNfc_Tpz_H_findNDEFTLV(NdefMap);
                /* As there is possibility of either having or not having TLV in 
                Topaz, no need to send the Actual status to the context*/
                Result = NFCSTATUS_SUCCESS;
            }
        }
        else
        {
            Result = NFCSTATUS_SUCCESS;
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
            NdefMap->CardMemSize = 
            NdefMap->TopazContainer.RemainingSize = (uint16_t)
                        /* 
                        4 is decremented from the max size because of the 4 CC bytes
                        2 is decremented because of the NDEF TLV T and L byte 
                        to get the actual data size
                        */
                        (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4 - 
                        PH_FRINFC_TOPAZ_VAL2);
        }
        break;

case PH_FRINFC_NDEFMAP_READ_OPE:
        /* Check the capabilty container values, according 
        to the spec */
        Result = phFriNfc_Tpz_H_ChkCCBytes(NdefMap);

/* If success, find the ndef TLV */
        Result = ((Result != NFCSTATUS_SUCCESS)?
                (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                NFCSTATUS_INVALID_FORMAT)):
                phFriNfc_Tpz_H_findNDEFTLV(NdefMap));

if(Result == NFCSTATUS_SUCCESS)
        {
            NdefMap->TopazContainer.ByteNumber += PH_FRINFC_TOPAZ_VAL2;
            /* If success, copy the read bytes to the user buffer */
            Result = phFriNfc_Tpz_H_CpDataToUsrBuf(NdefMap);
        }
        break;

case PH_FRINFC_NDEFMAP_WRITE_OPE:
    default:
        if((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_WRITE) || 
            (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED))
        {
            /* Check the capabilty container values, according 
            to the spec */
            Result = phFriNfc_Tpz_H_ChkCCBytes(NdefMap);
            if(Result == NFCSTATUS_SUCCESS)
            {
                /* Find the NDEF TLV */
                Result = phFriNfc_Tpz_H_findNDEFTLV(NdefMap);
                
                /* Write the TLV */
                NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_T_OF_TLV;
            }
            else
            {
                NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_TOPAZ_VAL4;
                NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_TOPAZ_VAL1;
                NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL4;
                /* Write the TLV */
                NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE0;
            }
            /* Write CC bytes */ 
            Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
        }
        break;
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_NO_NDEF_SUPPORT);

if(NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL0] == 
        PH_FRINFC_TOPAZ_CC_BYTE0)
    {
        /* Check the spec version */
        Result = phFriNfc_Tpz_H_ChkSpcVer( NdefMap,
            NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL1]);
        /*  Check the CC header size: Only valid ones are
        0x0C for 96 bytes. */
        Result = ((( NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL2] >  
                    PH_FRINFC_TOPAZ_CC_BYTE2_MAX) || (Result != 
                    NFCSTATUS_SUCCESS))?
                    (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                    NFCSTATUS_EOF_NDEF_CONTAINER_REACHED)):
                    Result);

/* Get the read/write card memory size */
        NdefMap->TopazContainer.RemainingSize = 
                NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)?
                (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4):
                NdefMap->CardMemSize);

/* if the call is from write ndef then check for read write access */
        if(((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE) && 
            (NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] != 
            PH_FRINFC_TOPAZ_CC_BYTE3_RW) && (Result == NFCSTATUS_SUCCESS)))
        {
            Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_INVALID_FORMAT));
        }

/* if the call is from read ndef then check for read only or read write access */
        if(((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE) && 
            ((NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] != 
            PH_FRINFC_TOPAZ_CC_BYTE3_RW) && 
            (NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] != 
            PH_FRINFC_TOPAZ_CC_BYTE3_RO))&& (Result == NFCSTATUS_SUCCESS)))
        {
            Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_INVALID_FORMAT));
        }
    }
    return Result;
}

extern NFCSTATUS phFriNfc_Tpz_H_ChkSpcVer( phFriNfc_NdefMap_t  *NdefMap,
                                          uint8_t             VersionNo)
{
    NFCSTATUS Result = NFCSTATUS_SUCCESS;
    uint8_t TagVerNo = VersionNo;

/* To remove "warning (VS C4100) : unreferenced formal parameter" */
    PHNFC_UNUSED_VARIABLE(NdefMap);

if ( TagVerNo == 0 )
    {
        /*Return Status Error � Invalid Format�*/
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT);
    }
    else
    {
        /* calculate the major and minor version number of T3VerNo */
        if( (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM == 
            PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo ) )&&
            ( PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM >= 
            PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo))) ||
            (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM == 
            PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo ) )&&
            ( PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM < 
            PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo) )))
        {
            Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
        }
        else 
        {
            if (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM <
                PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo) ) ||
                ( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM > 
                PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo)))
            {
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT);
            }
        }
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_NO_NDEF_SUPPORT);
    uint8_t     index = PH_FRINFC_TOPAZ_VAL4;

/* If remaining size is less than 3 then, there cant be any 
    TLV present in the card */
    while((index < PH_FRINFC_TOPAZ_TOTAL_RWBYTES) && 
        (NdefMap->TopazContainer.RemainingSize >= PH_FRINFC_TOPAZ_VAL3))
    {
        switch(NdefMap->TopazContainer.ReadBuffer[index])
        {
        case PH_FRINFC_TOPAZ_NDEF_T:
            /* To get the length field of the TLV */
            index++;
            /* Type and length are not data bytes, so to know the exact
            remaining size in the card, the below operation is done */
            NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL2;
            /* Set the card state depending on the L value */
            Result = phFriNfc_MapTool_SetCardState(NdefMap, 
                (uint32_t)NdefMap->TopazContainer.ReadBuffer[index]);
            /* Check the TLV is correct */
            if((NdefMap->TopazContainer.ReadBuffer[index] > 
                NdefMap->TopazContainer.RemainingSize) || 
                ((NdefMap->TopazContainer.ReadBuffer[index] == 
                PH_FRINFC_TOPAZ_VAL0) && (NdefMap->PrevOperation == 
                PH_FRINFC_NDEFMAP_READ_OPE)) || (Result != NFCSTATUS_SUCCESS))
            {
                /* L field value cant be greater than the remaining size, so error */
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_NO_NDEF_SUPPORT);
                /* To break out of the loop */
                index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
            }
            else
            {
                /* So remaining size also changes, according to the position of NDEF TLV  */
                NdefMap->TLVStruct.BytesRemainLinTLV = 
                    NdefMap->TopazContainer.ReadBuffer[index];

/* Get the byte number */
                NdefMap->TLVStruct.NdefTLVByte = (uint16_t)((index - PH_FRINFC_TOPAZ_VAL1) % 
                                                    PH_FRINFC_TOPAZ_VAL8);
                /* Get the block number */
                NdefMap->TLVStruct.NdefTLVBlock = (uint8_t)(((index - PH_FRINFC_TOPAZ_VAL1) / 
                                                    PH_FRINFC_TOPAZ_VAL8) + 
                                                    PH_FRINFC_TOPAZ_VAL1);
                /* TLV found flag is set */
                NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_TOPAZ_FLAG1;
                /* To know the position of V field in the TLV */
                NdefMap->TopazContainer.ByteNumber = (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock - 1) * 8) +
                                                    NdefMap->TLVStruct.NdefTLVByte);
                /* To break out of the loop */
                index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
                Result = NFCSTATUS_SUCCESS;
            }
            break;

case PH_FRINFC_TOPAZ_NULL_T:
            /* Null TLV, Skip the TLV */
            NdefMap->TopazContainer.RemainingSize--;
            index++;
            break;

case PH_FRINFC_TOPAZ_TERM_T:
            /* No more TLV present in the card, so error */
            index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
            break;

default:
            /* Go till the length field of the TLV */
            index++;
            /* Type and length is not the data, so to know the exact
            remaining size in the card, the below operation is done */
            NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL2;
            if(NdefMap->TopazContainer.ReadBuffer[index] > 
                NdefMap->TopazContainer.RemainingSize)
            {
                /* L field value cant be greater than the remaining size, so error */
                index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_NO_NDEF_SUPPORT);
            }
            else
            {
                /* Remaining size of the free space available in the card changes, 
                according to the position of NDEF TLV */
                NdefMap->TopazContainer.RemainingSize = 
                    NdefMap->TopazContainer.RemainingSize -
                    NdefMap->TopazContainer.ReadBuffer[index];

/* Get the position of the next TLV */
                index = (uint8_t)(index + 
                    (NdefMap->TopazContainer.ReadBuffer[index] + 
                     PH_FRINFC_TOPAZ_VAL1));                
            }
            break;
        }
    }

/* If no Ndef TLV found and operation done is read */
    if((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_TOPAZ_FLAG0) && 
        (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    }
    if((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_TOPAZ_FLAG0) && 
        ((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE) ||
        (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_CHECK_OPE)))
    {
        NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_TOPAZ_VAL4; 
        NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_TOPAZ_VAL1;
        NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL4;
        NdefMap->TopazContainer.RemainingSize = PH_FRINFC_TOPAZ_TOTAL_RWBYTES1;
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_CpDataToUsrBuf(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    
    /* Check the the TLV size and the user size */
    if(NdefMap->ApduBufferSize >=
        NdefMap->TLVStruct.BytesRemainLinTLV)
    {
        /* Copy the read bytes to user buffer till the value (V) 
        of TLV ends */
        (void)memcpy(NdefMap->ApduBuffer,
            &(NdefMap->TopazContainer.ReadBuffer[ 
                NdefMap->TopazContainer.ByteNumber]),
                    NdefMap->TLVStruct.BytesRemainLinTLV);

/* Update the number of read bytes to the user */
                *(NdefMap->NumOfBytesRead) = 
                    NdefMap->TLVStruct.BytesRemainLinTLV;
                /* There is no byte to read */
                NdefMap->TopazContainer.ByteNumber = 
                                                    PH_FRINFC_TOPAZ_VAL0;
                /* No further read is possible */
                NdefMap->TopazContainer.ReadWriteCompleteFlag = 
                                                    PH_FRINFC_TOPAZ_FLAG1;
                /* Remaining size in the card can be greater than length field in 
                the TLV */
                NdefMap->TopazContainer.RemainingSize = 
                    NdefMap->TopazContainer.RemainingSize -
                                        NdefMap->TLVStruct.BytesRemainLinTLV;
                /* TLV has been completely read, no more bytes to read */
                NdefMap->TLVStruct.BytesRemainLinTLV = 
                                                    PH_FRINFC_TOPAZ_VAL0;
    }
    else
    {
        /* Copy read bytes till the user buffer size */
        (void)memcpy(NdefMap->ApduBuffer,
                    &(NdefMap->TopazContainer.ReadBuffer[ 
                    NdefMap->TopazContainer.ByteNumber]),
                    NdefMap->ApduBufferSize);

/* Update the number of read bytes to the user */
        *(NdefMap->NumOfBytesRead) = 
            NdefMap->ApduBufferSize;
        /* Get the next byte number to read */
        NdefMap->TopazContainer.ByteNumber = 
            (uint8_t)(NdefMap->TopazContainer.ByteNumber +
                      NdefMap->ApduBufferSize);
        /* Free space left in the card */
        NdefMap->TopazContainer.RemainingSize 
            = NdefMap->TopazContainer.RemainingSize 
                  - (uint16_t)NdefMap->ApduBufferSize;
        /* Bytes left in the TLV */
        NdefMap->TLVStruct.BytesRemainLinTLV = 
            NdefMap->TLVStruct.BytesRemainLinTLV -
                   (uint16_t)NdefMap->ApduBufferSize;
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProWrNMN(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    uint8_t     BlockNo = PH_FRINFC_TOPAZ_VAL0,
        ByteNo = PH_FRINFC_TOPAZ_VAL0;

if((NdefMap->TopazContainer.InternalState == 
        PH_FRINFC_TOPAZ_WR_NMN_0) && 
        (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
        PH_FRINFC_TOPAZ_VAL0) && 
        (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
    {
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV;
        /* Get the L field of the TLV block */
        BlockNo = (uint8_t)(((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_TOPAZ_VAL1) > 
                            PH_FRINFC_TOPAZ_VAL7)?
                            (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_TOPAZ_VAL1):
                            NdefMap->TLVStruct.NdefTLVBlock);
        /* Get the L byte */
        ByteNo = (uint8_t)((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_TOPAZ_VAL1) % 
                                PH_FRINFC_TOPAZ_VAL8);

/* Here the NMN is written 0, so internal state is used */
        NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_L_TLV_0;
        /* Write the length value = 0x00 , Write L field of TLV  = 0  inside this*/
        Result = phFriNfc_Tpz_H_WrAByte( NdefMap, BlockNo, ByteNo,
                                        PH_FRINFC_TOPAZ_VAL0);
    }
    else 
    {
        if((NdefMap->TopazContainer.InternalState == 
            PH_FRINFC_TOPAZ_WR_NMN_E1) && 
            (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_CC_BYTE0) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            /* Card state is initialised or invalid */ 
            NdefMap->CardState = (uint8_t)((NdefMap->CardState == 
                                    PH_NDEFMAP_CARD_STATE_INITIALIZED)?
                                    PH_NDEFMAP_CARD_STATE_READ_WRITE:
                                    NdefMap->CardState);
            /* update the length to the user */
            *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
            Result = NFCSTATUS_SUCCESS;
        }
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    if((NdefMap->TopazContainer.InternalState == 
        PH_FRINFC_TOPAZ_WR_L_TLV_0) && 
        (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
        PH_FRINFC_TOPAZ_VAL0) && 
        (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
    {
        /* state is writing user data to the card */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;      
       
        NdefMap->TopazContainer.ByteNumber++;
        /* Check the byte number */
        phFriNfc_Tpz_H_BlkChk(NdefMap);

/* Write data to the specified location */
        /* Write the data to the card from the user buffer */
        Result = phFriNfc_Tpz_H_WrAByte( NdefMap, 
                                        NdefMap->TopazContainer.CurrentBlock,
                                        NdefMap->TopazContainer.ByteNumber,
                                        NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]
                                        );
    }
    else 
    {
        if((NdefMap->TopazContainer.InternalState == 
            PH_FRINFC_TOPAZ_WR_L_TLV) && 
            (((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 
            (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            NdefMap->ApduBuffIndex)) || 
            ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 
            (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            (NdefMap->ApduBuffIndex + NdefMap->TLVStruct.BytesRemainLinTLV)))) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            /* Update the L value in the context */
            NdefMap->TLVStruct.BytesRemainLinTLV = 
                ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
                NdefMap->ApduBuffIndex:
            (NdefMap->TLVStruct.BytesRemainLinTLV + NdefMap->ApduBuffIndex));

/* Write 0xE1 in block number = 1 and byte number = 0 */
            Result = phFriNfc_Tpz_H_WrByte0ValE1(NdefMap);
        }
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProWrUsrData(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    /* send buffer should be equal to receive buffer */
    if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
        NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]) && 
        (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
    {
        /* Increment the index */
        NdefMap->ApduBuffIndex += PH_FRINFC_TOPAZ_VAL1;

/* Remaining space left in the card is less by one */
        NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL1;

/* Increment the byte number */
        NdefMap->TopazContainer.ByteNumber++;

/* Check the block number */
        phFriNfc_Tpz_H_BlkChk(NdefMap);

/* check for the user space or the card size */
        if((NdefMap->ApduBufferSize == NdefMap->ApduBuffIndex) || 
            (NdefMap->TopazContainer.RemainingSize == PH_FRINFC_TOPAZ_VAL0))
        {
            /* Set write complete, if the end of card is reached */
            NdefMap->TopazContainer.ReadWriteCompleteFlag = (uint8_t)
                ((NdefMap->TopazContainer.RemainingSize == PH_FRINFC_TOPAZ_VAL0)?
                PH_FRINFC_TOPAZ_FLAG1:PH_FRINFC_TOPAZ_FLAG0);

Result = phFriNfc_Tpz_H_WrLByte(NdefMap);
        }
        else
        {
            /* State is continued to be in write */
            NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;           
            
            /* Write the byte to the specified location , and Byte to write */
            Result = phFriNfc_Tpz_H_WrAByte(NdefMap, NdefMap->TopazContainer.CurrentBlock,
                                            NdefMap->TopazContainer.ByteNumber,
                                            NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]
                                            );
        }
    }
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_WrLByte(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint8_t     BlockNo = PH_FRINFC_TOPAZ_VAL0,
        ByteNo = PH_FRINFC_TOPAZ_VAL0;
    uint8_t TempByteVal = 0;
    BlockNo = (uint8_t)(((NdefMap->TLVStruct.NdefTLVByte + 
                            PH_FRINFC_TOPAZ_VAL1) > 
                            PH_FRINFC_TOPAZ_VAL7)?
                            (NdefMap->TLVStruct.NdefTLVBlock + 
                            PH_FRINFC_TOPAZ_VAL1):
    NdefMap->TLVStruct.NdefTLVBlock);

ByteNo = (uint8_t)((NdefMap->TLVStruct.NdefTLVByte + 
                        PH_FRINFC_TOPAZ_VAL1) % PH_FRINFC_TOPAZ_VAL8);
    /* Update L field */
    NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV;
    /* Internal state for write */
    NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_L_TLV;
    /* Update the length field depending on the offset */
    TempByteVal = (uint8_t)
                    ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
                    NdefMap->ApduBuffIndex:
                    (NdefMap->ApduBuffIndex + 
                    NdefMap->TLVStruct.BytesRemainLinTLV));
    /* Write the L field */
    Result = phFriNfc_Tpz_H_WrAByte(NdefMap, BlockNo, ByteNo,TempByteVal);
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_WrByte0ValE1(phFriNfc_NdefMap_t   *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;

/* Update L field */
    NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_NMN;
    /* Internal state for writing 0xE1 */
    NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_NMN_E1;
    /* Update the length field depending on the offset */                          
    /* Write the L field */
    Result = phFriNfc_Tpz_H_WrAByte(NdefMap, PH_FRINFC_TOPAZ_VAL1, 
                                    PH_FRINFC_TOPAZ_VAL0,PH_FRINFC_TOPAZ_CC_BYTE0);
    return Result;
}

static void phFriNfc_Tpz_H_Complete(phFriNfc_NdefMap_t  *NdefMap,
                                    NFCSTATUS           Status)
{
    /* set the state back to the Reset_Init state*/
    NdefMap->State =  PH_FRINFC_NDEFMAP_STATE_RESET_INIT;

/* set the completion routine*/
    NdefMap->CompletionRoutine[NdefMap->TopazContainer.CRIndex].
        CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);
}

static void phFriNfc_Tpz_H_BlkChk(phFriNfc_NdefMap_t  *NdefMap)
{
    NdefMap->TopazContainer.CurrentBlock = 
                    (uint8_t)((NdefMap->TopazContainer.ByteNumber > 
                    PH_FRINFC_TOPAZ_VAL7)?
                    (NdefMap->TopazContainer.CurrentBlock + 
                    PH_FRINFC_TOPAZ_VAL1):
                    NdefMap->TopazContainer.CurrentBlock);

NdefMap->TopazContainer.ByteNumber = (uint8_t)(NdefMap->TopazContainer.ByteNumber % 
                                        PH_FRINFC_TOPAZ_VAL8);
}

static NFCSTATUS phFriNfc_Tpz_H_ChkCCinChkNdef(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_NO_NDEF_SUPPORT);

if(NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL0] == 
        PH_FRINFC_TOPAZ_CC_BYTE0)
    {
        /* Check the most significant nibble of byte 3 (RWA) = 0 */
        Result = (((NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] & 
                    PH_FRINFC_TOPAZ_BYTE3_MSB)== PH_FRINFC_TOPAZ_VAL0)?
                    NFCSTATUS_SUCCESS:
                    Result);

/* Card size is initialised */ 
        NdefMap->CardMemSize = NdefMap->TopazContainer.RemainingSize = 
                            ((Result == NFCSTATUS_SUCCESS)?
                            (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4):
                            NdefMap->CardMemSize);
    }

if (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY)
    {
        NdefMap->CardState = (uint8_t)((Result == NFCSTATUS_SUCCESS)?
                            PH_NDEFMAP_CARD_STATE_INITIALIZED:
                            PH_NDEFMAP_CARD_STATE_INVALID);
    }

return Result;
}

static void phFriNfc_Tpz_H_ChkLockBits(phFriNfc_NdefMap_t  *NdefMap)
{
    /* Set the card state */
    NdefMap->CardState =  (uint8_t)
        (((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_0] == 
        PH_FRINFC_TOPAZ_LOCKBIT_BYTE114) && 
        ((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_1] == 
        PH_FRINFC_TOPAZ_LOCKBIT_BYTE115_1) ||
        (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_1] == 
        PH_FRINFC_TOPAZ_LOCKBIT_BYTE115_2)))?
        PH_NDEFMAP_CARD_STATE_READ_WRITE:
        PH_NDEFMAP_CARD_STATE_READ_ONLY);

/* Set the card state from CC bytes */
    if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_WRITE)
    {
        if (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_CC_BYTENO_3] == PH_FRINFC_TOPAZ_CC_READWRITE)
        {
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
        }
        else if (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_CC_BYTENO_3] == PH_FRINFC_TOPAZ_CC_READONLY)
        {
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
        }
        else 
        {
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
        }
    }
}

static NFCSTATUS phFriNfc_Tpz_H_WrCCorTLV(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint8_t     ByteNo = PH_FRINFC_TOPAZ_VAL0,
        BlockNo = PH_FRINFC_TOPAZ_VAL0;
    uint8_t TempByteVal = 0;
    switch(NdefMap->TopazContainer.InternalState)
    {
    case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
        /* To write the CC bytes */
        TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE0;
        ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL0;
        BlockNo = PH_FRINFC_TOPAZ_VAL1;
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
        /* To write the CC bytes */
        TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE1;
        ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
        BlockNo = PH_FRINFC_TOPAZ_VAL1;
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
        /* To write the CC bytes */
        TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE2_MAX;
        ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL2;
        BlockNo = PH_FRINFC_TOPAZ_VAL1;
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
        /* To write the CC bytes */
        TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE3_RW;
        ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL3;
        BlockNo = PH_FRINFC_TOPAZ_VAL1;
        break;

case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
    default:
        /* To write the NDEF TLV (if not present) */
        TempByteVal = PH_FRINFC_TOPAZ_NDEF_T;
        ByteNo = (uint8_t)NdefMap->TLVStruct.NdefTLVByte;
        BlockNo = NdefMap->TLVStruct.NdefTLVBlock;
        break;
    }
    NdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV;
    Result = phFriNfc_Tpz_H_WrAByte( NdefMap, BlockNo, ByteNo,TempByteVal);
    return Result;
}

static NFCSTATUS phFriNfc_Tpz_H_ProCCTLV(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
        NFCSTATUS_INVALID_RECEIVE_LENGTH);
    switch(NdefMap->TopazContainer.InternalState)
    {
    case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
        /* Process the CC byte */
        /* Check the response */
        if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_CC_BYTE0) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE1;
            Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
        }
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
        /* Process the CC byte */
        /* Check the response */
        if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_CC_BYTE1) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE2;
            Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
        }
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
        /* Process the CC byte */
        /* Check the response */
        if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_CC_BYTE2_MAX) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE3;
            Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
        }
        break;

case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
        /* Process the CC byte */
        /* Check the response */
        if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_CC_BYTE3_RW) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_T_OF_TLV;
            Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
        }
        break;

case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
    default:
        /* Check the response */
        if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] == 
            PH_FRINFC_TOPAZ_NDEF_T) && 
            (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
        {
            /* Increment the Byte Number */
            NdefMap->TopazContainer.ByteNumber++;
            /* Check the block and byte number */
            phFriNfc_Tpz_H_BlkChk(NdefMap);
            /* Process the T of NDEF TLV */
            NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_NMN;            
            
            /* Here the NMN is written 0, so internal state is used */
            NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_NMN_0;

/*Inside this call Write NMN (block number 1 and byte number 0) = 0 */
            Result = phFriNfc_Tpz_H_WrAByte( NdefMap, PH_FRINFC_TOPAZ_VAL1,
                PH_FRINFC_TOPAZ_VAL0,PH_FRINFC_TOPAZ_VAL0);
        }
        break;
    }
    return Result;
}

#ifdef UNIT_TEST
#include <phUnitTestNfc_Topaz_static.c>
#endif

#endif  /* PH_FRINFC_MAP_TOPAZ_DISABLED */

C++程序 | 2017行 | 74.22 KB

登录后可以享受更多权益