path: root/src/phFriNfc_MifULFormat.c

/*
 * 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_MifULFormat.c
 * \brief NFC Ndef Formatting For Mifare ultralight card.
 *
 * Project: NFC-FRI
 *
 * $Date: Mon Dec 13 14:14:12 2010 $
 * $Author: ing02260 $
 * $Revision: 1.9 $
 * $Aliases:  $
 *
 */

#include <phFriNfc_MifULFormat.h>
#include <phFriNfc_OvrHal.h>

/*! \ingroup grp_file_attributes
 *  \name NDEF Mapping
 *
 * File: \ref phFriNfc_MifULFormat.c
 *
 */
/*@{*/
#define PHFRINFCMIFULFORMAT_FILEREVISION "$Revision: 1.9 $"
#define PHFRINFCMIFULFORMAT_FILEALIASES  "$Aliases:  $"
/*@}*/

#ifdef FRINFC_READONLY_NDEF
    /* Mifare UL OTP block number is 3 */
    #define RD_LOCK_OTP_BLOCK_NUMBER            0x02U
    #define OTP_BLOCK_NUMBER                    0x03U
    /* READ ONLY value that shall be written in the OTP to make the card read only */
    #define READ_ONLY_VALUE_IN_OTP              0x0FU
    /* Mifare UL OTP block number is 3 */
    #define MIFARE_UL_READ_MAX_SIZE             16U
    /* 1st Lock byte value */
    #define MIFARE_UL_LOCK_BYTE1_VALUE          0xF8U
    /* 2nd Lock byte value */
    #define MIFARE_UL_LOCK_BYTE2_VALUE          0xFFU
    /* Mifare ULC dynamic lock byte address */
    #define MIFARE_ULC_DYNAMIC_LOCK_BYTES_ADDR  0x28U
    /* Type 2 STATIC CARD memory value in the OTP */
    #define TYPE_2_STATIC_MEM_SIZE_VALUE        0x06U
    /* Type 2 DYNAMIC CARD memory value in the OTP */
    #define TYPE_2_DYNAMIC_MEM_SIZE_VALUE       0x12U
    /* Lock byte 3 value to be ORed with the existing value */
    #define MIFARE_UL_LOCK_BYTE3_VALUE          0xEEU
    /* Posiiton of the memory information in the stored OTP bytes */
    #define TYPE_2_MEM_SIZE_POSITION            0x02U
    /* 3rd Lock byte position after reading the block number 0x28 */
    #define TYPE_2_LOCK_BYTE3_POS_RD_BLK28      0x00U

#ifdef PH_NDEF_MIFARE_ULC

    /* Lock control TLVs, TYPE identifier */
    #define LOCK_CTRL_TYPE_IN_TLV               0x01U
    /* Lock control TLVs, Length expected */
    #define LOCK_CTRL_LEN_IN_TLV                0x03U

    /* NDEF message TLVs, TYPE identifier */
    #define NDEF_TYPE_IN_TLV                    0x03U

    #define MFUL_NULL_TLV                       0x00U
    #define THREE_BYTE_LENGTH_FIELD             0xFFU
    #define TERMINATOR_TLV                      0xFEU
    #define MIFARE_ULC_SIZE                     0xC0U
    #define MFUL_NIBBLE_SIZE                    0x04U
    #define MFUL_NIBBLE_MASK                    0x0FU
    #define MFUL_BYTE_SIZE_IN_BITS              0x08U
    #define MFUL_BLOCK_SIZE_IN_BYTES            0x04U
    /* Initial (0 to 3 blocks) 4 blocks are ignored, i.e., 16 bytes */
    #define MFUL_INITIAL_BYTES_IGNORED          0x10U

    #define MFUL_CONVERT_BITS_TO_BYTES(bits_to_bytes) \
            (((bits_to_bytes % MFUL_BYTE_SIZE_IN_BITS) > 0) ? \
            ((bits_to_bytes / MFUL_BYTE_SIZE_IN_BITS) + 1) : \
            (bits_to_bytes / MFUL_BYTE_SIZE_IN_BITS))

    typedef enum phFriNfc_MfUL_Parse
    {
        LOCK_TLV_T, 
        LOCK_TLV_L,
        LOCK_TLV_V, 
        NDEF_TLV_T, 
        NDEF_TLV_L,
        NDEF_TLV_V
    }phFriNfc_MfUL_Parse_t;

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

#endif /* #ifdef FRINFC_READONLY_NDEF */
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function calls the   
* transceive function
*/
static NFCSTATUS phFriNfc_MfUL_H_Transceive(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);

/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function calls the   
* read or write operation
*/
static NFCSTATUS phFriNfc_MfUL_H_WrRd(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);

/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function fills the  
* send buffer for transceive function
*/
static void phFriNfc_MfUL_H_fillSendBuf(phFriNfc_sNdefSmtCrdFmt_t   *NdefSmtCrdFmt,
                                        uint8_t                     BlockNo);

/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function shall process
* the read bytes
*/
static NFCSTATUS phFriNfc_MfUL_H_ProRd16Bytes(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);

/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function shall process the
* OTP bytes written
*/
static NFCSTATUS phFriNfc_MfUL_H_ProWrOTPBytes(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);

#ifdef FRINFC_READONLY_NDEF

#ifdef PH_NDEF_MIFARE_ULC

static 
NFCSTATUS 
phFriNfc_MfUL_ParseTLVs (
    phFriNfc_sNdefSmtCrdFmt_t       *NdefSmtCrdFmt, 
    uint8_t                         *data_to_parse, 
    uint8_t                         size_to_parse);

static 
NFCSTATUS 
phFriNfc_MfUL_GetLockBytesInfo (
    phFriNfc_sNdefSmtCrdFmt_t       *NdefSmtCrdFmt);

static 
NFCSTATUS 
phFriNfc_MfUL_GetDefaultLockBytesInfo (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt);

static 
uint8_t 
phFriNfc_MfUL_GetSkipSize (
    phFriNfc_sNdefSmtCrdFmt_t       *NdefSmtCrdFmt, 
    uint8_t                         block_number, 
    uint8_t                         byte_number);

static 
NFCSTATUS 
phFriNfc_MfUL_ReadWriteLockBytes (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt);

static 
NFCSTATUS
phFriNfc_MfUL_UpdateAndWriteLockBits (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt);

static 
uint8_t
phFriNfc_MfUL_CalcRemainingLockBits (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt);

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

#endif /* #ifdef FRINFC_READONLY_NDEF */

static int MemCompare1 ( void *s1, void *s2, unsigned int n );
/*The function does a comparision of two strings and returns a non zero value 
if two strings are unequal*/
static int MemCompare1 ( void *s1, void *s2, unsigned int n )
{
    int8_t   diff = 0;
    int8_t *char_1  =(int8_t *)s1;
    int8_t *char_2  =(int8_t *)s2;
    if(NULL == s1 || NULL == s2)
    {
        PHDBG_CRITICAL_ERROR("NULL pointer passed to memcompare");
    }
    else
    {
        for(;((n>0)&&(diff==0));n--,char_1++,char_2++)
        {
            diff = *char_1 - *char_2;
        }
    }
    return (int)diff;
}

void phFriNfc_MfUL_Reset(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
{
    uint8_t OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES; 

    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
    (void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                OTPByte,
                sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
#ifdef FRINFC_READONLY_NDEF
    NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[0] = 0;
    NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[1] = 0;
    NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = 0;
    NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = 0;
#endif /* #ifdef FRINFC_READONLY_NDEF */
}

NFCSTATUS phFriNfc_MfUL_Format(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
{
    NFCSTATUS               Result = NFCSTATUS_SUCCESS;
    uint8_t                 OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
    
    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
    (void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                OTPByte,
                sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));

    /* Set the state */
    NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RD_16BYTES;
    /* Initialise current block to the lock bits block */
    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_2;
    
    /* Start authentication */
    Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
    return Result;
}

#ifdef FRINFC_READONLY_NDEF

NFCSTATUS
phFriNfc_MfUL_ConvertToReadOnly (
    phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
{
    NFCSTATUS               result = NFCSTATUS_SUCCESS;

    NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag = TRUE;
    NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = 0;

    NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_RD_16BYTES;

    result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);

    return result;
}

#endif /* #ifdef FRINFC_READONLY_NDEF */

void phFriNfc_MfUL_Process(void             *Context,
                           NFCSTATUS        Status)
{
    phFriNfc_sNdefSmtCrdFmt_t  *NdefSmtCrdFmt = (phFriNfc_sNdefSmtCrdFmt_t *)Context;
    
    if(Status == NFCSTATUS_SUCCESS)
    {
        switch(NdefSmtCrdFmt->State)
        {
        case PH_FRINFC_MFUL_FMT_RD_16BYTES:
            Status = phFriNfc_MfUL_H_ProRd16Bytes(NdefSmtCrdFmt);
            break;

        case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
            Status = phFriNfc_MfUL_H_ProWrOTPBytes(NdefSmtCrdFmt);
            break;

        case PH_FRINFC_MFUL_FMT_WR_TLV:
#ifdef PH_NDEF_MIFARE_ULC               
            if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
            {
                /* Write NDEF TLV in block number 5 */
                NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                                                        PH_FRINFC_MFUL_FMT_VAL_5;
                /* Card already have the OTP bytes so write TLV */
                NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV1;
                
                Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
            }
#endif /* #ifdef PH_NDEF_MIFARE_ULC */

            break;

#ifdef FRINFC_READONLY_NDEF

        case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
        {
            if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
            {
                uint8_t         otp_lock_page_size = 0;
                uint8_t         i = 0;

                otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes);
                (void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
                            (void *)NdefSmtCrdFmt->SendRecvBuf,
                            sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes));

                NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = (uint8_t)
                                    (NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] 
                                    | MIFARE_UL_LOCK_BYTE1_VALUE);
                NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = MIFARE_UL_LOCK_BYTE2_VALUE;
                i = (uint8_t)(i + otp_lock_page_size);

                otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes);                                
                
                (void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                            (void *)(NdefSmtCrdFmt->SendRecvBuf + i),
                            sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));

                NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[(otp_lock_page_size - 1)] =
                                                        READ_ONLY_VALUE_IN_OTP;

                switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
                {
                    case TYPE_2_STATIC_MEM_SIZE_VALUE:
                    {
                        NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
                        Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
                        break;
                    }

#ifdef PH_NDEF_MIFARE_ULC
                    case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
                    {
                        NdefSmtCrdFmt->State = 
                                PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES;

                        /* Start reading from block 4 */
                        NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 4;
                        Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
                        break;
                    }
#endif /* #ifdef PH_NDEF_MIFARE_ULC */

                    default:
                    {
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                            NFCSTATUS_INVALID_DEVICE_REQUEST);
                        break;
                    }
                }
            }
            else
            {
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
        {
            switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
            {
                case TYPE_2_STATIC_MEM_SIZE_VALUE:
#ifdef PH_NDEF_MIFARE_ULC
                case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
                {
                    NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES;
                    Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
                    break;
                }

                default:
                {
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                        NFCSTATUS_INVALID_DEVICE_REQUEST);
                    break;
                }
            }
            break;
        }

#ifdef PH_NDEF_MIFARE_ULC

        case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
        {
            if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
            {
                Status = phFriNfc_MfUL_ParseTLVs (NdefSmtCrdFmt, 
                                        NdefSmtCrdFmt->SendRecvBuf, 
                                        (uint8_t)*NdefSmtCrdFmt->SendRecvLength);

                if (!Status)
                {
                    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                        NdefSmtCrdFmt->AddInfo.Type2Info.LockBlockNumber;
                    Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
                }
            }
            else
            {
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            }
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
        {
            if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
            {
                (void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.ReadData,
                            (void *)NdefSmtCrdFmt->SendRecvBuf,
                            sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.ReadData));

                NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = 0;

                Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
                
            }
            else
            {
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                    NFCSTATUS_INVALID_RECEIVE_LENGTH);
            } 
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
        {
            NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = (uint8_t)
                                    (NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex + 
                                    MFUL_BLOCK_SIZE_IN_BYTES);

            if (!phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt))
            {
                /* There is no lock bits to write, then write OTP bytes */
                NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
                Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
            }
            else if ((NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex < 
                MIFARE_UL_READ_MAX_SIZE) 
                && (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)))
            {
                /* If remaining lock bits has to be written and the data is already read */
                Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
            }
            else
            {
                /* Increment current block by 4 because if a data is read then 16 
                    bytes will be given which is 4 blocks */
                NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = (uint8_t)
                            (NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock + 4);
                Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
            }
            break;
        }

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

        case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
        {
            /* Do nothing */
            break;
        }

#endif /* #ifdef FRINFC_READONLY_NDEF */

#ifdef PH_NDEF_MIFARE_ULC   
        case PH_FRINFC_MFUL_FMT_WR_TLV1:
        
        break;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
        
        default:
            Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                NFCSTATUS_INVALID_DEVICE_REQUEST);
            break;
        }
    }
    /* Status is not success then call completion routine */
    if(Status != NFCSTATUS_PENDING)
    {
        phFriNfc_SmtCrdFmt_HCrHandler(NdefSmtCrdFmt, Status);
    }
}

#ifdef FRINFC_READONLY_NDEF

#ifdef PH_NDEF_MIFARE_ULC

static 
uint8_t 
phFriNfc_MfUL_GetSkipSize (
    phFriNfc_sNdefSmtCrdFmt_t       *NdefSmtCrdFmt, 
    uint8_t                         block_number, 
    uint8_t                         byte_number)
{
    uint8_t                     skip_size = 0;
    phFriNfc_Type2_AddInfo_t    *ps_type2_info = 
                                &NdefSmtCrdFmt->AddInfo.Type2Info;

    /* This check is added, because the default lock bits is always 
        present after the DATA AREA. 
        So, default lock bytes doesnt have any skip size */
    if (!ps_type2_info->DefaultLockBytesFlag)
    {
        /* Only check for the lock control TLV */
        if ((block_number == ps_type2_info->LockBlockNumber) 
            && (byte_number == ps_type2_info->LockByteNumber))
        {
            skip_size = MFUL_CONVERT_BITS_TO_BYTES(ps_type2_info->NoOfLockBits);
        }
    }
    
    return skip_size;
}

static 
NFCSTATUS 
phFriNfc_MfUL_GetLockBytesInfo (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_Type2_AddInfo_t        *ps_type2_info = 
                                    &(NdefSmtCrdFmt->AddInfo.Type2Info);
    uint8_t                         page_address = 0;
    uint8_t                         bytes_offset = 0;
    uint8_t                         lock_index = 0;


    page_address = (uint8_t)(ps_type2_info->DynLockBytes[lock_index] >> MFUL_NIBBLE_SIZE);
    bytes_offset = (uint8_t)(ps_type2_info->DynLockBytes[lock_index] & MFUL_NIBBLE_MASK);

    lock_index = (lock_index + 1);
    ps_type2_info->NoOfLockBits = ps_type2_info->DynLockBytes[lock_index];

    lock_index = (lock_index + 1);
    ps_type2_info->LockBytesPerPage = 
                            (ps_type2_info->DynLockBytes[lock_index] & MFUL_NIBBLE_MASK);
    ps_type2_info->BytesLockedPerLockBit = 
                            (ps_type2_info->DynLockBytes[lock_index] >> MFUL_NIBBLE_SIZE);

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

    ps_type2_info->LockBlockNumber = (uint8_t)(ps_type2_info->LockByteNumber / 
                                                MFUL_BLOCK_SIZE_IN_BYTES);
    ps_type2_info->LockByteNumber = (uint8_t)(ps_type2_info->LockByteNumber % 
                                                MFUL_BLOCK_SIZE_IN_BYTES);

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

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

    return result;
}

static 
uint8_t
phFriNfc_MfUL_CalcRemainingLockBits (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt)
{
    uint8_t                         lock_bits_remaining = 0;
    phFriNfc_Type2_AddInfo_t        *ps_type2_info = 
                                    &(NdefSmtCrdFmt->AddInfo.Type2Info);

    lock_bits_remaining = (uint8_t)(ps_type2_info->NoOfLockBits - 
                                    ps_type2_info->LockBitsWritten);

    return lock_bits_remaining;
}

static 
NFCSTATUS
phFriNfc_MfUL_UpdateAndWriteLockBits (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_Type2_AddInfo_t        *ps_type2_info = 
                                    &(NdefSmtCrdFmt->AddInfo.Type2Info);
    uint8_t                         byte_index = 0;
    uint8_t                         no_of_bits_left_in_block = 0;
    uint8_t                         remaining_lock_bits = 0;
    uint8_t                         remaining_lock_bytes = 0;
    /* Array of 3 is used because the lock bits with 4 bytes in a block
        is handled in the function phFriNfc_MfUL_ReadWriteLockBytes 
        So use this function only if lock bytes doesnt use the entire block */
    uint8_t                         lock_bytes_value[MFUL_BLOCK_SIZE_IN_BYTES] = {0};
    uint8_t                         lock_byte_index = 0;

    (void)memcpy ((void *)lock_bytes_value, 
                (void*)(ps_type2_info->ReadData + ps_type2_info->ReadDataIndex), 
                sizeof (ps_type2_info->DynLockBytes));
    remaining_lock_bits = phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt);
    
    if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
    {
        /* 1st write to lock bits, so byte_index is updated */
        byte_index = ps_type2_info->LockByteNumber;
    }
    
    no_of_bits_left_in_block = (uint8_t)((MFUL_BLOCK_SIZE_IN_BYTES - byte_index) * 
                                MFUL_BYTE_SIZE_IN_BITS);

    if (no_of_bits_left_in_block >= remaining_lock_bits)
    {
        /* Entire lock bits can be written 
            if block size is more than number of lock bits. 
            so allocate the lock bits with value 1b and 
            dont change the remaining bits */
        if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS)
        {
            /* mod operation has resulted in a value, means lock bits ends in between a byte */
            uint8_t         mod_value = 0;

            remaining_lock_bytes = ((remaining_lock_bits /
                                    MFUL_BYTE_SIZE_IN_BITS) + 1);

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

            while (lock_byte_index < remaining_lock_bytes)
            {
                /* Set 1b to all bits left in the block */
                lock_bytes_value[byte_index] = 0xFF;
                lock_byte_index = (uint8_t)(lock_byte_index + 1);
                byte_index = (uint8_t)(byte_index + 1);
            }
        } /* else of if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS) */
        ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten + 
                                            remaining_lock_bits);
    } /* if (no_of_bits_left_in_block >= remaining_lock_bits) */
    else
    {
        /* Update till the left bits in the block and then carry 
            out next operation after this write */
        while (lock_byte_index < (no_of_bits_left_in_block / MFUL_BYTE_SIZE_IN_BITS))
        {
            /* Set 1b to all bits left in the block */
            lock_bytes_value[byte_index] = 0xFF;
            lock_byte_index = (uint8_t)(lock_byte_index + 1);
            byte_index = (uint8_t)(byte_index + 1);
        }
        ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten + 
                                            no_of_bits_left_in_block);
    } /* else of if (no_of_bits_left_in_block >= remaining_lock_bits) */

    
    /* Copy the values back to the DynLockBytes structure member */ 
    (void)memcpy ((void*)ps_type2_info->DynLockBytes,
                (void *)lock_bytes_value,  
                sizeof (ps_type2_info->DynLockBytes));


    NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
    result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);

    return result;
}

static 
NFCSTATUS 
phFriNfc_MfUL_ReadWriteLockBytes (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_Type2_AddInfo_t        *ps_type2_info = 
                                    &(NdefSmtCrdFmt->AddInfo.Type2Info);
    uint8_t                         write_flag = FALSE;

    if (/* Lock bytes starts from the beginning of the block */
        (0 == ps_type2_info->LockByteNumber)
        /* To make sure this is the first read */
        && (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
        /* Lock bytes are greater than or equal to the block size, i.e., 4 bytes */
        && (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
        >= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
    {        
        /* Then directly write the lock bytes, dont waste time for read  */
        (void)memset ((void *)ps_type2_info->DynLockBytes, 0xFF, 
                        sizeof (ps_type2_info->DynLockBytes));
        write_flag = TRUE;
    }
    else if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
    {
        /* Read is mandatory, First read and then update the block, 
            because chances are there that lock byte may start in between 
            the block */
    }
    else if (/* check if remaining bytes exceeds or same as the block size */
        (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
        >= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
    {
        /* Then directly write the lock bytes, dont waste time for read */
        (void)memset ((void *)ps_type2_info->DynLockBytes, 0xFF, 
                        sizeof (ps_type2_info->DynLockBytes));
        write_flag = TRUE;
    }
    else
    {
        /* Read is mandatory, First read and then update the block */
    }

    if (write_flag)
    {
        NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
        result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
    }
    else
    {
        NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES;
        result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
    }

    return result;
}

static 
NFCSTATUS 
phFriNfc_MfUL_GetDefaultLockBytesInfo (
    phFriNfc_sNdefSmtCrdFmt_t          *NdefSmtCrdFmt)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    phFriNfc_Type2_AddInfo_t        *ps_type2_info = 
                                    &(NdefSmtCrdFmt->AddInfo.Type2Info);
    uint16_t                        lock_byte_start_addr = 0;

    /*  The position of the dynamic lock bits starts from 
        the first byte after the data area */
    lock_byte_start_addr = (uint16_t)(MFUL_INITIAL_BYTES_IGNORED + 
                        (ps_type2_info->OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8));

    ps_type2_info->LockBlockNumber = (uint8_t)(lock_byte_start_addr / 
                                                MFUL_BLOCK_SIZE_IN_BYTES);
    ps_type2_info->LockByteNumber = (uint8_t)(lock_byte_start_addr % 
                                                MFUL_BLOCK_SIZE_IN_BYTES);
    /* Default settings 
       NoOfLockBits = [(DataAreaSize - 48)/8] */
    ps_type2_info->NoOfLockBits = (uint8_t)
        (((ps_type2_info->OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8) - 48)/8);

    return result;
}

static 
NFCSTATUS 
phFriNfc_MfUL_ParseTLVs (
    phFriNfc_sNdefSmtCrdFmt_t       *NdefSmtCrdFmt, 
    uint8_t                         *data_to_parse, 
    uint8_t                         size_to_parse)
{
    NFCSTATUS                       result = NFCSTATUS_SUCCESS;
    static uint8_t                  lock_mem_ndef_index = 0;
    static uint8_t                  skip_lock_mem_size = 0;
    static uint16_t                 card_size_remaining = 0;
    static uint16_t                 ndef_data_size = 0;
    static phFriNfc_MfUL_Parse_t    parse_tlv = LOCK_TLV_T;
    uint8_t                         parse_index = 0;
    
    if ((0 == card_size_remaining) && (0 == parse_index))
    {
        /* card size is calculated only once */
        card_size_remaining = (uint16_t)
            (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8);
    }

    while ((parse_index < size_to_parse)
        && (NFCSTATUS_SUCCESS == result)  
        && (NDEF_TLV_V != parse_tlv)
        && (0 != card_size_remaining))
    {
        if (0 == skip_lock_mem_size)
        {
            /* Skip the lock TLVs, so get the lock bits */
            skip_lock_mem_size = phFriNfc_MfUL_GetSkipSize (NdefSmtCrdFmt, 
                                        NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock, 
                                        parse_index);
        }

        if (0 != skip_lock_mem_size)
        {
            if (skip_lock_mem_size >= (size_to_parse - parse_index))
            {
                /* if skip size is more than the size to parse, then  */
                card_size_remaining = (uint16_t)(card_size_remaining - 
                                    (size_to_parse - parse_index));
                skip_lock_mem_size = (uint8_t)(skip_lock_mem_size - 
                                            ((size_to_parse - parse_index)));
                parse_index = size_to_parse;
            }
            else
            {
                card_size_remaining = (uint16_t)(card_size_remaining - 
                                        skip_lock_mem_size);

                parse_index = (uint8_t)(parse_index + skip_lock_mem_size);
                skip_lock_mem_size = 0;
            }
        }
        else
        {
            switch (parse_tlv)
            {
                case LOCK_TLV_T:
                {
                    switch (*(data_to_parse + parse_index))
                    {
                        case MFUL_NULL_TLV:
                        {
                            /* Do nothing, parse further */
                            break;
                        }

                        case LOCK_CTRL_TYPE_IN_TLV:
                        {
                            parse_tlv = LOCK_TLV_L;
                            break;
                        }

                        case NDEF_TYPE_IN_TLV:
                        {
                            parse_tlv = NDEF_TLV_L;
                            /* Default lock bytes shall be taken */
                            NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag = 
                                                                            TRUE;
                            result = phFriNfc_MfUL_GetDefaultLockBytesInfo (NdefSmtCrdFmt);
                            break;
                        }

                        default:
                        {
                            parse_tlv = LOCK_TLV_T;
                            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                                NFCSTATUS_NO_NDEF_SUPPORT);
                            break;
                        }
                    }
                    break;
                }

                case LOCK_TLV_L:
                {
                    if (LOCK_CTRL_LEN_IN_TLV == *(data_to_parse + parse_index))
                    {
                        parse_tlv = LOCK_TLV_V;
                    }
                    else
                    {
                        skip_lock_mem_size = 0;
                        parse_tlv = LOCK_TLV_T;
                        result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                                NFCSTATUS_NO_NDEF_SUPPORT);
                    }
                    break;
                }

                case LOCK_TLV_V:
                {
                    switch (lock_mem_ndef_index)
                    {
                        case 0:
                        case 1:
                        {
                            NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag = 
                                                                                FALSE;
                            NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes[lock_mem_ndef_index] = 
                                            *(data_to_parse + parse_index);
                            lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
                            break;
                        }

                        case 2:
                        {
                            NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes[lock_mem_ndef_index] = 
                                            *(data_to_parse + parse_index);
                            parse_tlv = NDEF_TLV_T;
                            lock_mem_ndef_index = 0;
                            result = phFriNfc_MfUL_GetLockBytesInfo (NdefSmtCrdFmt);
                            break;
                        }

                        default:
                        {
                            skip_lock_mem_size = 0;
                            parse_tlv = LOCK_TLV_T;
                            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                                NFCSTATUS_NO_NDEF_SUPPORT);
                            break;
                        }
                    }
                    break;
                } /* switch (lock_mem_ndef_index) in case LOCK_TLV_V */

                case NDEF_TLV_T:
                {
                    switch (*(data_to_parse + parse_index))
                    {
                        case MFUL_NULL_TLV:
                        {
                            /* Do nothing, parse further */
                            break;
                        }

                        case NDEF_TYPE_IN_TLV:
                        {
                            parse_tlv = NDEF_TLV_L;
                            break;
                        }

                        default:
                        {
                            skip_lock_mem_size = 0;
                            parse_tlv = LOCK_TLV_T;
                            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                                NFCSTATUS_NO_NDEF_SUPPORT);
                            break;
                        }
                    }
                    break;
                } /* switch (*(data_to_parse + parse_index)) in case NDEF_TLV_T */

                case NDEF_TLV_L:
                {
                    switch (lock_mem_ndef_index)
                    {
                        case 0:
                        {
                            if (THREE_BYTE_LENGTH_FIELD == *(data_to_parse + parse_index))
                            {
                                lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
                            }
                            else
                            {
                                ndef_data_size = *(data_to_parse + parse_index);
                                parse_tlv = NDEF_TLV_V;
                                lock_mem_ndef_index = 0;
                            }
                            break;
                        }

                        case 1:
                        {
                            ndef_data_size = (uint16_t)(*(data_to_parse + parse_index) << 8);
                            break;
                        }

                        case 2:
                        {
                            ndef_data_size = (uint16_t)(ndef_data_size | 
                                                        *(data_to_parse + parse_index));
                            parse_tlv = NDEF_TLV_V;
                            lock_mem_ndef_index = 0;
                            break;
                        }
                    } /* switch (lock_mem_ndef_index) in case NDEF_TLV_L */
                    break;
                }

                case NDEF_TLV_V:
                {
                    break;
                }
                
                default:
                {
                    skip_lock_mem_size = 0;
                    parse_tlv = LOCK_TLV_T;
                    result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                        NFCSTATUS_NO_NDEF_SUPPORT);
                    break;
                }
            } /* switch (parse_tlv) */
            
        } /* else part of if (0 != skip_lock_mem_size) */

        if (0 == card_size_remaining)
        {
            skip_lock_mem_size = 0;
            parse_tlv = LOCK_TLV_T;
            result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                NFCSTATUS_NO_NDEF_SUPPORT);
        }
        else if (NDEF_TLV_V != parse_tlv)
        {
            /* Increment the index */
            parse_index = (uint8_t)(parse_index + 1);
            /* card size is decremented as the memory area is parsed  */
            card_size_remaining = (uint16_t)(card_size_remaining - 1);
        }
        else
        {
            /* L field of the NDEF TLV
                L field can have 1 byte or also 3 bytes 
               */
            uint8_t length_to_deduct = 1;

            if ((NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION] 
                * 8) >= THREE_BYTE_LENGTH_FIELD)
            {
                length_to_deduct = 3;
            }
            /* parse_tlv has reached the VALUE field of the NDEF TLV */
            if ((card_size_remaining - length_to_deduct) < ndef_data_size)
            {
                result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                    NFCSTATUS_NO_NDEF_SUPPORT);
            }

            lock_mem_ndef_index = 0;
            skip_lock_mem_size = 0;
            card_size_remaining = 0;
        }
    } /* while ((parse_index < size_to_parse)
        && (NFCSTATUS_SUCCESS != result)  
        && (NDEF_TLV_V != parse_tlv)
        && (0 != card_size_remaining)) */
    
    if ((NDEF_TLV_V == parse_tlv) || (NFCSTATUS_SUCCESS != result))
    {
        parse_tlv = LOCK_TLV_T;
    }
    else
    {
        NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES;
        NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                        (NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock + 4);

        result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
    }

    if (NFCSTATUS_PENDING != result)
    {
        lock_mem_ndef_index = 0;
        skip_lock_mem_size = 0;
        card_size_remaining = 0;
    }
    return result;
}

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

#endif /* #ifdef FRINFC_READONLY_NDEF */

static NFCSTATUS phFriNfc_MfUL_H_WrRd( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;

    /* Fill the send buffer */
    phFriNfc_MfUL_H_fillSendBuf(NdefSmtCrdFmt, 
                            NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock);

    /* Call transceive */
    Result = phFriNfc_MfUL_H_Transceive (NdefSmtCrdFmt);
    
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_Transceive(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;

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

    /*set the completion routines for the card operations*/
    NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine = phFriNfc_NdefSmtCrd_Process;
    NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = NdefSmtCrdFmt;

    *NdefSmtCrdFmt->SendRecvLength = PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE;

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

static void phFriNfc_MfUL_H_fillSendBuf( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
                                 uint8_t                    BlockNo)
{
#ifdef PH_NDEF_MIFARE_ULC
    uint8_t     NDEFTLV1[4] = {0x01, 0x03, 0xA0, 0x10}; 
    uint8_t     NDEFTLV2[4] = {0x44, 0x03, 0x00, 0xFE}; 
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
    uint8_t     NDEFTLV[4] = {0x03, 0x00, 0xFE, 0x00};


    
    
    /* First byte for send buffer is always the block number */
    NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_0] = (uint8_t)BlockNo;
    switch(NdefSmtCrdFmt->State)
    {
#ifdef FRINFC_READONLY_NDEF

        case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
        /* Read command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
            *NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
            break;
        }

#ifdef PH_NDEF_MIFARE_ULC

        case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
        /* Read command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
            *NdefSmtCrdFmt->SendRecvBuf = 
                    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
        /* Read command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
            *NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
            /* Write command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */

            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
            *NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
                         NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes,
                         PH_FRINFC_MFUL_FMT_VAL_4);
            break;
        }

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

        case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
            /* Read command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */

            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
            *NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
                         NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
                         PH_FRINFC_MFUL_FMT_VAL_4);
            break;
        }

        case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
        {
#ifdef PH_HAL4_ENABLE
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
            /* Read command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */

            /* Send length for read command is always one */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
            *NdefSmtCrdFmt->SendRecvBuf = OTP_BLOCK_NUMBER;
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
                         NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                         PH_FRINFC_MFUL_FMT_VAL_4);
            break;
        }

#endif /* #ifdef FRINFC_READONLY_NDEF */

    case PH_FRINFC_MFUL_FMT_RD_16BYTES:
#ifdef PH_HAL4_ENABLE
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
        /* Read command */
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
        /* Send length for read command is always one */
        NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
        break;

    case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
        /* Send length for read command is always Five */
        NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
        /* Write command */
#ifdef PH_HAL4_ENABLE
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
        /* Copy the OTP bytes */
        (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1], 
                    NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                    PH_FRINFC_MFUL_FMT_VAL_4);
        break;

    case PH_FRINFC_MFUL_FMT_WR_TLV:
#ifndef PH_NDEF_MIFARE_ULC      
    default:
#endif /* #ifndef PH_NDEF_MIFARE_ULC */    
        /* Send length for read command is always Five */
        NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
        /* Write command */
#ifdef PH_HAL4_ENABLE
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
        NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */        
        /* Copy the NDEF TLV */
#ifdef PH_NDEF_MIFARE_ULC

        if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
        {
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1], 
                    NDEFTLV1,
                    PH_FRINFC_MFUL_FMT_VAL_4);
        }
        else if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD)
        {
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1], 
                NDEFTLV,
                PH_FRINFC_MFUL_FMT_VAL_4);
        }
        else
        {
        }
#else
        (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1], 
                    NDEFTLV,
                    PH_FRINFC_MFUL_FMT_VAL_4);

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

        break;

#ifdef PH_NDEF_MIFARE_ULC
    case PH_FRINFC_MFUL_FMT_WR_TLV1:
        if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
        {
            /* Send length for write command is always Five */
            NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
            /* Write command */
            NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
            (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1], 
                        NDEFTLV2,
                        PH_FRINFC_MFUL_FMT_VAL_4);
        }
        break;
    default:
        break;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */

    
    }
}

static NFCSTATUS phFriNfc_MfUL_H_ProRd16Bytes( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
    NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
                                    NFCSTATUS_FORMAT_ERROR);
    uint32_t    memcompare = PH_FRINFC_MFUL_FMT_VAL_0;
    uint8_t     ZeroBuf[] = {0x00, 0x00, 0x00, 0x00};

#ifdef PH_NDEF_MIFARE_ULC
    uint8_t                 OTPByteUL[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
    uint8_t                 OTPByteULC[] = PH_FRINFC_MFULC_FMT_OTP_BYTES;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */

    /* Check the lock bits (byte number 2 and 3 of block number 2) */
    if ((NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_2] == 
        PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL) && 
        (NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_3] == 
        PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL))
    {

#ifdef PH_NDEF_MIFARE_ULC

        if (NdefSmtCrdFmt->SendRecvBuf[8] == 0x02 && 
            NdefSmtCrdFmt->SendRecvBuf[9] == 0x00) 
        {
            NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
            
            (void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                        OTPByteULC,
                        sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
        }
        else if (NdefSmtCrdFmt->SendRecvBuf[8] == 0xFF && 
                NdefSmtCrdFmt->SendRecvBuf[9] == 0xFF)
        {
            NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
            
            (void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                        OTPByteUL,
                        sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
        }
        else
        {
            NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
        }

#endif /* #ifdef PH_NDEF_MIFARE_ULC */

        memcompare = (uint32_t) 
                    MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
                            NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
                            PH_FRINFC_MFUL_FMT_VAL_4);

        if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
        {
            /* Write NDEF TLV in block number 4 */
            NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                                                PH_FRINFC_MFUL_FMT_VAL_4;
            /* Card already have the OTP bytes so write TLV */
            NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV;
        }
        else
        {
            /* IS the card new, OTP bytes = {0x00, 0x00, 0x00, 0x00} */
            memcompare = (uint32_t)MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
                                ZeroBuf,
                                PH_FRINFC_MFUL_FMT_VAL_4);
            /* If OTP bytes are Zero then the card is Zero */
            if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
            {
                /* Write OTP bytes in block number 3 */
                NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                                                PH_FRINFC_MFUL_FMT_VAL_3;
                /* Card already have the OTP bytes so write TLV */
                NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_OTPBYTES;
            }
        }
    }

    

#ifdef PH_NDEF_MIFARE_ULC
    if(
        ((NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_TLV) || 
        (NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_OTPBYTES)) &&
        ((NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD) ||
        (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD))
        )
#else
    if((NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_TLV) || 
        (NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_OTPBYTES))
#endif /* #ifdef PH_NDEF_MIFARE_ULC */        
    {
        Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
    }
    return Result;
}

static NFCSTATUS phFriNfc_MfUL_H_ProWrOTPBytes( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
    NFCSTATUS   Result = NFCSTATUS_SUCCESS;
    /* Card already have the OTP bytes so write TLV */
    NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV;

    /* Write NDEF TLV in block number 4 */
    NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 
                                PH_FRINFC_MFUL_FMT_VAL_4;

    Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
    return Result;
}