/*
 * 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_TopazDynamicMap.c
* \brief NFC Ndef Mapping For Remote Devices.
*
* Project: NFC-FRI
*
* $Date: Wed Oct 27 10:21:29 2010 $
* $Author: ing02260 $
* $Revision: 1.41 $
* $Aliases:  $
*
*/


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

#if !(defined(PH_FRINFC_MAP_TOPAZ_DISABLED ) || defined (PH_FRINFC_MAP_TOPAZ_DYNAMIC_DISABLED ))

/*! \ingroup grp_file_attributes
*  \name NDEF Mapping
*
* File: \ref phFriNfcNdefMap.c
*
*/
/*@{*/
#define PHFRINFCTOPAZMAP_FILEREVISION "$Revision: 1.41 $"
#define PHFRINFCTOPAZMAP_FILEALIASES  "$Aliases:  $"
/*@}*/
/*!
* \name Topaz Mapping - Helper data structures and macros
*
*/
/*@{*/

/********************************** Start of data structures *********************************/
#ifdef FRINFC_READONLY_NDEF

    #define DYN_CC_BLOCK_NUMBER                                     (0x01U)
    #define DYN_STATIC_LOCK_BLOCK_NUM                               (0x0EU)

    #define DYN_STATIC_LOCK0_BYTE_NUM                               (0x00U)
    #define DYN_STATIC_LOCK0_BYTE_VALUE                             (0xFFU)

    #define DYN_STATIC_LOCK1_BYTE_NUM                               (0x01U)
    #define DYN_STATIC_LOCK1_BYTE_VALUE                             (0x7FU)

    #define DYN_CC_RWA_BYTE_NUMBER                                  (0x03U)
    #define DYN_CC_READ_ONLY_VALUE                                  (0x0FU)

#endif /* #ifdef FRINFC_READONLY_NDEF */

/*!
* \brief \copydoc page_ovr enum for the topaz sequence of execution. 
*/
typedef enum phFriNfc_Tpz_ParseSeq
{
    LOCK_T_TLV, 
    LOCK_L_TLV, 
    LOCK_V_TLV,
    MEM_T_TLV, 
    MEM_L_TLV,
    MEM_V_TLV,
    NDEF_T_TLV, 
    NDEF_L_TLV, 
    NDEF_V_TLV
}phFriNfc_Tpz_ParseSeq_t;

typedef enum phFriNfc_Tpz_WrSeq
{
    WR_NDEF_T_TLV, 
    WR_NMN_0, 
    WR_LEN_1_0, 
    WR_LEN_2_0,
    WR_LEN_3_0,
    WR_DATA,
    WR_DATA_READ_REQD, 
    WR_LEN_1_VALUE, 
    WR_LEN_2_VALUE,
    WR_LEN_3_VALUE,     
    WR_NMN_E1
}phFriNfc_Tpz_WrSeq_t;

#ifdef FRINFC_READONLY_NDEF

typedef enum phFriNfc_Tpz_RO_Seq
{
    WR_READONLY_CC, 
    RD_LOCK_BYTES, 
    WR_LOCK_BYTES, 
    RD_STATIC_LOCK_BYTE0,
    WR_STATIC_LOCK_BYTE0,
    WR_STATIC_LOCK_BYTE1
}phFriNfc_Tpz_RO_Seq_t;

#endif /* #ifdef FRINFC_READONLY_NDEF  */

/********************************** End of data structures *********************************/

/********************************** Start of Macros *********************************/
/* New state for TOPAZ dynamic  card*/
#define PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF            (0x10U)

#ifdef FRINFC_READONLY_NDEF
    #define PH_FRINFC_TOPAZ_STATE_READ_ONLY             (0x11U)
#endif /* #ifdef FRINFC_READONLY_NDEF */

#define NIBBLE_SIZE                                     (0x04U)
/* Byte shifting for the topaz */
#define TOPAZ_BYTE_SHIFT                                (0x08U)
/* Lock and memory control TLV length. Always 3 bytes */
#define TOPAZ_MEM_LOCK_TLV_LENGTH                       (0x03U)
/* UID byte length */
#define TOPAZ_UID_BYTES_LENGTH                          (0x08U)

/* Number os static lock and reserved bytes */
#define TOPAZ_STATIC_LOCK_RES_BYTES                     (0x18U)
/* Number of static lock and reserved memory. This value is 3 (because 
    block number D, E and F are lock and reserved blocks */
#define TOPAZ_STATIC_LOCK_BLOCK_AREAS                   (0x03U)
/* First lock or reserved block in the static area of the card */
#define TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO                (0x0DU)
/* First lock or reserved byte number in the static area of the card */
#define TOPAZ_STATIC_LOCK_RES_START                     (0x68U)
/* End lock or reserved byte number in the static area of the card */
#define TOPAZ_STATIC_LOCK_RES_END                       (0x78U)

/* CC byte length */
#define TOPAZ_CC_BYTES_LENGTH                           (0x04U)

/* In TOPAZ card each block has 8 bytes */
#define TOPAZ_BYTES_PER_BLOCK                           (0x08U)
/* Each byte has 8 bites */
#define TOPAZ_BYTE_SIZE_IN_BITS                         (0x08U)

/* This mask is to get the least significant NIBBLE from a BYTE */
#define TOPAZ_NIBBLE_MASK                               (0x0FU)
/* This is used to mask the least significant BYTE from a TWO BYTE value */
#define TOPAZ_BYTE_LENGTH_MASK                          (0x00FFU)

/* Total segments in TOPAZ 512 bytes card. Each segment = 128 bytes, 
so there are 4 segements in the card */
#define TOPAZ_TOTAL_SEG_TO_READ                         (0x04U)
/* SPEC version value shall be 0x10 as per the TYPE 1 specification */
#define TOPAZ_SPEC_VERSION                              (0x10U)

/* Response length for READ SEGMENT command is 128 bytes */
#define TOPAZ_SEGMENT_READ_LENGTH                       (0x80U)
/* Response length for WRITE-1E command is 1 byte */
#define TOPAZ_WRITE_1_RESPONSE                          (0x01U)
/* Response length for WRITE-8E command is 8 bytes */
#define TOPAZ_WRITE_8_RESPONSE                          (0x08U)
/* Response length for READ-8 command is 8 bytes */
#define TOPAZ_READ_8_RESPONSE                           (0x08U)

/* Data bytes that can be written for the WRITE-8E command is 8 bytes */
#define TOPAZ_WRITE_8_DATA_LENGTH                       (0x08U)

/* Get the exact byte address of the card from the segment number 
    and the parse index of each segment */
#define TOPAZ_BYTE_ADR_FROM_SEG(seg, parse_index) \
    (((seg) * TOPAZ_SEGMENT_READ_LENGTH) + (parse_index))

/* Get the segment number of the card from the byte address */
#define TOPAZ_SEG_FROM_BYTE_ADR(byte_addr) \
    ((byte_addr) / TOPAZ_SEGMENT_READ_LENGTH)
/* Get the block number of the card from the byte address */ 
#define TOPAZ_BLK_FROM_BYTE_ADR(byte_addr) \
    ((byte_addr) / TOPAZ_BYTES_PER_BLOCK)
/* Get the block offset of a block number of the card from the byte address */ 
#define TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR(byte_addr) \
    ((byte_addr) % TOPAZ_BYTES_PER_BLOCK)
/* Get the exact byte address of the card from the block number 
    and the byte offset of the block number */
#define TOPAZ_BYTE_ADR_FROM_BLK(block_no, byte_offset) \
    (((block_no) * TOPAZ_BYTES_PER_BLOCK) + (byte_offset))
/* To increment the block number and if block number overlaps with the 
    static lock and reserved blocks, then skip the blocks */
#define TOPAZ_INCREMENT_SKIP_STATIC_BLOCK(block_no) \
    ((((block_no) + 1) == TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO) ? \
    (((block_no) + 1) + TOPAZ_STATIC_LOCK_BLOCK_AREAS) : \
    ((block_no) + 1))
/* Check topaz spec version number */
#define TOPAZ_COMPARE_VERSION(device_ver, tag_ver) \
    ((device_ver & 0xF0) >= (tag_ver & 0xF0))

#ifdef FRINFC_READONLY_NDEF

#define TOPAZ_CONVERT_BITS_TO_BYTES(bits_to_bytes) \
            (((bits_to_bytes % TOPAZ_BYTE_SIZE_IN_BITS) > 0) ? \
            ((bits_to_bytes / TOPAZ_BYTE_SIZE_IN_BITS) + 1) : \
            (bits_to_bytes / TOPAZ_BYTE_SIZE_IN_BITS))

#endif /* #ifdef FRINFC_READONLY_NDEF */
/********************************** End of Macros *********************************/

/*@}*/


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

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall read defined 
* bytes from the card.
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_NxpRead (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process 
* received read id command.
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_ChkReadID (
    phFriNfc_NdefMap_t          *psNdefMap);


/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function shall process 
* read response. 
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_ProReadResp (
    phFriNfc_NdefMap_t  *psNdefMap);

/*!
* \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 lock bits and set a card state
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_ChkLockBits (
    phFriNfc_NdefMap_t  *psNdefMap);

/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function writes defined 
* bytes into the card
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_NxpWrite (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_write_data, 
    uint8_t                     wr_data_len);


/*!
* \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
* till the NDEF TLV is found. Also, it returns error if it founds wrong TLVs.
*/
static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseTLVs (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 * till the TYPE of the LOCK control TLV is found. 
 * Also, it returns error if it founds wrong TYPE.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseLockTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 * till the TYPE of the MEMORY control TLV is found. 
 * Also, it returns error if it founds wrong TYPE.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseMemTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 * till the TYPE of the NDEF control TLV is found. 
 * Also, it returns error if it founds wrong TYPE.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseNdefTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gets the lock bytes 
 * information.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_GetLockBytesInfo (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_lock_info);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gets the reserved bytes 
 * information.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_GetMemBytesInfo (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_mem_info);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function copies and checks the CC bytes.  
 * This function checks for the lock bytes value and card state also.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_CheckCCBytes (
    phFriNfc_NdefMap_t          *psNdefMap);

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


/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function copies the read bytes.  
 * This function also checks for the lock and reserved bytes and skips the bytes before copying it 
 * in the buffer.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_CopyReadData (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function copies the stored read bytes.  
 * This function is used only for the offset " PH_FRINFC_NDEFMAP_SEEK_CUR ".
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_RemainingReadDataCopy (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gives the exact byte address
 * of the value field after the NDEF TYPE field
 */
static 
uint16_t 
phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gives the exact byte address
 * of the value field after the NDEF TYPE field
 */
static 
uint16_t 
phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint16_t                     size_to_write);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gives the number of bytes to skip.  
 * This function checks the input byte address and checks if any lock or reserved bytes matches with the 
 * given address. if yes, then it will return number od bytes to skip.
 */
static 
uint16_t
phFriNfc_Tpz_H_GetSkipSize (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint16_t                    byte_adr_card);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function gives the actual data that can 
 * be read and written in the card.  
 * This function checks for the lock and reserved bytes and subtracts the remaining size to give the 
 * actual size.
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ActualCardSize (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function processes the response for
 * the write data
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ProWrResp (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function processes the read 8 commands,  
 * that is required for writing the data
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_ProRdForWrResp (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function copies the user data to the 
 * write buffer and writes the data to the card. If the lock or memory blocks are in between the 
 * write data, then read the current block
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_CopySendWrData (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function compares the input block 
 * number with lock bytes block number and returns the p_skip_size which is the lock bytes 
 * size
 */
static 
uint16_t 
phFriNfc_Tpz_H_CompareLockBlocks (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     block_no, 
    uint16_t                    *p_skip_size);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function compares the input block 
 * number with reserved bytes block number and returns the p_skip_size which is the reserved bytes 
 * size
 */
static 
uint16_t 
phFriNfc_Tpz_H_CompareMemBlocks (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     block_no, 
    uint16_t                    *p_skip_size);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function copies the read data and update 
 * the user bytes by skipping lock or memory control areas. Also, used while updating the value field
 * skips the initial bytes and to start at the proper value field byte offset of the block
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_CopyReadDataAndWrite (
    phFriNfc_NdefMap_t          *psNdefMap);


/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function reads the required block for writing, 
 * as some of the bytes shall not be overwritten
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_RdForWrite (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function reads the length block for writing, 
 * updates the length bytes with 0
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function reads the length block for writing, 
 * updates the length bytes with exact bytes that was written in the card
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (
    phFriNfc_NdefMap_t          *psNdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Topaz. This function writes the NDEF TYPE of the 
 * NDEF TLV to the specific byte address. This function is called only if the previous write is  
 * failed or there is no NDEF TLV with correct CC bytes
 */
static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateNdefTypeField (
    phFriNfc_NdefMap_t          *psNdefMap);

#ifdef FRINFC_READONLY_NDEF

static
NFCSTATUS
phFriNfc_Tpz_H_ProcessReadOnly (
    phFriNfc_NdefMap_t          *psNdefMap);

static 
NFCSTATUS
phFriNfc_Tpz_H_UpdateAndWriteLockBits (
    phFriNfc_NdefMap_t          *psNdefMap);


#endif /* #ifdef FRINFC_READONLY_NDEF */


/*!
* \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_TopazDynamicMap_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.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;
        NdefMap->TopazContainer.CurrentSeg = 0;
        NdefMap->TopazContainer.NdefTLVByteAddress = 0;
        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;

        NdefMap->TopazContainer.CurrentBlock = 0;
        NdefMap->TopazContainer.WriteSeq = 0;
        NdefMap->TopazContainer.ExpectedSeq = 0;
        
        (void)memset ((void *)&(NdefMap->LockTlv), 0, 
                        sizeof (phFriNfc_LockCntrlTLVCont_t));

        (void)memset ((void *)&(NdefMap->MemTlv), 0, 
                    sizeof (phFriNfc_ResMemCntrlTLVCont_t));
        
        /* Set card state */
        NdefMap->CardType = PH_FRINFC_NDEFMAP_TOPAZ_DYNAMIC_CARD;

        /* Change the state to Read */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
        
        NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_DYNAMIC_INIT_CHK_NDEF;
#ifdef TOPAZ_RAW_SUPPORT

        *NdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;

#else 

#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;   
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

        Result = phFriNfc_Tpz_H_NxpRead(NdefMap);

      }
    return Result;    
}


/*!
* \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_TopazDynamicMap_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 = 0;
    /* 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;
    NdefMap->TopazContainer.SkipLockBlkFlag = 0;

    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
    if ((PH_FRINFC_NDEFMAP_SEEK_CUR == Offset) &&
        (TRUE == NdefMap->TopazContainer.ReadWriteCompleteFlag))
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 
    }
    else if ((PH_NDEFMAP_CARD_STATE_INITIALIZED == 
            NdefMap->CardState) || 
            (0 == NdefMap->TopazContainer.ActualNDEFMsgSize))
    {
        /* Length field of NDEF TLV is 0, so read cannot proceed */
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_READ_FAILED);
    }
    else if ((PH_FRINFC_NDEFMAP_SEEK_BEGIN == Offset) || 
        (PH_FRINFC_NDEFMAP_READ_OPE != NdefMap->PrevOperation))
    {
        /* If previous operation is not read then the read shall 
        start from BEGIN */
        NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
        /* Initialise byte number */
        NdefMap->TopazContainer.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;

        NdefMap->TopazContainer.RemainingReadSize = 0;
        NdefMap->TopazContainer.ReadBufferSize = 0;
        NdefMap->TopazContainer.ReadWriteCompleteFlag = FALSE;
        NdefMap->TopazContainer.CurrentBlock = 0;
        NdefMap->TopazContainer.WriteSeq = 0;

        NdefMap->TopazContainer.CurrentSeg = (uint8_t)TOPAZ_SEG_FROM_BYTE_ADR (
                        phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (NdefMap));
                
         /* Change the state to Read ID */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READID;
        /*Change the state to Read ID*/
        NdefMap->TopazContainer.ReadWriteCompleteFlag = 0;
#ifdef TOPAZ_RAW_SUPPORT

        NdefMap->SendRecvBuf[0] = 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_NxpRead(NdefMap);

    }
    else
    {
         /* Change the state to Read */
          NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
          Result = phFriNfc_Tpz_H_RemainingReadDataCopy (NdefMap);
    }

    
    return Result;
}

#ifdef FRINFC_READONLY_NDEF

NFCSTATUS
phFriNfc_TopazDynamicMap_ConvertToReadOnly (
    phFriNfc_NdefMap_t     *psNdefMap)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    uint8_t                     cc_read_only_byte = 0x0FU;

    psNdefMap->State = PH_FRINFC_TOPAZ_STATE_READ_ONLY;
    
    psNdefMap->TopazContainer.read_only_seq = 0;


    psNdefMap->TopazContainer.CurrentBlock = 0x01U;
    psNdefMap->TopazContainer.ByteNumber = 0x03U;
                    
#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else 
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

    result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &cc_read_only_byte, 
                                    1);
        
    if (NFCSTATUS_PENDING == result)
    {
        psNdefMap->TopazContainer.read_only_seq = (uint8_t)WR_READONLY_CC;
    }


    return result;
}

#endif /* #ifdef FRINFC_READONLY_NDEF */

/*!
* \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_TopazDynamicMap_WrNdef( 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;
    /* Index to know the length written */
    NdefMap->ApduBuffIndex = 0;
    /* 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 = 0;
    /* 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;

    /* Update the previous operation to write operation */
    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;

    if (PH_NDEFMAP_CARD_STATE_READ_ONLY == NdefMap->CardState)
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_WRITE_FAILED);
    }
    else if ((PH_FRINFC_NDEFMAP_SEEK_CUR == Offset) &&
        (TRUE == NdefMap->TopazContainer.ReadWriteCompleteFlag))
    {
        /* Offset = Current, but the read has reached the End of Card */
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 
    }
    else if (0 == NdefMap->TopazContainer.NdefTLVByteAddress)
    {
        /* No NDEF TLV found in the card, so write not possible */
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    else if ((PH_FRINFC_NDEFMAP_SEEK_BEGIN == Offset) || 
        (PH_FRINFC_NDEFMAP_WRITE_OPE != NdefMap->PrevOperation))
    {
        NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
        /* Initialise byte number */
        NdefMap->TopazContainer.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;
        /* State has to be changed */
        NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
        NdefMap->TopazContainer.ReadWriteCompleteFlag = FALSE;

        NdefMap->TopazContainer.CurrentSeg = 0;
        NdefMap->TopazContainer.CurrentBlock = 1;
        NdefMap->TopazContainer.WriteSeq = 0;

#ifdef TOPAZ_RAW_SUPPORT

        *NdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;

#else 

        /* Topaz command = Jewel Nxp Read */
#ifdef PH_HAL4_ENABLE
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
#else
        NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif  
        
        NdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        /* Call read segment */
        Result = phFriNfc_Tpz_H_NxpRead (NdefMap);
    }
    else
    {
#if 0
        /* This part is to handle the Current offset, 
        Current offset is not yet validated */
        Result = phFriNfc_Tpz_H_NxpWrite(NdefMap);
#endif /* #if 0 */
    } 
    
    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_TopazDynamicMap_Process( void       *Context,
                               NFCSTATUS   Status)
{

    phFriNfc_NdefMap_t      *NdefMap; 

    NdefMap = (phFriNfc_NdefMap_t *)Context;


    if((NFCSTATUS_SUCCESS & PHNFCSTBLOWER) == (Status & PHNFCSTBLOWER))
    {
        switch(NdefMap->State)
        {
            case PH_FRINFC_TOPAZ_STATE_READ:
            {
                Status = phFriNfc_Tpz_H_ProReadResp (NdefMap);
                break;
            }

            case PH_FRINFC_TOPAZ_STATE_WRITE:
            {
                Status =  phFriNfc_Tpz_H_ProWrResp (NdefMap);
                break;
            }

            case PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF:
            {
                Status =  phFriNfc_Tpz_H_ProRdForWrResp (NdefMap);
                break;
            }           

            case PH_FRINFC_TOPAZ_STATE_READID:
            {
                Status = phFriNfc_Tpz_H_ChkReadID(NdefMap);
                break;
            }

#ifdef FRINFC_READONLY_NDEF
            case PH_FRINFC_TOPAZ_STATE_READ_ONLY:
            {
                Status = phFriNfc_Tpz_H_ProcessReadOnly (NdefMap);
                break;
            }
#endif /* #ifdef FRINFC_READONLY_NDEF */
            
            default:
            {
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_DEVICE_REQUEST);
                break;
            }
        }
    }
    
    /* Call for the Completion Routine*/
    if(Status != NFCSTATUS_PENDING)
    {
        phFriNfc_Tpz_H_Complete(NdefMap, Status);
    }
}

#ifdef FRINFC_READONLY_NDEF

static 
NFCSTATUS
phFriNfc_Tpz_H_UpdateAndWriteLockBits (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t            *ps_tpz_info = NULL;
    phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
    uint8_t                         remaining_lock_bits = 0;
    uint8_t                         byte_index = 0;
    uint8_t                         lock_bytes_value[TOPAZ_BYTES_PER_BLOCK] = {0};
    uint8_t                         lock_byte_index = 0;
    uint8_t                         no_of_bits_left_in_block = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    ps_locktlv_info = &(psNdefMap->LockTlv);

    (void)memcpy ((void *)lock_bytes_value, (void *)psNdefMap->SendRecvBuf, 
                    TOPAZ_BYTES_PER_BLOCK);

    if (ps_tpz_info->CurrentBlock == ps_locktlv_info->BlkNum)
    {
        /* Get the lock bits that has to locked */
        remaining_lock_bits = ps_locktlv_info->LockTlvBuff[1];
        byte_index = (uint8_t)ps_locktlv_info->ByteNum;
    }
    else
    {
        /* This condition applies only for the lock bits not ending with 
        " ps_locktlv_info->BlkNum ".
        Calculate the remaining lock bits */
        remaining_lock_bits = (uint8_t)(ps_locktlv_info->LockTlvBuff[1] - 
                    ps_tpz_info->lock_bytes_written);
    }

    no_of_bits_left_in_block = (uint8_t)((TOPAZ_BYTES_PER_BLOCK - byte_index) * 
                                TOPAZ_BYTE_SIZE_IN_BITS);

    if (no_of_bits_left_in_block >= remaining_lock_bits)
    {
        /* Entire lock bits can be written */
        uint8_t                 mod_value = 0;

        mod_value = (uint8_t)(remaining_lock_bits % TOPAZ_BYTES_PER_BLOCK);

        if (mod_value)
        {
            /* The lock bits ends in between of a byte */
            /* lock bits to write is greater than 8 bits */
            if (mod_value > TOPAZ_BYTE_SIZE_IN_BITS)
            {
                while (lock_byte_index < 
                    (TOPAZ_CONVERT_BITS_TO_BYTES(remaining_lock_bits) - 1))
                {
                    /* Set 1b to all bits left in the block */
                    lock_bytes_value[byte_index] = 0xFF;
                    lock_byte_index = (uint8_t)(lock_byte_index + 1);
                    byte_index = (uint8_t)(byte_index + 1);
                }
                /* Last byte of the lock bits shall be filled partially,
                    Set only the remaining lock bits and dont change 
                    the other bit value */
                lock_bytes_value[byte_index] = 0;
                lock_bytes_value[byte_index] = (uint8_t)
                        SET_BITS8 (lock_bytes_value[byte_index], 0, 
                                    mod_value, 1);
            }
            else
            {
                /* lock bits to write is less than 8 bits, so 
                    there is only one byte to write.
                    Set only the remaining lock bits and dont change 
                    the other bit value */
                lock_bytes_value[0] = (uint8_t)
                        SET_BITS8 (lock_bytes_value[0], 0, 
                                    mod_value, 1);
            }            
        } /* if (mod_value) */
        else
        {
            /* The lock bits exactly ends at a byte 
            MOD operation is 00, that means entire byte value shall be 0xFF, means
            every bit shall be to 1 */

            while (lock_byte_index < TOPAZ_CONVERT_BITS_TO_BYTES(remaining_lock_bits))
            {
                /* Set 1b to all bits left in the block */
                lock_bytes_value[byte_index] = 0xFF;
                lock_byte_index = (uint8_t)(lock_byte_index + 1);
                byte_index = (uint8_t)(byte_index + 1);
            }
        } /* else of if (mod_value) */
        ps_tpz_info->lock_bytes_written = remaining_lock_bits;
    }
    else /* if (no_of_bits_left_in_block >= remaining_lock_bits) */
    {
        /* Partial lock bits can be written. use next read to write 
            the remaining lock bits  */
        while (lock_byte_index <  (no_of_bits_left_in_block / 
                            TOPAZ_BYTES_PER_BLOCK))
        {
            /* Set 1b to all bits left in the block */
            lock_bytes_value[byte_index] = 0xFF;
            lock_byte_index = (uint8_t)(lock_byte_index + 1);
            byte_index = (uint8_t)(byte_index + 1);
        }
        ps_tpz_info->lock_bytes_written = (uint8_t)(no_of_bits_left_in_block / 
                            TOPAZ_BYTES_PER_BLOCK);
    } /* else of if (no_of_bits_left_in_block >= remaining_lock_bits) */

#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

    result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, lock_bytes_value, 
                                    sizeof (lock_bytes_value));
    return result;
}

static
NFCSTATUS
phFriNfc_Tpz_H_ProcessReadOnly (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_Tpz_RO_Seq_t               e_readonly_seq = RD_LOCK_BYTES;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;
    static uint8_t                      static_lock_bytes[2] = {0};

    ps_tpz_info = &(psNdefMap->TopazContainer);
    ps_locktlv_info = &(psNdefMap->LockTlv);
    e_readonly_seq = (phFriNfc_Tpz_RO_Seq_t)psNdefMap->TopazContainer.read_only_seq;

    switch (e_readonly_seq)
    {
        case WR_READONLY_CC:
        {
            if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
            {
                psNdefMap->TopazContainer.CurrentBlock = (uint8_t)
                                psNdefMap->LockTlv.BlkNum;

                e_readonly_seq = RD_LOCK_BYTES;
#ifdef TOPAZ_RAW_SUPPORT

                *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;

#else 

        /* Topaz command = Jewel Nxp Read */
#ifdef PH_HAL4_ENABLE
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif  
        
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                /* Call read segment */
                result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case RD_LOCK_BYTES:
        {
            if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
            { 
                result = phFriNfc_Tpz_H_UpdateAndWriteLockBits (psNdefMap);

                if (NFCSTATUS_PENDING == result)
                {
                    e_readonly_seq = WR_LOCK_BYTES;
                }
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case WR_LOCK_BYTES:
        {
            if (TOPAZ_WRITE_8_RESPONSE == *psNdefMap->SendRecvLength)
            {
                ps_tpz_info->CurrentBlock = (uint8_t)
                                        (ps_tpz_info->CurrentBlock + 1); 
                if (ps_locktlv_info->LockTlvBuff[1] - 
                    ps_tpz_info->lock_bytes_written)
                {                    
#ifdef TOPAZ_RAW_SUPPORT

                    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;

#else 

                    /* Topaz command = Jewel Nxp Read */
#ifdef PH_HAL4_ENABLE
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
#else
                    psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif  
        
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                    /* Call read segment */
                    result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
                    e_readonly_seq = RD_LOCK_BYTES;
                }
                else
                {
                    ps_tpz_info->CurrentBlock = (uint8_t)
                                        DYN_STATIC_LOCK_BLOCK_NUM;
                    ps_tpz_info->ByteNumber = (uint8_t)
                                        DYN_STATIC_LOCK0_BYTE_NUM;
#ifdef TOPAZ_RAW_SUPPORT

                    *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_READ8;

#else 

                    /* Topaz command = Jewel Nxp Read */
#ifdef PH_HAL4_ENABLE
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
#else
                    psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif  
        
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                    /* Call read segment */
                    result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
                    e_readonly_seq = RD_STATIC_LOCK_BYTE0;

                }                
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }
        
        case RD_STATIC_LOCK_BYTE0:
        {
            if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
            {
                uint8_t                 lock_byte_value = 0;

                (void)memcpy ((void *)static_lock_bytes, 
                            (void *)(psNdefMap->SendRecvBuf + 
                                ps_tpz_info->ByteNumber), 
                            sizeof (static_lock_bytes));


                lock_byte_value = (uint8_t)(static_lock_bytes[0] | 
                                    DYN_STATIC_LOCK0_BYTE_VALUE);
                    
#ifdef TOPAZ_RAW_SUPPORT
                    *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

                result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &lock_byte_value, 
                                                    1);

                    if (NFCSTATUS_PENDING == result)
                    {
                    e_readonly_seq = (uint8_t)WR_STATIC_LOCK_BYTE0;
                    }
                }                
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }        

        case WR_STATIC_LOCK_BYTE0:
        {
            if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
            {
                uint8_t                 lock_byte_value = 
                                        (static_lock_bytes[1] | 
                                        DYN_STATIC_LOCK1_BYTE_VALUE);

                ps_tpz_info->CurrentBlock = (uint8_t)
                                    DYN_STATIC_LOCK_BLOCK_NUM;
                ps_tpz_info->ByteNumber = (uint8_t)
                                    DYN_STATIC_LOCK1_BYTE_NUM;
#ifdef TOPAZ_RAW_SUPPORT
                *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

                result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &lock_byte_value, 
                                                    1);

                if (NFCSTATUS_PENDING == result)
                {
                    e_readonly_seq = (uint8_t)WR_STATIC_LOCK_BYTE1;
                }
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case WR_STATIC_LOCK_BYTE1:
        {
            if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
            {
                /* READ ONLY successful */
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        default:
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            break;
        }
    }

    psNdefMap->TopazContainer.read_only_seq = (uint8_t)e_readonly_seq;
    return result;
}

#endif /* #ifdef FRINFC_READONLY_NDEF */

static 
NFCSTATUS 
phFriNfc_Tpz_H_ProWrResp (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    phFriNfc_Tpz_WrSeq_t                write_seq;
    uint8_t                             write_buf[] = {0x00};
    uint8_t                             write_index = 0;
    uint16_t                            write_len = 0;
    uint16_t                            len_byte_addr = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    write_seq = (phFriNfc_Tpz_WrSeq_t)(ps_tpz_info->WriteSeq);
    write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ? 
                psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);

    switch (write_seq)
    {
        case WR_NDEF_T_TLV:
        {
            /* TYPE field of the NDEF TLV write is complete */
            if (TOPAZ_WRITE_8_RESPONSE == *psNdefMap->SendRecvLength)
            {
                psNdefMap->State = (uint8_t)
                                    PH_FRINFC_TOPAZ_STATE_WRITE;

                /* Now, Write 0 to the magic number byte */
                ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_0;
                write_seq = WR_NMN_0;
                ps_tpz_info->CurrentBlock = 1;
                ps_tpz_info->ByteNumber = 0;
                        
#ifdef TOPAZ_RAW_SUPPORT
                *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf, 
                                                sizeof (write_buf));
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case WR_NMN_0:
        {
            /* Magic number set to 0 write is complete */
            if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
            {
                ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
                write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
                /* Now the sequence = WR_LEN_1_0, so Length block is read, 
                    and only length bytes are made 0, before writing data to 0 
                */
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case WR_LEN_1_0:
        {
            /* Length field is updated with the value 0 */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else if (write_len >= 0xFF)
            {
                ps_tpz_info->ByteNumber = 0;
                
                ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
                                    ps_tpz_info->CurrentBlock);                

                ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
                write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
                /* Now the sequence = WR_LEN_1_1, so Length block is read, 
                    and only length bytes are made 0, before writing data to 0 
                */
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            else
            {
                /* NDEF data length < 0xFF */
                len_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite 
                                                (psNdefMap, write_len);
                ps_tpz_info->CurrentBlock = (uint8_t)
                        TOPAZ_BLK_FROM_BYTE_ADR (len_byte_addr);
                ps_tpz_info->ByteNumber = (uint8_t)
                        TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (len_byte_addr);

                
                ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
                write_seq = WR_DATA;

                if (0 != ps_tpz_info->ByteNumber)
                {
                    /* If data starts in between the block then read 
                        the data */
                    result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
                }
                else
                {
                    /* Data starts at the beginning of the block, so start 
                        writing the user data */
                    result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
                }
            }
            break;
        }

        case WR_LEN_2_0:
        case WR_LEN_2_VALUE:
        {
            /* 2nd length field is updated with the value 0 or the correct 
                written value */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else
            {
                ps_tpz_info->ByteNumber = 0;
                ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
                                    ps_tpz_info->CurrentBlock);
                ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
                write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
                /* If length byte starts in between the block then read 
                    the length block */
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            break;
        }

        case WR_LEN_3_0:
        {
            /* 3rd length field is updated with the value 0 */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else
            {
                len_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite 
                                                (psNdefMap, write_len);
                ps_tpz_info->CurrentBlock = (uint8_t)
                        TOPAZ_BLK_FROM_BYTE_ADR (len_byte_addr);
                ps_tpz_info->ByteNumber = (uint8_t)
                        TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (len_byte_addr);

                ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
                write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);

                if (0 != ps_tpz_info->ByteNumber)
                {
                    /* If data starts in between the block then read 
                        the data */
                    result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
                }
                else
                {
                    /* Data starts at the beginning of the block, so start 
                        writing the user data */
                    result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
                }
            }
            break;
        }

        case WR_DATA:
        {
            /* Data is written from the input buffer */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else if (write_len == psNdefMap->ApduBuffIndex)
            {
                /* Data to be written is completely written to the card */
                *psNdefMap->WrNdefPacketLength = psNdefMap->ApduBuffIndex;
                ps_tpz_info->WriteSeq = (uint8_t)WR_LEN_1_VALUE;
                write_seq = WR_LEN_1_VALUE;
                /* To write the first length byte, it has to be read and then 
                    the length has to be updated */
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            else
            {
                ps_tpz_info->ByteNumber = 0;
                /* Go to the next block */
                ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
                                    ps_tpz_info->CurrentBlock);
                /* Copy and write the user data */
                result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
            }
            break;
        }

        case WR_DATA_READ_REQD: 
        {
            /* This sequence is executed, if the first read has some 
                lock or reserved blocks bytes and the lock or reserved 
                blocks are extended to the next block  */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else
            {
                ps_tpz_info->ByteNumber = 0;
                /* Go to the next block */
                ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
                                    ps_tpz_info->CurrentBlock);
                /* Write is complete for one block, now because lock bytes are 
                    shifted to next blocks, the next block is read and update 
                    the written data by skipping the lock or reserved memory bytes */
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            break;
        }

        case WR_LEN_3_VALUE:
        {
            /* 3rd LENGTH field byte is updated with correct written value */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else
            {
#ifdef TOPAZ_RAW_SUPPORT
                *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

                psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;

                write_buf[write_index] = PH_FRINFC_TOPAZ_CC_BYTE0;
                write_index = (uint8_t)(write_index + 1);

                ps_tpz_info->ByteNumber = 0;
                ps_tpz_info->CurrentBlock = 1;

                ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_E1;
                write_seq = WR_NMN_E1;

                /* Length byte write is complete, so now update the magic 
                    number byte with value 0xE1 */
                result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf, 
                                                write_index);
            }
            break;
        }

        case WR_LEN_1_VALUE:
        {
            /* 1st LENGTH field byte is updated */
            if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            else if (write_len < 0xFF)
            {
                /* Total length to write is less than 0xFF, so LENGTH field has 
                    only one byte, then update the magic number byte with 
                    value 0xE1 */
#ifdef TOPAZ_RAW_SUPPORT
                *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;

                write_buf[write_index] = PH_FRINFC_TOPAZ_CC_BYTE0;
                write_index = (uint8_t)(write_index + 1);

                ps_tpz_info->ByteNumber = 0;
                ps_tpz_info->CurrentBlock = 1;

                ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_E1;
                write_seq = WR_NMN_E1;
                result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf, 
                                                write_index);
            }
            else
            {
                /* 2nd byte of the LENGTH field has to be updated so, 
                    read the block, before updating it */
                ps_tpz_info->ByteNumber = 0;
                ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
                                    ps_tpz_info->CurrentBlock);
                ps_tpz_info->WriteSeq = (uint8_t)WR_LEN_2_VALUE;
                write_seq = WR_LEN_2_VALUE;
                result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
            }
            break;
        }

        case WR_NMN_E1:
        {
            /* Magic number is written, so update the actual ndef length.  */
            if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
            {
                *psNdefMap->WrNdefPacketLength = (uint32_t)
                                                psNdefMap->ApduBuffIndex;
                ps_tpz_info->ActualNDEFMsgSize = (uint16_t)
                                                psNdefMap->ApduBuffIndex;
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        default:
        {
            break;
        }
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateNdefTypeField (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];

    ps_tpz_info = &(psNdefMap->TopazContainer);

    (void)memcpy ((void *)write_buf, (void *)
                psNdefMap->SendRecvBuf, TOPAZ_WRITE_8_DATA_LENGTH);

    /* Update the TYPE field of the NDEF TLV */
    write_buf[ps_tpz_info->ByteNumber] = PH_FRINFC_TOPAZ_NDEF_T;

    psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;

#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf, 
                                    sizeof (write_buf));

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_ProRdForWrResp (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    /* This function is used during the write operation */
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;    

    ps_tpz_info = &(psNdefMap->TopazContainer);    

    psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;

    if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
    {        
        switch ((phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq)
        {
            case WR_NDEF_T_TLV:
            {
                /* Read bytes are for updating the TYPE field of the NDEF TLV */
                result = phFriNfc_Tpz_H_UpdateNdefTypeField (psNdefMap);
                break;
            }

            case WR_LEN_1_0:
            case WR_LEN_2_0:
            case WR_LEN_3_0:
            {
                /* Read bytes are for updating the LENGTH field to 0 of the NDEF TLV and 
                also to update the data from the user buffer */
                result = phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (psNdefMap);
                break;
            }

            case WR_DATA:
            case WR_DATA_READ_REQD:
            {
                /* Read bytes are for skipping the lock and reserved bytes */
                result = phFriNfc_Tpz_H_CopyReadDataAndWrite (psNdefMap);
                break;
            }

            case WR_LEN_1_VALUE:
            case WR_LEN_2_VALUE:
            case WR_LEN_3_VALUE:
            {
                /* Read bytes are for updating the LENGTH field to the correct values 
                    of the NDEF TLV */
                result = phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (psNdefMap);
                break;
            }

            default:
            {
                /* Code must not come come here */
                break;
            }
        }
    }
    else
    {
        /* Error in the length, wither the HW has sent wrong response length or 
            the response length byte is corrupted */
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
    }

    
    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_ChkReadID(
    phFriNfc_NdefMap_t      *psNdefMap)
{
    NFCSTATUS   result = NFCSTATUS_SUCCESS;
    int         compare_result = 0;
    uint8_t     recv_index = 0;
    
    
    if (PH_FRINFC_TOPAZ_VAL6 == *psNdefMap->SendRecvLength)
    {
        if (((psNdefMap->SendRecvBuf[recv_index] & 
            PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_DYNAMIC_HEADROM0_VAL))
        {
            /* Copy UID to the context*/
            compare_result = phOsalNfc_MemCompare (
                                psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid, 
                                &psNdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
                                TOPAZ_UID_LENGTH_FOR_READ_WRITE);
            if (0 == compare_result)
            {
                /* State has to be changed */
                psNdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;

                /* Topaz command = READSEG */
#ifdef TOPAZ_RAW_SUPPORT

                *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;

#else

#ifdef PH_HAL4_ENABLE
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
#else
                psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
#endif
                psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
                /* Read bytes from the card */
                result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_NO_NDEF_SUPPORT);

            }
        }
    }
    else
    {
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
    }

    return result;
}

#define TOPAZ_READ_ID_ZERO_LENGTH                   (0x06U)
static 
NFCSTATUS 
phFriNfc_Tpz_H_NxpRead (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS           result = NFCSTATUS_SUCCESS;
    uint8_t             send_index = 0;
#ifdef TOPAZ_RAW_SUPPORT
    uint8_t             read_append[] = { 0x00, 0x00, 0x00, 0x00, 
                                        0x00, 0x00, 0x00, 0x00};
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

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

    psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazDynamicMap_Process;
    psNdefMap->MapCompletionInfo.Context = psNdefMap;

    *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength;

    /* Depending on the jewel command, the send length is decided */
#ifdef TOPAZ_RAW_SUPPORT

    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
    /* " send_index " is incremented because already received buffer is filled with 
        TOPAZ command */
    send_index = (uint8_t)(send_index + 1);

    switch (*psNdefMap->SendRecvBuf)
#else
    switch(psNdefMap->Cmd.JewelCmd)
#endif /* #ifdef TOPAZ_RAW_SUPPORT */    
    {
#ifdef TOPAZ_RAW_SUPPORT

        case PH_FRINFC_TOPAZ_CMD_READID:
        {
            (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 
                        (void *)read_append, TOPAZ_READ_ID_ZERO_LENGTH);
            send_index = (uint8_t)(send_index + TOPAZ_READ_ID_ZERO_LENGTH);
            break;
        }

        case PH_FRINFC_TOPAZ_CMD_READ8:
        {
            psNdefMap->SendRecvBuf[send_index] = 
                                    psNdefMap->TopazContainer.CurrentBlock;
            send_index = (uint8_t)(send_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_CMD_RSEG:
        {
            psNdefMap->SendRecvBuf[send_index] = (uint8_t)
                                            (psNdefMap->TopazContainer.CurrentSeg
                                             << NIBBLE_SIZE);
            send_index = (uint8_t)(send_index + 1);
            break;
        }

#else /* #ifdef TOPAZ_RAW_SUPPORT */

#ifdef PH_HAL4_ENABLE
        case phHal_eJewel_RID:
        case phHal_eJewel_ReadAll:  
#else
        case phHal_eJewelCmdListJewelRid:
        case phHal_eJewelCmdListJewelReadAll:
#endif
        {
            /* For READ ID and READ ALL, send length is 0 */
            psNdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
            break;
        }

#ifdef PH_HAL4_ENABLE
        case phHal_eJewel_Read:
#else
        case phHal_eJewelCmdListJewelRead:
#endif
        {
            /* Need to check the User data size request*/

            psNdefMap->SendLength = PH_FRINFC_TOPAZ_VAL3;
            break;
        }

        case phHal_eJewel_ReadSeg:
        {
            psNdefMap->SendRecvBuf[send_index] = (uint8_t)
                                            (psNdefMap->TopazContainer.CurrentSeg
                                             << NIBBLE_SIZE);
            send_index = (uint8_t)(send_index + 1);
            psNdefMap->SendLength = send_index;
            break;
        }

        case phHal_eJewel_Read8:
        {
            psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read4;
            psNdefMap->SendRecvBuf[send_index] = psNdefMap->TopazContainer.CurrentBlock;
            send_index = (uint8_t)(send_index + 1);
            psNdefMap->SendLength = send_index;
            break;
        }

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

        default:
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_INVALID_DEVICE_REQUEST);
            break;
        }
    }
    if(result == NFCSTATUS_SUCCESS)
    {
#ifdef TOPAZ_RAW_SUPPORT

        if (PH_FRINFC_TOPAZ_CMD_READID != *psNdefMap->SendRecvBuf)
        {
            (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 
                            (void *)read_append, sizeof (read_append));
            send_index = (uint8_t)(send_index + sizeof (read_append));

            (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 
                        (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid, 
                        TOPAZ_UID_LENGTH_FOR_READ_WRITE);
            send_index = (uint8_t)(send_index + 
                        TOPAZ_UID_LENGTH_FOR_READ_WRITE);            
        }

        psNdefMap->SendLength = send_index;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        /* Call the Overlapped HAL Transceive function */ 
        result = phFriNfc_OvrHal_Transceive(    psNdefMap->LowerDevice,
                                                &psNdefMap->MapCompletionInfo,
                                                psNdefMap->psRemoteDevInfo,
                                                psNdefMap->Cmd,
                                                &psNdefMap->psDepAdditionalInfo,
                                                psNdefMap->SendRecvBuf,
                                                psNdefMap->SendLength,
                                                psNdefMap->SendRecvBuf,
                                                psNdefMap->SendRecvLength);
    }
    return result;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_NxpWrite(
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_write_data, 
    uint8_t                     wr_data_len)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t        *ps_tpz_info = NULL;
    uint8_t                     send_index = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);        

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

    psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazDynamicMap_Process;
    psNdefMap->MapCompletionInfo.Context = psNdefMap;

    *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength;

#ifdef TOPAZ_RAW_SUPPORT
    /* " send_index " is incremented because already received buffer is filled with 
        TOPAZ command */
    send_index = (uint8_t)(send_index + 1);
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;

    switch (*psNdefMap->SendRecvBuf)

#else /* #ifdef TOPAZ_RAW_SUPPORT */

    switch (psNdefMap->Cmd.JewelCmd)

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    {
#ifdef TOPAZ_RAW_SUPPORT

        case PH_FRINFC_TOPAZ_CMD_WRITE_1E:
        {
            psNdefMap->SendRecvBuf[send_index] = (uint8_t)((ps_tpz_info->CurrentBlock 
                                                << (NIBBLE_SIZE - 1)) | 
                                                ps_tpz_info->ByteNumber);
            send_index = (uint8_t)(send_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_CMD_WRITE_E8:
        {
            psNdefMap->SendRecvBuf[send_index] = ps_tpz_info->CurrentBlock;
            send_index = (uint8_t)(send_index + 1);
            break;
        }

#else /* #ifdef TOPAZ_RAW_SUPPORT */

        case phHal_eJewel_Write1E:
        {
            psNdefMap->SendRecvBuf[send_index] = (uint8_t)((ps_tpz_info->CurrentBlock 
                                                << (NIBBLE_SIZE - 1)) | 
                                                ps_tpz_info->ByteNumber);
            send_index = (uint8_t)(send_index + 1);

            
            break;
        }

        case phHal_eJewel_Write8E:
        {
            psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write4E;
            psNdefMap->SendRecvBuf[send_index] = ps_tpz_info->CurrentBlock;
            send_index = (uint8_t)(send_index + 1);
            break;
        }

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

        default:
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_INVALID_DEVICE_REQUEST); 
            break;
        }
    }
  

    if (NFCSTATUS_SUCCESS == result)
    {
        (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 
                    (void *)p_write_data, wr_data_len);

        send_index = (uint8_t)(send_index + wr_data_len);

#ifdef TOPAZ_RAW_SUPPORT

        (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 
                    (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid, 
                    TOPAZ_UID_LENGTH_FOR_READ_WRITE);
        send_index = (uint8_t)(send_index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);

#endif /* #ifdef TOPAZ_RAW_SUPPORT */

        psNdefMap->SendLength = send_index;

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

static 
NFCSTATUS 
phFriNfc_Tpz_H_ProReadResp(
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t        *ps_tpz_info = NULL;
    uint8_t                     write_buffer[] = {0x00};

    ps_tpz_info = &(psNdefMap->TopazContainer);

    switch (psNdefMap->PrevOperation)
    {
        case  PH_FRINFC_NDEFMAP_CHECK_OPE:
        {
            if (PH_FRINFC_TOPAZ_DYNAMIC_READSEG_RESP == 
                *psNdefMap->SendRecvLength)
            {
                if (0 == ps_tpz_info->CurrentSeg)
                {
                    result = phFriNfc_Tpz_H_CheckCCBytes (psNdefMap);
                }

                if (NFCSTATUS_SUCCESS == result)
                {
                    result = phFriNfc_Tpz_H_ParseTLVs (psNdefMap);
                }
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH); 
            }
            break;
        }

        case  PH_FRINFC_NDEFMAP_READ_OPE:
        {
            if (PH_FRINFC_TOPAZ_DYNAMIC_READSEG_RESP == 
                *psNdefMap->SendRecvLength)
            {
                /* call the data bytes to internal buffer*/
                result = phFriNfc_Tpz_H_CopyReadData (psNdefMap);
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH); 
            }
            break;
        }

        case  PH_FRINFC_NDEFMAP_WRITE_OPE:
        {
            /* read the bytes for cheking the CC bytes and lock bit status*/
            if(TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
            {
                (void)memcpy ((void *)ps_tpz_info->CCByteBuf, 
                            (void *)(psNdefMap->SendRecvBuf), 
                            TOPAZ_CC_BYTES_LENGTH);

                result = phFriNfc_Tpz_H_CheckCCBytesForWrite (psNdefMap);
                if (NFCSTATUS_SUCCESS == result)
                {
                    if ((0x00 == *ps_tpz_info->CCByteBuf) || 
                        (NDEF_T_TLV == ps_tpz_info->ExpectedSeq))
                    {
                        /* This statement is for getting the new 
                            NDEF TLV byte address, because 1st CC byte is  
                            corrupted or no NDEF TLV in the card

                            If the 1st CC byte (NDEF magic number) in the  
                            card is 0, means that previous write has failed, 
                            so to write the exact file 
                            OR
                            The NDEF TLV is not present in the entire card, and  
                            the sequence is NDEF_T_TLV (this means, that lock and  
                            memory control TLV is found in the card)                
                        */
                        psNdefMap->State = (uint8_t)
                                        PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF;
                        ps_tpz_info->WriteSeq = (uint8_t)WR_NDEF_T_TLV;

                        ps_tpz_info->CurrentBlock = (uint8_t)
                                    TOPAZ_BLK_FROM_BYTE_ADR (
                                        ps_tpz_info->NdefTLVByteAddress);

                        ps_tpz_info->ByteNumber = (uint8_t)
                                    TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (
                                        ps_tpz_info->NdefTLVByteAddress);

#ifdef TOPAZ_RAW_SUPPORT
                        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
#else
                        psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

                        result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
                    }
                    else
                    {
                        ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_0;
                        ps_tpz_info->CurrentBlock = 1;
                        ps_tpz_info->ByteNumber = 0;
                        psNdefMap->State = (uint8_t)
                                            PH_FRINFC_TOPAZ_STATE_WRITE;
#ifdef TOPAZ_RAW_SUPPORT
                        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
#else
                        psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

                        /* Call read 8 */
                        result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buffer, 
                                                    sizeof (write_buffer));
                    }
                    
                }
            }
            else
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH); 
            }
            break;
        }

        default:
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_INVALID_DEVICE_REQUEST);
            break;
        }
    }
    
    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 
NFCSTATUS  
phFriNfc_Tpz_H_ChkLockBits(
    phFriNfc_NdefMap_t  *psNdefMap)
{
    NFCSTATUS           result = NFCSTATUS_SUCCESS;
#ifdef ENABLE_LOCK_BITS_CHECK
    uint8_t             *p_recv_buf = psNdefMap->SendRecvBuf;
#endif /* #ifdef ENABLE_LOCK_BITS_CHECK */
    psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;

#ifdef ENABLE_LOCK_BITS_CHECK

    /* Set the card state */
    psNdefMap->CardState =  (uint8_t)
        (((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_0] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_0) && 
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_1] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_1)) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_2] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_3] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_4] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_5] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_6] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7))) &&
            ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_7] == 
            PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) ?
                PH_NDEFMAP_CARD_STATE_INITIALIZED :
                PH_NDEFMAP_CARD_STATE_READ_ONLY);

#endif /* #ifdef ENABLE_LOCK_BITS_CHECK */

    /* Set the card state from CC bytes */
    if (PH_NDEFMAP_CARD_STATE_INITIALIZED == psNdefMap->CardState)
    {
        switch ((psNdefMap->TopazContainer.CCByteBuf[3] & 0xFF))
        {
            case PH_FRINFC_TOPAZ_CC_READWRITE:
            {
                psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
                break;
            }

            case PH_FRINFC_TOPAZ_CC_READONLY:
            {
                psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
                break;
            }

            default: 
            {
                psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                    NFCSTATUS_NO_NDEF_SUPPORT);
                break;
            }
        }
    }
    
    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_CheckCCBytes (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
    uint8_t                         *p_recv_buf = psNdefMap->SendRecvBuf;
    uint16_t                        parse_index = 0;

    parse_index = (uint16_t)(parse_index + TOPAZ_UID_BYTES_LENGTH);

    (void)memcpy ((void *)ps_tpz_info->CCByteBuf, 
                (void *)(p_recv_buf + parse_index), 
                TOPAZ_CC_BYTES_LENGTH);

    p_recv_buf = ps_tpz_info->CCByteBuf;
    parse_index = 0;

#ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
    /* 1st CC byte value = 0 or 0xE1 */
    if ((PH_FRINFC_TOPAZ_CC_BYTE0 == p_recv_buf[parse_index])
#ifdef TOPAZ_MAGIC_NO_0_CHK_ENABLE
        || (0 == p_recv_buf[parse_index])
#endif /* #if TOPAZ_MAGIC_NO_0_CHK_ENABLE */
        )
#endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
    {
        parse_index = (uint16_t)(parse_index + 1);
        /* 2nd CC byte value = 0x10 */
        result = phFriNfc_Tpz_H_ChkSpcVer (psNdefMap, p_recv_buf[parse_index]);        
    }
#ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
    else
    {
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }
#endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */

    if (NFCSTATUS_SUCCESS == result)
    {
        parse_index = (uint16_t)(parse_index + 1);
        /* 3rd CC byte value = 0x3F for 512 card */
        if (PH_FRINFC_TOPAZ_DYNAMIC_CC_BYTE2_MMSIZE == p_recv_buf[parse_index])
        {
            /* Card size calculated as ((3rd CC byte * 8) - 4 CC bytes) */
            psNdefMap->CardMemSize = (uint16_t)((p_recv_buf[parse_index] * 
                                    TOPAZ_BYTES_PER_BLOCK) - 
                                    TOPAZ_CC_BYTES_LENGTH);
            ps_tpz_info->RemainingSize = (uint16_t)(psNdefMap->CardMemSize + 
                                        TOPAZ_UID_BYTES_LENGTH + 
                                        TOPAZ_CC_BYTES_LENGTH);
            result = phFriNfc_Tpz_H_ChkLockBits (psNdefMap);
        }
        else
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
        }
    }

    if (NFCSTATUS_SUCCESS != result)
    {
        psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_CheckCCBytesForWrite (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint8_t                             check_cc_rw[] = {TOPAZ_SPEC_VERSION, 
                                        PH_FRINFC_TOPAZ_DYNAMIC_CC_BYTE2_MMSIZE, 
                                        PH_FRINFC_TOPAZ_CC_READWRITE};
    uint8_t                             check_index = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);

#ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
    if (
        (PH_FRINFC_TOPAZ_CC_BYTE0 == ps_tpz_info->CCByteBuf[check_index]) 
#if TOPAZ_MAGIC_NO_0_CHK_ENABLE
        || (0 == ps_tpz_info->CCByteBuf[check_index])
#endif /* #if TOPAZ_MAGIC_NO_0_CHK_ENABLE */
        )
#endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
    {
        check_index = (uint8_t)(check_index + 1);

        if ((!TOPAZ_COMPARE_VERSION(check_cc_rw[0], ps_tpz_info->CCByteBuf[1])) ||
            (check_cc_rw[1] != ps_tpz_info->CCByteBuf[2]) || 
            (check_cc_rw[2] != ps_tpz_info->CCByteBuf[3]))
        {
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
        }
    }
#ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
    else
    {
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }    
#endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
    return result;
}

static 
uint16_t 
phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
    uint16_t                        skip_size = 0;
    uint16_t                        byte_addr = 0;
    uint8_t                         exit_index = 0;

    byte_addr = ps_tpz_info->NdefTLVByteAddress;

    while (exit_index < ((ps_tpz_info->ActualNDEFMsgSize >= 0xFF) ? 3 : 1))
    {
        byte_addr = (uint16_t)(byte_addr + 1);
        if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
        {
            byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
        }
        skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
        
        byte_addr = (uint16_t)(byte_addr + skip_size);
        exit_index = (uint8_t)(exit_index + 1);
    }

    byte_addr = (uint16_t)(byte_addr + 1);
    if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
    {
        byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
    }
    skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
    
    byte_addr = (uint16_t)(byte_addr + skip_size);

    return byte_addr;
}

static 
uint16_t 
phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint16_t                    size_to_write)
{
    phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
    uint16_t                        skip_size = 0;
    uint16_t                        byte_addr = 0;
    uint8_t                         exit_index = 0;

    byte_addr = ps_tpz_info->NdefTLVByteAddress;

    while (exit_index < ((size_to_write >= 0xFF) ? 3 : 1))
    {
        byte_addr = (uint16_t)(byte_addr + 1);
        if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
        {
            byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
        }
        skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
        
        byte_addr = (uint16_t)(byte_addr + skip_size);
        exit_index = (uint8_t)(exit_index + 1);
    }

    byte_addr = (uint16_t)(byte_addr + 1);
    if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
    {
        byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
    }
    skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
    
    byte_addr = (uint16_t)(byte_addr + skip_size);

    return byte_addr;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_RemainingReadDataCopy (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
    uint8_t                         copy_temp_buf[PH_FRINFC_NDEFMAP_TOPAZ_MAX_SIZE];
    uint16_t                        copy_length = 0;
    uint16_t                        read_copy_length = 0;


    if (0 != ps_tpz_info->ReadBufferSize)
    {
        /* Data is already copied, so give it from the stored buffer */
        if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) >= 
            ps_tpz_info->ReadBufferSize)
        {
            read_copy_length = ps_tpz_info->ReadBufferSize;
            (void)memcpy ((void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex), 
                    (void *)ps_tpz_info->ReadBuffer, ps_tpz_info->ReadBufferSize);
        }
        else
        {
            read_copy_length = (uint16_t)(psNdefMap->ApduBufferSize - 
                                psNdefMap->ApduBuffIndex);

            copy_length = (uint16_t)(ps_tpz_info->ReadBufferSize - 
                            read_copy_length);

            /* Copy data to user buffer */
            (void)memcpy ((void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex), 
                    (void *)ps_tpz_info->ReadBuffer, read_copy_length);

            /* Copy data from " ReadBuffer " to temporary buffer */
            (void)memcpy ((void *)copy_temp_buf, 
                    (void *)(ps_tpz_info->ReadBuffer + read_copy_length), 
                    copy_length);

            /* Copy data from temporary buffer to " ReadBuffer " */
            (void)memcpy ((void *)ps_tpz_info->ReadBuffer, 
                    (void *)copy_temp_buf, copy_length);

        }

        psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 
                                    read_copy_length);
        ps_tpz_info->ReadBufferSize = (uint8_t)
                            (ps_tpz_info->ReadBufferSize - 
                            read_copy_length);
        ps_tpz_info->RemainingReadSize = (uint16_t)(
                            ps_tpz_info->RemainingReadSize - read_copy_length);
    }

    if (0 == ps_tpz_info->RemainingReadSize)
    {
        /* No data to read, so return */
        *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
        ps_tpz_info->ReadBufferSize = 0;
        ps_tpz_info->ReadWriteCompleteFlag = TRUE;
    }
    else if (psNdefMap->ApduBuffIndex == psNdefMap->ApduBufferSize)
    {
        /* User data length is read completely */
        *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
    }
    else
    {
        /* Stored data is not enough, so continue reading the next segment */
        ps_tpz_info->CurrentSeg = (uint8_t)
                            (ps_tpz_info->CurrentSeg + 1);
#ifdef TOPAZ_RAW_SUPPORT

        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;

#else 

        psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_CopyReadData (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;    
    phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
    phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
    phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;
    uint16_t                        copy_index = 0;
    uint16_t                        copy_length = 0;
    uint16_t                        recv_length = 0;
    static uint16_t                 skip_size = 0;
    /* byte address read */
    uint16_t                        copy_till_address = 0;
    uint16_t                        exact_copy_length = 0;
    uint16_t                        actual_ndef_length = 0;
    

    recv_length = *(psNdefMap->SendRecvLength);
    
    actual_ndef_length = ps_tpz_info->ActualNDEFMsgSize;
    if (PH_FRINFC_NDEFMAP_SEEK_CUR == psNdefMap->Offset)
    {
        actual_ndef_length = (uint16_t)(
                            ps_tpz_info->RemainingReadSize + 
                            psNdefMap->ApduBuffIndex);
    }
    
    exact_copy_length = (uint16_t)((psNdefMap->ApduBufferSize > 
                            actual_ndef_length) ? actual_ndef_length : 
                            psNdefMap->ApduBufferSize);

    if (0 == ps_tpz_info->CurrentSeg)
    {
        /* Skip copying the UID bytes, CC bytes, and lock and reserved memory bytes 
             */
        recv_length = (*(psNdefMap->SendRecvLength) - TOPAZ_STATIC_LOCK_RES_BYTES);
    }

    if (TOPAZ_SEG_FROM_BYTE_ADR (
        phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (psNdefMap)) == 
        ps_tpz_info->CurrentSeg)
    {
        copy_index = (uint16_t)(copy_index + (
                    phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
                        psNdefMap) % TOPAZ_SEGMENT_READ_LENGTH));
        skip_size = 0;
    }

    if (0 != skip_size)
    {
        copy_index = (copy_index + skip_size);
        skip_size = 0;
    }
    
    while (copy_index < recv_length)
    {
        copy_length = (uint16_t)(recv_length - copy_index);
        copy_till_address = 0;
        /* IF MORE THAN ONE TLV EXISTS THEN ADD A WHILE LOOP HERE, AND PLACE THE 
            IF STATEMENT INSIDE THE WHILE LOOP. ALSO,
            ps_locktlv_info = &(psNdefMap->LockTlv) change this to 
            ps_locktlv_info = &(psNdefMap->LockTlv[index])
            */
        ps_locktlv_info = &(psNdefMap->LockTlv);
        if (
            /* Check the lock bytes belong to this segment */
            (ps_tpz_info->CurrentSeg == 
            (ps_locktlv_info->ByteAddr / TOPAZ_SEGMENT_READ_LENGTH)) && 
            /* Now to check if the copy_index has surpassed the lock byte address */
            (TOPAZ_BYTE_ADR_FROM_SEG(ps_tpz_info->CurrentSeg, copy_index) 
            <= ps_locktlv_info->ByteAddr)
            )
        {
            if ((ps_locktlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_START) || 
                (ps_locktlv_info->ByteAddr >= (TOPAZ_STATIC_LOCK_RES_END + 8)))
            {
                copy_till_address = ps_locktlv_info->ByteAddr;
            }
            skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, 
                                                        ps_locktlv_info->ByteAddr);
        }

        /* IF MORE THAN ONE TLV EXISTS THEN ADD A WHILE LOOP HERE, AND PLACE THE 
            IF STATEMENT INSIDE THE WHILE LOOP. ALSO,
            ps_memtlv_info = &(psNdefMap->MemTlv) change this to 
            ps_memtlv_info = &(psNdefMap->MemTlv[index])
            */
        ps_memtlv_info = &(psNdefMap->MemTlv);
        if (
            /* Check the reserved bytes belong to this segment */
            (ps_tpz_info->CurrentSeg == 
            (ps_memtlv_info->ByteAddr / TOPAZ_SEGMENT_READ_LENGTH)) && 
            /* Now to check if the copy_index has surpassed the reserved byte address */
            (TOPAZ_BYTE_ADR_FROM_SEG(ps_tpz_info->CurrentSeg, copy_index) 
            <= ps_memtlv_info->ByteAddr)
            )
        {
            if ((ps_memtlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_START) ||  
                (ps_memtlv_info->ByteAddr >= (TOPAZ_STATIC_LOCK_RES_END + 8)))
            {
                copy_till_address = (uint16_t)
                            (((ps_memtlv_info->ByteAddr < copy_till_address) || 
                                (0 == copy_till_address))?  
                            ps_memtlv_info->ByteAddr : copy_till_address);
            }

            if (copy_till_address == ps_memtlv_info->ByteAddr)
            {
                skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, 
                                                            ps_memtlv_info->ByteAddr);
            }
        }


        copy_length = (uint16_t) ((copy_till_address == 0) ? copy_length : 
                    ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) - 
                    copy_index));

        /* After lock bytes, there are immediate reserved bytes, so " copy_length " 
            can be 0 */
        if (0 != copy_length)
        {
            /* If complete user buffer is not filled and the 
                read data is greater than the user data buffer, then get the 
                remaining size that should be copied. 
                The below " if " statement is used for the above scenario */
            if ((copy_length > (uint16_t)
                (exact_copy_length - psNdefMap->ApduBuffIndex)) && 
                (exact_copy_length != psNdefMap->ApduBuffIndex))
            {            
                copy_length = (uint16_t)(exact_copy_length - 
                                        psNdefMap->ApduBuffIndex);
            }

            if (exact_copy_length != psNdefMap->ApduBuffIndex)
            {
                (void)memcpy ((void *)(psNdefMap->ApduBuffer + 
                        psNdefMap->ApduBuffIndex), 
                        (void *)(psNdefMap->SendRecvBuf + copy_index), 
                        copy_length);
#if 0
                if (((copy_till_address == 0) ? copy_length : 
                    ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) - 
                    copy_index)) > (uint16_t)
                    (exact_copy_length - psNdefMap->ApduBuffIndex))
                {                
                    /* Copy remaining buffer in the static memory */
                    (void)memcpy ((void *)(ps_tpz_info->ReadBuffer + 
                            ps_tpz_info->ReadBufferSize), 
                            (void *)(psNdefMap->SendRecvBuf + copy_index), 
                            (((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) - 
                            copy_index) - copy_length));

                    ps_tpz_info->ReadBufferSize = (uint16_t)(((copy_till_address % 
                                                    TOPAZ_SEGMENT_READ_LENGTH) - 
                                                    copy_index) - copy_length);

                    /* Copy the data in the user buffer */
                    copy_index = (uint16_t)(copy_index + 
                                ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) - 
                                copy_index));
                }
                else
#endif /* #if 0 */
                {
                    /* Copy the data in the user buffer */
                    copy_index = (uint16_t)(copy_index + copy_length);
                }

                psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 
                                            copy_length);


            }
            else
            {
                copy_length = (uint16_t) ((copy_till_address == 0) ? copy_length : 
                            ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) - 
                            copy_index));

                /* Actual NDEF message size is greater than the last index copied in 
                    the user buffer */
                if (actual_ndef_length > (psNdefMap->ApduBuffIndex + 
                    ps_tpz_info->ReadBufferSize))
                {
                    /* The statement is correct, check the remaining length */
                    copy_length = ((copy_length > (actual_ndef_length - 
                                psNdefMap->ApduBuffIndex)) ? 
                                (actual_ndef_length - 
                                psNdefMap->ApduBuffIndex) : 
                                copy_length);

                    /* Copy remaining buffer in the static memory */
                    (void)memcpy ((void *)(ps_tpz_info->ReadBuffer + 
                                ps_tpz_info->ReadBufferSize), 
                                (void *)(psNdefMap->SendRecvBuf + copy_index), 
                                copy_length);

                    ps_tpz_info->ReadBufferSize = (uint8_t)(
                                                    ps_tpz_info->ReadBufferSize + 
                                                    copy_length);
                }

                /* Copy the data in the user buffer */
                copy_index = (uint16_t)(copy_index + copy_length); 
            }
        }

        if (copy_index != copy_till_address)
        {
            skip_size = 0;
        }

        if ((copy_index + skip_size) <= recv_length)
        {
            copy_index = (uint16_t)(copy_index + skip_size);
            skip_size = 0;
        }
        else
        {
            skip_size = (uint16_t)((skip_size > 0) ? 
                                    (recv_length - copy_index) : 0);
            copy_index = (uint16_t)recv_length;
        }                        
    }

    if (exact_copy_length != psNdefMap->ApduBuffIndex)
    {
        ps_tpz_info->CurrentSeg = (uint8_t)
                            (ps_tpz_info->CurrentSeg + 1);
#ifdef TOPAZ_RAW_SUPPORT

        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;

#else 

        psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
    }
    else
    {
        *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
        if (psNdefMap->ApduBuffIndex == actual_ndef_length)
        {
            ps_tpz_info->ReadBufferSize = 0;
            ps_tpz_info->ReadWriteCompleteFlag = TRUE;
        }
        else
        {
            ps_tpz_info->RemainingReadSize = (actual_ndef_length - 
                                        psNdefMap->ApduBuffIndex);
        }
    }
    return result;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseTLVs (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t        *ps_tpz_info = &(psNdefMap->TopazContainer);
    uint8_t                     *p_recv_buf = NULL;
    uint16_t                    recv_length = 0;
    uint16_t                    parse_index = 0;
    phFriNfc_Tpz_ParseSeq_t     expected_seq = (phFriNfc_Tpz_ParseSeq_t)
                                ps_tpz_info->ExpectedSeq;
    uint16_t                    byte_addr = 0;
    /* This variable is kept static because if the size to skip LOCK or RESERVED 
    bytes extends to next read then it shall be stored and used to skip the next 
    read the bytes
    */
    static uint16_t             skip_size = 0;
    /* This variable is kept static because if the bytes extends from the read segment, 
        then the index shall be stored
    This is to store index copied from the 
    1. lock memory VALUE field bytes in the LOCK and MEMORY CONTROL TLV. 
    2. Also, LENGTH field of the NDEF TLV */
    static uint8_t              lock_mem_ndef_index = 0;
    /* This variable is kept static because if the bytes extends from the read segment, 
        then it has to stored
    This is to store the 
    1. lock memory VALUE field bytes in the LOCK and MEMORY CONTROL TLV. 
    2. Also, LENGTH field of the NDEF TLV */
    static uint8_t              lock_mem_buf[TOPAZ_MEM_LOCK_TLV_LENGTH] = {0};
    /* This is used in case if there is no MAGIC NUMBER found 
                        OR 
        TYPE field is not found after reading entire card */
    static uint16_t             ndef_tlv_byte_addr = 0;

    p_recv_buf = psNdefMap->SendRecvBuf;
    recv_length = *psNdefMap->SendRecvLength;

    if (0 == ps_tpz_info->CurrentSeg)
    {
        /* First read, so reset all the static variables */
        lock_mem_ndef_index = 0;
        skip_size = 0;
        ndef_tlv_byte_addr = 0;

        /* Skip copying the UID bytes and CC bytes, which is first 12 bytes */
        parse_index = (uint16_t)(TOPAZ_UID_BYTES_LENGTH + 
                                TOPAZ_CC_BYTES_LENGTH);
        /* Delete the lock and reserved memory bytes 
            (which are the last 24 bytes in the card) */
        recv_length = (uint16_t)(*(psNdefMap->SendRecvLength) - 
                                TOPAZ_STATIC_LOCK_RES_BYTES);        
    }

    while ((parse_index < recv_length) && (NFCSTATUS_SUCCESS == result) && 
        (NDEF_V_TLV != expected_seq))
    {
        if (0 == skip_size)
        {
            /* Macro used to get the exact byte address of the card. 
                This is done by using the current segment and the parse index */
            byte_addr = TOPAZ_BYTE_ADR_FROM_SEG (ps_tpz_info->CurrentSeg, parse_index);
            /* Skip size is to skip the lock or memory reserved bytes  */
            skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
        }

        if (0 != skip_size)
        {
            if ((recv_length - parse_index) >= skip_size)
            {
                parse_index = (uint16_t)(parse_index + skip_size);
                skip_size = 0;
            }
            else
            {
                parse_index = (uint16_t)(parse_index + (recv_length - 
                                parse_index));
                skip_size = (uint16_t)(skip_size - (recv_length - 
                                parse_index));
            }
        }
        else 
        {
            switch (expected_seq)
            {
                case LOCK_T_TLV:
                {
                    /* Parse the bytes till TYPE field of LOCK TLV is found, Once the 
                        TYPE field is found then change the sequence to LOCK_L_TLV */
                    result = phFriNfc_Tpz_H_ParseLockTLVType (psNdefMap, p_recv_buf, 
                                            &parse_index, recv_length, &expected_seq);
                    
                    break;
                }

                case LOCK_L_TLV:
                {
                    /* Parse the length field of LOCK TLV. Length field value of the 
                        LOCK TLV is always 3 */
                    if (TOPAZ_MEM_LOCK_TLV_LENGTH != p_recv_buf[parse_index])
                    {
                        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                            NFCSTATUS_NO_NDEF_SUPPORT);
                    }
                    else
                    {
                        parse_index = (uint16_t)(parse_index + 1);
                        expected_seq = LOCK_V_TLV;
                    }
                    break;
                }

                case LOCK_V_TLV:
                {
                    /* Parse the VALUE field of the LOCK TLV */
                    lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
                    parse_index = (uint16_t)(parse_index + 1);
                    lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
                    

                    /* All the 3 bytes are copied in the local buffer */
                    if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
                    {
#ifdef FRINFC_READONLY_NDEF
                        (void)memcpy ((void *)psNdefMap->LockTlv.LockTlvBuff, 
                                (void *)lock_mem_buf, sizeof (lock_mem_buf));
#endif /* #ifdef FRINFC_READONLY_NDEF */
                        /* Calculate the byte address and size of the lock bytes */
                        result = phFriNfc_Tpz_H_GetLockBytesInfo (psNdefMap, lock_mem_buf);
                        lock_mem_ndef_index = 0;
                        expected_seq = MEM_T_TLV;                    
                    }
                    break;
                }

                case MEM_T_TLV:
                {
                    /* Parse the bytes till TYPE field of MEMORY TLV is found, Once the 
                        TYPE field is found then change the sequence to MEM_L_TLV */
                    result = phFriNfc_Tpz_H_ParseMemTLVType (psNdefMap, p_recv_buf, 
                                            &parse_index, recv_length, &expected_seq);                    
                    break;
                }

                case MEM_L_TLV:
                {
                    /* Parse the length field of MEMORY TLV. Length field value of the 
                        MEMORY TLV is always 3 */
                    if (TOPAZ_MEM_LOCK_TLV_LENGTH != p_recv_buf[parse_index])
                    {
                        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                            NFCSTATUS_NO_NDEF_SUPPORT);
                    }
                    else
                    {
                        parse_index = (uint16_t)(parse_index + 1);
                        expected_seq = MEM_V_TLV;
                    }

                    break;
                }

                case MEM_V_TLV:
                {
                    /* Parse the VALUE field of the MEMORY TLV */
                    lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
                    parse_index = (uint16_t)(parse_index + 1);
                    lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);

                    /* All the 3 bytes are copied in the local buffer */
                    if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
                    {
                        /* Calculate the byte address and size of the lock bytes */
                        ndef_tlv_byte_addr = TOPAZ_BYTE_ADR_FROM_SEG (
                                            ps_tpz_info->CurrentSeg , parse_index);
                        result = phFriNfc_Tpz_H_GetMemBytesInfo (psNdefMap, lock_mem_buf);
                        lock_mem_ndef_index = 0;
                        expected_seq = NDEF_T_TLV;
                    }

                    break;
                }

                case NDEF_T_TLV:
                {
                    /* Parse the bytes till TYPE field of NDEF TLV is found, Once the 
                        TYPE field is found then change the sequence to NDEF_L_TLV */
                    result = phFriNfc_Tpz_H_ParseNdefTLVType (psNdefMap, p_recv_buf, 
                                            &parse_index, recv_length, &expected_seq);
                    
                    break;
                }

                case NDEF_L_TLV:
                {
                    /* Length field of the NDEF TLV */
                    if (0 == lock_mem_ndef_index)
                    {
                        /* This is the 1st time, the loop has entered this case, 
                            means that the NDEF byte address has to be updated */
                        ps_tpz_info->NdefTLVByteAddress = (uint16_t)
                                TOPAZ_BYTE_ADR_FROM_SEG (ps_tpz_info->CurrentSeg, 
                                (parse_index - 1));
                    }

                    if (0 != lock_mem_ndef_index)
                    {
                        /* There is already index has been updated, update remaining 
                            buffer */
                        lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
                        parse_index = (uint16_t)(parse_index + 1);
                        lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);

                        if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
                        {
                            lock_mem_ndef_index = 0;
                            ps_tpz_info->ActualNDEFMsgSize = (uint16_t)((lock_mem_buf[1] << 
                                        TOPAZ_BYTE_SHIFT) | lock_mem_buf[2]);
                            expected_seq = NDEF_V_TLV;
                        }
                    }
                    /* Check for remaining size in the card and the actual ndef length */
                    else if (p_recv_buf[parse_index] <= 
                            (ps_tpz_info->RemainingSize - (parse_index + 1)))
                    {
                        /* This check is added to see that length field in the TLV is 
                            greater than the 1 byte */
                        if (0xFF == p_recv_buf[parse_index])
                        {
                            lock_mem_buf[lock_mem_ndef_index] = 
                                                    p_recv_buf[parse_index];
                            lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
                        }
                        else
                        {
                            /* Length field of the TLV is ONE byte, so update the 
                            actual ndef size */
                            lock_mem_ndef_index = 0;
                            ps_tpz_info->ActualNDEFMsgSize = (uint16_t)
                                                        p_recv_buf[parse_index];
                            
                            expected_seq = NDEF_V_TLV;
                        }
                        parse_index = (uint16_t)(parse_index + 1);
                    }
                    else
                    {
                        /* Wrong length, remaining size in the card is lesser than the actual 
                            ndef message length */
                        lock_mem_ndef_index = 0;
                        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                            NFCSTATUS_NO_NDEF_SUPPORT);
                    }
                    break;
                }

                default:
                {
                    break;
                }
            }/* end of switch (expected_seq) */
        } /* end of if (0 != skip_size) */
    } /* while ((parse_index < recv_length) && (NFCSTATUS_SUCCESS != result) && 
        (NDEF_V_TLV != expected_seq)) */

    ps_tpz_info->ExpectedSeq = (uint8_t)expected_seq;

    if (0 == ps_tpz_info->CurrentSeg)
    {
        /* First segment has the STATIC lock and reserved bytes, so delete it from 
            the remaining size */
        ps_tpz_info->RemainingSize = (uint16_t)(ps_tpz_info->RemainingSize - 
                                    (parse_index + TOPAZ_STATIC_LOCK_RES_BYTES));

    }
    else
    {
        ps_tpz_info->RemainingSize = (uint16_t)(ps_tpz_info->RemainingSize - 
                                    parse_index);
    }

    if ((NDEF_V_TLV == expected_seq) && (NFCSTATUS_SUCCESS == result))
    {
        /* NDEF TLV found */
        result = phFriNfc_Tpz_H_ActualCardSize (psNdefMap);

        if ((PH_NDEFMAP_CARD_STATE_READ_ONLY != psNdefMap->CardState) && 
            (0 != ps_tpz_info->ActualNDEFMsgSize))
        {
            /* Check if the card state is READ ONLY or the actual NDEF size is 0 
                if actual NDEF size is 0, then card state is INITIALISED
            */
            psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
        }
    }

    if ((NFCSTATUS_SUCCESS == result) && (NDEF_V_TLV != expected_seq))
    {
        ps_tpz_info->CurrentSeg = (uint8_t)(ps_tpz_info->CurrentSeg + 1);
        if (TOPAZ_TOTAL_SEG_TO_READ == ps_tpz_info->CurrentSeg)
        {
            /* Max segment to read reached, so no more read can be done */
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
        }
        else
        {
#ifdef TOPAZ_RAW_SUPPORT

            *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;

#else 

            psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */ 
            result = phFriNfc_Tpz_H_NxpRead(psNdefMap);
        }
    }

    if ((NFCSTATUS_SUCCESS != result) && (NFCSTATUS_PENDING != result))
    {
        /* Error scenario */
        ps_tpz_info->NdefTLVByteAddress = 0;
        ps_tpz_info->ActualNDEFMsgSize = 0;
    }
    
    if (NFCSTATUS_PENDING != result)
    {
        /* Exit scenario */
        if ((0x00 == *ps_tpz_info->CCByteBuf) || 
            ((NDEF_T_TLV == expected_seq) && 
            (TOPAZ_TOTAL_SEG_TO_READ == ps_tpz_info->CurrentSeg)))
        {
            /* This statement is for getting the new 
                NDEF TLV byte address, because 1st CC byte is corrupted or 
                no NDEF TLV in the card

                If the 1st CC byte (NDEF magic number) in the card is 0, means 
                that previous write has failed, so to write the exact TLV, 
                calculate the byte number
                                            OR
                The NDEF TLV is not present in the entire card, and the sequence is 
                NDEF_T_TLV (this means, that lock and memory control TLV is found 
                in the card)                
                */
            uint16_t             size_to_skip = 0;
            ps_tpz_info->ActualNDEFMsgSize = 0;
            
            if (0 != ndef_tlv_byte_addr)
            {
                /* ndef_tlv_byte_addr is updated, only after complete parsing the 
                    memory control TLV so the value shall not be 0 */
                do 
                {
                    /* This loop is added to make sure the lock and reserved bytes are not 
                    overwritten */
                    size_to_skip = 0;
                    size_to_skip = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, 
                                                            ndef_tlv_byte_addr);

                    ndef_tlv_byte_addr = (uint16_t)(ndef_tlv_byte_addr + 
                                            size_to_skip);
                }while (0 != size_to_skip);

                /* Update the TLV byte address */
                ps_tpz_info->NdefTLVByteAddress = ndef_tlv_byte_addr;

                /* Update the remaining size */
                ps_tpz_info->RemainingSize = (uint16_t)(psNdefMap->CardMemSize + 
                                        TOPAZ_UID_BYTES_LENGTH + 
                                        TOPAZ_CC_BYTES_LENGTH);

                ps_tpz_info->RemainingSize = (uint16_t)
                                            (ps_tpz_info->RemainingSize - 
                                            (ndef_tlv_byte_addr + 
                                            TOPAZ_STATIC_LOCK_RES_BYTES));
                (void)phFriNfc_Tpz_H_ActualCardSize (psNdefMap);

                /* Length byte is subtracted here to get the actual NDEF 
                    read and write size */
                ps_tpz_info->NDEFRWSize = (uint16_t)
                                        (ps_tpz_info->NDEFRWSize - 2);
                ndef_tlv_byte_addr = 0;
                result = NFCSTATUS_SUCCESS;
            }
        }
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_CopyReadDataAndWrite (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
    uint16_t                            write_index = 0;
    uint16_t                            write_len = 0;
    uint16_t                            byte_addr = 0;
    static uint16_t                     skip_size = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);

    write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
                        psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);

    (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf, 
                    TOPAZ_WRITE_8_DATA_LENGTH);

    if (ps_tpz_info->CurrentBlock == TOPAZ_BLK_FROM_BYTE_ADR (
        phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (psNdefMap, write_len)))
    {
        skip_size = 0;
    }

    /* Byte Number != 0 menas that the VALUE field of the TLV is in between the 
        block, so the first few bytes shall be copied and then user data has to 
        be copied
        */
    if (0 != ps_tpz_info->ByteNumber)
    {
        write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber);
    }
    

    if (0 != skip_size)
    {
        write_index = (uint16_t)(write_index + skip_size);        
    }

    while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) && 
        (write_len != psNdefMap->ApduBuffIndex))
    {
        skip_size = 0;
        byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock, 
                                            ps_tpz_info->ByteNumber);
        skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);

        if (0 == skip_size)
        {
            write_buf[write_index] = 
                        psNdefMap->ApduBuffer[psNdefMap->ApduBuffIndex];

            write_index = (uint16_t)(write_index + 1);
            psNdefMap->ApduBuffIndex = (uint16_t)
                                        (psNdefMap->ApduBuffIndex + 1);
            ps_tpz_info->ByteNumber = (uint8_t)
                                        (ps_tpz_info->ByteNumber + 1);
        }
        else
        {
            
            if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
            {
                skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
                            - write_index));
                write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
            }
            else
            {
                ps_tpz_info->ByteNumber = (uint8_t)
                            (ps_tpz_info->ByteNumber + skip_size);
                write_index = (uint16_t)(write_index + skip_size);
                skip_size = 0;
            }            
        }
    }

    if (psNdefMap->ApduBuffIndex == write_len)
    {
        ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
    }
    else
    {
        if (0 != skip_size)
        {
            ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
            
        }
        else
        {
            ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
        }
    }

#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf, 
                                            sizeof (write_buf));

    return result;

}

static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    /* This function is called, only when the LENGTH field has to be updated 
        with the correct value */
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint16_t                            write_len = 0;
    uint16_t                            write_index = 0;    
    uint16_t                            byte_addr = 0;
    phFriNfc_Tpz_WrSeq_t                write_seq;
    /* This variable is kept static because if the size to skip LOCK or RESERVED 
    bytes extends to next read then it shall be stored and used to skip the next 
    read the bytes
    */
    static uint16_t                     skip_size = 0;
    uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
    uint8_t                             exit_while = FALSE;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ? 
                psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
   
    psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;

    (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf, 
                    TOPAZ_WRITE_8_DATA_LENGTH);

    write_seq = (phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq;

    if (WR_LEN_1_VALUE == write_seq)
    {
        /* First LENGTH field is geting updated, so the skip size 
            reset is done */
        skip_size = 0;
    }

    if (0 != ps_tpz_info->ByteNumber)
    {
        /* Byte Number is not 0, means that some data shall not be overwriteen till 
            that position in the block */
        write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber); 
    }

    if (0 != skip_size)
    {
        /* This is possible after updating the FIRST length field 
            skip size is skipped because of the pending LOCK or 
            RESERVED bytes
        */
        write_index = (uint16_t)(write_index + skip_size);        
    }

    while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) && 
        (FALSE == exit_while))
    {
        skip_size = 0;
        /* Get the exact byte address from the block number and 
            byte number */
        byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock, 
                                            ps_tpz_info->ByteNumber);
        /* Get the skip size */
        skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);

        if (0 == skip_size)
        {
            switch (write_seq)
            {
                case WR_LEN_1_VALUE:
                {
                    /* First sequenc is always to update 1st LENGTH field of the TLV */
                    if (write_len < 0xFF)
                    {
                        /* This means the LENGTH field is only one BYTE */
                        write_buf[write_index] = (uint8_t)
                                        psNdefMap->ApduBuffIndex;
                        /* Exit the loop */
                        exit_while = TRUE;
                    }
                    else
                    {
                        /* Update the 1st LENGTH field */
                        write_buf[write_index] = (uint8_t)0xFF;                        
                    }
                    break;
                }

                case WR_LEN_2_VALUE:
                {
                    /* Update the 2nd LENGTH field */
                    write_buf[write_index] = (uint8_t)
                                (psNdefMap->ApduBuffIndex >> BYTE_SIZE);
                    break;
                }

                case WR_LEN_3_VALUE:
                {
                    /* Update the 3rd LENGTH field */
                    write_buf[write_index] = (uint8_t)
                                (psNdefMap->ApduBuffIndex & 
                                TOPAZ_BYTE_LENGTH_MASK);
                    /* Exit the loop */
                    exit_while = TRUE;
                    break;
                }                

                default:
                {
                    /* Invalid case */
                    break;
                }
            }
            write_index = (uint16_t)(write_index + 1);
            if (
                /* As the write is done for 8 bytes, the write index cant 
                    go for more than or equal to 8 bytes, if it reaches 8 bytes 
                    then sequence shall not be incrmented */
                (TOPAZ_WRITE_8_DATA_LENGTH != write_index) && 
                /* If the last length field byte is updated then the 
                    write sequence shall not be incremented */
                (WR_LEN_3_VALUE != write_seq) && 
                /* Check added if the write length is less than 0xFF. 
                    If length is less than 0xFF, then write sequence   
                    shall not be incremented */
                (write_len >= 0xFF)
                )
            {
                /* Sequence is incremented to the next level */
                write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
            }
            /* Byte number is incremented */
            ps_tpz_info->ByteNumber = (uint8_t)
                            (ps_tpz_info->ByteNumber + 1);
        }
        else
        {
            
            if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
            {
                skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
                            - write_index));
                write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
            }
            else
            {
                ps_tpz_info->ByteNumber = (uint8_t)
                            (ps_tpz_info->ByteNumber + skip_size);
                write_index = (uint16_t)(write_index + skip_size);
                skip_size = 0;
            }
            
        }
    }

    ps_tpz_info->WriteSeq = (uint8_t)write_seq;

#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

    result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf, 
                                            sizeof (write_buf));
    return result;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    /* This function is called, only when the LENGTH field has to be updated 
        with the 0 */
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint16_t                            write_len = 0;
    uint16_t                            write_index = 0;
    uint16_t                            prev_apdu_index = 0;
    uint16_t                            byte_addr = 0;
    phFriNfc_Tpz_WrSeq_t                write_seq;
    /* This variable is kept static because if the size to skip LOCK or RESERVED 
        bytes extends to next read then it shall be stored and used to skip the next 
        read bytes
    */
    static uint16_t                     skip_size = 0;
    uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];

    ps_tpz_info = &(psNdefMap->TopazContainer);
    write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ? 
                psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);

    psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;

    (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf, 
                    TOPAZ_WRITE_8_DATA_LENGTH);

    prev_apdu_index = psNdefMap->ApduBuffIndex;
    write_seq = (phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq;

    if (WR_LEN_1_0 == write_seq)
    {
         /* First LENGTH field is geting updated, so the skip size 
            reset is done */
        skip_size = 0;
    }

    if (0 != ps_tpz_info->ByteNumber)
    {
        /* Byte Number is not 0, means that some data shall not be overwriteen till 
            that position in the block */
        write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber);   
        ps_tpz_info->ByteNumber = 0;
    }

    if (0 != skip_size)
    {
        /* This is possible after updating the FIRST length field 
            skip size is skipped because of the pending LOCK or 
            RESERVED bytes
        */
        write_index = (uint16_t)(write_index + skip_size);        
    }

    while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) && 
        (write_len != psNdefMap->ApduBuffIndex))
    {
        skip_size = 0;
        byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock, 
                                            ps_tpz_info->ByteNumber);
        skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);

        if (0 == skip_size)
        {
            switch (write_seq)
            {
                case WR_LEN_1_0:
                {
                    /* First sequence is always to update 1st LENGTH field 
                        of the TLV */
                    write_buf[write_index] = 0x00;
                    write_index = (uint16_t)(write_index + 1);
                    if (write_len < 0xFF)
                    {
                        /* LENGTH field is only 1 byte, so update change the sequence to 
                            update user data */
                        write_seq = WR_DATA;
                    }
                    else
                    {
                        /* Go to the next LENGTH field to update */
                        write_seq = (phFriNfc_Tpz_WrSeq_t)((TOPAZ_WRITE_8_DATA_LENGTH != 
                                    write_index) ? 
                                    (write_seq + 1) : write_seq);
                    }
                    break;
                }

                case WR_LEN_2_0:
                case WR_LEN_3_0:
                {
                    /* Update 2nd and 3rd LEGNTH field */
                    write_buf[write_index] = 0x00;
                    write_index = (uint16_t)(write_index + 1);
                    write_seq = (phFriNfc_Tpz_WrSeq_t)((TOPAZ_WRITE_8_DATA_LENGTH != 
                                write_index) ? 
                                (write_seq + 1) : write_seq);
                    break;
                }                

                case WR_DATA:
                default:
                {
                    /* Update the buffer by the user data */
                    write_buf[write_index] = 
                            psNdefMap->ApduBuffer[psNdefMap->ApduBuffIndex];
                    
                    write_index = (uint16_t)(write_index + 1);
                    psNdefMap->ApduBuffIndex = (uint16_t)
                                        (psNdefMap->ApduBuffIndex + 1);
                    break;
                }
                
            }
            
            ps_tpz_info->ByteNumber = (uint8_t)
                            (ps_tpz_info->ByteNumber + 1);
        }
        else
        {
            /* LOCK and MEMORY bytes are found */
            if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
            {
                /* skip size has exceeded the block number, so calculate the 
                remaining skip size  */
                skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
                            - write_index));
                write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
            }
            else
            {
                /* skip the LOCK and MEMORY bytes size */
                ps_tpz_info->ByteNumber = (uint8_t)
                            (ps_tpz_info->ByteNumber + skip_size);
                write_index = (uint16_t)(write_index + skip_size);
                skip_size = 0;
            }
        }
    }

    if (psNdefMap->ApduBuffIndex == write_len)
    {
        /* User data has been completely copied and it is ready to write, so 
            change the sequence */
        ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
    }
    else if ((WR_DATA == write_seq) && (prev_apdu_index == 
        psNdefMap->ApduBuffIndex))
    {
        /* The user data has not been written, only the LENGTH field is 
            updated */
        ps_tpz_info->WriteSeq = (uint8_t)((write_len < 0xFF) ? 
                                WR_LEN_1_0 : WR_LEN_3_0);        
    }
    else
    {
        /*  Update the sequence in the context */
        ps_tpz_info->WriteSeq = (uint8_t)write_seq;
    }

    ps_tpz_info->ByteNumber = 0;

#ifdef TOPAZ_RAW_SUPPORT
    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

    result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf, 
                                            sizeof (write_buf));
    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_RdForWrite (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    phFriNfc_Tpz_WrSeq_t                write_seq;
    uint16_t                            byte_addr = 0;
    uint8_t                             exit_while = FALSE;
    uint16_t                            skip_size = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    write_seq = (phFriNfc_Tpz_WrSeq_t)(ps_tpz_info->WriteSeq);

#ifdef TOPAZ_RAW_SUPPORT

    *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;

#else 

    psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;

#endif /* #ifdef TOPAZ_RAW_SUPPORT */
    
    psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF;

    switch (write_seq)
    {
        case WR_LEN_1_0:
        case WR_LEN_1_VALUE:
        {
            byte_addr = (ps_tpz_info->NdefTLVByteAddress + 1);
            
            /* This loop is to skip the lock amd reserved bytes */
            while (FALSE == exit_while)
            {
                if (TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO == 
                    TOPAZ_BLK_FROM_BYTE_ADR (byte_addr))
                {
                    byte_addr = (uint16_t)(byte_addr + 
                                TOPAZ_STATIC_LOCK_RES_BYTES);
                }
                skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, 
                                                            byte_addr);
                if (0 != skip_size)
                {
                    byte_addr = (uint16_t)(byte_addr + skip_size);

                    
                }
                else
                {
                    exit_while = TRUE;
                }
            }
            break;
        }

        case WR_LEN_2_0:
        case WR_LEN_3_0:
        case WR_LEN_2_VALUE:
        case WR_LEN_3_VALUE:
        {            
            byte_addr = (uint16_t)TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock, 
                                                    ps_tpz_info->ByteNumber); 
            /* This loop is for to skip the lock amd reserved bytes */
            while (FALSE == exit_while)
            {
                skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, 
                                                            byte_addr);
                if (0 != skip_size)
                {
                    byte_addr = (uint16_t)(byte_addr + skip_size);
                }
                else
                {
                    exit_while = TRUE;
                }
            }
            break;
        }

        case WR_DATA_READ_REQD:
        {
            /* Lock or reserved bytes found bytes */
            byte_addr = (uint16_t)TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock, 
                                                    ps_tpz_info->ByteNumber); 
            break;
        }
        
        default:
        {
            break;
        }
    }

    ps_tpz_info->CurrentBlock = (uint8_t)
                        TOPAZ_BLK_FROM_BYTE_ADR (byte_addr);
    ps_tpz_info->ByteNumber = (uint8_t)
                        TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (byte_addr);

    result = phFriNfc_Tpz_H_NxpRead (psNdefMap);

    return result;
}

static 
uint16_t 
phFriNfc_Tpz_H_CompareLockBlocks (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     block_no, 
    uint16_t                    *p_skip_size)
{
    uint16_t                            return_addr = 0;
    phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;

    ps_locktlv_info = &(psNdefMap->LockTlv);

    if (block_no == ps_locktlv_info->BlkNum)
    {
        /* ps_tpz_info->ByteNumber = (uint8_t)ps_locktlv_info->ByteNum; */
        *p_skip_size = ps_locktlv_info->Size;
        return_addr = ps_locktlv_info->ByteAddr;
    }
   
    return return_addr;
}

static 
uint16_t 
phFriNfc_Tpz_H_CompareMemBlocks (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     block_no, 
    uint16_t                    *p_skip_size)
{
    uint16_t                            return_addr = 0;
    phFriNfc_ResMemCntrlTLVCont_t       *ps_memtlv_info = NULL;

    ps_memtlv_info = &(psNdefMap->MemTlv);

    if (block_no == ps_memtlv_info->BlkNum)
    {
        /* ps_tpz_info->ByteNumber = (uint8_t)ps_memtlv_info->ByteNum; */
        *p_skip_size = ps_memtlv_info->Size;
        return_addr = ps_memtlv_info->ByteAddr;
    }

    return return_addr;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_CopySendWrData (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
    uint16_t                            write_len;
    uint8_t                             copy_length;
    uint16_t                            skip_size = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ? 
                psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize); 

    if (0 != phFriNfc_Tpz_H_CompareLockBlocks (psNdefMap, 
                ps_tpz_info->CurrentBlock, &skip_size))
    {
        ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
        ps_tpz_info->ByteNumber = 0;
        result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
    }
    else if (0 != phFriNfc_Tpz_H_CompareMemBlocks (psNdefMap, 
                ps_tpz_info->CurrentBlock, &skip_size))
    {
        ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
        ps_tpz_info->ByteNumber = 0;
        result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
    }
    else
    {
#ifdef TOPAZ_RAW_SUPPORT
        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
        psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */
        psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;

        if ((write_len - psNdefMap->ApduBuffIndex) >= (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH)
        {
            copy_length = (uint8_t)TOPAZ_WRITE_8_DATA_LENGTH;
            (void)memcpy ((void *)write_buf, 
                    (void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex), 
                    copy_length);

            psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 
                                        copy_length);
        }
        else
        {
            copy_length = (uint8_t)(write_len - psNdefMap->ApduBuffIndex);

            (void)memcpy ((void *)write_buf, 
                    (void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex), 
                    TOPAZ_WRITE_8_DATA_LENGTH);

            psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 
                                        copy_length);

            (void)memset ((void *)(write_buf + copy_length), 0x00, 
                        (TOPAZ_WRITE_8_DATA_LENGTH - copy_length));
        }

#ifdef TOPAZ_RAW_SUPPORT
        *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
#else
        psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
#endif /* #ifdef TOPAZ_RAW_SUPPORT */

        result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf, 
                                            sizeof (write_buf));
    }


    return result;
}


static 
NFCSTATUS 
phFriNfc_Tpz_H_ActualCardSize (
    phFriNfc_NdefMap_t          *psNdefMap)
{
    NFCSTATUS                           result = NFCSTATUS_SUCCESS;
    phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
    phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;
    phFriNfc_ResMemCntrlTLVCont_t       *ps_memtlv_info = NULL;
    uint16_t                            ndef_value_byte_addr = 0;
    uint16_t                            ndef_read_write_size = 0;

    ps_tpz_info = &(psNdefMap->TopazContainer);
    if (ps_tpz_info->ActualNDEFMsgSize > ps_tpz_info->RemainingSize)
    {
        ps_tpz_info->ActualNDEFMsgSize = 0;
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    else
    {
        ndef_read_write_size = ps_tpz_info->RemainingSize;
        ndef_value_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead 
                                (psNdefMap);
        
        ps_locktlv_info = &(psNdefMap->LockTlv);
        if (ps_locktlv_info->ByteAddr > ndef_value_byte_addr)
        {
            ndef_read_write_size = (ndef_read_write_size -  
                                    ps_locktlv_info->Size);
        }

        ps_memtlv_info = &(psNdefMap->MemTlv);
        if (ps_memtlv_info->ByteAddr > ndef_value_byte_addr)
        {
            ndef_read_write_size = (ndef_read_write_size -  
                                    ps_memtlv_info->Size);
        }

        if (ps_tpz_info->ActualNDEFMsgSize > ndef_read_write_size)
        {
            ps_tpz_info->ActualNDEFMsgSize = 0;
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
        }
        else
        {
            ps_tpz_info->NDEFRWSize = (uint16_t)
                            ((ps_tpz_info->ActualNDEFMsgSize < 0xFF) ? 
                            (ndef_read_write_size - 2) : 
                            ndef_read_write_size);
        }
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseLockTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    uint16_t                    parse_index = *p_parse_index;
    phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;

    PHNFC_UNUSED_VARIABLE(psNdefMap);
    PHNFC_UNUSED_VARIABLE(total_len_to_parse);

    switch (p_parse_data[parse_index])
    {
        case PH_FRINFC_TOPAZ_LOCK_CTRL_T:
        {
            expected_seq = LOCK_L_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_NULL_T:
        {
            expected_seq = LOCK_T_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        default:
        {                        
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
            break;
        }
    }
    
    
    *seq_to_execute = expected_seq;
    *p_parse_index = parse_index;
    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseMemTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    uint16_t                    parse_index = *p_parse_index;
    phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;

    PHNFC_UNUSED_VARIABLE(psNdefMap);
    PHNFC_UNUSED_VARIABLE(total_len_to_parse);

    switch (p_parse_data[parse_index])
    {
        case PH_FRINFC_TOPAZ_LOCK_CTRL_T:
        {
            expected_seq = LOCK_L_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_NULL_T:
        {
            expected_seq = MEM_T_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_MEM_CTRL_T:
        {
            expected_seq = MEM_L_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        default:
        {                        
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
            break;
        }
    }
    
    *seq_to_execute = expected_seq;
    *p_parse_index = parse_index;
    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_ParseNdefTLVType (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_parse_data, 
    uint16_t                    *p_parse_index, 
    uint16_t                    total_len_to_parse, 
    phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
{
    NFCSTATUS                   result = NFCSTATUS_SUCCESS;
    uint16_t                    parse_index = *p_parse_index;
    phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;

    PHNFC_UNUSED_VARIABLE(psNdefMap);
    PHNFC_UNUSED_VARIABLE(total_len_to_parse);

    switch (p_parse_data[parse_index])
    {
        case PH_FRINFC_TOPAZ_MEM_CTRL_T:
        {
            /* TYPE field of Memory control TLV is found. 
                This means that more than one memory control 
                TLV exists */
            expected_seq = MEM_L_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_NULL_T:
        {
            /* Skip the NULL TLV */
            expected_seq = NDEF_T_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        case PH_FRINFC_TOPAZ_NDEF_T:
        {
            /* TYPE field of NDEF TLV found, so next expected
                sequence is LENGTH field */
            expected_seq = NDEF_L_TLV;
            parse_index = (parse_index + 1);
            break;
        }

        default:
        {
            /* Reset the sequence */
            expected_seq = LOCK_T_TLV;
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_NO_NDEF_SUPPORT);
            break;
        }
    }
    
    *seq_to_execute = expected_seq;
    *p_parse_index = parse_index;
    return result;
}

static 
uint16_t
phFriNfc_Tpz_H_GetSkipSize (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint16_t                    byte_adr_card)
{
    uint16_t                        return_size = 0;
    phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
    phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;

    ps_locktlv_info = &(psNdefMap->LockTlv);
    ps_memtlv_info = &(psNdefMap->MemTlv);

    /* If there are more than one LOCK CONTROL TLV, then 
    ADD A LOOP HERE OF THE NUMBER OF TLVs FOUND */
    if (byte_adr_card == ps_locktlv_info->ByteAddr)
    {
        return_size = ps_locktlv_info->Size;
    }

    /* If there are more than one MEMORY CONTROL TLV, then 
        ADD A LOOP HERE OF THE NUMBER OF TLVs FOUND */
    if (byte_adr_card == ps_memtlv_info->ByteAddr)
    {
        return_size = ps_memtlv_info->Size;
    }
    return return_size;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_GetLockBytesInfo (
    phFriNfc_NdefMap_t          *psNdefMap, 
    uint8_t                     *p_lock_info)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
    uint8_t                         page_address = 0;
    uint8_t                         bytes_offset = 0;
    uint8_t                         lock_index = 0;

    ps_locktlv_info = &(psNdefMap->LockTlv);

    page_address = (uint8_t)(p_lock_info[lock_index] >> NIBBLE_SIZE);
    bytes_offset = (uint8_t)(p_lock_info[lock_index] & TOPAZ_NIBBLE_MASK);

    lock_index = (lock_index + 1);
    ps_locktlv_info->Size = (uint16_t)
                            (((p_lock_info[lock_index] % TOPAZ_BYTE_SIZE_IN_BITS) > 0)? 
                            ((p_lock_info[lock_index] / TOPAZ_BYTE_SIZE_IN_BITS) + 1) : 
                            (p_lock_info[lock_index] / TOPAZ_BYTE_SIZE_IN_BITS));

    lock_index = (lock_index + 1);
    ps_locktlv_info->BytesPerPage = 
                            (p_lock_info[lock_index] & TOPAZ_NIBBLE_MASK);
    ps_locktlv_info->BytesLockedPerLockBit = 
                            (p_lock_info[lock_index] >> NIBBLE_SIZE);

    /* Apply the formula to calculate byte address 
        ByteAddr = PageAddr*2^BytesPerPage + ByteOffset
    */
    ps_locktlv_info->ByteAddr = (uint16_t)((page_address 
                                * (1 << ps_locktlv_info->BytesPerPage))
                                + bytes_offset);

    
    if (
        /* Out of bound memory check */    
        ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size) > 
        (uint16_t)(psNdefMap->TopazContainer.CCByteBuf[2] * 
        TOPAZ_BYTES_PER_BLOCK)) || 

        /* Check the static lock and reserved areas memory blocks */
        ((ps_locktlv_info->ByteAddr >= TOPAZ_STATIC_LOCK_RES_START) && 
        (ps_locktlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_END)) || 
        (((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) >= 
        TOPAZ_STATIC_LOCK_RES_START) && 
        ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) < 
        TOPAZ_STATIC_LOCK_RES_END))
        )
    {
        ps_locktlv_info->ByteAddr = 0;
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    else
    {
        ps_locktlv_info->BlkNum = (ps_locktlv_info->ByteAddr / 
                                    TOPAZ_BYTES_PER_BLOCK);
        ps_locktlv_info->ByteNum = (ps_locktlv_info->ByteAddr % 
                                    TOPAZ_BYTES_PER_BLOCK);
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_Tpz_H_GetMemBytesInfo (
    phFriNfc_NdefMap_t          *psNdefMap,      
    uint8_t                     *p_mem_info)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;
    phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
    uint8_t                         page_address = 0;
    uint8_t                         bytes_offset = 0;
    uint8_t                         mem_index = 0;

    ps_memtlv_info = &(psNdefMap->MemTlv);
    ps_locktlv_info = &(psNdefMap->LockTlv);
    page_address = (uint8_t)(p_mem_info[mem_index] >> NIBBLE_SIZE);
    bytes_offset = (uint8_t)(p_mem_info[mem_index] & TOPAZ_NIBBLE_MASK);

    mem_index = (mem_index + 1);
    ps_memtlv_info->Size = (uint16_t)p_mem_info[mem_index];

    mem_index = (mem_index + 1);
    ps_memtlv_info->BytesPerPage = 
                            (p_mem_info[mem_index] & TOPAZ_NIBBLE_MASK);

    /* Apply the formula to calculate byte address 
        ByteAddr = PageAddr * 2^BytesPerPage + ByteOffset
    */
    ps_memtlv_info->ByteAddr = (uint16_t)((page_address 
                            * (1 << ps_memtlv_info->BytesPerPage))
                            + bytes_offset);

    
    if (
        /* Check if the lock and memory bytes are overlapped */
        ((ps_memtlv_info->ByteAddr >= ps_locktlv_info->ByteAddr) &&
        (ps_memtlv_info->ByteAddr <= 
        (ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1))) || 

        (((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) >= 
        ps_locktlv_info->ByteAddr) &&
        ((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) <= 
        (ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1))) || 

        /* Check the static lock and reserved areas memory blocks */
        ((ps_memtlv_info->ByteAddr >= TOPAZ_STATIC_LOCK_RES_START) && 
        (ps_memtlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_END)) || 
        (((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) >= 
        TOPAZ_STATIC_LOCK_RES_START) && 
        ((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) < 
        TOPAZ_STATIC_LOCK_RES_END)) ||

        /* Check if the memory address is out bound */
        ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size) > 
        (uint16_t)(psNdefMap->TopazContainer.CCByteBuf[2] * 
        TOPAZ_BYTES_PER_BLOCK))
        )
    {
        ps_memtlv_info->ByteAddr = 0;
        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    else
    {
        ps_memtlv_info->BlkNum = (ps_memtlv_info->ByteAddr / 
                                    TOPAZ_BYTES_PER_BLOCK);
        ps_memtlv_info->ByteNum = (ps_memtlv_info->ByteAddr % 
                                    TOPAZ_BYTES_PER_BLOCK);
    }

    return result;
}

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

#endif  /*#if !(defined(PH_FRINFC_MAP_TOPAZ_DISABLED ) || defined (PH_FRINFC_MAP_TOPAZ_DYNAMIC_DISABLED ))*/