/*
 * 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_Desfire.c
* \brief This component encapsulates read/write/check ndef/process functionalities,
*        for the Desfire Card.
*
* Project: NFC-FRI
*
* $Date: Tue Jul 27 08:58:22 2010 $
* $Author: ing02260 $
* $Revision: 1.11 $
* $Aliases:  $
*
*/

#ifndef PH_FRINFC_MAP_DESFIRE_DISABLED

#include <phFriNfc_OvrHal.h>
#include <phFriNfc_DesfireMap.h>
#include <phFriNfc_MapTools.h>


/*! \ingroup grp_file_attributes
*  \name NDEF Mapping
*
* File: \ref phFriNfc_Desfire.c
*
*/
/*@{*/
#define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.11 $"
#define PHFRINFCNDEFMAP_FILEALIASES  "$Aliases:  $"

/*@}*/

/***************** Start of MACROS ********************/
#ifdef DESFIRE_EV1
    #define DESFIRE_EV1_P2_OFFSET_VALUE                         (0x0CU)
#endif /* #ifdef DESFIRE_EV1 */

/***************** End of MACROS ********************/

/*@}*/

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

/*!
 * \brief \copydoc page_ovr Helper function for Desfire. This function specifies
 *  the card is a Desfire card or not.
 */
static NFCSTATUS phFriNfc_Desfire_SelectSmartTag(  phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Desfire. This function is used
 *  to selct a file in the card.
 */
static NFCSTATUS phFriNfc_Desfire_SelectFile ( phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Desfire. This function is to
 *  read the card.
 */
static NFCSTATUS  phFriNfc_Desfire_ReadBinary( phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Desfire. This function is to
 *  write to the card.
 */
static NFCSTATUS  phFriNfc_Desfire_UpdateBinary(   phFriNfc_NdefMap_t  *NdefMap);

/*!
 * \brief \copydoc page_ovr Helper function for Desfire. This function is to
 *  update the capability container of the card.
 */
static NFCSTATUS  phFriNfc_Desfire_Update_SmartTagCapContainer( phFriNfc_NdefMap_t *NdefMap);


/* Completion Helper*/
static void phFriNfc_Desfire_HCrHandler(    phFriNfc_NdefMap_t  *NdefMap,
                                        NFCSTATUS           Status);

/* Calculates the Le Bytes for Read Operation*/
static uint32_t phFriNfc_Desfire_HGetLeBytes(   phFriNfc_NdefMap_t  *NdefMap);

static NFCSTATUS phFriNfc_Desf_HChkAndParseTLV( phFriNfc_NdefMap_t  *NdefMap,
                                               uint8_t             BuffIndex);

static NFCSTATUS phFriNfc_Desfire_HSetGet_NLEN( phFriNfc_NdefMap_t  *NdefMap);

static void phFriNfc_Desfire_HProcReadData( phFriNfc_NdefMap_t  *NdefMap);

static void phFriNfc_Desfire_HChkNDEFFileAccessRights(  phFriNfc_NdefMap_t  *NdefMap);
static NFCSTATUS phFriNfc_Desfire_HSendTransCmd(phFriNfc_NdefMap_t *NdefMap,uint8_t SendRecvLen);

#ifdef PH_HAL4_ENABLE

#else

/* Following are the API's are used to get the version of the desfire card*/
static NFCSTATUS phFriNfc_Desfire_HGetHWVersion(phFriNfc_NdefMap_t    *NdefMap);
static NFCSTATUS phFriNfc_Desfire_HGetSWVersion(phFriNfc_NdefMap_t    *NdefMap);
static NFCSTATUS phFriNfc_Desfire_HGetUIDDetails(phFriNfc_NdefMap_t   *NdefMap);
static NFCSTATUS phFriNfc_Desfire_HUpdateVersionDetails(const phFriNfc_NdefMap_t *NdefMap);

#endif /* #ifdef PH_HAL4_ENABLE */

#ifdef PH_HAL4_ENABLE

#else

static NFCSTATUS phFriNfc_Desfire_HGetHWVersion(phFriNfc_NdefMap_t    *NdefMap)
{

    NFCSTATUS status = NFCSTATUS_PENDING;

    /*set the state*/
    NdefMap->State = PH_FRINFC_DESF_STATE_GET_HW_VERSION;

    /* Helper routine to wrap the native desfire cmds*/
    PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();
    status =  phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);

    return (status);
}

static NFCSTATUS phFriNfc_Desfire_HGetSWVersion(phFriNfc_NdefMap_t *NdefMap)
{

    NFCSTATUS status = NFCSTATUS_PENDING;
    if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == PH_FRINFC_DESF_NATIVE_GETVER_RESP) )
    {
        /*set the state*/
        NdefMap->State = PH_FRINFC_DESF_STATE_GET_SW_VERSION;

        /* Helper routine to wrap the native desfire commands*/
        PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();
        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    }
#ifdef PH_HAL4_ENABLE
    else
    {
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                       NFCSTATUS_INVALID_PARAMETER);
    }
#endif /* #ifdef PH_HAL4_ENABLE */
    return status;
}

static NFCSTATUS phFriNfc_Desfire_HGetUIDDetails(phFriNfc_NdefMap_t *NdefMap)
{

    NFCSTATUS status = NFCSTATUS_PENDING;

    if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == PH_FRINFC_DESF_NATIVE_GETVER_RESP) )
    {
        /*set the state*/
        NdefMap->State = PH_FRINFC_DESF_STATE_GET_UID;

        /* Helper routine to wrap the native desfire commands*/
        PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();

        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    }
#ifdef PH_HAL4_ENABLE
    else
    {
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                       NFCSTATUS_INVALID_PARAMETER);
    }
#endif /* #ifdef PH_HAL4_ENABLE */
    return status;

}

static NFCSTATUS phFriNfc_Desfire_HUpdateVersionDetails(const phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                       NFCSTATUS_INVALID_PARAMETER);

    if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == 0xAF) )
    {

        status = NFCSTATUS_SUCCESS;

        /* We do not need the following details presently.Retained for future use*/
        #if 0
        NdefMap->AddInfo.Type4Info.MajorVersion = NdefSmtCrdFmt->SendRecvBuf[3];
        NdefMap->AddInfo.Type4Info.MinorVersion = NdefSmtCrdFmt->SendRecvBuf[4];
        if ( ( NdefMap->AddInfo.Type4Info.MajorVersion == 0x00 )&&
            ( NdefMap->AddInfo.Type4Info.MinorVersion == 0x06 ))
        {
            /* card size of DESFire4 type */
            //NdefMap->AddInfo.Type4Info.CardSize = 0xEDE;

        }
        else
        {
            // need to handle the Desfire8 type cards
            // need to use get free memory
        }
        #endif
    }
    return status;
}


#endif /* #ifdef PH_HAL4_ENABLE */

/*!
* \brief Initiates Reading of NDEF information from the Desfire Card.
*
* The function initiates the reading of NDEF information from a Remote Device.
* It performs a reset of the state and starts the action (state machine).
* A periodic call of the \ref phFriNfcNdefMap_Process has to be
* done once the action has been triggered.
*/

NFCSTATUS phFriNfc_Desfire_RdNdef(  phFriNfc_NdefMap_t  *NdefMap,
                                  uint8_t             *PacketData,
                                  uint32_t            *PacketDataLength,
                                  uint8_t             Offset)
{
    NFCSTATUS   status = NFCSTATUS_PENDING;

    NdefMap->ApduBufferSize = *PacketDataLength;
    /*  To return actual number of bytes read to the caller */
    NdefMap->NumOfBytesRead = PacketDataLength ;
    *NdefMap->NumOfBytesRead = 0;

    /* store the offset in to map context*/
    NdefMap->Offset = Offset;

    if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
        (*NdefMap->DataCount == NdefMap->DesfireCapContainer.NdefDataLen))
    {
        /*  No space on card for Reading : we have already
        reached the end of file !
        Offset is set to Continue Operation */
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    }
    else
    {

        /* reset the inter flag*/
        NdefMap->DesfireCapContainer.IsNlenPresentFlag = 0;
        NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 0;

        /*  Set the desfire read operation  */
        NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_READ_OP;

        /*  Save the packet data buffer address in the context  */
        NdefMap->ApduBuffer = PacketData;

        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;

#ifdef DESFIRE_EV1
        /* Select smart tag operation. First step for the read operation. */
        if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
        {
            status = phFriNfc_Desfire_SelectFile(NdefMap);
        }
        else
#endif /* #ifdef DESFIRE_EV1 */
        {
            status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
        }
    }

    return status;
}

/*!
* \brief Initiates Writing of NDEF information to the Remote Device.
*
* The function initiates the writing of NDEF information to a Remote Device.
* It performs a reset of the state and starts the action (state machine).
* A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
* has been triggered.
*/

NFCSTATUS phFriNfc_Desfire_WrNdef(  phFriNfc_NdefMap_t  *NdefMap,
                                  uint8_t             *PacketData,
                                  uint32_t            *PacketDataLength,
                                  uint8_t             Offset)
{
    NFCSTATUS   status = NFCSTATUS_PENDING;

    NdefMap->ApduBufferSize = *PacketDataLength;
    NdefMap->WrNdefPacketLength = PacketDataLength;

    /*  Now, let's initialize     *NdefMap->WrNdefPacketLength    to zero.
    In case we get an error, this will be correctly set to "no byte written".
    In case there is no error, this will be updated later on, in the _process function.
    */
    *NdefMap->WrNdefPacketLength =   0;

    /*  we have write access. */
    if( *NdefMap->DataCount >= PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE)
    {
        /*  No space on card for writing : we have already
        reached the end of file !
        Offset is set to Continue Operation */
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
            NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    }
    else
    {
        /*  Adapt the nb of bytes that the user would like to write */

        /*set the defire write operation*/
        NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_WRITE_OP;
        NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
        NdefMap->Offset = Offset;

        /*Store the packet data buffer*/
        NdefMap->ApduBuffer = PacketData;

#ifdef DESFIRE_EV1
        if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
        {
            status = phFriNfc_Desfire_SelectFile(NdefMap);
        }
        else
#endif /* #ifdef DESFIRE_EV1 */
        {
            /* Select smart tag operation. First step for the write operation. */
            status = phFriNfc_Desfire_SelectSmartTag (NdefMap);
        }
    }
    return status;
}

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

NFCSTATUS phFriNfc_Desfire_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)
{
    NFCSTATUS    status = NFCSTATUS_PENDING;

#ifdef PH_HAL4_ENABLE

#ifdef DESFIRE_EV1
    /* Reset card type */
    NdefMap->CardType = 0;
#endif /* #ifdef DESFIRE_EV1 */
	/*Set the desfire operation flag*/
	NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;

    /*Call Select Smart tag Functinality*/
    status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
#else
	/* Need to get the version details of the card, to
	   identify the the desfire4card type */
	status = phFriNfc_Desfire_HGetHWVersion(NdefMap);
#endif

    return (status);
}

static NFCSTATUS phFriNfc_Desf_HChkAndParseTLV(phFriNfc_NdefMap_t     *NdefMap, uint8_t BuffIndex)
{
    NFCSTATUS    status = NFCSTATUS_SUCCESS;

    if((NdefMap->SendRecvBuf[BuffIndex] <= 0x03) ||
        (NdefMap->SendRecvBuf[BuffIndex] >= 0x06) )
    {
        status =  PHNFCSTVAL(   CID_FRI_NFC_NDEF_MAP,
            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    else
    {
        /* check for the type of TLV*/
        NdefMap->TLVFoundFlag =
            ((NdefMap->SendRecvBuf[BuffIndex] == 0x04)?
            PH_FRINFC_NDEFMAP_DESF_NDEF_CNTRL_TLV:
            PH_FRINFC_NDEFMAP_DESF_PROP_CNTRL_TLV);

        status =  PHNFCSTVAL(   CID_FRI_NFC_NDEF_MAP,
            NFCSTATUS_SUCCESS);
    }
    return status;
}

static NFCSTATUS    phFriNfc_Desfire_HSetGet_NLEN(phFriNfc_NdefMap_t *NdefMap)
{

    NFCSTATUS    status = NFCSTATUS_PENDING;

    if ( PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP == NdefMap->DespOpFlag)
    {

        /*Call Select Smart tag Functinality*/
        status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    }
    else
    {

        /* Get the Data Count and set it to NoOfBytesWritten
        Update the NLEN using Transceive cmd*/

        /*Form the packet for the update binary command*/
        NdefMap->SendRecvBuf[0] = 0x00;
        NdefMap->SendRecvBuf[1] = 0xD6;

        /* As we need to set the NLEN @ first 2 bytes of NDEF File*/
        /* set the p1/p2 offsets */
        NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
        NdefMap->SendRecvBuf[3] = 0x00; /* p2 */

        /* Set only two bytes as NLEN*/
        NdefMap->SendRecvBuf[4] = 0x02;

        /* update NLEN */
        NdefMap->SendRecvBuf[5] = (uint8_t)(*NdefMap->DataCount >> PH_FRINFC_NDEFMAP_DESF_SHL8);
        NdefMap->SendRecvBuf[6] = (uint8_t)(*NdefMap->DataCount & (0x00ff));

        NdefMap->SendLength = 0x07 ;

        /* Change the state to Write */
        NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_END;

        status =  phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);
    }
    return status;
}

static void phFriNfc_Desfire_HProcReadData(phFriNfc_NdefMap_t *NdefMap)
{
    NFCSTATUS   Result = NFCSTATUS_PENDING;
    uint32_t    BufferSize = 0;
    uint8_t     BufIndex=0;
    uint16_t    SizeToCpy=0;

    /* Need to check the Actual Ndef Length before copying the data to buffer*/
    /* Only NDEF data should be copied , rest all the data should be ignored*/
    /* Ex : Ndef File Size 50 bytes , but only 5 bytes(NLEN) are relavent to NDEF data*/
    /* component should only copy 5 bytes to user buffer*/

    /*  Data has been read successfully in the TRX buffer. */
    /*  copy it to the user buffer. */

    /* while copying need check the offset if its begin need to skip the first 2 bytes
    while copying. If its current no need to skip the first 2 bytes*/

    if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
    {
        BufIndex = (uint8_t)(( NdefMap->DesfireCapContainer.IsNlenPresentFlag == 1 )?
            0:PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES);

        /* Update the latest NLEN to context*/
        NdefMap->DesfireCapContainer.NdefDataLen = ((*NdefMap->DataCount == 0)?
            ( (((uint16_t)NdefMap->SendRecvBuf[
                PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_FIRST_INDEX])<<8)+ \
                    NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_SECOND_INDEX]):
                NdefMap->DesfireCapContainer.NdefDataLen);

        /* Decide how many byes to be copied into user buffer: depending upon the actual NDEF
           size need to copy the content*/
        if ( (NdefMap->DesfireCapContainer.NdefDataLen) <= (*NdefMap->SendRecvLength - \
            (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET + BufIndex)))
        {
            SizeToCpy = NdefMap->DesfireCapContainer.NdefDataLen;

        }
        else
        {
            SizeToCpy = ((*NdefMap->SendRecvLength)-(PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET+BufIndex));
        }

        /* Check do we have Ndef Data len > 0 present in the card.If No Ndef Data
        present in the card , set the card state to Initalised and set an Error*/
        if ( NdefMap->DesfireCapContainer.NdefDataLen == 0x00 )
        {
            NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
#ifdef PH_HAL4_ENABLE
#else
            NdefMap->PrevOperation = 0;
#endif /* #ifdef PH_HAL4_ENABLE */
            phFriNfc_Desfire_HCrHandler(NdefMap,Result);
        }
        else
        {
            (void)memcpy( (&(NdefMap->ApduBuffer[
            NdefMap->ApduBuffIndex])),
            (&(NdefMap->SendRecvBuf[BufIndex])),
            (SizeToCpy));

            /*  Increment the Number of Bytes Read, which will be returned to the caller. */
            *NdefMap->NumOfBytesRead = (uint32_t)(*NdefMap->NumOfBytesRead + SizeToCpy);

            /*update the data count*/
            *NdefMap->DataCount = (uint16_t)(*NdefMap->DataCount + SizeToCpy);

            /*update the buffer index of the apdu buffer*/
            NdefMap->ApduBuffIndex = (uint16_t)(NdefMap->ApduBuffIndex + SizeToCpy);
        }
    }
    else
    {
            (void)memcpy( (&(NdefMap->ApduBuffer[
            NdefMap->ApduBuffIndex])),
                (NdefMap->SendRecvBuf),/* to avoid the length of the NDEF File*/
                (*(NdefMap->SendRecvLength)-(PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET)));

            /*  Increment the Number of Bytes Read, which will be returned to the caller. */
            *NdefMap->NumOfBytesRead +=( *NdefMap->SendRecvLength - \
                (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));

            /*update the data count*/
            *NdefMap->DataCount += \
                (*NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));

            /*update the buffer index of the apdu buffer*/
            NdefMap->ApduBuffIndex += \
                *NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET );
    }

    /*  check whether we still have to read some more data. */
    if (*NdefMap->DataCount < NdefMap->DesfireCapContainer.NdefDataLen )
    {
        /*  we have some bytes to read. */

        /*  Now check, we still have bytes left in the user buffer. */
        BufferSize = NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex;
        if(BufferSize != 0)
        {
            /* Before read need to set the flag to intimate the module to
            dont skip the first 2 bytes as we are in mode reading next
            continues available bytes, which will not contain the NLEN
            information in the begining part that is 2 bytes*/
            NdefMap->DesfireCapContainer.IsNlenPresentFlag = 1;
            /* Read Operation is not complete */
            Result = phFriNfc_Desfire_ReadBinary( NdefMap );
            /* handle the error in Transc function*/
            if  ( (Result & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER) )
            {
                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Result);
            }
        }
        else
        {
            /*  There are some more bytes to read, but
            no space in the user buffer */
            Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
            NdefMap->ApduBuffIndex =0;
            /* call respective CR */
            phFriNfc_Desfire_HCrHandler(NdefMap,Result);
        }
    }
    else
    {
        if (*NdefMap->DataCount == NdefMap->DesfireCapContainer.NdefDataLen )
        {
            /*  we have read all the bytes available in the card. */
            Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
#ifdef PH_HAL4_ENABLE
            /* Do nothing */
#else
            NdefMap->PrevOperation = 0;
#endif /* #ifndef PH_HAL4_ENABLE */
        }
        else
        {
            /*  The control should not come here. */
            /*  we have actually read more byte than available in the card. */
            NdefMap->PrevOperation = 0;
#ifndef PH_HAL4_ENABLE
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                NFCSTATUS_CMD_ABORTED);
#else
            Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                NFCSTATUS_FAILED);
#endif
        }


        NdefMap->ApduBuffIndex = 0;

        /* call respective CR */
        phFriNfc_Desfire_HCrHandler(NdefMap,Result);
    }
}


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

void phFriNfc_Desfire_Process(void       *Context,
                              NFCSTATUS   Status)
{
    /*Set the context to Map Module*/
    phFriNfc_NdefMap_t  *NdefMap = (phFriNfc_NdefMap_t *)Context;
    uint8_t             ErrFlag = 0;
    uint16_t            NLength = 0,
                        SendRecLen=0;
    uint32_t            BytesRead = 0;


    /*  Sujatha P: Fix for 0000255/0000257:[gk] MAP:Handling HAL Errors */
    if ( Status == NFCSTATUS_SUCCESS )
    {
        switch (NdefMap->State)
        {

#ifdef PH_HAL4_ENABLE
#else

            case PH_FRINFC_DESF_STATE_GET_HW_VERSION :

                /* Check and store the h/w and s/w specific details.
                Ex: Major/Minor version, memory storage info. */
                Status = phFriNfc_Desfire_HGetSWVersion(NdefMap);

                /* handle the error in Transc function*/
                if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                {
                    /* call respective CR */
                    phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                }

                break;

            case PH_FRINFC_DESF_STATE_GET_SW_VERSION :

                /* Check and store the h/w and s/w specific details.
                Ex: Major/Minor version, memory storage info. */

                Status = phFriNfc_Desfire_HUpdateVersionDetails(NdefMap);
                if ( Status == NFCSTATUS_SUCCESS )
                {
                    Status = phFriNfc_Desfire_HGetUIDDetails(NdefMap);
                    /* handle the error in Transc function*/
                    if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                    {
                        /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }
                }

                break;

            case PH_FRINFC_DESF_STATE_GET_UID :

                /*Set the desfire operation flag*/
                NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;

                /*Call Select Smart tag Functinality*/
                Status = phFriNfc_Desfire_SelectSmartTag(NdefMap);

                break;
#endif /* #ifdef PH_HAL4_ENABLE */

#ifdef DESFIRE_EV1
            case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1:
            {
                if(( NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 2)] ==
                    PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                    (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 1)] ==
                    PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
                {
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;

                    Status = phFriNfc_Desfire_SelectFile(NdefMap);

                    /* handle the error in Transc function*/
                    if ((Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                    {
                        /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }
                }
                else
                {
                    NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
                    /* The card is not the new desfire, so send select smart tag command
                    of the old desfire */
                    Status = phFriNfc_Desfire_SelectSmartTag(NdefMap);


                }
                break;
            }
#endif /* #ifdef DESFIRE_EV1 */

        case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG:
#ifdef DESFIRE_EV1
            if(( NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 2)] ==
                    PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                    (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 1)] ==
                    PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
#else
            if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] ==
                PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] ==
                PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
#endif /* #ifdef DESFIRE_EV1 */
            {
                Status = phFriNfc_Desfire_SelectFile(NdefMap);

                /* handle the error in Transc function*/
                if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                {
                    /* call respective CR */
                    phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                }
            }
            else
            {
                /*Error " Smart Tag Functionality Not Supported"*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                    NFCSTATUS_SMART_TAG_FUNC_NOT_SUPPORTED);
#ifdef DESFIRE_EV1
                NdefMap->CardType = 0;
#endif /* #ifdef DESFIRE_EV1 */

                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Status);

            }

            break;

        case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_FILE :

            if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
            {
                /*check for the which operation */
                if( (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_READ_OP) ||
                    (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP) ||
                    (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP ))
                {
                    /* call for read binary operation*/
                    Status = phFriNfc_Desfire_ReadBinary(NdefMap);

                    /* handle the error in Transc function*/
                    if  ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER) )
                    {
                        /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }
                }
                /*its a write Operation*/
                else if(NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_WRITE_OP )
                {
                    Status = phFriNfc_Desfire_UpdateBinary (NdefMap);
                    /* handle the error in Transc function*/
                    if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                    {
                        /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }
                }
                else
                {
                    /* unknown/invalid desfire operations*/
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                        NFCSTATUS_INVALID_REMOTE_DEVICE);

                    /* call respective CR */
                    phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                }
            }
            else
            {
                /*return Error " Select File Operation Failed"*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                    NFCSTATUS_INVALID_REMOTE_DEVICE);

                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            }
            break;

        case PH_FRINFC_NDEFMAP_DESF_STATE_READ_CAP_CONT:
            if( (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength)-2)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength)-1)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
            {
                /*  Read successful. */
                /*Update the smart tag capability container*/
                Status = phFriNfc_Desfire_Update_SmartTagCapContainer(NdefMap);

                if ( Status == NFCSTATUS_SUCCESS)
                {
                    NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP;
#ifdef DESFIRE_EV1
                    if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
                    {
                        Status = phFriNfc_Desfire_SelectFile(NdefMap);
                    }
                    else
#endif /* #ifdef DESFIRE_EV1 */
                    {
                        Status = phFriNfc_Desfire_HSetGet_NLEN(NdefMap);
                    }
                    /* handle the error in Transc function*/
                    if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
                    {
                        /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }
                }
                else
                {
                    /* call respective CR */
                    phFriNfc_Desfire_HCrHandler(NdefMap,Status);

                }

            }
            else
            {
                /*return Error " Capability Container Not Found"*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                    NFCSTATUS_INVALID_REMOTE_DEVICE);
                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            }
            break;

        case  PH_FRINFC_NDEFMAP_DESF_STATE_READ_BIN:

            /* Check how many bytes have been read/returned from the card*/
            BytesRead = phFriNfc_Desfire_HGetLeBytes(NdefMap);

            /* set the send recev len*/
            SendRecLen = *NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET );
            if ( (NdefMap->DesfireCapContainer.SkipNlenBytesFlag  == 1) && ((BytesRead == 1) || (BytesRead == 2 )))
            {
                BytesRead += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES; /* to take care of first 2 len bytes*/

            }
            else
            {
                /* Nothing to process*/
                ;
            }
            /* Read More Number Of Bytes than Expected*/
            if ( ( BytesRead == SendRecLen ) &&
                ((NdefMap->SendRecvBuf[(*NdefMap->SendRecvLength-2)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[(*NdefMap->SendRecvLength-1)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE)))

            {
                /* this is to check the card state in first Read Operation*/
                if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP )
                {
                    /* check the actual length of the ndef data : NLEN*/
                    NLength = ( (((uint16_t)NdefMap->SendRecvBuf[0])<<PH_FRINFC_NDEFMAP_DESF_SHL8)+ \
                        NdefMap->SendRecvBuf[1]);
                    if (( NLength > PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE )||
                        ( NLength == 0xFFFF))
                    {
                        ErrFlag = 1;
                        Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                            NFCSTATUS_NO_NDEF_SUPPORT);
                    }
                    else
                    {
                        /* Store the NLEN into the context  */
                        NdefMap->DesfireCapContainer.NdefDataLen = NLength;

                        Status = phFriNfc_MapTool_SetCardState( NdefMap,
                            NLength);
                        if ( Status == NFCSTATUS_SUCCESS )
                        {
                            /*Set the card type to Desfire*/
#ifndef DESFIRE_EV1
                            NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
#endif /* #ifdef DESFIRE_EV1 */
                            /*Set the state to specify True for Ndef Compliant*/
                            NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_CHK_NDEF;

                            /*set the data count back to zero*/;
                            *NdefMap->DataCount = 0;
                            /*set the apdu buffer index to zero*/
                            NdefMap->ApduBuffIndex = 0;
                            /* Set the Operationg flag to Complete check NDEF Operation*/
                            NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;

                        }
                         /* call respective CR */
                        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                    }/* End ofNdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP*/
                }
                else if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_READ_OP )
                {
                    phFriNfc_Desfire_HProcReadData(NdefMap);
                }
                else
                {
                    /* Invalid Desfire Operation  */
                    Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                        NFCSTATUS_INVALID_REMOTE_DEVICE);
                    phFriNfc_Desfire_HCrHandler(NdefMap,Status);
                }

            }
            else
            {
                /*handle the  Error case*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                    NFCSTATUS_READ_FAILED);
                ErrFlag =1;
            }
            if( ErrFlag == 1)
            {
                *NdefMap->DataCount = 0;

                /*set the buffer index back to zero*/
                NdefMap->ApduBuffIndex = 0;

                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            }

            break;

        case  PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_BEGIN:
            if( (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
            {
                /*  Write operation was successful. */
                /*  NdefMap->NumOfBytesWritten have been written on to the card.
                Update the DataCount and the ApduBufferIndex */
                *NdefMap->DataCount = (uint16_t)(*NdefMap->DataCount +
                                                NdefMap->NumOfBytesWritten);
                NdefMap->ApduBuffIndex = (uint16_t)(NdefMap->ApduBuffIndex +
                                                NdefMap->NumOfBytesWritten);

                /*  Update the user-provided buffer size to write */
                *NdefMap->WrNdefPacketLength += NdefMap->NumOfBytesWritten;

                /*  Call Upadte Binary function to check if some more bytes are to be written. */
                Status = phFriNfc_Desfire_UpdateBinary( NdefMap );
            }
            else
            {
                /*handle the  Error case*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                    NFCSTATUS_WRITE_FAILED);

                /*set the buffer index back to zero*/
                NdefMap->ApduBuffIndex = 0;

                /* call respective CR */
                phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            }
            break;
        case PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_END :
            if((NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
                (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
            {
                /*  Updating NLEN operation was successful. */
                /* Entire Write Operation is complete*/
                /*  Reset the relevant parameters. */
                Status = PHNFCSTVAL(CID_NFC_NONE,\
                    NFCSTATUS_SUCCESS);

                /* set the state & Data len into context*/
                NdefMap->CardState = (uint8_t)((NdefMap->CardState ==
                                            PH_NDEFMAP_CARD_STATE_INITIALIZED)?
                                            PH_NDEFMAP_CARD_STATE_READ_WRITE :
                                            NdefMap->CardState);

                NdefMap->DesfireCapContainer.NdefDataLen = (uint16_t)(*NdefMap->WrNdefPacketLength);
#ifdef PH_HAL4_ENABLE
            /* Do nothing */
#else
                NdefMap->PrevOperation = 0;
#endif /* #ifndef PH_HAL4_ENABLE */

            }
            else
            {
                NdefMap->PrevOperation = 0;
                /*handle the  Error case*/
                Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                    NFCSTATUS_WRITE_FAILED);
            }

            /*set the buffer index back to zero*/
            NdefMap->ApduBuffIndex = 0;

            /* call respective CR */
            phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            break;

        default:
            /*define the invalid state*/
            Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
                NFCSTATUS_INVALID_DEVICE_REQUEST);
            phFriNfc_Desfire_HCrHandler(NdefMap,Status);
            break;
        }
    }
    else
    {
        /* call respective CR */
        phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    }
}


/*!
* \brief this shall select the smart tag functinality of the Desfire card.
*
* Only when this command returns command completed it is a Smart Tag
* compatible product.
*
*/
static
NFCSTATUS   phFriNfc_Desfire_SelectSmartTag(phFriNfc_NdefMap_t *NdefMap)
{

    NFCSTATUS                   status = NFCSTATUS_PENDING;
#ifdef DESFIRE_EV1
    uint8_t                     card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
#endif /* #ifdef DESFIRE_EV1 */

    /*form the packet for Select smart tag command*/
    NdefMap->SendRecvBuf[0]  = 0x00; /* cls */
    NdefMap->SendRecvBuf[1]  = 0xa4; /* ins */
    NdefMap->SendRecvBuf[2]  = 0x04; /* p1 */
    NdefMap->SendRecvBuf[3]  = 0x00; /* p2 */
    NdefMap->SendRecvBuf[4]  = 0x07; /* lc */

    /* next 7 bytes specify the DF Name*/
    NdefMap->SendRecvBuf[5]  = 0xd2;
    NdefMap->SendRecvBuf[6]  = 0x76;
    NdefMap->SendRecvBuf[7]  = 0x00;
    NdefMap->SendRecvBuf[8]  = 0x00;
    NdefMap->SendRecvBuf[9]  = 0x85;
    NdefMap->SendRecvBuf[10] = 0x01;

#ifdef DESFIRE_EV1

    switch (NdefMap->DespOpFlag)
    {
        case PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP:
        {
            /* First select the smart tag using the new desfire EV1 and increment the
                "sel_index" and if it fails then try the old desfire select smart tag
                command */
            if (0 == NdefMap->CardType)
            {
                /* p2
                NdefMap->SendRecvBuf[3]  = DESFIRE_EV1_P2_OFFSET_VALUE; */
                NdefMap->SendRecvBuf[11] = 0x01;
                /* Le */
                NdefMap->SendRecvBuf[12] = 0x00;
                NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1;
                card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
            }
            else
            {
                NdefMap->SendRecvBuf[3]  = 0x00; /* p2 */
                NdefMap->SendRecvBuf[11] = 0x00;
                NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
                card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
            }
            break;
        }

        case PH_FRINFC_NDEFMAP_DESF_READ_OP:
        default :
        {
            if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
            {
                NdefMap->SendRecvBuf[11] = 0x01;
                NdefMap->SendRecvBuf[12] = 0x00;
                NdefMap->State = (uint8_t)PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1;
                card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
            }
            else
            {
                NdefMap->SendRecvBuf[11] = 0x00;
                NdefMap->State = (uint8_t)PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
                card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
            }
            break;
        }
    }

#else /* #ifdef DESFIRE_EV1 */

    NdefMap->SendRecvBuf[11] = 0x00;

#endif /* #ifdef DESFIRE_EV1 */

    /*Set the Send length*/
    NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_SMARTTAG_PKT_SIZE;
#ifdef DESFIRE_EV1

    if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == card_type)
    {
        /* Send length is updated for the NEW DESFIRE EV1 */
        NdefMap->SendLength = (uint16_t)(NdefMap->SendLength + 1);
    }

#else
    /* Change the state to Select Smart Tag */
    NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
#endif /* #ifdef DESFIRE_EV1 */

    status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);

    return status;
}

/*!
* \brief this shall select/access the capability container of the Desfire
* card.
*
* This shall be used to identify, if NDEF data structure do exist on
* the smart tag, we receive command completed status.
*
*/
static
NFCSTATUS phFriNfc_Desfire_SelectFile (phFriNfc_NdefMap_t  *NdefMap)
{

    NFCSTATUS                   status = NFCSTATUS_PENDING;

    /* check for the invalid/unknown desfire operations*/
    if ((NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP)&& \
        (NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_READ_OP)&&\
        ( NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_WRITE_OP) &&
        ( NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP))
    {
        status  =   PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);
    }
    else
    {

        /*  Set the command*/
        //NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_CmdListTClCmd;

        /*  Form the packet for select file command either for the
        Check Ndef/Read/Write functionalities*/
        NdefMap->SendRecvBuf[0] = 0x00; /* cls */
        NdefMap->SendRecvBuf[1] = 0xa4; /* ins */
        NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
        NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
        NdefMap->SendRecvBuf[4] = 0x02; /* lc */

#ifdef DESFIRE_EV1
        if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
        {
            NdefMap->SendRecvBuf[3]  = DESFIRE_EV1_P2_OFFSET_VALUE; /* p2 */
        }
#endif /* #ifdef DESFIRE_EV1 */

        if ( (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP))

        {
            /* cap container file identifier*/
            NdefMap->SendRecvBuf[5] = 0xe1;
            NdefMap->SendRecvBuf[6] = 0x03;
        }
        /* Mantis entry 0394 fixed */
        else
        {
            NdefMap->SendRecvBuf[5] = (uint8_t)((NdefMap->DesfireCapContainer.NdefMsgFid) >> PH_FRINFC_NDEFMAP_DESF_SHL8);
            NdefMap->SendRecvBuf[6] = (uint8_t)((NdefMap->DesfireCapContainer.NdefMsgFid) & (0x00ff));
        }
        /*Set the Send length*/
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_SELECT_FILE_PKT_SIZE;

        /* Change the state to Select File */
        NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_FILE;

        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);

    }

    return status;

}

/*!
* \brief this shall read the data from Desfire card.
*
* This is used in two cases namely Reading the Capability container
* data( le == 0 ) and reading the file data.Maximum bytes to be read during
* a single read binary is known after the reading the data from the capability
* conatainer.
*
*/
static
NFCSTATUS  phFriNfc_Desfire_ReadBinary(phFriNfc_NdefMap_t    *NdefMap)
{
    NFCSTATUS    status = NFCSTATUS_PENDING;
    uint32_t     BytesToRead = 0;
    uint8_t      BufIndex=0,OperFlag=0;
    uint16_t     DataCnt=0;

    /* to read the capability container data*/
    if (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP )
    {
        /*specifies capability container shall be read*/
        NdefMap->SendRecvBuf[0] = 0x00;
        NdefMap->SendRecvBuf[1] = 0xb0;
        NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
        NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
        NdefMap->SendRecvBuf[4] = 0x0F; /* le */

        NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_READ_BIN_PKT_SIZE;

        /* Change the state to Cap Container Read */
        NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_READ_CAP_CONT;

        /* set the send receive buffer length*/
        OperFlag = 1;
    }
    /*desfire file read operation*/
    else
    {
        NdefMap->SendRecvBuf[0] = 0x00;
        NdefMap->SendRecvBuf[1] = 0xb0;

        /*TBD the NLEN bytes*/
        if( *NdefMap->DataCount == 0 )
        {
            /* first read */
            /* set the offset p1 and p2*/
            NdefMap->SendRecvBuf[2] = 0;
            NdefMap->SendRecvBuf[3] = 0;
        }
        else
        {
            /* as the p1 of the 8bit is 0, p1 and p2 are used to store the
            ofset value*/
            DataCnt = *NdefMap->DataCount;
            DataCnt += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
            NdefMap->SendRecvBuf[2] = (uint8_t)((DataCnt)>> PH_FRINFC_NDEFMAP_DESF_SHL8);
            NdefMap->SendRecvBuf[3] = (uint8_t)((DataCnt)& (0x00ff));
        }
        /* calculate the Le Byte*/
        BytesToRead = phFriNfc_Desfire_HGetLeBytes(NdefMap);

        if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
        {
            /* BufIndex represents the 2 NLEN bytes and decides about the presence of
            2 bytes NLEN data*/

            BufIndex = (uint8_t)(( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1 ) ?
            PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES:0);

            if( ((BytesToRead == 1) || (BytesToRead == 2)) && (NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1))
            {
                BytesToRead += BufIndex;
            }
        }

        /* set the Le byte*/
        /* This following code is true for get nlen  and current offset set*/
        NdefMap->SendRecvBuf[4]=(uint8_t) BytesToRead  ;

        /* Change the state to Read */
        NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_READ_BIN;

        /*set the send length*/
        NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_READ_BIN_PKT_SIZE;
        OperFlag = 2;
    }

    if (OperFlag == 1 )
    {
        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    }
    else
    {
        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,(uint8_t)(BytesToRead +PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));
    }
    return (status);
}

/*!
* \brief this shall write the data to Desfire card.
* Maximum bytes to be written during a single update binary
* is known after the reading the data from the capability
* conatainer.
*
* le filed specifes , how many bytes of data to be written to the
* Card.
*
*/
static
NFCSTATUS  phFriNfc_Desfire_UpdateBinary(phFriNfc_NdefMap_t  *NdefMap)
{

    NFCSTATUS   status = NFCSTATUS_PENDING;
    uint16_t    noOfBytesToWrite = 0, DataCnt=0,
        index=0;

    /*  Do we have space in the file to write? */
    if ( (*NdefMap->DataCount < PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) &&
        (NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize))
    {
        /*  Yes, we have some bytes to write */
        /*  Check and set the card memory size , if user sent bytes are more than the
        card memory size*/
        if( (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >\
            (uint16_t)(PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE - *NdefMap->DataCount))
        {
            NdefMap->ApduBufferSize =( (PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) - (*NdefMap->DataCount + NdefMap->ApduBuffIndex));
        }

        /*  Now, we have space in the card to write the data, */
        /*Form the packet for the update binary command*/
        NdefMap->SendRecvBuf[0] = 0x00;
        NdefMap->SendRecvBuf[1] = 0xD6;

        if( *NdefMap->DataCount == 0)
        {
            /* set the p1/p2 offsets */
            NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
            NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
            NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 0;
        }
        else
        {
            /*  as the p1 of the 8bit is 0, p1 and p2 are used to store the
            ofset value*/
            /*  This sets card offset in a card for a write operation. + 2 is
            added as first 2 offsets represents the size of the NDEF Len present
            in the file*/

            DataCnt = *NdefMap->DataCount;
            DataCnt += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
            NdefMap->SendRecvBuf[2] = (uint8_t)((DataCnt)>> PH_FRINFC_NDEFMAP_DESF_SHL8);
            NdefMap->SendRecvBuf[3] = (uint8_t)((DataCnt)& (0x00ff));
            /* No need to attach 2 NLEN bytes at the begining.
            as we have already attached in the first write operation.*/
            NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 1;

        }

        /*  Calculate the bytes to write */
        if( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)( NdefMap->DesfireCapContainer.MaxCmdSize ))

        {
            noOfBytesToWrite = ( ( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1) ?
                NdefMap->DesfireCapContainer.MaxCmdSize :
            (NdefMap->DesfireCapContainer.MaxCmdSize - PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES));
        }
        else
        {
            /*  Read only till the available buffer space */
            noOfBytesToWrite = (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
        }

        if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
        {
            if ( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1 )
            {
                index = 5;
                /* To Specify the NDEF data len written : updated at the of write cycle*/
                NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite;
            }
            else
            {
                /* Leave space to update NLEN */
                NdefMap->SendRecvBuf[5] = 0x00;
                NdefMap->SendRecvBuf[6] = 0x00;
                index =7;
                /* To Specify the NDEF data len written : updated at the of write cycle*/
                NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite + PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
            }

            /* copy the data to SendRecvBuf from the apdu buffer*/
            (void)memcpy( &NdefMap->SendRecvBuf[index],
                &NdefMap->ApduBuffer[NdefMap->ApduBuffIndex],
                noOfBytesToWrite);
            NdefMap->SendLength = (noOfBytesToWrite + index);
        }
        else
        {
            NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite;

            /* copy the data to SendRecvBuf from the apdu buffer*/
            (void)memcpy( &NdefMap->SendRecvBuf[5],
                &NdefMap->ApduBuffer[NdefMap->ApduBuffIndex],
                noOfBytesToWrite);
            NdefMap->SendLength = (noOfBytesToWrite + 5);
        }

        /*  Store the number of bytes being written in the context structure, so that
        the parameters can be updated, after a successful write operation. */
        NdefMap->NumOfBytesWritten = noOfBytesToWrite;

        /* Change the state to Write */
        NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_BEGIN;

        status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);

    }   /*  if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize) */
    else
    {
        if ( (*NdefMap->DataCount == PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) ||
            (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize))
        {
            /* The NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_SET_LEN_OP is not
                required, because the DespOpFlag shall be WRITE_OP
                */
            /* Update the NLEN Bytes*/
#ifdef PH_HAL4_ENABLE
            /* Do nothing */
#else
            NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_SET_LEN_OP;
#endif /* #ifdef PH_HAL4_ENABLE */
            status = phFriNfc_Desfire_HSetGet_NLEN(NdefMap);
        }
        else
        {
            /*  The control should not come here.
            wrong internal calculation.
            we have actually written more than the space available
            in the card ! */
#ifndef PH_HAL4_ENABLE
            status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                NFCSTATUS_CMD_ABORTED);
#else
            status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                NFCSTATUS_FAILED);
#endif
            /*  Reset the relevant parameters. */
            NdefMap->ApduBuffIndex = 0;
            NdefMap->PrevOperation = 0;

            /* call respective CR */
            phFriNfc_Desfire_HCrHandler(NdefMap,status);
        }

    }
    /*  if(*NdefMap->DataCount < PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) */

    return status;
}


static void phFriNfc_Desfire_HChkNDEFFileAccessRights(phFriNfc_NdefMap_t *NdefMap)
{
    if ( (NdefMap->DesfireCapContainer.ReadAccess  == 0x00) &&
        (NdefMap->DesfireCapContainer.WriteAccess == 0x00 ))
    {
        /* Set the card state to Read/write State*/
        /* This state can be either INITIALISED or READWRITE. but default
        is INITIALISED */
        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;

    }
    else if((NdefMap->DesfireCapContainer.ReadAccess  == 0x00) &&
        (NdefMap->DesfireCapContainer.WriteAccess == 0xFF ))
    {
        /* Set the card state to Read Only State*/
        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
    }
    else
    {
        /* Set the card state to invalid State*/
        NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
    }
}

/*!
* \brief this shall update the Desfire capability container structure.
*
* This function shall store version,maximum Ndef data structure size,
* Read Access permissions, Write Access permissions , Maximum data size
* that can be sent using a single Update Binary, maximum data size that
* can be read from the Desfire using a singlr read binary.
* These vaues shall be stored and used during the read/update binary
* operations.
*
*/
static
NFCSTATUS  phFriNfc_Desfire_Update_SmartTagCapContainer(phFriNfc_NdefMap_t    *NdefMap)
{
    uint16_t    CapContSize = 0,
        /* this is initalised 2 because CCLEN includes the field size bytes i.e 2bytes*/
        CCLen= 0;
    uint8_t     ErrFlag = 0;

    NFCSTATUS status= NFCSTATUS_SUCCESS;

    /*Check the Size of Cap Container */
    CapContSize = ( (((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_FIRST_INDEX])<<8)+ \
        NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_SECOND_INDEX]);

    CCLen += 2;

    if ( (CapContSize < 0x0f) || (CapContSize == 0xffff))
    {
        ErrFlag =1;
    }
    else
    {
        /*Version : Smart Tag Spec version */
        /* check for the validity of Major and Minor Version numbers*/
        status = phFriNfc_MapTool_ChkSpcVer (   NdefMap,
            PH_FRINFC_NDEFMAP_DESF_VER_INDEX);
        if ( status  !=  NFCSTATUS_SUCCESS )
        {
            ErrFlag =1;
        }
        else
        {
            CCLen += 1;

            /*Get Response APDU data size
            to check the integration s/w response size*/
#ifdef PH_HAL4_ENABLE
			{
				uint16_t	max_rsp_size =
					((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_FIRST_INDEX]) << 8)\
					+ NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_SECOND_INDEX]);
				NdefMap->DesfireCapContainer.MaxRespSize =
								((max_rsp_size > PHHAL_MAX_DATASIZE)?
								(PHHAL_MAX_DATASIZE) : max_rsp_size);
			}
#else
			NdefMap->DesfireCapContainer.MaxRespSize =
				((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_FIRST_INDEX]) << 8)\
                +NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_SECOND_INDEX]);
#endif /* #ifdef PH_HAL4_ENABLE */

            /*Get Command APDU data size*/
#ifdef PH_HAL4_ENABLE
			{
				uint16_t	max_cmd_size =
					((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_FIRST_INDEX])<<8)\
					+ NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_SECOND_INDEX]);

				NdefMap->DesfireCapContainer.MaxCmdSize =
								((max_cmd_size > PHHAL_MAX_DATASIZE)?
								(PHHAL_MAX_DATASIZE): max_cmd_size);
			}
#else
			NdefMap->DesfireCapContainer.MaxCmdSize =
				((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_FIRST_INDEX])<<8)\
                +NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_SECOND_INDEX]);
#endif /* #ifdef PH_HAL4_ENABLE */
            /* Check for the Validity of Cmd & Resp Size*/
            /* check the Validity of the Cmd Size*/
            if( (NdefMap->DesfireCapContainer.MaxRespSize < 0x0f) ||
                ( NdefMap->DesfireCapContainer.MaxCmdSize == 0x00))
            {
                ErrFlag=1;

            }
            else
            {
                CCLen += 4;

                /* Check and Parse the TLV structure */
                /* In future this chk can be extended to Propritery TLV */
                //status = phFriNfc_ChkAndParseTLV(NdefMap);
                status = phFriNfc_Desf_HChkAndParseTLV(NdefMap,PH_FRINFC_NDEFMAP_DESF_TLV_INDEX);
                if ( (status == NFCSTATUS_SUCCESS) && (NdefMap->TLVFoundFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CNTRL_TLV))
                {
                    CCLen += 1;

                    /* check the TLV length*/
                    if ( (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) > 0x00 ) &&
                        (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) <= 0xFE )&&
                        (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) == 0x06 ))
                    {
                        CCLen +=1;
                        /* store the contents in to the container structure*/
                        NdefMap->DesfireCapContainer.NdefMsgFid = ( (((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEID_BYTE_FIRST_INDEX])<<PH_FRINFC_NDEFMAP_DESF_SHL8)+ \
                            NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEID_BYTE_SECOND_INDEX]);

                        CCLen +=2;

                        /* Invalid Msg File Id : User Can't Have read/write Opeartion*/
                        if (    (NdefMap->DesfireCapContainer.NdefMsgFid == 0xFFFF) ||
                            (NdefMap->DesfireCapContainer.NdefMsgFid == 0xE102) ||
                            (NdefMap->DesfireCapContainer.NdefMsgFid == 0xE103) ||
                            (NdefMap->DesfireCapContainer.NdefMsgFid == 0x3F00) ||
                            (NdefMap->DesfireCapContainer.NdefMsgFid == 0x3FFF ) )
                        {

                            ErrFlag=1;
                        }
                        else
                        {
                            /*Get Ndef Size*/
                            NdefMap->DesfireCapContainer.NdefFileSize =
                                ((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILESZ_BYTE_FIRST_INDEX])<<8)
                                | (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILESZ_BYTE_SECOND_INDEX] & 0x00ff));


                            /*Check Ndef Size*/
                            /* TBD : Do we need to minus 2 bytes of size it self?*/
                            if ( ((NdefMap->DesfireCapContainer.NdefFileSize -2) <= 0x0004 ) ||
                                ((NdefMap->DesfireCapContainer.NdefFileSize -2) == 0xFFFD ) )
                            {
                                ErrFlag=1;
                            }
                            else
                            {
                                CCLen +=2;

                                /*Ndef File Read Access*/
                                NdefMap->DesfireCapContainer.ReadAccess = NdefMap->\
                                    SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILERD_ACCESS_INDEX] ;

                                /*Ndef File Write Access*/
                                NdefMap->DesfireCapContainer.WriteAccess = NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEWR_ACCESS_INDEX];

                                CCLen +=2;

                                phFriNfc_Desfire_HChkNDEFFileAccessRights(NdefMap);
                            }
                        }
                    }
                    else
                    {

                        /* TLV Lenth is of two byte value
                        TBD: As the length of TLV is fixed for 6 bytes. We need not
                        handle the 2 byte value*/


                    }
                }
                else
                {
                    if ( NdefMap->TLVFoundFlag == PH_FRINFC_NDEFMAP_DESF_PROP_CNTRL_TLV )
                    {
                        /*TBD: To Handle The Proprietery TLV*/
                    }
                    else
                    {
                        /*Invalid T found case*/
                        ErrFlag =1;
                    }
                }
                /* check for the entire LENGTH Validity
                CCLEN + TLV L value == CCLEN*/
                if ( CapContSize != CCLen )
                {
                    ErrFlag=1;
                }

            }/* if NdefMap->DesfireCapContainer.MaxRespSize < 0x0f */
        }/* Chkeck Map Version*/
    }/* CC size invalid*/
    if( ErrFlag == 1 )
    {
        status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
            NFCSTATUS_NO_NDEF_SUPPORT);
    }
    return ( status );
}

static uint32_t phFriNfc_Desfire_HGetLeBytes(phFriNfc_NdefMap_t *NdefMap)
{
    /*Represents the LE byte*/
    uint16_t BytesToRead =0;

    if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP )
    {
        BytesToRead = PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
         NdefMap->DesfireCapContainer.SkipNlenBytesFlag =0;
    }
    else
    {

        /* Calculate Le bytes : No of bytes to read*/
        /* Check for User Apdu Buffer Size and Msg Size of Desfire Capability container */
        if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= NdefMap->DesfireCapContainer.MaxRespSize)
        {
            /*  We have enough buffer space to read the whole capability container
            size bytes
            Now, check do we have NdefMap->DesfireCapContainer.MaxRespSize to read ? */

            BytesToRead = (((NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount) >=
                NdefMap->DesfireCapContainer.MaxRespSize) ?
                NdefMap->DesfireCapContainer.MaxRespSize :
            (NdefMap->DesfireCapContainer.NdefDataLen -
                *NdefMap->DataCount));
        }
        else
        {
            /*  Read only till the available buffer space */
            BytesToRead = (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
            if(BytesToRead >= (uint16_t)(NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount))
            {
                BytesToRead = (NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount);
            }
        }

        NdefMap->DesfireCapContainer.SkipNlenBytesFlag =
            (uint8_t)(((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )&&( *NdefMap->DataCount == 0 )) ?
            1 : 0);

    }
    return (BytesToRead);
}


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

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

    switch(NdefMap->DespOpFlag)
    {
        /* check which routine has the problem and set the CR*/
    case PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP :
        /* set the completion routine*/
        NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_CHK_NDEF].\
            CompletionRoutine(NdefMap->CompletionRoutine->Context,\
            Status);
        break;

    case PH_FRINFC_NDEFMAP_DESF_READ_OP :
        /* set the completion routine*/
        NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_RD_NDEF].\
            CompletionRoutine(NdefMap->CompletionRoutine->Context,\
            Status);
        break;

    case PH_FRINFC_NDEFMAP_DESF_WRITE_OP :
        /* set the completion routine*/
        NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_WR_NDEF].\
            CompletionRoutine(NdefMap->CompletionRoutine->Context,\
            Status);
        break;

    default :
        /* set the completion routine*/
        NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_INVALID_OPE].\
            CompletionRoutine(NdefMap->CompletionRoutine->Context,\
            Status);
        break;

    }
}

static NFCSTATUS phFriNfc_Desfire_HSendTransCmd(phFriNfc_NdefMap_t *NdefMap,uint8_t SendRecvLen)
{

    NFCSTATUS status =  NFCSTATUS_SUCCESS;

    /* set the command type*/
#ifndef PH_HAL4_ENABLE
    NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_CmdListTClCmd;
#else
    NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_Raw;
#endif

    /* set the Additional Info*/
    NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
    NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;

    /*set the completion routines for the desfire card operations*/
    NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Desfire_Process;
    NdefMap->MapCompletionInfo.Context = NdefMap;

    /* set the receive length */
    *NdefMap->SendRecvLength = ((uint16_t)(SendRecvLen));


    /*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);

    return (status);


}


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

#endif  /* PH_FRINFC_MAP_DESFIRE_DISABLED */