Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2010 NXP Semiconductors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*!
     18 * \file  phFriNfc_Desfire.c
     19 * \brief This component encapsulates read/write/check ndef/process functionalities,
     20 *        for the Desfire Card.
     21 *
     22 * Project: NFC-FRI
     23 *
     24 * $Date: Tue Jul 27 08:58:22 2010 $
     25 * $Author: ing02260 $
     26 * $Revision: 1.11 $
     27 * $Aliases:  $
     28 *
     29 */
     30 
     31 #ifndef PH_FRINFC_MAP_DESFIRE_DISABLED
     32 
     33 #include <phFriNfc_OvrHal.h>
     34 #include <phFriNfc_DesfireMap.h>
     35 #include <phFriNfc_MapTools.h>
     36 
     37 
     38 /*! \ingroup grp_file_attributes
     39 *  \name NDEF Mapping
     40 *
     41 * File: \ref phFriNfc_Desfire.c
     42 *
     43 */
     44 /*@{*/
     45 #define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.11 $"
     46 #define PHFRINFCNDEFMAP_FILEALIASES  "$Aliases:  $"
     47 
     48 /*@}*/
     49 
     50 /***************** Start of MACROS ********************/
     51 #ifdef DESFIRE_EV1
     52     #define DESFIRE_EV1_P2_OFFSET_VALUE                         (0x0CU)
     53 #endif /* #ifdef DESFIRE_EV1 */
     54 
     55 /***************** End of MACROS ********************/
     56 
     57 /*@}*/
     58 
     59 /*!
     60  * \name Desfire Mapping - Helper Functions
     61  *
     62  */
     63 /*@{*/
     64 
     65 /*!
     66  * \brief \copydoc page_ovr Helper function for Desfire. This function specifies
     67  *  the card is a Desfire card or not.
     68  */
     69 static NFCSTATUS phFriNfc_Desfire_SelectSmartTag(  phFriNfc_NdefMap_t  *NdefMap);
     70 
     71 /*!
     72  * \brief \copydoc page_ovr Helper function for Desfire. This function is used
     73  *  to selct a file in the card.
     74  */
     75 static NFCSTATUS phFriNfc_Desfire_SelectFile ( phFriNfc_NdefMap_t  *NdefMap);
     76 
     77 /*!
     78  * \brief \copydoc page_ovr Helper function for Desfire. This function is to
     79  *  read the card.
     80  */
     81 static NFCSTATUS  phFriNfc_Desfire_ReadBinary( phFriNfc_NdefMap_t  *NdefMap);
     82 
     83 /*!
     84  * \brief \copydoc page_ovr Helper function for Desfire. This function is to
     85  *  write to the card.
     86  */
     87 static NFCSTATUS  phFriNfc_Desfire_UpdateBinary(   phFriNfc_NdefMap_t  *NdefMap);
     88 
     89 /*!
     90  * \brief \copydoc page_ovr Helper function for Desfire. This function is to
     91  *  update the capability container of the card.
     92  */
     93 static NFCSTATUS  phFriNfc_Desfire_Update_SmartTagCapContainer( phFriNfc_NdefMap_t *NdefMap);
     94 
     95 
     96 /* Completion Helper*/
     97 static void phFriNfc_Desfire_HCrHandler(    phFriNfc_NdefMap_t  *NdefMap,
     98                                         NFCSTATUS           Status);
     99 
    100 /* Calculates the Le Bytes for Read Operation*/
    101 static uint32_t phFriNfc_Desfire_HGetLeBytes(   phFriNfc_NdefMap_t  *NdefMap);
    102 
    103 static NFCSTATUS phFriNfc_Desf_HChkAndParseTLV( phFriNfc_NdefMap_t  *NdefMap,
    104                                                uint8_t             BuffIndex);
    105 
    106 static NFCSTATUS phFriNfc_Desfire_HSetGet_NLEN( phFriNfc_NdefMap_t  *NdefMap);
    107 
    108 static void phFriNfc_Desfire_HProcReadData( phFriNfc_NdefMap_t  *NdefMap);
    109 
    110 static void phFriNfc_Desfire_HChkNDEFFileAccessRights(  phFriNfc_NdefMap_t  *NdefMap);
    111 static NFCSTATUS phFriNfc_Desfire_HSendTransCmd(phFriNfc_NdefMap_t *NdefMap,uint8_t SendRecvLen);
    112 
    113 #ifdef PH_HAL4_ENABLE
    114 
    115 #else
    116 
    117 /* Following are the API's are used to get the version of the desfire card*/
    118 static NFCSTATUS phFriNfc_Desfire_HGetHWVersion(phFriNfc_NdefMap_t    *NdefMap);
    119 static NFCSTATUS phFriNfc_Desfire_HGetSWVersion(phFriNfc_NdefMap_t    *NdefMap);
    120 static NFCSTATUS phFriNfc_Desfire_HGetUIDDetails(phFriNfc_NdefMap_t   *NdefMap);
    121 static NFCSTATUS phFriNfc_Desfire_HUpdateVersionDetails(const phFriNfc_NdefMap_t *NdefMap);
    122 
    123 #endif /* #ifdef PH_HAL4_ENABLE */
    124 
    125 #ifdef PH_HAL4_ENABLE
    126 
    127 #else
    128 
    129 static NFCSTATUS phFriNfc_Desfire_HGetHWVersion(phFriNfc_NdefMap_t    *NdefMap)
    130 {
    131 
    132     NFCSTATUS status = NFCSTATUS_PENDING;
    133 
    134     /*set the state*/
    135     NdefMap->State = PH_FRINFC_DESF_STATE_GET_HW_VERSION;
    136 
    137     /* Helper routine to wrap the native desfire cmds*/
    138     PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();
    139     status =  phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    140 
    141     return (status);
    142 }
    143 
    144 static NFCSTATUS phFriNfc_Desfire_HGetSWVersion(phFriNfc_NdefMap_t *NdefMap)
    145 {
    146 
    147     NFCSTATUS status = NFCSTATUS_PENDING;
    148     if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == PH_FRINFC_DESF_NATIVE_GETVER_RESP) )
    149     {
    150         /*set the state*/
    151         NdefMap->State = PH_FRINFC_DESF_STATE_GET_SW_VERSION;
    152 
    153         /* Helper routine to wrap the native desfire commands*/
    154         PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();
    155         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    156     }
    157 #ifdef PH_HAL4_ENABLE
    158     else
    159     {
    160         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    161                        NFCSTATUS_INVALID_PARAMETER);
    162     }
    163 #endif /* #ifdef PH_HAL4_ENABLE */
    164     return status;
    165 }
    166 
    167 static NFCSTATUS phFriNfc_Desfire_HGetUIDDetails(phFriNfc_NdefMap_t *NdefMap)
    168 {
    169 
    170     NFCSTATUS status = NFCSTATUS_PENDING;
    171 
    172     if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == PH_FRINFC_DESF_NATIVE_GETVER_RESP) )
    173     {
    174         /*set the state*/
    175         NdefMap->State = PH_FRINFC_DESF_STATE_GET_UID;
    176 
    177         /* Helper routine to wrap the native desfire commands*/
    178         PH_FRINFC_DESF_ISO_NATIVE_WRAPPER();
    179 
    180         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
    181     }
    182 #ifdef PH_HAL4_ENABLE
    183     else
    184     {
    185         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    186                        NFCSTATUS_INVALID_PARAMETER);
    187     }
    188 #endif /* #ifdef PH_HAL4_ENABLE */
    189     return status;
    190 
    191 }
    192 
    193 static NFCSTATUS phFriNfc_Desfire_HUpdateVersionDetails(const phFriNfc_NdefMap_t *NdefMap)
    194 {
    195     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    196                        NFCSTATUS_INVALID_PARAMETER);
    197 
    198     if( ( NdefMap->SendRecvBuf[*(NdefMap->SendRecvLength)- 1] == 0xAF) )
    199     {
    200 
    201         status = NFCSTATUS_SUCCESS;
    202 
    203         /* We do not need the following details presently.Retained for future use*/
    204         #if 0
    205         NdefMap->AddInfo.Type4Info.MajorVersion = NdefSmtCrdFmt->SendRecvBuf[3];
    206         NdefMap->AddInfo.Type4Info.MinorVersion = NdefSmtCrdFmt->SendRecvBuf[4];
    207         if ( ( NdefMap->AddInfo.Type4Info.MajorVersion == 0x00 )&&
    208             ( NdefMap->AddInfo.Type4Info.MinorVersion == 0x06 ))
    209         {
    210             /* card size of DESFire4 type */
    211             //NdefMap->AddInfo.Type4Info.CardSize = 0xEDE;
    212 
    213         }
    214         else
    215         {
    216             // need to handle the Desfire8 type cards
    217             // need to use get free memory
    218         }
    219         #endif
    220     }
    221     return status;
    222 }
    223 
    224 
    225 #endif /* #ifdef PH_HAL4_ENABLE */
    226 
    227 /*!
    228 * \brief Initiates Reading of NDEF information from the Desfire Card.
    229 *
    230 * The function initiates the reading of NDEF information from a Remote Device.
    231 * It performs a reset of the state and starts the action (state machine).
    232 * A periodic call of the \ref phFriNfcNdefMap_Process has to be
    233 * done once the action has been triggered.
    234 */
    235 
    236 NFCSTATUS phFriNfc_Desfire_RdNdef(  phFriNfc_NdefMap_t  *NdefMap,
    237                                   uint8_t             *PacketData,
    238                                   uint32_t            *PacketDataLength,
    239                                   uint8_t             Offset)
    240 {
    241     NFCSTATUS   status = NFCSTATUS_PENDING;
    242 
    243     NdefMap->ApduBufferSize = *PacketDataLength;
    244     /*  To return actual number of bytes read to the caller */
    245     NdefMap->NumOfBytesRead = PacketDataLength ;
    246     *NdefMap->NumOfBytesRead = 0;
    247 
    248     /* store the offset in to map context*/
    249     NdefMap->Offset = Offset;
    250 
    251     if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
    252         (*NdefMap->DataCount == NdefMap->DesfireCapContainer.NdefDataLen))
    253     {
    254         /*  No space on card for Reading : we have already
    255         reached the end of file !
    256         Offset is set to Continue Operation */
    257         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    258             NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    259     }
    260     else
    261     {
    262 
    263         /* reset the inter flag*/
    264         NdefMap->DesfireCapContainer.IsNlenPresentFlag = 0;
    265         NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 0;
    266 
    267         /*  Set the desfire read operation  */
    268         NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_READ_OP;
    269 
    270         /*  Save the packet data buffer address in the context  */
    271         NdefMap->ApduBuffer = PacketData;
    272 
    273         NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
    274 
    275 #ifdef DESFIRE_EV1
    276         /* Select smart tag operation. First step for the read operation. */
    277         if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
    278         {
    279             status = phFriNfc_Desfire_SelectFile(NdefMap);
    280         }
    281         else
    282 #endif /* #ifdef DESFIRE_EV1 */
    283         {
    284             status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    285         }
    286     }
    287 
    288     return status;
    289 }
    290 
    291 /*!
    292 * \brief Initiates Writing of NDEF information to the Remote Device.
    293 *
    294 * The function initiates the writing of NDEF information to a Remote Device.
    295 * It performs a reset of the state and starts the action (state machine).
    296 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
    297 * has been triggered.
    298 */
    299 
    300 NFCSTATUS phFriNfc_Desfire_WrNdef(  phFriNfc_NdefMap_t  *NdefMap,
    301                                   uint8_t             *PacketData,
    302                                   uint32_t            *PacketDataLength,
    303                                   uint8_t             Offset)
    304 {
    305     NFCSTATUS   status = NFCSTATUS_PENDING;
    306 
    307     NdefMap->ApduBufferSize = *PacketDataLength;
    308     NdefMap->WrNdefPacketLength = PacketDataLength;
    309 
    310     /*  Now, let's initialize     *NdefMap->WrNdefPacketLength    to zero.
    311     In case we get an error, this will be correctly set to "no byte written".
    312     In case there is no error, this will be updated later on, in the _process function.
    313     */
    314     *NdefMap->WrNdefPacketLength =   0;
    315 
    316     /*  we have write access. */
    317     if( *NdefMap->DataCount >= PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE)
    318     {
    319         /*  No space on card for writing : we have already
    320         reached the end of file !
    321         Offset is set to Continue Operation */
    322         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    323             NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    324     }
    325     else
    326     {
    327         /*  Adapt the nb of bytes that the user would like to write */
    328 
    329         /*set the defire write operation*/
    330         NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_WRITE_OP;
    331         NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
    332         NdefMap->Offset = Offset;
    333 
    334         /*Store the packet data buffer*/
    335         NdefMap->ApduBuffer = PacketData;
    336 
    337 #ifdef DESFIRE_EV1
    338         if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
    339         {
    340             status = phFriNfc_Desfire_SelectFile(NdefMap);
    341         }
    342         else
    343 #endif /* #ifdef DESFIRE_EV1 */
    344         {
    345             /* Select smart tag operation. First step for the write operation. */
    346             status = phFriNfc_Desfire_SelectSmartTag (NdefMap);
    347         }
    348     }
    349     return status;
    350 }
    351 
    352 /*!
    353 * \brief Check whether a particular Remote Device is NDEF compliant.
    354 *
    355 * The function checks whether the peer device is NDEF compliant.
    356 *
    357 */
    358 
    359 NFCSTATUS phFriNfc_Desfire_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)
    360 {
    361     NFCSTATUS    status = NFCSTATUS_PENDING;
    362 
    363 #ifdef PH_HAL4_ENABLE
    364 
    365 #ifdef DESFIRE_EV1
    366     /* Reset card type */
    367     NdefMap->CardType = 0;
    368 #endif /* #ifdef DESFIRE_EV1 */
    369 	/*Set the desfire operation flag*/
    370 	NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;
    371 
    372     /*Call Select Smart tag Functinality*/
    373     status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    374 #else
    375 	/* Need to get the version details of the card, to
    376 	   identify the the desfire4card type */
    377 	status = phFriNfc_Desfire_HGetHWVersion(NdefMap);
    378 #endif
    379 
    380     return (status);
    381 }
    382 
    383 static NFCSTATUS phFriNfc_Desf_HChkAndParseTLV(phFriNfc_NdefMap_t     *NdefMap, uint8_t BuffIndex)
    384 {
    385     NFCSTATUS    status = NFCSTATUS_SUCCESS;
    386 
    387     if((NdefMap->SendRecvBuf[BuffIndex] <= 0x03) ||
    388         (NdefMap->SendRecvBuf[BuffIndex] >= 0x06) )
    389     {
    390         status =  PHNFCSTVAL(   CID_FRI_NFC_NDEF_MAP,
    391             NFCSTATUS_NO_NDEF_SUPPORT);
    392     }
    393     else
    394     {
    395         /* check for the type of TLV*/
    396         NdefMap->TLVFoundFlag =
    397             ((NdefMap->SendRecvBuf[BuffIndex] == 0x04)?
    398             PH_FRINFC_NDEFMAP_DESF_NDEF_CNTRL_TLV:
    399             PH_FRINFC_NDEFMAP_DESF_PROP_CNTRL_TLV);
    400 
    401         status =  PHNFCSTVAL(   CID_FRI_NFC_NDEF_MAP,
    402             NFCSTATUS_SUCCESS);
    403     }
    404     return status;
    405 }
    406 
    407 static NFCSTATUS    phFriNfc_Desfire_HSetGet_NLEN(phFriNfc_NdefMap_t *NdefMap)
    408 {
    409 
    410     NFCSTATUS    status = NFCSTATUS_PENDING;
    411 
    412     if ( PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP == NdefMap->DespOpFlag)
    413     {
    414 
    415         /*Call Select Smart tag Functinality*/
    416         status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    417     }
    418     else
    419     {
    420 
    421         /* Get the Data Count and set it to NoOfBytesWritten
    422         Update the NLEN using Transceive cmd*/
    423 
    424         /*Form the packet for the update binary command*/
    425         NdefMap->SendRecvBuf[0] = 0x00;
    426         NdefMap->SendRecvBuf[1] = 0xD6;
    427 
    428         /* As we need to set the NLEN @ first 2 bytes of NDEF File*/
    429         /* set the p1/p2 offsets */
    430         NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
    431         NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
    432 
    433         /* Set only two bytes as NLEN*/
    434         NdefMap->SendRecvBuf[4] = 0x02;
    435 
    436         /* update NLEN */
    437         NdefMap->SendRecvBuf[5] = (uint8_t)(*NdefMap->DataCount >> PH_FRINFC_NDEFMAP_DESF_SHL8);
    438         NdefMap->SendRecvBuf[6] = (uint8_t)(*NdefMap->DataCount & (0x00ff));
    439 
    440         NdefMap->SendLength = 0x07 ;
    441 
    442         /* Change the state to Write */
    443         NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_END;
    444 
    445         status =  phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);
    446     }
    447     return status;
    448 }
    449 
    450 static void phFriNfc_Desfire_HProcReadData(phFriNfc_NdefMap_t *NdefMap)
    451 {
    452     NFCSTATUS   Result = NFCSTATUS_PENDING;
    453     uint32_t    BufferSize = 0;
    454     uint8_t     BufIndex=0;
    455     uint16_t    SizeToCpy=0;
    456 
    457     /* Need to check the Actual Ndef Length before copying the data to buffer*/
    458     /* Only NDEF data should be copied , rest all the data should be ignored*/
    459     /* Ex : Ndef File Size 50 bytes , but only 5 bytes(NLEN) are relavent to NDEF data*/
    460     /* component should only copy 5 bytes to user buffer*/
    461 
    462     /*  Data has been read successfully in the TRX buffer. */
    463     /*  copy it to the user buffer. */
    464 
    465     /* while copying need check the offset if its begin need to skip the first 2 bytes
    466     while copying. If its current no need to skip the first 2 bytes*/
    467 
    468     if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
    469     {
    470         BufIndex = (uint8_t)(( NdefMap->DesfireCapContainer.IsNlenPresentFlag == 1 )?
    471             0:PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES);
    472 
    473         /* Update the latest NLEN to context*/
    474         NdefMap->DesfireCapContainer.NdefDataLen = ((*NdefMap->DataCount == 0)?
    475             ( (((uint16_t)NdefMap->SendRecvBuf[
    476                 PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_FIRST_INDEX])<<8)+ \
    477                     NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_SECOND_INDEX]):
    478                 NdefMap->DesfireCapContainer.NdefDataLen);
    479 
    480         /* Decide how many byes to be copied into user buffer: depending upon the actual NDEF
    481            size need to copy the content*/
    482         if ( (NdefMap->DesfireCapContainer.NdefDataLen) <= (*NdefMap->SendRecvLength - \
    483             (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET + BufIndex)))
    484         {
    485             SizeToCpy = NdefMap->DesfireCapContainer.NdefDataLen;
    486 
    487         }
    488         else
    489         {
    490             SizeToCpy = ((*NdefMap->SendRecvLength)-(PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET+BufIndex));
    491         }
    492 
    493         /* Check do we have Ndef Data len > 0 present in the card.If No Ndef Data
    494         present in the card , set the card state to Initalised and set an Error*/
    495         if ( NdefMap->DesfireCapContainer.NdefDataLen == 0x00 )
    496         {
    497             NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
    498             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
    499 #ifdef PH_HAL4_ENABLE
    500 #else
    501             NdefMap->PrevOperation = 0;
    502 #endif /* #ifdef PH_HAL4_ENABLE */
    503             phFriNfc_Desfire_HCrHandler(NdefMap,Result);
    504         }
    505         else
    506         {
    507             (void)memcpy( (&(NdefMap->ApduBuffer[
    508             NdefMap->ApduBuffIndex])),
    509             (&(NdefMap->SendRecvBuf[BufIndex])),
    510             (SizeToCpy));
    511 
    512             /*  Increment the Number of Bytes Read, which will be returned to the caller. */
    513             *NdefMap->NumOfBytesRead = (uint32_t)(*NdefMap->NumOfBytesRead + SizeToCpy);
    514 
    515             /*update the data count*/
    516             *NdefMap->DataCount = (uint16_t)(*NdefMap->DataCount + SizeToCpy);
    517 
    518             /*update the buffer index of the apdu buffer*/
    519             NdefMap->ApduBuffIndex = (uint16_t)(NdefMap->ApduBuffIndex + SizeToCpy);
    520         }
    521     }
    522     else
    523     {
    524             (void)memcpy( (&(NdefMap->ApduBuffer[
    525             NdefMap->ApduBuffIndex])),
    526                 (NdefMap->SendRecvBuf),/* to avoid the length of the NDEF File*/
    527                 (*(NdefMap->SendRecvLength)-(PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET)));
    528 
    529             /*  Increment the Number of Bytes Read, which will be returned to the caller. */
    530             *NdefMap->NumOfBytesRead +=( *NdefMap->SendRecvLength - \
    531                 (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));
    532 
    533             /*update the data count*/
    534             *NdefMap->DataCount += \
    535                 (*NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));
    536 
    537             /*update the buffer index of the apdu buffer*/
    538             NdefMap->ApduBuffIndex += \
    539                 *NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET );
    540     }
    541 
    542     /*  check whether we still have to read some more data. */
    543     if (*NdefMap->DataCount < NdefMap->DesfireCapContainer.NdefDataLen )
    544     {
    545         /*  we have some bytes to read. */
    546 
    547         /*  Now check, we still have bytes left in the user buffer. */
    548         BufferSize = NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex;
    549         if(BufferSize != 0)
    550         {
    551             /* Before read need to set the flag to intimate the module to
    552             dont skip the first 2 bytes as we are in mode reading next
    553             continues available bytes, which will not contain the NLEN
    554             information in the begining part that is 2 bytes*/
    555             NdefMap->DesfireCapContainer.IsNlenPresentFlag = 1;
    556             /* Read Operation is not complete */
    557             Result = phFriNfc_Desfire_ReadBinary( NdefMap );
    558             /* handle the error in Transc function*/
    559             if  ( (Result & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER) )
    560             {
    561                 /* call respective CR */
    562                 phFriNfc_Desfire_HCrHandler(NdefMap,Result);
    563             }
    564         }
    565         else
    566         {
    567             /*  There are some more bytes to read, but
    568             no space in the user buffer */
    569             Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
    570             NdefMap->ApduBuffIndex =0;
    571             /* call respective CR */
    572             phFriNfc_Desfire_HCrHandler(NdefMap,Result);
    573         }
    574     }
    575     else
    576     {
    577         if (*NdefMap->DataCount == NdefMap->DesfireCapContainer.NdefDataLen )
    578         {
    579             /*  we have read all the bytes available in the card. */
    580             Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
    581 #ifdef PH_HAL4_ENABLE
    582             /* Do nothing */
    583 #else
    584             NdefMap->PrevOperation = 0;
    585 #endif /* #ifndef PH_HAL4_ENABLE */
    586         }
    587         else
    588         {
    589             /*  The control should not come here. */
    590             /*  we have actually read more byte than available in the card. */
    591             NdefMap->PrevOperation = 0;
    592 #ifndef PH_HAL4_ENABLE
    593             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    594                 NFCSTATUS_CMD_ABORTED);
    595 #else
    596             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    597                 NFCSTATUS_FAILED);
    598 #endif
    599         }
    600 
    601 
    602         NdefMap->ApduBuffIndex = 0;
    603 
    604         /* call respective CR */
    605         phFriNfc_Desfire_HCrHandler(NdefMap,Result);
    606     }
    607 }
    608 
    609 
    610 
    611 /*!
    612 * \brief Completion Routine, Processing function, needed to avoid long blocking.
    613 * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion
    614 *       Routine in order to be able to notify the component that an I/O has finished and data are
    615 *       ready to be processed.
    616 *
    617 */
    618 
    619 void phFriNfc_Desfire_Process(void       *Context,
    620                               NFCSTATUS   Status)
    621 {
    622     /*Set the context to Map Module*/
    623     phFriNfc_NdefMap_t  *NdefMap = (phFriNfc_NdefMap_t *)Context;
    624     uint8_t             ErrFlag = 0;
    625     uint16_t            NLength = 0,
    626                         SendRecLen=0;
    627     uint32_t            BytesRead = 0;
    628 
    629 
    630     /*  Sujatha P: Fix for 0000255/0000257:[gk] MAP:Handling HAL Errors */
    631     if ( Status == NFCSTATUS_SUCCESS )
    632     {
    633         switch (NdefMap->State)
    634         {
    635 
    636 #ifdef PH_HAL4_ENABLE
    637 #else
    638 
    639             case PH_FRINFC_DESF_STATE_GET_HW_VERSION :
    640 
    641                 /* Check and store the h/w and s/w specific details.
    642                 Ex: Major/Minor version, memory storage info. */
    643                 Status = phFriNfc_Desfire_HGetSWVersion(NdefMap);
    644 
    645                 /* handle the error in Transc function*/
    646                 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    647                 {
    648                     /* call respective CR */
    649                     phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    650                 }
    651 
    652                 break;
    653 
    654             case PH_FRINFC_DESF_STATE_GET_SW_VERSION :
    655 
    656                 /* Check and store the h/w and s/w specific details.
    657                 Ex: Major/Minor version, memory storage info. */
    658 
    659                 Status = phFriNfc_Desfire_HUpdateVersionDetails(NdefMap);
    660                 if ( Status == NFCSTATUS_SUCCESS )
    661                 {
    662                     Status = phFriNfc_Desfire_HGetUIDDetails(NdefMap);
    663                     /* handle the error in Transc function*/
    664                     if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    665                     {
    666                         /* call respective CR */
    667                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    668                     }
    669                 }
    670 
    671                 break;
    672 
    673             case PH_FRINFC_DESF_STATE_GET_UID :
    674 
    675                 /*Set the desfire operation flag*/
    676                 NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;
    677 
    678                 /*Call Select Smart tag Functinality*/
    679                 Status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    680 
    681                 break;
    682 #endif /* #ifdef PH_HAL4_ENABLE */
    683 
    684 #ifdef DESFIRE_EV1
    685             case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1:
    686             {
    687                 if(( NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 2)] ==
    688                     PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    689                     (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 1)] ==
    690                     PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    691                 {
    692                     NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
    693 
    694                     Status = phFriNfc_Desfire_SelectFile(NdefMap);
    695 
    696                     /* handle the error in Transc function*/
    697                     if ((Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    698                     {
    699                         /* call respective CR */
    700                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    701                     }
    702                 }
    703                 else
    704                 {
    705                     NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
    706                     /* The card is not the new desfire, so send select smart tag command
    707                     of the old desfire */
    708                     Status = phFriNfc_Desfire_SelectSmartTag(NdefMap);
    709 
    710 
    711                 }
    712                 break;
    713             }
    714 #endif /* #ifdef DESFIRE_EV1 */
    715 
    716         case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG:
    717 #ifdef DESFIRE_EV1
    718             if(( NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 2)] ==
    719                     PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    720                     (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength) - 1)] ==
    721                     PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    722 #else
    723             if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] ==
    724                 PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    725                 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] ==
    726                 PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    727 #endif /* #ifdef DESFIRE_EV1 */
    728             {
    729                 Status = phFriNfc_Desfire_SelectFile(NdefMap);
    730 
    731                 /* handle the error in Transc function*/
    732                 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    733                 {
    734                     /* call respective CR */
    735                     phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    736                 }
    737             }
    738             else
    739             {
    740                 /*Error " Smart Tag Functionality Not Supported"*/
    741                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
    742                     NFCSTATUS_SMART_TAG_FUNC_NOT_SUPPORTED);
    743 #ifdef DESFIRE_EV1
    744                 NdefMap->CardType = 0;
    745 #endif /* #ifdef DESFIRE_EV1 */
    746 
    747                 /* call respective CR */
    748                 phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    749 
    750             }
    751 
    752             break;
    753 
    754         case PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_FILE :
    755 
    756             if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    757                 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    758             {
    759                 /*check for the which operation */
    760                 if( (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_READ_OP) ||
    761                     (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP) ||
    762                     (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP ))
    763                 {
    764                     /* call for read binary operation*/
    765                     Status = phFriNfc_Desfire_ReadBinary(NdefMap);
    766 
    767                     /* handle the error in Transc function*/
    768                     if  ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER) )
    769                     {
    770                         /* call respective CR */
    771                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    772                     }
    773                 }
    774                 /*its a write Operation*/
    775                 else if(NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_WRITE_OP )
    776                 {
    777                     Status = phFriNfc_Desfire_UpdateBinary (NdefMap);
    778                     /* handle the error in Transc function*/
    779                     if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    780                     {
    781                         /* call respective CR */
    782                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    783                     }
    784                 }
    785                 else
    786                 {
    787                     /* unknown/invalid desfire operations*/
    788                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
    789                         NFCSTATUS_INVALID_REMOTE_DEVICE);
    790 
    791                     /* call respective CR */
    792                     phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    793                 }
    794             }
    795             else
    796             {
    797                 /*return Error " Select File Operation Failed"*/
    798                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
    799                     NFCSTATUS_INVALID_REMOTE_DEVICE);
    800 
    801                 /* call respective CR */
    802                 phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    803             }
    804             break;
    805 
    806         case PH_FRINFC_NDEFMAP_DESF_STATE_READ_CAP_CONT:
    807             if( (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength)-2)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    808                 (NdefMap->SendRecvBuf[(*(NdefMap->SendRecvLength)-1)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    809             {
    810                 /*  Read successful. */
    811                 /*Update the smart tag capability container*/
    812                 Status = phFriNfc_Desfire_Update_SmartTagCapContainer(NdefMap);
    813 
    814                 if ( Status == NFCSTATUS_SUCCESS)
    815                 {
    816                     NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP;
    817 #ifdef DESFIRE_EV1
    818                     if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
    819                     {
    820                         Status = phFriNfc_Desfire_SelectFile(NdefMap);
    821                     }
    822                     else
    823 #endif /* #ifdef DESFIRE_EV1 */
    824                     {
    825                         Status = phFriNfc_Desfire_HSetGet_NLEN(NdefMap);
    826                     }
    827                     /* handle the error in Transc function*/
    828                     if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
    829                     {
    830                         /* call respective CR */
    831                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    832                     }
    833                 }
    834                 else
    835                 {
    836                     /* call respective CR */
    837                     phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    838 
    839                 }
    840 
    841             }
    842             else
    843             {
    844                 /*return Error " Capability Container Not Found"*/
    845                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    846                     NFCSTATUS_INVALID_REMOTE_DEVICE);
    847                 /* call respective CR */
    848                 phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    849             }
    850             break;
    851 
    852         case  PH_FRINFC_NDEFMAP_DESF_STATE_READ_BIN:
    853 
    854             /* Check how many bytes have been read/returned from the card*/
    855             BytesRead = phFriNfc_Desfire_HGetLeBytes(NdefMap);
    856 
    857             /* set the send recev len*/
    858             SendRecLen = *NdefMap->SendRecvLength - (PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET );
    859             if ( (NdefMap->DesfireCapContainer.SkipNlenBytesFlag  == 1) && ((BytesRead == 1) || (BytesRead == 2 )))
    860             {
    861                 BytesRead += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES; /* to take care of first 2 len bytes*/
    862 
    863             }
    864             else
    865             {
    866                 /* Nothing to process*/
    867                 ;
    868             }
    869             /* Read More Number Of Bytes than Expected*/
    870             if ( ( BytesRead == SendRecLen ) &&
    871                 ((NdefMap->SendRecvBuf[(*NdefMap->SendRecvLength-2)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    872                 (NdefMap->SendRecvBuf[(*NdefMap->SendRecvLength-1)] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE)))
    873 
    874             {
    875                 /* this is to check the card state in first Read Operation*/
    876                 if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP )
    877                 {
    878                     /* check the actual length of the ndef data : NLEN*/
    879                     NLength = ( (((uint16_t)NdefMap->SendRecvBuf[0])<<PH_FRINFC_NDEFMAP_DESF_SHL8)+ \
    880                         NdefMap->SendRecvBuf[1]);
    881                     if (( NLength > PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE )||
    882                         ( NLength == 0xFFFF))
    883                     {
    884                         ErrFlag = 1;
    885                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    886                             NFCSTATUS_NO_NDEF_SUPPORT);
    887                     }
    888                     else
    889                     {
    890                         /* Store the NLEN into the context  */
    891                         NdefMap->DesfireCapContainer.NdefDataLen = NLength;
    892 
    893                         Status = phFriNfc_MapTool_SetCardState( NdefMap,
    894                             NLength);
    895                         if ( Status == NFCSTATUS_SUCCESS )
    896                         {
    897                             /*Set the card type to Desfire*/
    898 #ifndef DESFIRE_EV1
    899                             NdefMap->CardType = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
    900 #endif /* #ifdef DESFIRE_EV1 */
    901                             /*Set the state to specify True for Ndef Compliant*/
    902                             NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_CHK_NDEF;
    903 
    904                             /*set the data count back to zero*/;
    905                             *NdefMap->DataCount = 0;
    906                             /*set the apdu buffer index to zero*/
    907                             NdefMap->ApduBuffIndex = 0;
    908                             /* Set the Operationg flag to Complete check NDEF Operation*/
    909                             NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP;
    910 
    911                         }
    912                          /* call respective CR */
    913                         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    914                     }/* End ofNdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP*/
    915                 }
    916                 else if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_READ_OP )
    917                 {
    918                     phFriNfc_Desfire_HProcReadData(NdefMap);
    919                 }
    920                 else
    921                 {
    922                     /* Invalid Desfire Operation  */
    923                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
    924                         NFCSTATUS_INVALID_REMOTE_DEVICE);
    925                     phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    926                 }
    927 
    928             }
    929             else
    930             {
    931                 /*handle the  Error case*/
    932                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
    933                     NFCSTATUS_READ_FAILED);
    934                 ErrFlag =1;
    935             }
    936             if( ErrFlag == 1)
    937             {
    938                 *NdefMap->DataCount = 0;
    939 
    940                 /*set the buffer index back to zero*/
    941                 NdefMap->ApduBuffIndex = 0;
    942 
    943                 /* call respective CR */
    944                 phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    945             }
    946 
    947             break;
    948 
    949         case  PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_BEGIN:
    950             if( (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    951                 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    952             {
    953                 /*  Write operation was successful. */
    954                 /*  NdefMap->NumOfBytesWritten have been written on to the card.
    955                 Update the DataCount and the ApduBufferIndex */
    956                 *NdefMap->DataCount = (uint16_t)(*NdefMap->DataCount +
    957                                                 NdefMap->NumOfBytesWritten);
    958                 NdefMap->ApduBuffIndex = (uint16_t)(NdefMap->ApduBuffIndex +
    959                                                 NdefMap->NumOfBytesWritten);
    960 
    961                 /*  Update the user-provided buffer size to write */
    962                 *NdefMap->WrNdefPacketLength += NdefMap->NumOfBytesWritten;
    963 
    964                 /*  Call Upadte Binary function to check if some more bytes are to be written. */
    965                 Status = phFriNfc_Desfire_UpdateBinary( NdefMap );
    966             }
    967             else
    968             {
    969                 /*handle the  Error case*/
    970                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
    971                     NFCSTATUS_WRITE_FAILED);
    972 
    973                 /*set the buffer index back to zero*/
    974                 NdefMap->ApduBuffIndex = 0;
    975 
    976                 /* call respective CR */
    977                 phFriNfc_Desfire_HCrHandler(NdefMap,Status);
    978             }
    979             break;
    980         case PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_END :
    981             if((NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW1_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW1_BYTE) &&
    982                 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_SW2_INDEX] == PH_FRINFC_NDEFMAP_DESF_RAPDU_SW2_BYTE))
    983             {
    984                 /*  Updating NLEN operation was successful. */
    985                 /* Entire Write Operation is complete*/
    986                 /*  Reset the relevant parameters. */
    987                 Status = PHNFCSTVAL(CID_NFC_NONE,\
    988                     NFCSTATUS_SUCCESS);
    989 
    990                 /* set the state & Data len into context*/
    991                 NdefMap->CardState = (uint8_t)((NdefMap->CardState ==
    992                                             PH_NDEFMAP_CARD_STATE_INITIALIZED)?
    993                                             PH_NDEFMAP_CARD_STATE_READ_WRITE :
    994                                             NdefMap->CardState);
    995 
    996                 NdefMap->DesfireCapContainer.NdefDataLen = (uint16_t)(*NdefMap->WrNdefPacketLength);
    997 #ifdef PH_HAL4_ENABLE
    998             /* Do nothing */
    999 #else
   1000                 NdefMap->PrevOperation = 0;
   1001 #endif /* #ifndef PH_HAL4_ENABLE */
   1002 
   1003             }
   1004             else
   1005             {
   1006                 NdefMap->PrevOperation = 0;
   1007                 /*handle the  Error case*/
   1008                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
   1009                     NFCSTATUS_WRITE_FAILED);
   1010             }
   1011 
   1012             /*set the buffer index back to zero*/
   1013             NdefMap->ApduBuffIndex = 0;
   1014 
   1015             /* call respective CR */
   1016             phFriNfc_Desfire_HCrHandler(NdefMap,Status);
   1017             break;
   1018 
   1019         default:
   1020             /*define the invalid state*/
   1021             Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
   1022                 NFCSTATUS_INVALID_DEVICE_REQUEST);
   1023             phFriNfc_Desfire_HCrHandler(NdefMap,Status);
   1024             break;
   1025         }
   1026     }
   1027     else
   1028     {
   1029         /* call respective CR */
   1030         phFriNfc_Desfire_HCrHandler(NdefMap,Status);
   1031     }
   1032 }
   1033 
   1034 
   1035 
   1036 /*!
   1037 * \brief this shall select the smart tag functinality of the Desfire card.
   1038 *
   1039 * Only when this command returns command completed it is a Smart Tag
   1040 * compatible product.
   1041 *
   1042 */
   1043 static
   1044 NFCSTATUS   phFriNfc_Desfire_SelectSmartTag(phFriNfc_NdefMap_t *NdefMap)
   1045 {
   1046 
   1047     NFCSTATUS                   status = NFCSTATUS_PENDING;
   1048 #ifdef DESFIRE_EV1
   1049     uint8_t                     card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
   1050 #endif /* #ifdef DESFIRE_EV1 */
   1051 
   1052     /*form the packet for Select smart tag command*/
   1053     NdefMap->SendRecvBuf[0]  = 0x00; /* cls */
   1054     NdefMap->SendRecvBuf[1]  = 0xa4; /* ins */
   1055     NdefMap->SendRecvBuf[2]  = 0x04; /* p1 */
   1056     NdefMap->SendRecvBuf[3]  = 0x00; /* p2 */
   1057     NdefMap->SendRecvBuf[4]  = 0x07; /* lc */
   1058 
   1059     /* next 7 bytes specify the DF Name*/
   1060     NdefMap->SendRecvBuf[5]  = 0xd2;
   1061     NdefMap->SendRecvBuf[6]  = 0x76;
   1062     NdefMap->SendRecvBuf[7]  = 0x00;
   1063     NdefMap->SendRecvBuf[8]  = 0x00;
   1064     NdefMap->SendRecvBuf[9]  = 0x85;
   1065     NdefMap->SendRecvBuf[10] = 0x01;
   1066 
   1067 #ifdef DESFIRE_EV1
   1068 
   1069     switch (NdefMap->DespOpFlag)
   1070     {
   1071         case PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP:
   1072         {
   1073             /* First select the smart tag using the new desfire EV1 and increment the
   1074                 "sel_index" and if it fails then try the old desfire select smart tag
   1075                 command */
   1076             if (0 == NdefMap->CardType)
   1077             {
   1078                 /* p2
   1079                 NdefMap->SendRecvBuf[3]  = DESFIRE_EV1_P2_OFFSET_VALUE; */
   1080                 NdefMap->SendRecvBuf[11] = 0x01;
   1081                 /* Le */
   1082                 NdefMap->SendRecvBuf[12] = 0x00;
   1083                 NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1;
   1084                 card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
   1085             }
   1086             else
   1087             {
   1088                 NdefMap->SendRecvBuf[3]  = 0x00; /* p2 */
   1089                 NdefMap->SendRecvBuf[11] = 0x00;
   1090                 NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
   1091                 card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
   1092             }
   1093             break;
   1094         }
   1095 
   1096         case PH_FRINFC_NDEFMAP_DESF_READ_OP:
   1097         default :
   1098         {
   1099             if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
   1100             {
   1101                 NdefMap->SendRecvBuf[11] = 0x01;
   1102                 NdefMap->SendRecvBuf[12] = 0x00;
   1103                 NdefMap->State = (uint8_t)PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG_EV1;
   1104                 card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1;
   1105             }
   1106             else
   1107             {
   1108                 NdefMap->SendRecvBuf[11] = 0x00;
   1109                 NdefMap->State = (uint8_t)PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
   1110                 card_type = PH_FRINFC_NDEFMAP_ISO14443_4A_CARD;
   1111             }
   1112             break;
   1113         }
   1114     }
   1115 
   1116 #else /* #ifdef DESFIRE_EV1 */
   1117 
   1118     NdefMap->SendRecvBuf[11] = 0x00;
   1119 
   1120 #endif /* #ifdef DESFIRE_EV1 */
   1121 
   1122     /*Set the Send length*/
   1123     NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_SMARTTAG_PKT_SIZE;
   1124 #ifdef DESFIRE_EV1
   1125 
   1126     if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == card_type)
   1127     {
   1128         /* Send length is updated for the NEW DESFIRE EV1 */
   1129         NdefMap->SendLength = (uint16_t)(NdefMap->SendLength + 1);
   1130     }
   1131 
   1132 #else
   1133     /* Change the state to Select Smart Tag */
   1134     NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_SMART_TAG;
   1135 #endif /* #ifdef DESFIRE_EV1 */
   1136 
   1137     status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);
   1138 
   1139     return status;
   1140 }
   1141 
   1142 /*!
   1143 * \brief this shall select/access the capability container of the Desfire
   1144 * card.
   1145 *
   1146 * This shall be used to identify, if NDEF data structure do exist on
   1147 * the smart tag, we receive command completed status.
   1148 *
   1149 */
   1150 static
   1151 NFCSTATUS phFriNfc_Desfire_SelectFile (phFriNfc_NdefMap_t  *NdefMap)
   1152 {
   1153 
   1154     NFCSTATUS                   status = NFCSTATUS_PENDING;
   1155 
   1156     /* check for the invalid/unknown desfire operations*/
   1157     if ((NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP)&& \
   1158         (NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_READ_OP)&&\
   1159         ( NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_WRITE_OP) &&
   1160         ( NdefMap->DespOpFlag != PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP))
   1161     {
   1162         status  =   PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);
   1163     }
   1164     else
   1165     {
   1166 
   1167         /*  Set the command*/
   1168         //NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_CmdListTClCmd;
   1169 
   1170         /*  Form the packet for select file command either for the
   1171         Check Ndef/Read/Write functionalities*/
   1172         NdefMap->SendRecvBuf[0] = 0x00; /* cls */
   1173         NdefMap->SendRecvBuf[1] = 0xa4; /* ins */
   1174         NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
   1175         NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
   1176         NdefMap->SendRecvBuf[4] = 0x02; /* lc */
   1177 
   1178 #ifdef DESFIRE_EV1
   1179         if (PH_FRINFC_NDEFMAP_ISO14443_4A_CARD_EV1 == NdefMap->CardType)
   1180         {
   1181             NdefMap->SendRecvBuf[3]  = DESFIRE_EV1_P2_OFFSET_VALUE; /* p2 */
   1182         }
   1183 #endif /* #ifdef DESFIRE_EV1 */
   1184 
   1185         if ( (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP))
   1186 
   1187         {
   1188             /* cap container file identifier*/
   1189             NdefMap->SendRecvBuf[5] = 0xe1;
   1190             NdefMap->SendRecvBuf[6] = 0x03;
   1191         }
   1192         /* Mantis entry 0394 fixed */
   1193         else
   1194         {
   1195             NdefMap->SendRecvBuf[5] = (uint8_t)((NdefMap->DesfireCapContainer.NdefMsgFid) >> PH_FRINFC_NDEFMAP_DESF_SHL8);
   1196             NdefMap->SendRecvBuf[6] = (uint8_t)((NdefMap->DesfireCapContainer.NdefMsgFid) & (0x00ff));
   1197         }
   1198         /*Set the Send length*/
   1199         NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_SELECT_FILE_PKT_SIZE;
   1200 
   1201         /* Change the state to Select File */
   1202         NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_SELECT_FILE;
   1203 
   1204         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);
   1205 
   1206     }
   1207 
   1208     return status;
   1209 
   1210 }
   1211 
   1212 /*!
   1213 * \brief this shall read the data from Desfire card.
   1214 *
   1215 * This is used in two cases namely Reading the Capability container
   1216 * data( le == 0 ) and reading the file data.Maximum bytes to be read during
   1217 * a single read binary is known after the reading the data from the capability
   1218 * conatainer.
   1219 *
   1220 */
   1221 static
   1222 NFCSTATUS  phFriNfc_Desfire_ReadBinary(phFriNfc_NdefMap_t    *NdefMap)
   1223 {
   1224     NFCSTATUS    status = NFCSTATUS_PENDING;
   1225     uint32_t     BytesToRead = 0;
   1226     uint8_t      BufIndex=0,OperFlag=0;
   1227     uint16_t     DataCnt=0;
   1228 
   1229     /* to read the capability container data*/
   1230     if (NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP )
   1231     {
   1232         /*specifies capability container shall be read*/
   1233         NdefMap->SendRecvBuf[0] = 0x00;
   1234         NdefMap->SendRecvBuf[1] = 0xb0;
   1235         NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
   1236         NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
   1237         NdefMap->SendRecvBuf[4] = 0x0F; /* le */
   1238 
   1239         NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_READ_BIN_PKT_SIZE;
   1240 
   1241         /* Change the state to Cap Container Read */
   1242         NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_READ_CAP_CONT;
   1243 
   1244         /* set the send receive buffer length*/
   1245         OperFlag = 1;
   1246     }
   1247     /*desfire file read operation*/
   1248     else
   1249     {
   1250         NdefMap->SendRecvBuf[0] = 0x00;
   1251         NdefMap->SendRecvBuf[1] = 0xb0;
   1252 
   1253         /*TBD the NLEN bytes*/
   1254         if( *NdefMap->DataCount == 0 )
   1255         {
   1256             /* first read */
   1257             /* set the offset p1 and p2*/
   1258             NdefMap->SendRecvBuf[2] = 0;
   1259             NdefMap->SendRecvBuf[3] = 0;
   1260         }
   1261         else
   1262         {
   1263             /* as the p1 of the 8bit is 0, p1 and p2 are used to store the
   1264             ofset value*/
   1265             DataCnt = *NdefMap->DataCount;
   1266             DataCnt += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
   1267             NdefMap->SendRecvBuf[2] = (uint8_t)((DataCnt)>> PH_FRINFC_NDEFMAP_DESF_SHL8);
   1268             NdefMap->SendRecvBuf[3] = (uint8_t)((DataCnt)& (0x00ff));
   1269         }
   1270         /* calculate the Le Byte*/
   1271         BytesToRead = phFriNfc_Desfire_HGetLeBytes(NdefMap);
   1272 
   1273         if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
   1274         {
   1275             /* BufIndex represents the 2 NLEN bytes and decides about the presence of
   1276             2 bytes NLEN data*/
   1277 
   1278             BufIndex = (uint8_t)(( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1 ) ?
   1279             PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES:0);
   1280 
   1281             if( ((BytesToRead == 1) || (BytesToRead == 2)) && (NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1))
   1282             {
   1283                 BytesToRead += BufIndex;
   1284             }
   1285         }
   1286 
   1287         /* set the Le byte*/
   1288         /* This following code is true for get nlen  and current offset set*/
   1289         NdefMap->SendRecvBuf[4]=(uint8_t) BytesToRead  ;
   1290 
   1291         /* Change the state to Read */
   1292         NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_READ_BIN;
   1293 
   1294         /*set the send length*/
   1295         NdefMap->SendLength = PH_FRINFC_NDEFMAP_DESF_CAPDU_READ_BIN_PKT_SIZE;
   1296         OperFlag = 2;
   1297     }
   1298 
   1299     if (OperFlag == 1 )
   1300     {
   1301         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE);
   1302     }
   1303     else
   1304     {
   1305         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,(uint8_t)(BytesToRead +PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET));
   1306     }
   1307     return (status);
   1308 }
   1309 
   1310 /*!
   1311 * \brief this shall write the data to Desfire card.
   1312 * Maximum bytes to be written during a single update binary
   1313 * is known after the reading the data from the capability
   1314 * conatainer.
   1315 *
   1316 * le filed specifes , how many bytes of data to be written to the
   1317 * Card.
   1318 *
   1319 */
   1320 static
   1321 NFCSTATUS  phFriNfc_Desfire_UpdateBinary(phFriNfc_NdefMap_t  *NdefMap)
   1322 {
   1323 
   1324     NFCSTATUS   status = NFCSTATUS_PENDING;
   1325     uint16_t    noOfBytesToWrite = 0, DataCnt=0,
   1326         index=0;
   1327 
   1328     /*  Do we have space in the file to write? */
   1329     if ( (*NdefMap->DataCount < PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) &&
   1330         (NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize))
   1331     {
   1332         /*  Yes, we have some bytes to write */
   1333         /*  Check and set the card memory size , if user sent bytes are more than the
   1334         card memory size*/
   1335         if( (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >\
   1336             (uint16_t)(PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE - *NdefMap->DataCount))
   1337         {
   1338             NdefMap->ApduBufferSize =( (PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) - (*NdefMap->DataCount + NdefMap->ApduBuffIndex));
   1339         }
   1340 
   1341         /*  Now, we have space in the card to write the data, */
   1342         /*Form the packet for the update binary command*/
   1343         NdefMap->SendRecvBuf[0] = 0x00;
   1344         NdefMap->SendRecvBuf[1] = 0xD6;
   1345 
   1346         if( *NdefMap->DataCount == 0)
   1347         {
   1348             /* set the p1/p2 offsets */
   1349             NdefMap->SendRecvBuf[2] = 0x00; /* p1 */
   1350             NdefMap->SendRecvBuf[3] = 0x00; /* p2 */
   1351             NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 0;
   1352         }
   1353         else
   1354         {
   1355             /*  as the p1 of the 8bit is 0, p1 and p2 are used to store the
   1356             ofset value*/
   1357             /*  This sets card offset in a card for a write operation. + 2 is
   1358             added as first 2 offsets represents the size of the NDEF Len present
   1359             in the file*/
   1360 
   1361             DataCnt = *NdefMap->DataCount;
   1362             DataCnt += PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
   1363             NdefMap->SendRecvBuf[2] = (uint8_t)((DataCnt)>> PH_FRINFC_NDEFMAP_DESF_SHL8);
   1364             NdefMap->SendRecvBuf[3] = (uint8_t)((DataCnt)& (0x00ff));
   1365             /* No need to attach 2 NLEN bytes at the begining.
   1366             as we have already attached in the first write operation.*/
   1367             NdefMap->DesfireCapContainer.SkipNlenBytesFlag = 1;
   1368 
   1369         }
   1370 
   1371         /*  Calculate the bytes to write */
   1372         if( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)( NdefMap->DesfireCapContainer.MaxCmdSize ))
   1373 
   1374         {
   1375             noOfBytesToWrite = ( ( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1) ?
   1376                 NdefMap->DesfireCapContainer.MaxCmdSize :
   1377             (NdefMap->DesfireCapContainer.MaxCmdSize - PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES));
   1378         }
   1379         else
   1380         {
   1381             /*  Read only till the available buffer space */
   1382             noOfBytesToWrite = (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
   1383         }
   1384 
   1385         if ( NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
   1386         {
   1387             if ( NdefMap->DesfireCapContainer.SkipNlenBytesFlag == 1 )
   1388             {
   1389                 index = 5;
   1390                 /* To Specify the NDEF data len written : updated at the of write cycle*/
   1391                 NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite;
   1392             }
   1393             else
   1394             {
   1395                 /* Leave space to update NLEN */
   1396                 NdefMap->SendRecvBuf[5] = 0x00;
   1397                 NdefMap->SendRecvBuf[6] = 0x00;
   1398                 index =7;
   1399                 /* To Specify the NDEF data len written : updated at the of write cycle*/
   1400                 NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite + PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
   1401             }
   1402 
   1403             /* copy the data to SendRecvBuf from the apdu buffer*/
   1404             (void)memcpy( &NdefMap->SendRecvBuf[index],
   1405                 &NdefMap->ApduBuffer[NdefMap->ApduBuffIndex],
   1406                 noOfBytesToWrite);
   1407             NdefMap->SendLength = (noOfBytesToWrite + index);
   1408         }
   1409         else
   1410         {
   1411             NdefMap->SendRecvBuf[4] = (uint8_t)noOfBytesToWrite;
   1412 
   1413             /* copy the data to SendRecvBuf from the apdu buffer*/
   1414             (void)memcpy( &NdefMap->SendRecvBuf[5],
   1415                 &NdefMap->ApduBuffer[NdefMap->ApduBuffIndex],
   1416                 noOfBytesToWrite);
   1417             NdefMap->SendLength = (noOfBytesToWrite + 5);
   1418         }
   1419 
   1420         /*  Store the number of bytes being written in the context structure, so that
   1421         the parameters can be updated, after a successful write operation. */
   1422         NdefMap->NumOfBytesWritten = noOfBytesToWrite;
   1423 
   1424         /* Change the state to Write */
   1425         NdefMap->State = PH_FRINFC_NDEFMAP_DESF_STATE_UPDATE_BIN_BEGIN;
   1426 
   1427         status = phFriNfc_Desfire_HSendTransCmd(NdefMap,PH_FRINFC_NDEFMAP_DESF_RESP_OFFSET);
   1428 
   1429     }   /*  if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize) */
   1430     else
   1431     {
   1432         if ( (*NdefMap->DataCount == PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) ||
   1433             (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize))
   1434         {
   1435             /* The NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_SET_LEN_OP is not
   1436                 required, because the DespOpFlag shall be WRITE_OP
   1437                 */
   1438             /* Update the NLEN Bytes*/
   1439 #ifdef PH_HAL4_ENABLE
   1440             /* Do nothing */
   1441 #else
   1442             NdefMap->DespOpFlag = PH_FRINFC_NDEFMAP_DESF_SET_LEN_OP;
   1443 #endif /* #ifdef PH_HAL4_ENABLE */
   1444             status = phFriNfc_Desfire_HSetGet_NLEN(NdefMap);
   1445         }
   1446         else
   1447         {
   1448             /*  The control should not come here.
   1449             wrong internal calculation.
   1450             we have actually written more than the space available
   1451             in the card ! */
   1452 #ifndef PH_HAL4_ENABLE
   1453             status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
   1454                 NFCSTATUS_CMD_ABORTED);
   1455 #else
   1456             status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
   1457                 NFCSTATUS_FAILED);
   1458 #endif
   1459             /*  Reset the relevant parameters. */
   1460             NdefMap->ApduBuffIndex = 0;
   1461             NdefMap->PrevOperation = 0;
   1462 
   1463             /* call respective CR */
   1464             phFriNfc_Desfire_HCrHandler(NdefMap,status);
   1465         }
   1466 
   1467     }
   1468     /*  if(*NdefMap->DataCount < PH_NFCFRI_NDEFMAP_DESF_NDEF_FILE_SIZE) */
   1469 
   1470     return status;
   1471 }
   1472 
   1473 
   1474 static void phFriNfc_Desfire_HChkNDEFFileAccessRights(phFriNfc_NdefMap_t *NdefMap)
   1475 {
   1476     if ( (NdefMap->DesfireCapContainer.ReadAccess  == 0x00) &&
   1477         (NdefMap->DesfireCapContainer.WriteAccess == 0x00 ))
   1478     {
   1479         /* Set the card state to Read/write State*/
   1480         /* This state can be either INITIALISED or READWRITE. but default
   1481         is INITIALISED */
   1482         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
   1483 
   1484     }
   1485     else if((NdefMap->DesfireCapContainer.ReadAccess  == 0x00) &&
   1486         (NdefMap->DesfireCapContainer.WriteAccess == 0xFF ))
   1487     {
   1488         /* Set the card state to Read Only State*/
   1489         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
   1490     }
   1491     else
   1492     {
   1493         /* Set the card state to invalid State*/
   1494         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
   1495     }
   1496 }
   1497 
   1498 /*!
   1499 * \brief this shall update the Desfire capability container structure.
   1500 *
   1501 * This function shall store version,maximum Ndef data structure size,
   1502 * Read Access permissions, Write Access permissions , Maximum data size
   1503 * that can be sent using a single Update Binary, maximum data size that
   1504 * can be read from the Desfire using a singlr read binary.
   1505 * These vaues shall be stored and used during the read/update binary
   1506 * operations.
   1507 *
   1508 */
   1509 static
   1510 NFCSTATUS  phFriNfc_Desfire_Update_SmartTagCapContainer(phFriNfc_NdefMap_t    *NdefMap)
   1511 {
   1512     uint16_t    CapContSize = 0,
   1513         /* this is initalised 2 because CCLEN includes the field size bytes i.e 2bytes*/
   1514         CCLen= 0;
   1515     uint8_t     ErrFlag = 0;
   1516 
   1517     NFCSTATUS status= NFCSTATUS_SUCCESS;
   1518 
   1519     /*Check the Size of Cap Container */
   1520     CapContSize = ( (((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_FIRST_INDEX])<<8)+ \
   1521         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_CCLEN_BYTE_SECOND_INDEX]);
   1522 
   1523     CCLen += 2;
   1524 
   1525     if ( (CapContSize < 0x0f) || (CapContSize == 0xffff))
   1526     {
   1527         ErrFlag =1;
   1528     }
   1529     else
   1530     {
   1531         /*Version : Smart Tag Spec version */
   1532         /* check for the validity of Major and Minor Version numbers*/
   1533         status = phFriNfc_MapTool_ChkSpcVer (   NdefMap,
   1534             PH_FRINFC_NDEFMAP_DESF_VER_INDEX);
   1535         if ( status  !=  NFCSTATUS_SUCCESS )
   1536         {
   1537             ErrFlag =1;
   1538         }
   1539         else
   1540         {
   1541             CCLen += 1;
   1542 
   1543             /*Get Response APDU data size
   1544             to check the integration s/w response size*/
   1545 #ifdef PH_HAL4_ENABLE
   1546 			{
   1547 				uint16_t	max_rsp_size =
   1548 					((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_FIRST_INDEX]) << 8)\
   1549 					+ NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_SECOND_INDEX]);
   1550 				NdefMap->DesfireCapContainer.MaxRespSize =
   1551 								((max_rsp_size > PHHAL_MAX_DATASIZE)?
   1552 								(PHHAL_MAX_DATASIZE) : max_rsp_size);
   1553 			}
   1554 #else
   1555 			NdefMap->DesfireCapContainer.MaxRespSize =
   1556 				((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_FIRST_INDEX]) << 8)\
   1557                 +NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLE_BYTE_SECOND_INDEX]);
   1558 #endif /* #ifdef PH_HAL4_ENABLE */
   1559 
   1560             /*Get Command APDU data size*/
   1561 #ifdef PH_HAL4_ENABLE
   1562 			{
   1563 				uint16_t	max_cmd_size =
   1564 					((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_FIRST_INDEX])<<8)\
   1565 					+ NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_SECOND_INDEX]);
   1566 
   1567 				NdefMap->DesfireCapContainer.MaxCmdSize =
   1568 								((max_cmd_size > PHHAL_MAX_DATASIZE)?
   1569 								(PHHAL_MAX_DATASIZE): max_cmd_size);
   1570 			}
   1571 #else
   1572 			NdefMap->DesfireCapContainer.MaxCmdSize =
   1573 				((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_FIRST_INDEX])<<8)\
   1574                 +NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_MLC_BYTE_SECOND_INDEX]);
   1575 #endif /* #ifdef PH_HAL4_ENABLE */
   1576             /* Check for the Validity of Cmd & Resp Size*/
   1577             /* check the Validity of the Cmd Size*/
   1578             if( (NdefMap->DesfireCapContainer.MaxRespSize < 0x0f) ||
   1579                 ( NdefMap->DesfireCapContainer.MaxCmdSize == 0x00))
   1580             {
   1581                 ErrFlag=1;
   1582 
   1583             }
   1584             else
   1585             {
   1586                 CCLen += 4;
   1587 
   1588                 /* Check and Parse the TLV structure */
   1589                 /* In future this chk can be extended to Propritery TLV */
   1590                 //status = phFriNfc_ChkAndParseTLV(NdefMap);
   1591                 status = phFriNfc_Desf_HChkAndParseTLV(NdefMap,PH_FRINFC_NDEFMAP_DESF_TLV_INDEX);
   1592                 if ( (status == NFCSTATUS_SUCCESS) && (NdefMap->TLVFoundFlag == PH_FRINFC_NDEFMAP_DESF_NDEF_CNTRL_TLV))
   1593                 {
   1594                     CCLen += 1;
   1595 
   1596                     /* check the TLV length*/
   1597                     if ( (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) > 0x00 ) &&
   1598                         (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) <= 0xFE )&&
   1599                         (( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_TLV_LEN_INDEX]) == 0x06 ))
   1600                     {
   1601                         CCLen +=1;
   1602                         /* store the contents in to the container structure*/
   1603                         NdefMap->DesfireCapContainer.NdefMsgFid = ( (((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEID_BYTE_FIRST_INDEX])<<PH_FRINFC_NDEFMAP_DESF_SHL8)+ \
   1604                             NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEID_BYTE_SECOND_INDEX]);
   1605 
   1606                         CCLen +=2;
   1607 
   1608                         /* Invalid Msg File Id : User Can't Have read/write Opeartion*/
   1609                         if (    (NdefMap->DesfireCapContainer.NdefMsgFid == 0xFFFF) ||
   1610                             (NdefMap->DesfireCapContainer.NdefMsgFid == 0xE102) ||
   1611                             (NdefMap->DesfireCapContainer.NdefMsgFid == 0xE103) ||
   1612                             (NdefMap->DesfireCapContainer.NdefMsgFid == 0x3F00) ||
   1613                             (NdefMap->DesfireCapContainer.NdefMsgFid == 0x3FFF ) )
   1614                         {
   1615 
   1616                             ErrFlag=1;
   1617                         }
   1618                         else
   1619                         {
   1620                             /*Get Ndef Size*/
   1621                             NdefMap->DesfireCapContainer.NdefFileSize =
   1622                                 ((((uint16_t)NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILESZ_BYTE_FIRST_INDEX])<<8)
   1623                                 | (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILESZ_BYTE_SECOND_INDEX] & 0x00ff));
   1624 
   1625 
   1626                             /*Check Ndef Size*/
   1627                             /* TBD : Do we need to minus 2 bytes of size it self?*/
   1628                             if ( ((NdefMap->DesfireCapContainer.NdefFileSize -2) <= 0x0004 ) ||
   1629                                 ((NdefMap->DesfireCapContainer.NdefFileSize -2) == 0xFFFD ) )
   1630                             {
   1631                                 ErrFlag=1;
   1632                             }
   1633                             else
   1634                             {
   1635                                 CCLen +=2;
   1636 
   1637                                 /*Ndef File Read Access*/
   1638                                 NdefMap->DesfireCapContainer.ReadAccess = NdefMap->\
   1639                                     SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILERD_ACCESS_INDEX] ;
   1640 
   1641                                 /*Ndef File Write Access*/
   1642                                 NdefMap->DesfireCapContainer.WriteAccess = NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_DESF_NDEF_FILEWR_ACCESS_INDEX];
   1643 
   1644                                 CCLen +=2;
   1645 
   1646                                 phFriNfc_Desfire_HChkNDEFFileAccessRights(NdefMap);
   1647                             }
   1648                         }
   1649                     }
   1650                     else
   1651                     {
   1652 
   1653                         /* TLV Lenth is of two byte value
   1654                         TBD: As the length of TLV is fixed for 6 bytes. We need not
   1655                         handle the 2 byte value*/
   1656 
   1657 
   1658                     }
   1659                 }
   1660                 else
   1661                 {
   1662                     if ( NdefMap->TLVFoundFlag == PH_FRINFC_NDEFMAP_DESF_PROP_CNTRL_TLV )
   1663                     {
   1664                         /*TBD: To Handle The Proprietery TLV*/
   1665                     }
   1666                     else
   1667                     {
   1668                         /*Invalid T found case*/
   1669                         ErrFlag =1;
   1670                     }
   1671                 }
   1672                 /* check for the entire LENGTH Validity
   1673                 CCLEN + TLV L value == CCLEN*/
   1674                 if ( CapContSize != CCLen )
   1675                 {
   1676                     ErrFlag=1;
   1677                 }
   1678 
   1679             }/* if NdefMap->DesfireCapContainer.MaxRespSize < 0x0f */
   1680         }/* Chkeck Map Version*/
   1681     }/* CC size invalid*/
   1682     if( ErrFlag == 1 )
   1683     {
   1684         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
   1685             NFCSTATUS_NO_NDEF_SUPPORT);
   1686     }
   1687     return ( status );
   1688 }
   1689 
   1690 static uint32_t phFriNfc_Desfire_HGetLeBytes(phFriNfc_NdefMap_t *NdefMap)
   1691 {
   1692     /*Represents the LE byte*/
   1693     uint16_t BytesToRead =0;
   1694 
   1695     if ( NdefMap->DespOpFlag == PH_FRINFC_NDEFMAP_DESF_GET_LEN_OP )
   1696     {
   1697         BytesToRead = PH_FRINFC_NDEFMAP_DESF_NLEN_SIZE_IN_BYTES;
   1698          NdefMap->DesfireCapContainer.SkipNlenBytesFlag =0;
   1699     }
   1700     else
   1701     {
   1702 
   1703         /* Calculate Le bytes : No of bytes to read*/
   1704         /* Check for User Apdu Buffer Size and Msg Size of Desfire Capability container */
   1705         if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= NdefMap->DesfireCapContainer.MaxRespSize)
   1706         {
   1707             /*  We have enough buffer space to read the whole capability container
   1708             size bytes
   1709             Now, check do we have NdefMap->DesfireCapContainer.MaxRespSize to read ? */
   1710 
   1711             BytesToRead = (((NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount) >=
   1712                 NdefMap->DesfireCapContainer.MaxRespSize) ?
   1713                 NdefMap->DesfireCapContainer.MaxRespSize :
   1714             (NdefMap->DesfireCapContainer.NdefDataLen -
   1715                 *NdefMap->DataCount));
   1716         }
   1717         else
   1718         {
   1719             /*  Read only till the available buffer space */
   1720             BytesToRead = (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
   1721             if(BytesToRead >= (uint16_t)(NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount))
   1722             {
   1723                 BytesToRead = (NdefMap->DesfireCapContainer.NdefDataLen - *NdefMap->DataCount);
   1724             }
   1725         }
   1726 
   1727         NdefMap->DesfireCapContainer.SkipNlenBytesFlag =
   1728             (uint8_t)(((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )&&( *NdefMap->DataCount == 0 )) ?
   1729             1 : 0);
   1730 
   1731     }
   1732     return (BytesToRead);
   1733 }
   1734 
   1735 
   1736 
   1737 /*!
   1738 * \brief this shall notify the integration software with respective
   1739 *  success/error status along with the completion routines.
   1740 *
   1741 *  This routine is called from the desfire process function.
   1742 *
   1743 */
   1744 
   1745 static void phFriNfc_Desfire_HCrHandler(    phFriNfc_NdefMap_t  *NdefMap,
   1746                                         NFCSTATUS           Status)
   1747 {
   1748     /* set the state back to the Reset_Init state*/
   1749     NdefMap->State =  PH_FRINFC_NDEFMAP_STATE_RESET_INIT;
   1750 
   1751     switch(NdefMap->DespOpFlag)
   1752     {
   1753         /* check which routine has the problem and set the CR*/
   1754     case PH_FRINFC_NDEFMAP_DESF_NDEF_CHK_OP :
   1755         /* set the completion routine*/
   1756         NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_CHK_NDEF].\
   1757             CompletionRoutine(NdefMap->CompletionRoutine->Context,\
   1758             Status);
   1759         break;
   1760 
   1761     case PH_FRINFC_NDEFMAP_DESF_READ_OP :
   1762         /* set the completion routine*/
   1763         NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_RD_NDEF].\
   1764             CompletionRoutine(NdefMap->CompletionRoutine->Context,\
   1765             Status);
   1766         break;
   1767 
   1768     case PH_FRINFC_NDEFMAP_DESF_WRITE_OP :
   1769         /* set the completion routine*/
   1770         NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_WR_NDEF].\
   1771             CompletionRoutine(NdefMap->CompletionRoutine->Context,\
   1772             Status);
   1773         break;
   1774 
   1775     default :
   1776         /* set the completion routine*/
   1777         NdefMap->CompletionRoutine[PH_FRINFC_NDEFMAP_CR_INVALID_OPE].\
   1778             CompletionRoutine(NdefMap->CompletionRoutine->Context,\
   1779             Status);
   1780         break;
   1781 
   1782     }
   1783 }
   1784 
   1785 static NFCSTATUS phFriNfc_Desfire_HSendTransCmd(phFriNfc_NdefMap_t *NdefMap,uint8_t SendRecvLen)
   1786 {
   1787 
   1788     NFCSTATUS status =  NFCSTATUS_SUCCESS;
   1789 
   1790     /* set the command type*/
   1791 #ifndef PH_HAL4_ENABLE
   1792     NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_CmdListTClCmd;
   1793 #else
   1794     NdefMap->Cmd.Iso144434Cmd = phHal_eIso14443_4_Raw;
   1795 #endif
   1796 
   1797     /* set the Additional Info*/
   1798     NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
   1799     NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
   1800 
   1801     /*set the completion routines for the desfire card operations*/
   1802     NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Desfire_Process;
   1803     NdefMap->MapCompletionInfo.Context = NdefMap;
   1804 
   1805     /* set the receive length */
   1806     *NdefMap->SendRecvLength = ((uint16_t)(SendRecvLen));
   1807 
   1808 
   1809     /*Call the Overlapped HAL Transceive function */
   1810     status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
   1811         &NdefMap->MapCompletionInfo,
   1812         NdefMap->psRemoteDevInfo,
   1813         NdefMap->Cmd,
   1814         &NdefMap->psDepAdditionalInfo,
   1815         NdefMap->SendRecvBuf,
   1816         NdefMap->SendLength,
   1817         NdefMap->SendRecvBuf,
   1818         NdefMap->SendRecvLength);
   1819 
   1820     return (status);
   1821 
   1822 
   1823 }
   1824 
   1825 
   1826 #ifdef UNIT_TEST
   1827 #include <phUnitTestNfc_Desfire_static.c>
   1828 #endif
   1829 
   1830 #endif  /* PH_FRINFC_MAP_DESFIRE_DISABLED */
   1831