/*
 * 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_MifareUL.c
 * \brief This component encapsulates read/write/check ndef/process functionalities,
 *        for the Mifare UL card.   
 *
 * Project: NFC-FRI
 *
 * $Date: Wed Feb 17 15:18:08 2010 $
 * $Author: ing07385 $
 * $Revision: 1.36 $
 * $Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $
 *
 */

#ifndef PH_FRINFC_MAP_MIFAREUL_DISABLED

#include <phFriNfc_NdefMap.h>
#include <phFriNfc_MifareULMap.h>
#include <phFriNfc_MapTools.h>
#include <phFriNfc_OvrHal.h>
#include <phFriNfc.h>


/*! \ingroup grp_file_attributes
 *  \name NDEF Mapping
 *
 * File: \ref phFriNfc_MifareUL.c
 *
 */
/*@{*/
#define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.35 $"
#define PHFRINFCNDEFMAP_FILEALIASES  "$Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $"
/*@}*/
/* Completion Helper */
static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t  *NdefMap,
                                        NFCSTATUS            Status);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function reads  
 *  a 16 bytes from the card.
 */
static NFCSTATUS phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   
 *  to find NDEF TLV
 */
static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap, 
                                        uint8_t                 *CRFlag);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   
 *  to check the completing the reading 16 bytes
 */
static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t   *NdefMap,
                                            uint16_t             TempLength);


/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   
 *  to read 16 bytes for the finding the ndef TLV
 */
static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t  *NdefMap,
                                                 uint8_t                BlockNo);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   
 *  to check the remaining size of the 3 byte of length field in TLV
 */
static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t  *NdefMap,
                                              uint8_t             *CRFlag);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   
 *  to byte and block number of the next TLV in the card and updating the 
 *  remaining free space in the card
 */
static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t        *NdefMap,
                                      uint16_t                  DataLen);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL. Depending on the
 * operation (read/write/check ndef), the next function is called
 */
static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t       *NdefMap,
                                       uint8_t                  *CRFlag);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to copy the read bytes to the internal "ReadBuf" buffer 
 */
static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to copy the read bytes to the user buffer 
 */
static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to write 4 bytes to 1 block in the card
 */
static NFCSTATUS   phFriNfc_MfUL_H_Wr4bytes(phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to check the CC bytes in block 3 card
 */
static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to read the TLVs and then start writing
 */
static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to call write operation after reading the NDEF TLV block
 */
static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t        *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to process the written data
 */
static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to fill the send buffer before write
 */
static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to update the length L of the TLV
 */
static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Mifare UL function. This 
 * function is to write the terminator TLV after writing all the bytes
 */
static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t   *NdefMap);

#ifdef LOCK_BITS_CHECK_ENABLE 
    static 
    void
    phFriNfc_MfUL_H_ChkLockBits (
        phFriNfc_NdefMap_t *NdefMap);
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */

/*!
 * \brief \copydoc select sector function for Mifare UL function. This 
 * function is to write the terminator TLV after writing all the bytes
 */
static NFCSTATUS  phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t  *NdefMap,
                                                   uint8_t              SectorNo,
                                                   uint8_t              CmdNo,
                                                   uint8_t              NextState);


static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch, 
                                          uint16_t *lpwCrc );

static void phFriNfc_MfUL_H_ComputeCrc( int      CRCType, 
                                 uint8_t  *Data, 
                                 int      Length,
                                 uint8_t  *TransmitFirst, 
                                 uint8_t  *TransmitSecond
                                 );

static void
phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap);


#define CRC_A 0
#define CRC_B 1


NFCSTATUS phFriNfc_MifareUL_H_Reset(phFriNfc_NdefMap_t        *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    
    if ( NdefMap == NULL)
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER);
    }
    else
    {
        /* TLV structure initialisation */
        NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;
        NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->TLVStruct.prevLenByteValue = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
        NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
        NdefMap->TLVStruct.ActualSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
        NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;

        /* Mifare UL container initialisation */
        NdefMap->MifareULContainer.ByteNumber = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.CurrentSector = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
        NdefMap->MifareULContainer.RemainingSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;

        /* Fill all the structure related buffer to ZERO */
        (void)memset(NdefMap->TLVStruct.NdefTLVBuffer, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL4);
        (void)memset(NdefMap->MifareULContainer.Buffer, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL4);
        (void)memset(NdefMap->MifareULContainer.InternalBuf, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL4);
        (void)memset(NdefMap->MifareULContainer.ReadBuf, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0, 
                    PH_FRINFC_NDEFMAP_MFUL_VAL64);
    }
    return Result;
}

/*!
 * \brief Initiates Reading of NDEF information from the Mifare UL.
 *
 * 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_MifareUL_RdNdef( phFriNfc_NdefMap_t  *NdefMap,
                                    uint8_t             *PacketData,
                                    uint32_t            *PacketDataLength,
                                    uint8_t             Offset)
{
    NFCSTATUS                   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                                    NFCSTATUS_INVALID_PARAMETER);
    
    if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) && 
        (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) && 
        (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 
        (NdefMap->CompletionRoutine->CompletionRoutine != NULL) && 
        (NdefMap->CompletionRoutine->Context != NULL ) && 
        ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INITIALIZED) && 
        (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))
    {
        /*Register PacketData to Data Buffer of NdefMap */
        NdefMap->ApduBuffer = PacketData;
        /*Register PacketDataLength to Data Length of NdefMap */
        NdefMap->ApduBufferSize = *PacketDataLength ;
        /*  To return actual number of bytes read to the caller */
        NdefMap->NumOfBytesRead = PacketDataLength ;
        *NdefMap->NumOfBytesRead = 0;
        
        if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == 
            PH_FRINFC_NDEFMAP_WRITE_OPE))
        {
            NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
            NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
            NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
            NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
            NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;
            NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
            NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
            NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
            NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
        }
        
        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
        NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;

        if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
            (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1))
        {
            /*  No space on card for reading : we have already
                reached the end of file !
                Offset is set to Continue Operation */  
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
        }
        else
        {
            NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 
                                ( NdefMap->PrevOperation != PH_FRINFC_NDEFMAP_READ_OPE))?
                                PH_FRINFC_NDEFMAP_SEEK_BEGIN:
                                Offset);

            Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
            phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, NdefMap->MifareULContainer.CurrentBlock):
            phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap));
        }
    }
    return Result;
}


/*!
 * \brief Initiates writing of NDEF information to the Mifare UL.
 *
 * The function initiates the writing of NDEF information to a Mifare UL.
 * 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_MifareUL_WrNdef( phFriNfc_NdefMap_t  *NdefMap,
                                    uint8_t             *PacketData,
                                    uint32_t            *PacketDataLength,
                                    uint8_t             Offset)
{
      NFCSTATUS                   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                                    NFCSTATUS_INVALID_PARAMETER);
    
    
        if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) && 
            (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) && 
            (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 
            (NdefMap->CompletionRoutine->CompletionRoutine != NULL) && 
            (NdefMap->CompletionRoutine->Context != NULL ) && 
            ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY) && 
            (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))
        {
            NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
            /*Register PacketData to Data Buffer of NdefMap */
            NdefMap->ApduBuffer = PacketData;
            /*Register PacketDataLength to Data Length of NdefMap */
            NdefMap->ApduBufferSize = *PacketDataLength ;
            /*  To return actual number of bytes read to the caller */
            NdefMap->WrNdefPacketLength = PacketDataLength ;
            *NdefMap->WrNdefPacketLength = 0;

            if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == 
                PH_FRINFC_NDEFMAP_READ_OPE))
            {
                NdefMap->MifareULContainer.CurrentSector = NdefMap->TLVStruct.NdefTLVSector;
                NdefMap->MifareULContainer.CurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;
                NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
                NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
                NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
                NdefMap->MifareULContainer.RemainingSize = 
                                    (NdefMap->CardMemSize - 
                                    (((NdefMap->TLVStruct.NdefTLVBlock - 
                                    PH_FRINFC_NDEFMAP_MFUL_BYTE4) * 
                                    PH_FRINFC_NDEFMAP_MFUL_BYTE4) + 
                                    NdefMap->TLVStruct.NdefTLVByte + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1));
            }
            NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
            NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;

            if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
                (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1))
            {
                /*  No space on card for reading : we have already
                    reached the end of file !
                    Offset is set to Continue Operation */  
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
            }
            else
            {
                NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 
                                    ( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))?
                                    PH_FRINFC_NDEFMAP_SEEK_BEGIN:
                                    Offset);

                if (NdefMap->TLVStruct.NdefTLVSector == 1)
                {
                    NdefMap->MifareULContainer.CurrentSector = 1;

                    /* Change to sector 1 */
                    Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                    NdefMap->MifareULContainer.CurrentSector, 1, 
                    PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1);

                }
                else 
                {
                    Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
                        phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):
                        phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));
                }
            }
        }
    

    return Result;
}


/*!
 * \brief Check whether a particular Mifare UL is NDEF compliant.
 *
 * The function checks whether the peer device is NDEF compliant.
 *
 */

NFCSTATUS phFriNfc_MifareUL_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)
{
    NFCSTATUS                   status =    NFCSTATUS_PENDING;
    uint8_t                     index=0,
                                pSensRes[2] = {0};

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

    /*
     *  Changed 
     *  Description: CardInfo106 replase 
     */

    /* retrive remote card information */
    pSensRes[0]  = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0];
                   
    NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;
#ifdef LOCK_BITS_CHECK_ENABLE
    NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK2;
#else
    NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK3;
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
    NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;
        
    /* Check for Mifare Bit information  */
    if (((pSensRes[0] & PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP) == PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP))
    {
        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
        /* set the offset*/
        NdefMap->SendRecvBuf[index] = NdefMap->MifareULContainer.CurrentBlock;
        
        /*set the send length*/
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_MAX_SEND_BUF_TO_READ; 
                                        
        /* Change the state to check ndef compliancy */
        NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP;
        
        /* Set the card type as Mifare UL */
        NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;

        /* set the cmd to mifare read*/
        /* 
         * Changed 
         * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead
         */ 
        NdefMap->Cmd.MfCmd = phHal_eMifareRead;
        
        /* Set the CR and context for Mifare operations*/
        NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;
        NdefMap->MapCompletionInfo.Context = NdefMap;

        /*Set the Length*/
        *NdefMap->SendRecvLength = PH_FRINFC_NDEFMAP_MF_READ_BLOCK_SIZE;
        

        /*Call the Overlapped HAL Transceive function */ 
        status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
                                            &NdefMap->MapCompletionInfo,
                                            NdefMap->psRemoteDevInfo,
                                            NdefMap->Cmd,
                                            &NdefMap->psDepAdditionalInfo,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendLength,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendRecvLength);
    }
    else
    {
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);
    }
    return status;
}

static void
phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap)
{
    uint8_t     i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        

    for (i = 0; i < 16; i++)
    {
        if ((NdefMap->MifareULContainer.ReadBuf[i] ==
        PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) && 
        ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==
        NdefMap->TLVStruct.ActualSize) || 
        (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))
        {
            if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)
            {
                TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |
                ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);

                if (TemLength == NdefMap->TLVStruct.ActualSize)
                {
                    NdefMap->MifareULContainer.ByteNumber = i + 1;
                    break;
                }
            }
            else
            {   
                NdefMap->MifareULContainer.ByteNumber = i + 1;
                break;
            }
        }
     }

    return;
}


#ifdef LOCK_BITS_CHECK_ENABLE 

#define MIF_UL_LOCK_BIT_CHECK           0xFF
#define MIF_UL_LOCK_BIT_0_VALUE         0x0F
#define MIF_UL_LOCK_BIT_1_VALUE         0x00

static 
void
phFriNfc_MfUL_H_ChkLockBits (
    phFriNfc_NdefMap_t *NdefMap)
{
    uint8_t         index = 2;

    if (((NdefMap->SendRecvBuf[index] & 
        MIF_UL_LOCK_BIT_CHECK) > MIF_UL_LOCK_BIT_0_VALUE) ||  
        (MIF_UL_LOCK_BIT_1_VALUE != 
        (NdefMap->SendRecvBuf[(index + 1)] & MIF_UL_LOCK_BIT_CHECK)))
    {
        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
    }
}

#endif /* #ifdef LOCK_BITS_CHECK_ENABLE  */

/*!
 * \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_MifareUL_Process( void        *Context,
                                NFCSTATUS   Status)

{
    
    uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    phFriNfc_NdefMap_t          *NdefMap;
    uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    /*uint16_t                    TempByte = PH_FRINFC_NDEFMAP_MFUL_VAL0; */
    static uint8_t                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;

    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;

    /* set the context to Map module */

    NdefMap = (phFriNfc_NdefMap_t *)Context;    

    if ( Status == NFCSTATUS_SUCCESS )
    {
        switch (NdefMap->State)
        {
            case PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP:
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
                {
                    /* Checks for the Ndef Compliency and validy of the memory size*/ 
                    Status = phFriNfc_MfUL_H_ChkCCBytes(NdefMap);
                    CRFlag = (uint8_t)((Status != NFCSTATUS_SUCCESS)?
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                PH_FRINFC_NDEFMAP_MFUL_FLAG0);

#ifdef LOCK_BITS_CHECK_ENABLE

                    /* Check for lock bits */
                    if (NFCSTATUS_SUCCESS == Status)
                    {
                        phFriNfc_MfUL_H_ChkLockBits(NdefMap);
                    }

#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */

                    /* Find the NDEF TLV */
                    NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
                    Status = ((Status != NFCSTATUS_SUCCESS)?
                                Status:
                                phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 
                                            NdefMap->MifareULContainer.CurrentBlock));
                    CRFlag = (uint8_t)(((Status != NFCSTATUS_PENDING ) || 
                                (CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1))?
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                PH_FRINFC_NDEFMAP_MFUL_FLAG0);

#ifdef PH_HAL4_ENABLE
                    if ((Status != NFCSTATUS_PENDING ) && 
                        (Status != NFCSTATUS_SUCCESS))
                    {
                        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
                    }
#endif /* #ifdef PH_HAL4_ENABLE */
                }               
            break;


            case PH_FRINFC_NDEFMAP_MFUL_STATE_READ:
                /* check the received bytes size equals 16 bytes*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
                {
                    if(NdefMap->MifareULContainer.ReadBufIndex < 
                        (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock - 
						PH_FRINFC_NDEFMAP_MFUL_BLOCK4) 
                            * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))

                    {
                        Status = phFriNfc_MfUL_H_CopyRdBytes(NdefMap);
                    }

                    if (Status == NFCSTATUS_SUCCESS)
                    {
                        if(NdefMap->MifareULContainer.ReadBufIndex >= 
                            (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock - 
							PH_FRINFC_NDEFMAP_MFUL_BLOCK4) 
                            * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))
                        {

                            phFriNfc_MfUL_CalcByteNum(NdefMap);
#if 0
                            for (i = 0; i < 16; i++)
                            {
                                if ((NdefMap->MifareULContainer.ReadBuf[i] ==
                                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) && 
                                    ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==
                                    NdefMap->TLVStruct.ActualSize) || 
                                    (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))
                                {
                                    if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)
                                    {
                                        TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |
                                            ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);
 
                                        if (TemLength == NdefMap->TLVStruct.ActualSize)
                                        {
                                            NdefMap->MifareULContainer.ByteNumber = i + 1;
                                            break;
                                        }
                                    }
                                    else
                                    {   
                                        NdefMap->MifareULContainer.ByteNumber = i + 1;
                                        break;
                                    }
                                }
                            }
#endif                          
 
                            if (NdefMap->MifareULContainer.ReadBuf
                                [NdefMap->MifareULContainer.ByteNumber] == 0xFF)
                            {
                                NdefMap->MifareULContainer.ByteNumber =
                                    NdefMap->MifareULContainer.ByteNumber + 3;
                            }
                            else
                            {
                                NdefMap->MifareULContainer.ByteNumber =
                                    NdefMap->MifareULContainer.ByteNumber + 1;
                            }
                        
                            Status = phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap);
                            if (NdefMap->MifareULContainer.CurrentSector > 0)
                            {
                                NdefMap->MifareULContainer.CurrentSector = 0;
                                NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;
                                    
                                Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                                    NdefMap->MifareULContainer.CurrentSector, 1,
                                    PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
                                CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                            }
                            else
                            {
                                CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                            }
                        }
                        else
                        {
                            Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
                            CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                        }
                    }
                    else
                    {
                        
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE:
                Status = phFriNfc_MfUL_H_ProWrittenBytes(NdefMap);
                CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
            break;
            
            case PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP: 
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
                {
                    switch(NdefMap->PrevOperation)
                    {
                    case PH_FRINFC_NDEFMAP_CHECK_OPE:
                    case PH_FRINFC_NDEFMAP_READ_OPE:
                            CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                            if(NdefMap->TLVStruct.NoLbytesinTLV > 
                                PH_FRINFC_NDEFMAP_MFUL_VAL0)
                            {
                                Status = phFriNfc_MfUL_H_ChkRemainTLV(NdefMap, &CRFlag);
                            }
                            else
                            {
                                if(NdefMap->TLVStruct.NdefTLVFoundFlag != 
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1)
                                {
                                    /* Find the NDEF TLV */
                                    Status = phFriNfc_MfUL_H_findNDEFTLV(NdefMap, &CRFlag);
                                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                                }
                            }
                            if((NdefMap->TLVStruct.NdefTLVFoundFlag == 
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 
                                (NdefMap->TLVStruct.NoLbytesinTLV == 
                                PH_FRINFC_NDEFMAP_MFUL_VAL0))
                            {
                                CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                                /* Ndef TLV found, so call the next function depending on the 
                                    check/read/write ndef operation */

                                if (NdefMap->MifareULContainer.CurrentSector > 0)
                                {
                                    NdefMap->MifareULContainer.CurrentSector = 0;
                                    NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;
                                    
                                    Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                                        NdefMap->MifareULContainer.CurrentSector, 1,
                                        PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
                                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                                }
                                else 
                                {
                                    /* Sector is 0 no need to send sector select */
                                    Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);
                                }
                            }

#ifdef PH_HAL4_ENABLE
                            if ((Status != NFCSTATUS_PENDING ) && 
                                (Status != NFCSTATUS_SUCCESS) && 
                                (PH_FRINFC_NDEFMAP_CHECK_OPE == 
                                NdefMap->PrevOperation))
                            {
                                NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
                            }
#endif /* #ifdef PH_HAL4_ENABLE */
                        break;

                    case PH_FRINFC_NDEFMAP_WRITE_OPE:
                        /* Remove UpdateWrLen */
                        Status = ((NdefMap->TLVStruct.WrLenFlag == 
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1)?
                                    phFriNfc_MfUL_H_UpdateWrLen(NdefMap):
                                    phFriNfc_MfUL_H_CallWrOp(NdefMap));
                        CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                        break;

                    default:
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_REMOTE_DEVICE);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                        break;

                    }
                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV:
                Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
                CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV:
                if(((((NdefMap->TLVStruct.NdefTLVByte - 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1) == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL3) && 
                    (NdefMap->MifareULContainer.CurrentBlock == 
                    (NdefMap->TLVStruct.NdefTLVBlock + 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1))) || 
                    (((NdefMap->TLVStruct.NdefTLVByte - 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1) < 
                    PH_FRINFC_NDEFMAP_MFUL_VAL3) && (
                    NdefMap->MifareULContainer.CurrentBlock == 
                    NdefMap->TLVStruct.NdefTLVBlock))))
                {
                    (void)memcpy(NdefMap->MifareULContainer.InternalBuf, 
                                NdefMap->MifareULContainer.Buffer,
                                NdefMap->MifareULContainer.InternalLength);             
                }
                (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 
                            NdefMap->MifareULContainer.Buffer,
                            PH_FRINFC_NDEFMAP_MFUL_VAL4);

                NdefMap->CardState =(uint8_t) ((NdefMap->CardState == 
                                    PH_NDEFMAP_CARD_STATE_INITIALIZED)?
                                    PH_NDEFMAP_CARD_STATE_READ_WRITE:
                                    NdefMap->CardState);
                NdefMap->ApduBuffIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
                NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL0;

                if (NdefMap->MifareULContainer.CurrentSector > 0)
                {
                    /* Reset sector */
                    NdefMap->MifareULContainer.CurrentSector = 0;
                    NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;
                                                
                    Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 1,
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                }
                else
                {
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                }
                
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2);
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2:
                {
                    NdefMap->MifareULContainer.CurrentBlock += 
                                PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
                    
                    Status = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                NdefMap->MifareULContainer.CurrentBlock);
                }
            break;  

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2:
                {
                    if (NdefMap->MifareULContainer.CurrentBlock == 0xFF)
                    {
                        NdefMap->MifareULContainer.CurrentBlock = 0;
                    }
                    else 
                    {
                        NdefMap->MifareULContainer.CurrentBlock = 
                            (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;
                    }
                    
                    Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                }
            break;  

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2);
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2:
                {
                    NdefMap->MifareULContainer.CurrentBlock = 0;
                    Status = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);
                    
                    if((Status == NFCSTATUS_SUCCESS) && 
                        (NdefMap->TLVStruct.SetTermTLVFlag != 
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 
                            (NdefMap->MifareULContainer.RemainingSize > 
                            PH_FRINFC_NDEFMAP_MFUL_VAL0))
                    {
                        Status = phFriNfc_MfUL_H_WrTermTLV(NdefMap);
                    }
                    else 
                    {
                        if((Status == NFCSTATUS_SUCCESS) && 
                            (NdefMap->TLVStruct.SetTermTLVFlag == 
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1))
                        {
                            Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
                        }
                    }                   

                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                }
            break;  

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2);
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2:
                {
                    Status = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
                        phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):
                        phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));
                    
                    
                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                }
            break;  


            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2);
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2:
                {
                    NdefMap->MifareULContainer.CurrentBlock = 0;

                    NdefMap->SendRecvBuf[index] = 
                                        NdefMap->MifareULContainer.CurrentBlock;
                    index++;
                    NdefMap->SendRecvBuf[index] = 
                                            PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                    index++;        

                    if((((NdefMap->TLVStruct.NdefTLVByte - 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || 
                            ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) 
                            == PH_FRINFC_NDEFMAP_MFUL_VAL3)))
                        {
                            /* Length to know how many bytes has to be written to the card */
                        TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                                        PH_FRINFC_NDEFMAP_MFUL_VAL2:
                                        PH_FRINFC_NDEFMAP_MFUL_VAL3);

                        if(NdefMap->ApduBufferSize >= TemLength)
                        {
                            /* Prepare the receive buffer */
                            (void)memcpy(&(NdefMap->SendRecvBuf[ 
                                            index]),
                                            &(NdefMap->ApduBuffer[ 
                                            NdefMap->ApduBuffIndex]),
                                            TemLength);

                            /* Number of bytes written to the card from user buffer */
                            NdefMap->NumOfBytesWritten = TemLength;

                            index = index+(uint8_t)TemLength;
                            /* Exact number of bytes written in the card including TLV */
                            *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
                        }
                        else
                        {
                            /* Prepare the receive buffer */
                            (void)memcpy(&(NdefMap->SendRecvBuf[ 
                                            index]),
                                            &(NdefMap->ApduBuffer[ 
                                            NdefMap->ApduBuffIndex]),
                                            (uint16_t)NdefMap->ApduBufferSize);

                            /* Number of bytes written to the card from user buffer */
                            NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;

                            index= index +(uint8_t)NdefMap->ApduBufferSize;
                            /* Exact number of bytes written in the card including TLV */
                            *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);

                            for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)
                            {
                                NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?
                                        PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
                                        PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
                                NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                            }
                        }

                        /* store the bytes in buffer till the bytes are 
                            written in a block */
                        (void)memcpy(NdefMap->MifareULContainer.Buffer,
                                        &(NdefMap->SendRecvBuf[ 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL1]), 
                                        (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL1));

                        (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
                                    NdefMap->MifareULContainer.Buffer,
                                    (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL1));
                        
                        /* Change the state to check ndef compliancy */
                        NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;

                        Status = phFriNfc_MfUL_H_Wr4bytes(NdefMap);                 
                    }

                    
                    CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                }
            break;  

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1:
                 /* check the received bytes size equals 1 byte*/
                if (*NdefMap->SendRecvLength == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1)
                {
                    if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
                    {
                        /* Send second command */
                        Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                            NdefMap->MifareULContainer.CurrentSector, 2, 
                            PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2);
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_FORMAT);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                }
                else
                {
                    /* read error */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_RECEIVE_LENGTH);
                    CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                }
            break;

            case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2:
                {
                    if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP)
                    {
                        Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);
                    }
                    else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_READ)
                    {
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                    else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE)
                    {
                        Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
                        CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
                            PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                            PH_FRINFC_NDEFMAP_MFUL_FLAG0);
                    }
                    else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV)
                    {
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    }
                    else
                    {
                        /* read error */
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_READ_FAILED);
                        CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;

                    }
                }
            break;  

            default:
                /*set the invalid state*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
                phFriNfc_MifareUL_H_Complete(NdefMap, Status);
            break;
        }
        if(CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1)
        {
            /* call the CR routine*/
            phFriNfc_MifareUL_H_Complete(NdefMap, Status);
        }
    }
    else
    {
        phFriNfc_MifareUL_H_Complete(NdefMap,Status);
    }
}

static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t  *NdefMap )
{
    NFCSTATUS Result = PHNFCSTVAL(  CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);
    
#ifdef LOCK_BITS_CHECK_ENABLE        
        switch(NdefMap->SendRecvBuf[7])     
#else
        switch(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE3])        
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 
        {
            case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RW:
                /* This state can be either INITIALISED or READWRITE. but default 
                    is INITIALISED */
                NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
                break;

            case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RO:
                NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
                break;

            default :
                NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
        }


        /* Check for Ndef compliancy : 0 and 1 byte spcifies the ndef compliancy
           2 byte specifies the version of the MF UL tag*/
#ifdef LOCK_BITS_CHECK_ENABLE
        if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE4] ==  
#else
        if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE0] ==         
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 
            PH_FRINFC_NDEFMAP_MFUL_CC_BYTE0) && (
            (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED) || 
            (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)))
        {
            /* Check the version number */
            Result =phFriNfc_MapTool_ChkSpcVer( NdefMap,
#ifdef LOCK_BITS_CHECK_ENABLE
                                                5);

#else
                                                PH_FRINFC_NDEFMAP_MFUL_BYTE1);

#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 
#if 0
#ifdef PH_NDEF_MIFARE_ULC
            if (Result == NFCSTATUS_SUCCESS)
            {
#ifdef LOCK_BITS_CHECK_ENABLE

                if (NdefMap->SendRecvBuf[6] == 0x06)
                {
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   
                } 
                else if (NdefMap->SendRecvBuf[6] == 0x12)
                {
//                  NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   
                }               

#else /* #ifdef LOCK_BITS_CHECK_ENABLE */

                if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x06)
                {
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   
                } 
                else if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x12)
                {
//                  NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   
                }

#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
                else
                {
                    Result = PHNFCSTVAL(  CID_FRI_NFC_NDEF_MAP, 
                                                        NFCSTATUS_INVALID_REMOTE_DEVICE);
                }
            }
#else   
            
        /*  Check the CC header size: Only valid ones are
                0x06 for 48 bytes. */
#ifdef LOCK_BITS_CHECK_ENABLE
            Result = ((( NdefMap->SendRecvBuf[6] != 
#else /* #ifdef LOCK_BITS_CHECK_ENABLE */
            Result = ((( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] != 
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
                        PH_FRINFC_NDEFMAP_MFUL_CC_BYTE2) || (Result != 
                        NFCSTATUS_SUCCESS))?
                        (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                        NFCSTATUS_INVALID_REMOTE_DEVICE)):
                        Result);
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
#endif
            NdefMap->MifareULContainer.RemainingSize = 
            NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)?
#ifdef LOCK_BITS_CHECK_ENABLE
                                    (NdefMap->SendRecvBuf[6] * 
#else /* #ifdef LOCK_BITS_CHECK_ENABLE */
                                    (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] * 
#endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
                                    PH_FRINFC_NDEFMAP_MFUL_MUL8):
                                    NdefMap->CardMemSize);

            if (NdefMap->CardMemSize > 256)
            {
                NdefMap->CardMemSize = NdefMap->CardMemSize - 2;
                NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;
            }
                
        }
        else
        {
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
        }

    
    return Result;
}

/*!
 * \brief this shall notify the integration software with respective
 *  success/error status along with the completion routines.
 *
 *  This routine is called from the mifareul process function.
 *
 */

static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t  *NdefMap,
                                        NFCSTATUS            Status)
{
    if(NdefMap!=NULL)
    {
        if((PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE   ==  NdefMap->State)
            &&  (NFCSTATUS_SUCCESS !=  Status))
        {
            *NdefMap->WrNdefPacketLength    =   0;
        }
        /* set the state back to the Reset_Init state*/
        NdefMap->State =  PH_FRINFC_NDEFMAP_STATE_RESET_INIT;

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

static NFCSTATUS   phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                    NFCSTATUS_INVALID_PARAMETER);

    NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;

    /*  Set the previous operation flag to read. */
    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;

    /*  Have we already read the entire file? */
    if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)
    {
        /* set the data for additional data exchange */
        NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 
                                NdefMap->MifareULContainer.CurrentBlock;
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;
        *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
        /*
         * Changed 
         * Description: replace with  phHal_eMifareRead
         */

        NdefMap->Cmd.MfCmd =  phHal_eMifareRead;
        
        /* Call the overlapped HAL Transceive function */ 
        Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,
                                                &NdefMap->MapCompletionInfo,
                                                NdefMap->psRemoteDevInfo,
                                                NdefMap->Cmd,
                                                &NdefMap->psDepAdditionalInfo,
                                                NdefMap->SendRecvBuf,
                                                NdefMap->SendLength,
                                                NdefMap->SendRecvBuf,
                                                NdefMap->SendRecvLength);
    }
    return Result;
}

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

    /* set the receive length*/
    *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
                                    
    NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
    
    /*
     * Changed
     * Description: phHal_eMifareCmdListMifareWrite4 replace with phHal_eMifareWrite4
     */
    /* set the cmd to mifare read*/
    NdefMap->Cmd.MfCmd = phHal_eMifareWrite4;
    
    /* Set the CR and context for Mifare operations*/
    NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;
    NdefMap->MapCompletionInfo.Context = NdefMap;

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

static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t     *NdefMap, 
                                            uint8_t                 *CRFlag)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint16_t    ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                Temp16Bytes = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    Temp16Bytes = ((NdefMap->TLVStruct.NdefTLVByte > PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                    (NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1):
                    NdefMap->TLVStruct.NdefTLVByte);
    for(;;)
    {
        if(NdefMap->SendRecvBuf[Temp16Bytes] == 
                        PH_FRINFC_NDEFMAP_MFUL_NULLTLV)
        {
            NdefMap->MifareULContainer.RemainingSize -= 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1;
#ifdef PH_HAL4_ENABLE
            /* This check is added to know the remaining size in 
            the card is not 0, if this is 0, then complete card has 
            been read */
            if (NdefMap->MifareULContainer.RemainingSize == 
                        PH_FRINFC_NDEFMAP_MFUL_VAL0)
            {
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);
                break;
            }
            else
            {
                Result = NFCSTATUS_SUCCESS;                
            }
#else
            Result = ((NdefMap->MifareULContainer.RemainingSize == 
                        PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                        (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT)):
                        NFCSTATUS_SUCCESS);
#endif /* #ifdef PH_HAL4_ENABLE */
            Temp16Bytes++;
#ifdef PH_HAL4_ENABLE
            /* This code is added to read next 16 bytes. This means previous 
            16 bytes read contains only NULL TLV, so read further to get the 
            NDEF TLV */
            Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                Temp16Bytes);
            if(NFCSTATUS_SUCCESS != Result)
            {
                NdefMap->TLVStruct.NdefTLVBlock = 
                    NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL4;
                break;
            }
#endif /* #ifdef PH_HAL4_ENABLE */
        }
        else
        {
            Result = ((NdefMap->SendRecvBuf[Temp16Bytes] == 
                        PH_FRINFC_NDEFMAP_MFUL_TERMTLV)?
                        (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT)):
                        NFCSTATUS_SUCCESS);

            if(Result != NFCSTATUS_SUCCESS)
            {
                *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                break;
            }
            
#ifdef PH_NDEF_MIFARE_ULC
            if ((NdefMap->SendRecvBuf[Temp16Bytes] == 
                        PH_FRINFC_NDEFMAP_MFUL_LOCK_CTRL_TLV) ||
                        (NdefMap->SendRecvBuf[Temp16Bytes] == 
                        PH_FRINFC_NDEFMAP_MFUL_MEM_CTRL_TLV) )  
            {

                 NdefMap->TLVStruct.NdefTLVByte = 
                                    ((Temp16Bytes % 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1);
            
                 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                Temp16Bytes);
                if(Result != NFCSTATUS_SUCCESS)
                {
                    NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    NdefMap->TLVStruct.NoLbytesinTLV = 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL3;
                    break;
                }
                Temp16Bytes++;
                NdefMap->MifareULContainer.RemainingSize -= 
                                PH_FRINFC_NDEFMAP_MFUL_VAL1;

                if(NdefMap->MifareULContainer.RemainingSize == 
                  PH_FRINFC_NDEFMAP_MFUL_VAL0)
                {
                    Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_NO_NDEF_SUPPORT));
                    break;
                }
                
                Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                    Temp16Bytes);
                if(Result != NFCSTATUS_SUCCESS)
                {
                    NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                        PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    NdefMap->TLVStruct.NoLbytesinTLV = 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL3;
                    break;
                }


                 /* If the value of the Length(L) in TLV is FF then enter else
                            check for the card memory */
                if((NdefMap->SendRecvBuf[Temp16Bytes] == 
                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 
                    ((NdefMap->SendRecvBuf[Temp16Bytes] == 
                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 
                    (NdefMap->TLVStruct.NdefTLVFoundFlag != 
                    PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
                {
                    /* In the present case, the card space is not greater 
                        than 0xFF */
                    Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_NO_NDEF_SUPPORT);

                    *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    break;
                }
                else
                {
                    NdefMap->TLVStruct.BytesRemainLinTLV = 
                                    NdefMap->SendRecvBuf[Temp16Bytes];

                    NdefMap->TLVStruct.ActualSize = 
                                    NdefMap->SendRecvBuf[Temp16Bytes];

                    if((NdefMap->MifareULContainer.RemainingSize < 
                        NdefMap->SendRecvBuf[Temp16Bytes]) || 
                        (NdefMap->MifareULContainer.RemainingSize < 
                        PH_FRINFC_NDEFMAP_MFUL_VAL2) || 
                        (NdefMap->TLVStruct.BytesRemainLinTLV > 
                        (NdefMap->MifareULContainer.RemainingSize)) || 
                        ((NdefMap->TLVStruct.BytesRemainLinTLV == 
                        PH_FRINFC_NDEFMAP_MFUL_VAL0) && 
                        (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
                    {
                        /* No NDEF TLV found */
                        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                            NFCSTATUS_NO_NDEF_SUPPORT);
                        *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                        break;
                    }
                    
                    if(NdefMap->TLVStruct.NdefTLVFoundFlag != 
                        PH_FRINFC_NDEFMAP_MFUL_FLAG1)
                    {
                        NdefMap->TLVStruct.NdefTLVByte = 
                                        (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
                                        NdefMap->SendRecvBuf[Temp16Bytes]) % 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL1);
#if 0                       
                        NdefMap->TLVStruct.NdefTLVBlock = 
                                        (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 
                                        + ((Temp16Bytes + 
                                        NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL4));
#endif
                        NdefMap->TLVStruct.NdefTLVBlock = 
                                        (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock / PH_FRINFC_NDEFMAP_MFUL_VAL4) * 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL4)
                                            + ((Temp16Bytes + NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL4));


                        TemLength = (Temp16Bytes + 
                                NdefMap->SendRecvBuf[Temp16Bytes]);

                        NdefMap->MifareULContainer.RemainingSize = 
                                        (NdefMap->MifareULContainer.RemainingSize -
                                        (NdefMap->SendRecvBuf[Temp16Bytes]
                                        + PH_FRINFC_NDEFMAP_MFUL_VAL1)); 

                        /* If the Length (L) in TLV < 16 bytes */
                        Temp16Bytes = ((TemLength >= 
                                PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
                                PH_FRINFC_NDEFMAP_MFUL_VAL0:
                                (TemLength + 
                                PH_FRINFC_NDEFMAP_MFUL_VAL1));

                        Result = ((TemLength >= 
                                PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
                                phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                            NdefMap->TLVStruct.NdefTLVBlock):
                                NFCSTATUS_SUCCESS);
                        
                        if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
                        {
                            break;
                        }
                        TemLength = Temp16Bytes;
                    }
                }


#if 0   
            
                 NdefMap->MifareULContainer.RemainingSize = 
                                    (NdefMap->MifareULContainer.RemainingSize -
                                    (NdefMap->SendRecvBuf[Temp16Bytes + 1]
                                    + PH_FRINFC_NDEFMAP_MFUL_VAL2)); 

                NdefMap->TLVStruct.NdefTLVBlock = 
                                    (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 
                                    + ((Temp16Bytes + 
                                    NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2)/ 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4));

                
                Temp16Bytes = Temp16Bytes + 
                        NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2;
#endif                
            }
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
            else {
                
            /* Check the byte for 0x03 Type of NDEF TLV */
            NdefMap->TLVStruct.NdefTLVFoundFlag = 
                    ((NdefMap->SendRecvBuf[Temp16Bytes] == 
                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T)?
                    PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                    PH_FRINFC_NDEFMAP_MFUL_FLAG0);

            if(NdefMap->TLVStruct.NdefTLVFoundFlag == 
                PH_FRINFC_NDEFMAP_MFUL_FLAG1)
            {
                ShiftLength = (Temp16Bytes + 
                                    NdefMap->SendRecvBuf[Temp16Bytes]);

                 NdefMap->TLVStruct.NdefTLVByte = 
                                    ((Temp16Bytes % 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1);

                NdefMap->TLVStruct.NdefTLVBlock = 
                                    (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock /4) * 4)
                                    + (Temp16Bytes)/ 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4);
                
                NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;
                
            }            
#ifdef PH_HAL4_ENABLE
            else
            {
                /* if the Type of the NDEF TLV is not found, then return  
                    error saying no ndef TLV found*/
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);
                break;
#if 0
                /* This change is added to continue the loop, if the Type of the 
                    NDEF TLV is not found 
                    16 bytes are read, so for each byte, there is a check for the 
                    Type (T) of the TLV, if T != 0x03, then increment the byte 
                    count and restart the loop, till the T = 0x03 is found or all 
                    the bytes in the card is completely read.
                */
                Temp16Bytes = (uint16_t)(Temp16Bytes + 1);
                NdefMap->MifareULContainer.RemainingSize -= 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1;
                if (NdefMap->MifareULContainer.RemainingSize == 
                            PH_FRINFC_NDEFMAP_MFUL_VAL0)
                {                    
                    Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_NO_NDEF_SUPPORT);
                    break;
                }
                else
                {
                    Result = NFCSTATUS_SUCCESS;
                    Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                Temp16Bytes);
                    if(NFCSTATUS_PENDING == Result)
                    {
                        break;
                    }
                    continue;                    
                }
#endif /* #if 0 */
            }
#endif /* #ifdef PH_HAL4_ENABLE */

            Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                Temp16Bytes);
            if(Result != NFCSTATUS_SUCCESS)
            {
                NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                        PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                NdefMap->TLVStruct.NoLbytesinTLV = 
                                        PH_FRINFC_NDEFMAP_MFUL_VAL3;
                break;
            }
            Temp16Bytes++;
            NdefMap->MifareULContainer.RemainingSize -= 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1;

            if(NdefMap->MifareULContainer.RemainingSize == 
              PH_FRINFC_NDEFMAP_MFUL_VAL0)
            {
                Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT));
                break;
            }
            
            Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                Temp16Bytes);
            if(Result != NFCSTATUS_SUCCESS)
            {
                NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                    PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                NdefMap->TLVStruct.NoLbytesinTLV = 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL3;
                break;
            }
            
            /* If the value of the Length(L) in TLV is FF then enter else
                check for the card memory */
            if((NdefMap->SendRecvBuf[Temp16Bytes] == 
                PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 
                ((NdefMap->SendRecvBuf[Temp16Bytes] == 
                PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 
                (NdefMap->TLVStruct.NdefTLVFoundFlag != 
                PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
            {
                /* In the present case, the card space is not greater 
                    than 0xFF */
                /*
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);

                *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                break;
                */

                Temp16Bytes++;
                Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                    Temp16Bytes);
                if(Result != NFCSTATUS_SUCCESS)
                {
                    NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    NdefMap->TLVStruct.NoLbytesinTLV = 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL2;
                    
                    break;
                }
                
                ShiftLength = (uint16_t) NdefMap->SendRecvBuf[Temp16Bytes];
                NdefMap->MifareULContainer.RemainingSize--;

                Temp16Bytes++;
                Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
                                                    Temp16Bytes);
                if(Result != NFCSTATUS_SUCCESS)
                {
                    NdefMap->TLVStruct.TcheckedinTLVFlag = 
                                            PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    NdefMap->TLVStruct.NoLbytesinTLV = 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL1;
                    NdefMap->TLVStruct.prevLenByteValue = 
                                    NdefMap->SendRecvBuf[Temp16Bytes - 1];
                    break;
                }


                ShiftLength = 
                    (uint16_t) (NdefMap->SendRecvBuf[Temp16Bytes]
                         | (ShiftLength << PH_FRINFC_NDEFMAP_MFUL_SHIFT8));

    //          NdefMap->MifareULContainer.RemainingSize--;

                if(ShiftLength > (NdefMap->MifareULContainer.RemainingSize))
                {
                    // Size in the Length(L) of TLV is greater 
                    //than the actual size of the card 
                    Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_INVALID_PARAMETER);
                    *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    break;
                }

        //      NdefMap->MifareULContainer.RemainingSize--;
                /*
                NdefMap->TLVStruct.NdefTLVByte = 
                                    (NdefMap->SendRecvBuf[Temp16Bytes] % 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4);
                
                NdefMap->TLVStruct.NdefTLVBlock = 
                                (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 
                            + (Temp16Bytes/PH_FRINFC_NDEFMAP_MFUL_VAL4));
                */  
                
                NdefMap->TLVStruct.ActualSize = 
                    NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
                    
                NdefMap->TLVStruct.NdefTLVFoundFlag = 1;
                
                NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;

                
                Result = ((NdefMap->TLVStruct.NoLbytesinTLV == 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                                    phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):
                                    Result);
/*  
                Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                                    NdefMap->TLVStruct.NdefTLVBlock);
*/
                break;
            }
            else
            {
                NdefMap->TLVStruct.BytesRemainLinTLV = 
                                NdefMap->SendRecvBuf[Temp16Bytes];

                NdefMap->TLVStruct.ActualSize = 
                                NdefMap->SendRecvBuf[Temp16Bytes];

                if((NdefMap->MifareULContainer.RemainingSize < 
                    NdefMap->SendRecvBuf[Temp16Bytes]) || 
                    (NdefMap->MifareULContainer.RemainingSize < 
                    PH_FRINFC_NDEFMAP_MFUL_VAL2) || 
                    (NdefMap->TLVStruct.BytesRemainLinTLV > 
                    (NdefMap->MifareULContainer.RemainingSize)) || 
                    ((NdefMap->TLVStruct.BytesRemainLinTLV == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0) && 
                    (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
                {
                    /* No NDEF TLV found */
                    Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                        NFCSTATUS_NO_NDEF_SUPPORT);
                    *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                    break;
                }
                
                if(NdefMap->TLVStruct.NdefTLVFoundFlag != 
                    PH_FRINFC_NDEFMAP_MFUL_FLAG1)
                {
                    NdefMap->TLVStruct.NdefTLVByte = 
                                    (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
                                    NdefMap->SendRecvBuf[Temp16Bytes]) % 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1);
                    NdefMap->TLVStruct.NdefTLVBlock = 
                                    (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 
                                    + ((Temp16Bytes + 
                                    NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4));

                    TemLength = (Temp16Bytes + 
                            NdefMap->SendRecvBuf[Temp16Bytes]);

                    NdefMap->MifareULContainer.RemainingSize = 
                                    (NdefMap->MifareULContainer.RemainingSize -
                                    (NdefMap->SendRecvBuf[Temp16Bytes]
                                    + PH_FRINFC_NDEFMAP_MFUL_VAL1)); 

                    /* If the Length (L) in TLV < 16 bytes */
                    Temp16Bytes = ((TemLength >= 
                            PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
                            PH_FRINFC_NDEFMAP_MFUL_VAL0:
                            (TemLength + 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1));

                    Result = ((TemLength >= 
                            PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
                            phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                        NdefMap->TLVStruct.NdefTLVBlock):
                            NFCSTATUS_SUCCESS);
                    
                    if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
                    {
                        break;
                    }
                    TemLength = Temp16Bytes;
                }
            }
            if(NdefMap->TLVStruct.NdefTLVFoundFlag == 
                        PH_FRINFC_NDEFMAP_MFUL_FLAG1)
            {
#if 0
                NdefMap->TLVStruct.NdefTLVBlock = 
                                    (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 
                                    + ((Temp16Bytes + 1)/ 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL4)) - 1;
#endif
                NdefMap->MifareULContainer.RemainingSize = 
                                    (NdefMap->MifareULContainer.RemainingSize -
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1);
                    ShiftLength = NdefMap->SendRecvBuf[Temp16Bytes];
                    Result = ((NdefMap->TLVStruct.NoLbytesinTLV == 
                            PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                            phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):
                            Result);

                break;
            }
        }
        }   
    }

    return Result;
}


static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t   *NdefMap,
                                            uint16_t             TempLength)
{
    uint16_t localCurrentBlock;
    
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    if(TempLength == PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
    {
        localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock +
                            PH_FRINFC_NDEFMAP_MFUL_BLOCK4;

        if (localCurrentBlock < 256)
        {
            NdefMap->MifareULContainer.CurrentBlock += 
                                PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
                        
            Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                            NdefMap->MifareULContainer.CurrentBlock);
        }
        else 
        {
            /* Go to next sector */
            NdefMap->MifareULContainer.CurrentSector++;

            Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                NdefMap->MifareULContainer.CurrentSector, 1, 
                PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1);
        }
    }

    return Result;
}


static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch, 
                                          uint16_t *lpwCrc )
{
    ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF));
    ch = (ch^(ch<<4));
    *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^ \
                ((uint16_t)ch<<3)^((uint16_t)ch>>4);
    
    return;
}

static void phFriNfc_MfUL_H_ComputeCrc( int      CRCType, 
                                 uint8_t  *Data, 
                                 int      Length,
                                 uint8_t  *TransmitFirst, 
                                 uint8_t  *TransmitSecond
                                 )
{
    uint8_t chBlock;
    uint16_t wCrc;
    switch(CRCType) 
    {
    case CRC_A:
        wCrc = 0x6363; /* ITU-V.41 */
        break;
    case CRC_B:
        wCrc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
        break;
    default:
        return;
    }

    do 
    {
        chBlock = *Data++;
        phFriNfc_MfUL_H_UpdateCrc(chBlock, &wCrc);
    } while (--Length);
    *TransmitFirst = (uint8_t) (wCrc & 0xFF);
    *TransmitSecond = (uint8_t) ((wCrc >> 8) & 0xFF);
    return;
}


static NFCSTATUS  phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t  *NdefMap,
                                                   uint8_t              SectorNo,
                                                   uint8_t              CmdNo,
                                                   uint8_t              NextState)
{
    
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;

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

    NdefMap->State = NextState;

    if (CmdNo == 1)
    {
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0xC2;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0xFF;
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL4;                                               
    }
    else
    {
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = SectorNo;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL4] = 0;
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL5] = 0;
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL5 + 1;
    }
    
    /* Calculate CRC */

    phFriNfc_MfUL_H_ComputeCrc(CRC_A, &NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2], 
            NdefMap->SendLength - 2, 
            &NdefMap->SendRecvBuf[NdefMap->SendLength], 
            &NdefMap->SendRecvBuf[NdefMap->SendLength + 1]);
    
    NdefMap->SendLength += PH_FRINFC_NDEFMAP_MFUL_VAL2; 

    
    *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
     
    NdefMap->Cmd.MfCmd = phHal_eMifareRaw;
     
    /* Call the overlapped HAL Transceive function */ 
    Result = phFriNfc_OvrHal_Transceive(     NdefMap->LowerDevice,
                                             &NdefMap->MapCompletionInfo,
                                             NdefMap->psRemoteDevInfo,
                                             NdefMap->Cmd,
                                             &NdefMap->psDepAdditionalInfo,
                                             NdefMap->SendRecvBuf,
                                             NdefMap->SendLength,
                                             NdefMap->SendRecvBuf,
                                             NdefMap->SendRecvLength);
     return Result;
}


static NFCSTATUS   phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t  *NdefMap,
                                                   uint8_t              BlockNo)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;
    /* set the data for additional data exchange */
    NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 
                                                    BlockNo;
    NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;
    *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
    
    /* 
     * Changed 
     * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead
     */
    NdefMap->Cmd.MfCmd = phHal_eMifareRead;
    
    /* Call the overlapped HAL Transceive function */ 
    Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,
                                            &NdefMap->MapCompletionInfo,
                                            NdefMap->psRemoteDevInfo,
                                            NdefMap->Cmd,
                                            &NdefMap->psDepAdditionalInfo,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendLength,
                                            NdefMap->SendRecvBuf,
                                            NdefMap->SendRecvLength);
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t  *NdefMap,
                                              uint8_t             *CRFlag)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint16_t    TempLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;

    switch(NdefMap->TLVStruct.NoLbytesinTLV)
    {
        case PH_FRINFC_NDEFMAP_MFUL_VAL1:
        case PH_FRINFC_NDEFMAP_MFUL_VAL2:
            ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1)?
                            NdefMap->TLVStruct.prevLenByteValue:
                            NdefMap->SendRecvBuf[TempLength]);
            ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1)?
                            (((uint16_t)(NdefMap->SendRecvBuf[TempLength]) << 
                            PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 
                            ShiftLength):
                            (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1)]) << 
                            PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 
                            ShiftLength));

            NdefMap->MifareULContainer.RemainingSize -= 
                                            PH_FRINFC_NDEFMAP_MFUL_VAL1;

            NdefMap->TLVStruct.ActualSize = 
            NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;

            /* Check for remaining free space in the card with the 
                length (L) of TLV OR length(L) of TLV is less than 
                255 bytes (The length (L) of TLV for 3 byte should not 
                be less than 255) */ 
            Result = ((((NdefMap->MifareULContainer.RemainingSize)<= 
                        ShiftLength) || (ShiftLength < 
                        PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF))?
                        (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                        NFCSTATUS_INVALID_PARAMETER)):
                        Result);

            
            Result = ((Result == NFCSTATUS_SUCCESS)?
                            phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):
                            Result);

            *CRFlag = (uint8_t)((Result == (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                        NFCSTATUS_INVALID_PARAMETER)))?
                        PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                        PH_FRINFC_NDEFMAP_MFUL_FLAG0);


            if(Result == NFCSTATUS_SUCCESS)
            {

                NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
                    NdefMap->TLVStruct.NoLbytesinTLV;
/*              
                NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% 
                        PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1);
                       
                NdefMap->TLVStruct.NdefTLVBlock = 
                        (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 
                        + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));
                NdefMap->MifareULContainer.CurrentBlock = 
                                NdefMap->TLVStruct.NdefTLVBlock;

                Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 
                                                NdefMap->TLVStruct.NdefTLVBlock);
                                                */
            }
            break;      

        default:
            if((NdefMap->SendRecvBuf[TempLength] == 
                PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 
                ((NdefMap->SendRecvBuf[TempLength] == 
                PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 
                (NdefMap->TLVStruct.NdefTLVFoundFlag != 
                PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
            {
                /* In the present case, the card space is not greater 
                    than 0xFF */
/*                    
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);

                *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
                
*/
            
                ShiftLength = NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL1)];
                ShiftLength = (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL2)]) 
                                << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 
                                ShiftLength);
                Result = ((ShiftLength > (NdefMap->MifareULContainer.RemainingSize))?
                            (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                            NFCSTATUS_INVALID_PARAMETER)):
                            Result);

                            
                Result = ((Result == NFCSTATUS_SUCCESS)?
                                            phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):
                                            Result);

                NdefMap->TLVStruct.ActualSize = 
                    NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
                
                if(Result == NFCSTATUS_SUCCESS)
                {
                    
                    NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
                    NdefMap->TLVStruct.NoLbytesinTLV;
/*                  
                    NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% 
                        PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1);
                        
                    NdefMap->TLVStruct.NdefTLVBlock = 
                        (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 
                        + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));

                    NdefMap->MifareULContainer.CurrentBlock = 
                                NdefMap->TLVStruct.NdefTLVBlock;

                    Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                                        NdefMap->TLVStruct.NdefTLVBlock);
*/
                }
            }
            else
            {
                /* length (L) value in TLV shall not be greater than 
                    remaining free space in the card */
                Result = ((NdefMap->SendRecvBuf[TempLength] > 
                    NdefMap->MifareULContainer.RemainingSize)?
                        (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                        NFCSTATUS_INVALID_PARAMETER)):
                        Result);

                NdefMap->TLVStruct.ActualSize = 
                NdefMap->TLVStruct.BytesRemainLinTLV = 
                                NdefMap->SendRecvBuf[TempLength];
                NdefMap->MifareULContainer.RemainingSize--;

                if((Result == NFCSTATUS_SUCCESS) && 
                    (NdefMap->TLVStruct.NdefTLVFoundFlag != 
                    PH_FRINFC_NDEFMAP_MFUL_FLAG1))
                {
                    phFriNfc_MfUL_H_UpdateLen(NdefMap, 
                                (uint16_t)NdefMap->SendRecvBuf[TempLength]);
                    
                    NdefMap->MifareULContainer.CurrentBlock =  
                                        NdefMap->TLVStruct.NdefTLVBlock;
                    TempLength=TempLength+(NdefMap->SendRecvBuf[TempLength]);
                    Result =((TempLength < PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
                            phFriNfc_MfUL_H_findNDEFTLV(NdefMap, CRFlag):
                            phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
                                    NdefMap->TLVStruct.NdefTLVBlock));
                }
            }
            break;
    }
    NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;

    Result = phFriNfc_MapTool_SetCardState(  NdefMap, NdefMap->TLVStruct.ActualSize);

    return Result;
}

static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t        *NdefMap,
                                      uint16_t                  DataLen) 
{
    NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-DataLen;
    NdefMap->TLVStruct.NdefTLVByte = ((DataLen % 
                        PH_FRINFC_NDEFMAP_MFUL_VAL4) + 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1);
    NdefMap->TLVStruct.NdefTLVBlock = 
                        (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 
                        + (DataLen/PH_FRINFC_NDEFMAP_MFUL_VAL4));
}

 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t       *NdefMap,
                                       uint8_t                  *CRFlag)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
  
    switch(NdefMap->PrevOperation)
    {
        case PH_FRINFC_NDEFMAP_CHECK_OPE:
            *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
			/* Fix to check if the actual size in the TLV is greater than card */
            if (NdefMap->TLVStruct.ActualSize > (NdefMap->CardMemSize - 2))
            {
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                    NFCSTATUS_NO_NDEF_SUPPORT);
            }
            break;

        case PH_FRINFC_NDEFMAP_READ_OPE:
            if (NdefMap->TLVStruct.NdefTLVSector == 1)
            {
                /* Goto sector 1 */
                NdefMap->MifareULContainer.CurrentSector = 1;
                NdefMap->MifareULContainer.CurrentBlock = 0;
                
                Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                        NdefMap->MifareULContainer.CurrentSector, 1, 
                        PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1); 
            }
            else
            {
                NdefMap->MifareULContainer.CurrentBlock = (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;

                Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
            }
#if 0           
            NdefMap->MifareULContainer.CurrentBlock = 
                PH_FRINFC_NDEFMAP_MFUL_VAL4;

             Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
#endif
      

            *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)?
                        PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                        PH_FRINFC_NDEFMAP_MFUL_FLAG0);
            break;

        case PH_FRINFC_NDEFMAP_WRITE_OPE:
            break;

        default:
            break;
    }
    return Result;
}


static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t  *NdefMap)
{
    NFCSTATUS Result = NFCSTATUS_SUCCESS;
    uint16_t localCurrentBlock;

#ifndef NDEF_READ_CHANGE
	uint16_t			v_field_byte = 0;

	if (NdefMap->MifareULContainer.CurrentBlock 
		== NdefMap->TLVStruct.NdefTLVBlock)
	{
		if (NdefMap->CardMemSize > (0x12 * PH_FRINFC_NDEFMAP_MFUL_MUL8))
		{
			v_field_byte = NdefMap->TLVStruct.NdefTLVByte;
		}

		/* Calculate the Value field of the TLV to read */
		if (NdefMap->TLVStruct.ActualSize >= 0xFF)
		{
			
			/* here 
				3 is the 3 LENGTH bytes to skip  
				4 is the block size
				1 is to increment the byte number
			*/
			v_field_byte = (uint16_t)
							(((v_field_byte + 3) % 4) + 1);
		}
		else
		{
			/* less than 0xFF */
#if 0
			if ((0x03 == v_field_byte) 
				|| (0x04 == v_field_byte))
			{
				/*
					here 
					1 is the 1 LENGTH byte to skip  
					4 is the block size
					1 is to increment the byte number
				*/
				v_field_byte = (uint16_t)
								(((v_field_byte + 1) % 4) + 1);
			}
			else
			{
				v_field_byte = (uint16_t)
								(v_field_byte + 1);
			}	
#endif /* #if 0 */
		}
	}
#endif /* #ifndef NDEF_READ_CHANGE */

#ifndef NDEF_READ_CHANGE
	(void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[ 
                NdefMap->MifareULContainer.ReadBufIndex]),
                (void *)(NdefMap->SendRecvBuf + v_field_byte),
                (*NdefMap->SendRecvLength - v_field_byte));

	NdefMap->MifareULContainer.ReadBufIndex = (uint16_t)
		(NdefMap->MifareULContainer.ReadBufIndex + 
		(*NdefMap->SendRecvLength - v_field_byte));
#else /* #ifndef NDEF_READ_CHANGE */

    (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[ 
                NdefMap->MifareULContainer.ReadBufIndex]),
                NdefMap->SendRecvBuf,
                *NdefMap->SendRecvLength);

    NdefMap->MifareULContainer.ReadBufIndex=NdefMap->MifareULContainer.ReadBufIndex +*NdefMap->SendRecvLength;
#endif /* #ifndef NDEF_READ_CHANGE */

    localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
                            (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != 
                            NdefMap->CardMemSize)?
                            PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
                            PH_FRINFC_NDEFMAP_MFUL_VAL0);
    if (localCurrentBlock < 256)
    {
        NdefMap->MifareULContainer.CurrentBlock =  NdefMap->MifareULContainer.CurrentBlock+
                            (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != 
                            NdefMap->CardMemSize)?
                            PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
                            PH_FRINFC_NDEFMAP_MFUL_VAL0);
    }
    else 
    {
        /* Go to next sector */
        if (NdefMap->MifareULContainer.CurrentSector == 0)
        {
            NdefMap->MifareULContainer.CurrentSector++;
            NdefMap->MifareULContainer.CurrentBlock = 0xff;
            
            Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                    NdefMap->MifareULContainer.CurrentSector, 1, 
                    PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);
        }
    }
   
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    
    /* Check the user buffer size with the 
    L value of TLV */
    if(NdefMap->ApduBufferSize >=
        NdefMap->TLVStruct.BytesRemainLinTLV)
    {
        (void)memcpy(NdefMap->ApduBuffer,
            &(NdefMap->MifareULContainer.ReadBuf[ 
            NdefMap->MifareULContainer.ByteNumber]),
            NdefMap->TLVStruct.BytesRemainLinTLV);

        *(NdefMap->NumOfBytesRead) = 
                    NdefMap->TLVStruct.BytesRemainLinTLV;
        NdefMap->MifareULContainer.ByteNumber = 
                                PH_FRINFC_NDEFMAP_MFUL_VAL0;
        NdefMap->MifareULContainer.ReadWriteCompleteFlag = 
                                PH_FRINFC_NDEFMAP_MFUL_FLAG1;
        NdefMap->MifareULContainer.RemainingSize =  NdefMap->MifareULContainer.RemainingSize-
                                                    NdefMap->TLVStruct.BytesRemainLinTLV;
        NdefMap->TLVStruct.BytesRemainLinTLV = 
                                PH_FRINFC_NDEFMAP_MFUL_VAL0;
    }
    else
    {
        (void)memcpy(NdefMap->ApduBuffer,
            &(NdefMap->MifareULContainer.ReadBuf[ 
            NdefMap->MifareULContainer.ByteNumber]),
            NdefMap->ApduBufferSize);

        *(NdefMap->NumOfBytesRead) = 
                    NdefMap->ApduBufferSize;
        NdefMap->MifareULContainer.ByteNumber = NdefMap->MifareULContainer.ByteNumber+
                                                (uint16_t)NdefMap->ApduBufferSize;
        NdefMap->MifareULContainer.RemainingSize=NdefMap->MifareULContainer.RemainingSize-
                                                     (uint16_t)NdefMap->ApduBufferSize;
        NdefMap->TLVStruct.BytesRemainLinTLV =  NdefMap->TLVStruct.BytesRemainLinTLV-
                    (uint16_t)NdefMap->ApduBufferSize;
    }
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t       *NdefMap)
{
    uint16_t localCurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;

    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    /*            BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;*/
    uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    
    switch((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1))
    {
        case PH_FRINFC_NDEFMAP_MFUL_VAL0:
            /* go the NDEF TLV block to start write */
            NdefMap->MifareULContainer.CurrentBlock = 
                NdefMap->TLVStruct.NdefTLVBlock;
            /* fill send buffer for write */
            NdefMap->SendRecvBuf[index] = 
                                NdefMap->MifareULContainer.CurrentBlock;
            index++;
            NdefMap->SendRecvBuf[index] = 
                                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T;
            index++;
            if (NdefMap->ApduBufferSize > 254)
            {
                NdefMap->SendRecvBuf[index] = 0xFF;
                index++;
                NdefMap->SendRecvBuf[index] = 
                                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                index++;
                NdefMap->SendRecvBuf[index] = 
                                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                index++;
            }
            else
            {
                NdefMap->SendRecvBuf[index] = 
                                    PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                index++;    
            }
            

            break;

        case PH_FRINFC_NDEFMAP_MFUL_VAL1:
        case PH_FRINFC_NDEFMAP_MFUL_VAL2:
            /* read to get the previous bytes */
            Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 
                            NdefMap->TLVStruct.NdefTLVBlock);
            break;

        case PH_FRINFC_NDEFMAP_MFUL_VAL3:
            
            localCurrentBlock = (NdefMap->MifareULContainer.CurrentBlock + 
                                PH_FRINFC_NDEFMAP_MFUL_VAL1);

            if (localCurrentBlock < 256)
            {
            
                NdefMap->MifareULContainer.CurrentBlock = 
                            (NdefMap->MifareULContainer.CurrentBlock + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1);
                NdefMap->SendRecvBuf[index] = 
                                    NdefMap->MifareULContainer.CurrentBlock;
                index++;

                if (NdefMap->ApduBufferSize > 254)
                {
                    NdefMap->SendRecvBuf[index] = 0xFF;
                    index++;
                    NdefMap->SendRecvBuf[index] = 
                                        PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                    index++;
                    NdefMap->SendRecvBuf[index] = 
                                        PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                    index++;
                }
                else
                {
                    NdefMap->SendRecvBuf[index] = 
                                        PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
                    index++;    
                }
            }
            else
            {
                /* Go to next sector */
                NdefMap->MifareULContainer.CurrentSector++;

                Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                    NdefMap->MifareULContainer.CurrentSector, 1, 
                    PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1);
            }
            break;

        default:
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_REMOTE_DEVICE);
            break;
    }

    if((((NdefMap->TLVStruct.NdefTLVByte - 
        PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || 
        ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) 
        == PH_FRINFC_NDEFMAP_MFUL_VAL3)) && localCurrentBlock < 256)
    {
        /* Length to know how many bytes has to be written to the card */
        TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == 
                        PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                        PH_FRINFC_NDEFMAP_MFUL_VAL2:
                        PH_FRINFC_NDEFMAP_MFUL_VAL3);

        if (NdefMap->ApduBufferSize > 254)
        {
            TemLength -= 2;
        }

        if(NdefMap->ApduBufferSize >= TemLength)
        {
            /* Prepare the receive buffer */
            (void)memcpy(&(NdefMap->SendRecvBuf[ 
                            index]),
                            &(NdefMap->ApduBuffer[ 
                            NdefMap->ApduBuffIndex]),
                            TemLength);

            /* Number of bytes written to the card from user buffer */
            NdefMap->NumOfBytesWritten = TemLength;

            index = index+(uint8_t)TemLength;
            /* Exact number of bytes written in the card including TLV */
            if (index >= 1)
            {
                *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
            }
            else
            {
                Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                                NFCSTATUS_INVALID_REMOTE_DEVICE);
            }
        }
        else
        {
            /* Prepare the receive buffer */
            (void)memcpy(&(NdefMap->SendRecvBuf[ 
                            index]),
                            &(NdefMap->ApduBuffer[ 
                            NdefMap->ApduBuffIndex]),
                            (uint16_t)NdefMap->ApduBufferSize);

            /* Number of bytes written to the card from user buffer */
            NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;

            index= index +(uint8_t)NdefMap->ApduBufferSize;
            /* Exact number of bytes written in the card including TLV */
            *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);

            for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)
            {
                NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?
                        PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
                        PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
                NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
            }
        }

        /* store the bytes in buffer till the bytes are 
            written in a block */
        (void)memcpy(NdefMap->MifareULContainer.Buffer,
                        &(NdefMap->SendRecvBuf[ 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1]), 
                        (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1));

        (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
                    NdefMap->MifareULContainer.Buffer,
                    (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 
                        PH_FRINFC_NDEFMAP_MFUL_VAL1));
        
        /* Change the state to check ndef compliancy */
        NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;

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

static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t        *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
   /* uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL1;*/
    
    
    NdefMap->MifareULContainer.CurrentBlock = 
                        NdefMap->TLVStruct.NdefTLVBlock;
        
    (void)memcpy(&(NdefMap->SendRecvBuf[ 
                PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                NdefMap->SendRecvBuf,
                PH_FRINFC_NDEFMAP_MFUL_VAL4);

    NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 
                            NdefMap->MifareULContainer.CurrentBlock;

    if (NdefMap->ApduBufferSize > 254)
    {
         NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 
                            PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 0xFF;
                            

        if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < 
            PH_FRINFC_NDEFMAP_MFUL_VAL4)
        {
            NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 
                            PH_FRINFC_NDEFMAP_MFUL_VAL2 )] = 0x00;

            NdefMap->NumOfLReminWrite = 1;

        }
        else
        {
            NdefMap->NumOfLReminWrite = 2;
        }
        NdefMap->NumOfBytesWritten = 0; 
    }
    else
    {
        /* Write the length value = 0 */
        NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 
                                PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 
                                PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;

        if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < 
            PH_FRINFC_NDEFMAP_MFUL_VAL4)
        {
            /* Only one byte  */
            (void)memcpy(&(NdefMap->SendRecvBuf[ 
                    PH_FRINFC_NDEFMAP_MFUL_VAL4]),
                    &(NdefMap->ApduBuffer[ 
                    NdefMap->ApduBuffIndex]),
                    PH_FRINFC_NDEFMAP_MFUL_VAL1);
            /* Number of bytes written to the card from user buffer */
            NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL1;
        }
    }

    (void)memcpy(NdefMap->MifareULContainer.Buffer,
                &(NdefMap->SendRecvBuf[ 
                PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                PH_FRINFC_NDEFMAP_MFUL_VAL4);

    /* Copy the Ndef TLV buffer to send buffer */
    (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
                NdefMap->MifareULContainer.Buffer,
                PH_FRINFC_NDEFMAP_MFUL_BYTE4);

    /* Exact number of bytes written in the card including TLV */
    *NdefMap->DataCount = PH_FRINFC_NDEFMAP_MFUL_VAL4;

    /* Change the state to check ndef compliancy */
    NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;

    Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
    
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap)
{
    uint16_t localCurrentBlock;
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 
                        NFCSTATUS_INVALID_REMOTE_DEVICE);
    
    if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)
    {
        NdefMap->ApduBuffIndex =  NdefMap->ApduBuffIndex+NdefMap->NumOfBytesWritten;
        if(*NdefMap->DataCount < 
            PH_FRINFC_NDEFMAP_MFUL_VAL4)
        {
            (void)memcpy(NdefMap->MifareULContainer.InternalBuf,
                        NdefMap->MifareULContainer.Buffer,
                        *NdefMap->DataCount);

            NdefMap->MifareULContainer.InternalLength = *NdefMap->DataCount;
        }
        else
        {
            NdefMap->MifareULContainer.InternalLength = 
                                PH_FRINFC_NDEFMAP_MFUL_VAL0;
        }

        NdefMap->MifareULContainer.RemainingSize=  NdefMap->MifareULContainer.RemainingSize-
                                            NdefMap->NumOfBytesWritten;
        if((NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize) || 
            (NdefMap->MifareULContainer.RemainingSize == 
            PH_FRINFC_NDEFMAP_MFUL_VAL0))
        {
            Result = NFCSTATUS_SUCCESS;
            NdefMap->MifareULContainer.ReadWriteCompleteFlag = 
                (uint8_t)((NdefMap->MifareULContainer.RemainingSize == 
                PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                PH_FRINFC_NDEFMAP_MFUL_FLAG0);

                NdefMap->TLVStruct.SetTermTLVFlag = 
                (uint8_t)(((NdefMap->MifareULContainer.RemainingSize == 
                PH_FRINFC_NDEFMAP_MFUL_VAL0) || 
                (NdefMap->TLVStruct.SetTermTLVFlag == 
                PH_FRINFC_NDEFMAP_MFUL_FLAG1))?
                PH_FRINFC_NDEFMAP_MFUL_FLAG1:
                PH_FRINFC_NDEFMAP_MFUL_FLAG0);

                NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
                    (uint8_t)((NdefMap->MifareULContainer.InternalLength != 
                    PH_FRINFC_NDEFMAP_MFUL_VAL0)?
                    PH_FRINFC_NDEFMAP_MFUL_VAL0:
                    PH_FRINFC_NDEFMAP_MFUL_VAL1);

            *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
        }
        else
        {
            localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 1;
            if (localCurrentBlock < 256)
            {
                NdefMap->MifareULContainer.CurrentBlock++;
                Result = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);
            }
            else
            {
                /* Go to next sector */
                NdefMap->MifareULContainer.CurrentSector++;

                Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                    NdefMap->MifareULContainer.CurrentSector, 1, 
                    PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1);
            }
        }
    }

    if((Result == NFCSTATUS_SUCCESS) && 
        (NdefMap->TLVStruct.SetTermTLVFlag != 
        PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 
        (NdefMap->MifareULContainer.RemainingSize > 
        PH_FRINFC_NDEFMAP_MFUL_VAL0))
    {
        Result = phFriNfc_MfUL_H_WrTermTLV(NdefMap);
    }
    else 
    {
        if((Result == NFCSTATUS_SUCCESS) && 
            (NdefMap->TLVStruct.SetTermTLVFlag == 
            PH_FRINFC_NDEFMAP_MFUL_FLAG1))
        {
            Result = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
        }
    }
    return Result;
}
static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint16_t    RemainingBytes = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0;
    
    RemainingBytes = (uint16_t)(( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= 
                        NdefMap->MifareULContainer.RemainingSize)?
                        (uint16_t)(NdefMap->ApduBufferSize - 
                        NdefMap->ApduBuffIndex):
                        NdefMap->MifareULContainer.RemainingSize);

    NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 
                        NdefMap->MifareULContainer.CurrentBlock;
    
    /* Get the number of bytes that can be written after copying 
        the internal buffer */
    BytesToWrite = ((RemainingBytes < 
                    (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - 
                    NdefMap->MifareULContainer.InternalLength))? 
                    RemainingBytes:
                    (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - 
                    NdefMap->MifareULContainer.InternalLength));

    if (NdefMap->NumOfBytesWritten == 0 && NdefMap->NumOfLReminWrite > 0)
    {
        BytesToWrite = BytesToWrite - NdefMap->NumOfLReminWrite;

        if (NdefMap->NumOfLReminWrite == 1)
        {
            NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; 
        }
        else
        {
            NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
            NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0x00;
        }
    }   

    if(NdefMap->MifareULContainer.InternalLength > 
        PH_FRINFC_NDEFMAP_MFUL_VAL0)
    {
        /* copy the internal buffer to the send buffer */
        (void)memcpy(&(NdefMap->SendRecvBuf[ 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                    NdefMap->MifareULContainer.InternalBuf,
                    NdefMap->MifareULContainer.InternalLength);

    }

    /* Copy Bytes to write in the send buffer */
    (void)memcpy(&(NdefMap->SendRecvBuf[ 
                (PH_FRINFC_NDEFMAP_MFUL_VAL1 + 
                NdefMap->MifareULContainer.InternalLength) + 
                NdefMap->NumOfLReminWrite]),
                &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]),
                BytesToWrite);
    
    /* update number of bytes written from the user buffer */
    NdefMap->NumOfBytesWritten = BytesToWrite;
    
    /* check the exact number of bytes written to a block including the 
        internal length */
    *NdefMap->DataCount = 
            (BytesToWrite + NdefMap->MifareULContainer.InternalLength +
                    NdefMap->NumOfLReminWrite);


    /* if total bytes to write in the card is less than 4 bytes then 
    pad zeroes till 4 bytes */
    if((BytesToWrite + NdefMap->MifareULContainer.InternalLength + 
        NdefMap->NumOfLReminWrite) 
            < PH_FRINFC_NDEFMAP_MFUL_BYTE4)
    {
        for(index = (uint8_t)((BytesToWrite + NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1); 
            index < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; 
            index++)
            {
                NdefMap->SendRecvBuf[index] = (uint8_t)((index == 
                                    ((BytesToWrite + 
                                    NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + 
                                    PH_FRINFC_NDEFMAP_MFUL_VAL1))?
                                    PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
                                    PH_FRINFC_NDEFMAP_MFUL_NULLTLV);

                NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
            }
    }

    /* A temporary buffer to hold four bytes of data that is 
        written to the card */
    (void)memcpy(NdefMap->MifareULContainer.Buffer,
                &(NdefMap->SendRecvBuf[ 
                PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                PH_FRINFC_NDEFMAP_MFUL_BYTE4);

    
        if((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) < 
        PH_FRINFC_NDEFMAP_MFUL_VAL3)
        {
            if ((NdefMap->TLVStruct.NdefTLVSector == 
                NdefMap->MifareULContainer.CurrentSector))
            {
                if(NdefMap->MifareULContainer.CurrentBlock == 
                        NdefMap->TLVStruct.NdefTLVBlock)
                {
                    (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
                        NdefMap->MifareULContainer.Buffer,
                        PH_FRINFC_NDEFMAP_MFUL_BYTE4);
                }                                   
            }
            
            if ((NdefMap->TLVStruct.NdefTLVSector == 
                NdefMap->MifareULContainer.CurrentSector) ||
                (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
            {
                if(NdefMap->MifareULContainer.CurrentBlock == 
                    (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL1))
                {
                    (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
                    NdefMap->MifareULContainer.Buffer,
                    PH_FRINFC_NDEFMAP_MFUL_BYTE4);
                }
            }
        }
        else
        {
            if ((NdefMap->TLVStruct.NdefTLVSector == 
                NdefMap->MifareULContainer.CurrentSector))
            {
                if(NdefMap->MifareULContainer.CurrentBlock == 
                    (NdefMap->TLVStruct.NdefTLVBlock + 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1))
                {
                    (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
                                NdefMap->MifareULContainer.Buffer,
                                PH_FRINFC_NDEFMAP_MFUL_BYTE4);
                }
            }
            
            if ((NdefMap->TLVStruct.NdefTLVSector == 
                NdefMap->MifareULContainer.CurrentSector)||
                (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
            {
                if(NdefMap->MifareULContainer.CurrentBlock == 
                    (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL2))
                {
                    (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
                                NdefMap->MifareULContainer.Buffer,
                                PH_FRINFC_NDEFMAP_MFUL_BYTE4);
                }             
            }
        }
    

    /* Change the state to check ndef compliancy */
    NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;

    NdefMap->NumOfLReminWrite = 0;
    
    /* Start writing to the current block */
    Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);

    return Result; 
}
static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t   *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                i = PH_FRINFC_NDEFMAP_MFUL_VAL0;

    /* Change the state to check ndef compliancy */
    NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
    
    NdefMap->SendRecvBuf[index] = 
                        (NdefMap->MifareULContainer.CurrentBlock + 
                        PH_FRINFC_NDEFMAP_MFUL_VAL0);
    index++;
    NdefMap->SendRecvBuf[index] = PH_FRINFC_NDEFMAP_MFUL_TERMTLV;
    index++;

    for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_VAL4; i++)
    {
        NdefMap->SendRecvBuf[i] = PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
    }
    
    Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    uint16_t    BlockNo = PH_FRINFC_NDEFMAP_MFUL_VAL0,
                ByteNo = PH_FRINFC_NDEFMAP_MFUL_VAL0;

    if ((NdefMap->TLVStruct.NdefTLVSector == 
        NdefMap->MifareULContainer.CurrentSector) ||
        ((NdefMap->TLVStruct.NdefTLVBlock == 0xFF) &&
        (NdefMap->TLVStruct.NdefTLVByte == 4) &&
        (NdefMap->TLVStruct.NdefTLVSector == 0)))
    {
        BlockNo = (((NdefMap->TLVStruct.NdefTLVByte - 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1) != 
                    PH_FRINFC_NDEFMAP_MFUL_VAL3)?
                    NdefMap->TLVStruct.NdefTLVBlock:
                    (NdefMap->TLVStruct.NdefTLVBlock + 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1));

        ByteNo = (((NdefMap->TLVStruct.NdefTLVByte - 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1) == 
                    PH_FRINFC_NDEFMAP_MFUL_VAL3)?
                    PH_FRINFC_NDEFMAP_MFUL_VAL1:
                    (NdefMap->TLVStruct.NdefTLVByte + 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1));

        if (NdefMap->NumOfLReminWrite > 0)
        {
            BlockNo++;

            /* Copy the Ndef TLV buffer to send buffer */
            (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                        NdefMap->TLVStruct.NdefTLVBuffer1,
                        PH_FRINFC_NDEFMAP_MFUL_BYTE4);

            if (NdefMap->NumOfLReminWrite == 1)
            {
                /* NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); */
				NdefMap->SendRecvBuf[1] = (uint8_t) NdefMap->ApduBuffIndex;
                
            }
            else if (NdefMap->NumOfLReminWrite == 2)
            {
				NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
                NdefMap->SendRecvBuf[2]= (uint8_t) (NdefMap->ApduBuffIndex);
                
            }
            else
            {

            }
            NdefMap->NumOfLReminWrite = 0;
        }
        else 
        {
            /* Copy the Ndef TLV buffer to send buffer */
            (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                        NdefMap->TLVStruct.NdefTLVBuffer,
                        PH_FRINFC_NDEFMAP_MFUL_BYTE4);


            if (NdefMap->ApduBuffIndex > 254)
            {
                ByteNo++;
                if  ((ByteNo == 3) || (ByteNo == 2))
                {
                    NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
                    ByteNo++;
                    NdefMap->SendRecvBuf[ByteNo] = (uint8_t) (NdefMap->ApduBuffIndex);
                    ByteNo++;
                    NdefMap->NumOfLReminWrite = 0;
                }
                else if (ByteNo == 4)
                {
                    /* NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); */
					NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
                    ByteNo++;
                    NdefMap->NumOfLReminWrite = 1;
                }
                else
                {
                    NdefMap->NumOfLReminWrite = 2;
                }
            }
            else 
            {
                NdefMap->SendRecvBuf[ByteNo]= 
                                    (uint8_t)((NdefMap->Offset == 
                                    PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
                                    (uint8_t)NdefMap->ApduBuffIndex:
                                    (NdefMap->ApduBuffIndex + 
                                    NdefMap->SendRecvBuf[ByteNo]));
            }
        }

        (void)memcpy(NdefMap->MifareULContainer.Buffer,
                    &(NdefMap->SendRecvBuf[ 
                    PH_FRINFC_NDEFMAP_MFUL_VAL1]),
                    PH_FRINFC_NDEFMAP_MFUL_BYTE4);
        
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = (uint8_t)BlockNo;
        Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);

        if (NdefMap->NumOfLReminWrite == 0)
        {
            NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;
        }
        else 
        {
            NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
        }
    }
    else if (NdefMap->TLVStruct.NdefTLVSector == 0)
    {
        /* Reset sector */
        NdefMap->MifareULContainer.CurrentSector = 0;
        NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
                                    
        Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 
                NdefMap->MifareULContainer.CurrentSector, 1,
                PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);

    }
    else
    {
        Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
    }
    
        
    return Result;
}
#ifdef UNIT_TEST
extern void phFriNfc_MifareUL_UnitTest(void *Context,uint32_t Length)
{
        uint8_t value=10;
        uint8_t* CrFlag=&value;
        phFriNfc_NdefMap_t *pNdefMap=(phFriNfc_NdefMap_t*)Context;
        phFriNfc_MfUL_H_UpdateLen(pNdefMap,(uint16_t) Length);
        phFriNfc_MfUL_H_WrTermTLV(pNdefMap);
        phFriNfc_MfUL_H_CallWrOp(pNdefMap);
        phFriNfc_MfUL_H_UpdateWrLen(pNdefMap);
        phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);
        phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
        
        pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_READ_OPE;
        phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);
        
        pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_WRITE_OPE;
        phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);

        pNdefMap->TLVStruct.NoLbytesinTLV=PH_FRINFC_NDEFMAP_MFUL_VAL1;
        phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);

        pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
        phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);
        

        pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
        phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);

        
        phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
        pNdefMap->TLVStruct.NdefTLVByte=1;
        phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
        
        pNdefMap->TLVStruct.NdefTLVByte=3;
        phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);

        pNdefMap->TLVStruct.NdefTLVByte=4;
        phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);


        phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
        phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
        phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
        pNdefMap->State=PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
        phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);

        phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
        phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
        phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
        
        *pNdefMap->DataCount=0x3;
        phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);

        pNdefMap->ApduBuffIndex=0x31;
        phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
            
        
}

#endif
#endif  /* PH_FRINFC_MAP_MIFAREUL_DISABLED */