src/phFriNfc_MifareULMap.c

   1 /*\r
   2  * Copyright (C) 2010 NXP Semiconductors\r
   3  *\r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *      http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 /*!\r
  18  * \file  phFriNfc_MifareUL.c\r
  19  * \brief This component encapsulates read/write/check ndef/process functionalities,\r
  20  *        for the Mifare UL card.   \r
  21  *\r
  22  * Project: NFC-FRI\r
  23  *\r
  24  * $Date: Wed Feb 17 15:18:08 2010 $\r
  25  * $Author: ing07385 $\r
  26  * $Revision: 1.36 $\r
  27  * $Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $\r
  28  *\r
  29  */\r
  30 \r
  31 #ifndef PH_FRINFC_MAP_MIFAREUL_DISABLED\r
  32 \r
  33 #include <phFriNfc_NdefMap.h>\r
  34 #include <phFriNfc_MifareULMap.h>\r
  35 #include <phFriNfc_MapTools.h>\r
  36 #include <phFriNfc_OvrHal.h>\r
  37 #include <phFriNfc.h>\r
  38 \r
  39 \r
  40 /*! \ingroup grp_file_attributes\r
  41  *  \name NDEF Mapping\r
  42  *\r
  43  * File: \ref phFriNfc_MifareUL.c\r
  44  *\r
  45  */\r
  46 /*@{*/\r
  47 #define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.35 $"\r
  48 #define PHFRINFCNDEFMAP_FILEALIASES  "$Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $"\r
  49 /*@}*/\r
  50 /* Completion Helper */\r
  51 static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t  *NdefMap,\r
  52                                         NFCSTATUS            Status);\r
  53 \r
  54 /*!\r
  55  * \brief \copydoc page_ovr Helper function for Mifare UL. This function reads  \r
  56  *  a 16 bytes from the card.\r
  57  */\r
  58 static NFCSTATUS phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t  *NdefMap);\r
  59 \r
  60 /*!\r
  61  * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   \r
  62  *  to find NDEF TLV\r
  63  */\r
  64 static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap, \r
  65                                         uint8_t                 *CRFlag);\r
  66 \r
  67 /*!\r
  68  * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   \r
  69  *  to check the completing the reading 16 bytes\r
  70  */\r
  71 static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t   *NdefMap,\r
  72                                             uint16_t             TempLength);\r
  73 \r
  74 \r
  75 /*!\r
  76  * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   \r
  77  *  to read 16 bytes for the finding the ndef TLV\r
  78  */\r
  79 static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t  *NdefMap,\r
  80                                                  uint8_t                BlockNo);\r
  81 \r
  82 /*!\r
  83  * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   \r
  84  *  to check the remaining size of the 3 byte of length field in TLV\r
  85  */\r
  86 static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t  *NdefMap,\r
  87                                               uint8_t             *CRFlag);\r
  88 \r
  89 /*!\r
  90  * \brief \copydoc page_ovr Helper function for Mifare UL. This function is   \r
  91  *  to byte and block number of the next TLV in the card and updating the \r
  92  *  remaining free space in the card\r
  93  */\r
  94 static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t        *NdefMap,\r
  95                                       uint16_t                  DataLen);\r
  96 \r
  97 /*!\r
  98  * \brief \copydoc page_ovr Helper function for Mifare UL. Depending on the\r
  99  * operation (read/write/check ndef), the next function is called\r
 100  */\r
 101 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t       *NdefMap,\r
 102                                        uint8_t                  *CRFlag);\r
 103 \r
 104 /*!\r
 105  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 106  * function is to copy the read bytes to the internal "ReadBuf" buffer \r
 107  */\r
 108 static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t  *NdefMap);\r
 109 \r
 110 /*!\r
 111  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 112  * function is to copy the read bytes to the user buffer \r
 113  */\r
 114 static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap);\r
 115 \r
 116 /*!\r
 117  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 118  * function is to write 4 bytes to 1 block in the card\r
 119  */\r
 120 static NFCSTATUS   phFriNfc_MfUL_H_Wr4bytes(phFriNfc_NdefMap_t  *NdefMap);\r
 121 \r
 122 /*!\r
 123  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 124  * function is to check the CC bytes in block 3 card\r
 125  */\r
 126 static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t  *NdefMap);\r
 127 \r
 128 /*!\r
 129  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 130  * function is to read the TLVs and then start writing\r
 131  */\r
 132 static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t  *NdefMap);\r
 133 \r
 134 /*!\r
 135  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 136  * function is to call write operation after reading the NDEF TLV block\r
 137  */\r
 138 static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t        *NdefMap);\r
 139 \r
 140 /*!\r
 141  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 142  * function is to process the written data\r
 143  */\r
 144 static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap);\r
 145 \r
 146 /*!\r
 147  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 148  * function is to fill the send buffer before write\r
 149  */\r
 150 static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap);\r
 151 \r
 152 /*!\r
 153  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 154  * function is to update the length L of the TLV\r
 155  */\r
 156 static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap);\r
 157 \r
 158 /*!\r
 159  * \brief \copydoc page_ovr Helper function for Mifare UL function. This \r
 160  * function is to write the terminator TLV after writing all the bytes\r
 161  */\r
 162 static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t   *NdefMap);\r
 163 \r
 164 #ifdef LOCK_BITS_CHECK_ENABLE \r
 165     static \r
 166     void\r
 167     phFriNfc_MfUL_H_ChkLockBits (\r
 168         phFriNfc_NdefMap_t *NdefMap);\r
 169 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
 170 \r
 171 /*!\r
 172  * \brief \copydoc select sector function for Mifare UL function. This \r
 173  * function is to write the terminator TLV after writing all the bytes\r
 174  */\r
 175 static NFCSTATUS  phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t  *NdefMap,\r
 176                                                    uint8_t              SectorNo,\r
 177                                                    uint8_t              CmdNo,\r
 178                                                    uint8_t              NextState);\r
 179 \r
 180 \r
 181 \r
 182 static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch, \r
 183                                           uint16_t *lpwCrc );\r
 184 \r
 185 static void phFriNfc_MfUL_H_ComputeCrc( int      CRCType, \r
 186                                  uint8_t  *Data, \r
 187                                  int      Length,\r
 188                                  uint8_t  *TransmitFirst, \r
 189                                  uint8_t  *TransmitSecond\r
 190                                  );\r
 191 \r
 192 static void\r
 193 phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap);\r
 194 \r
 195 \r
 196 #define CRC_A 0\r
 197 #define CRC_B 1\r
 198 \r
 199 \r
 200 NFCSTATUS phFriNfc_MifareUL_H_Reset(phFriNfc_NdefMap_t        *NdefMap)\r
 201 {\r
 202     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
 203     \r
 204     if ( NdefMap == NULL)\r
 205     {\r
 206         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER);\r
 207     }\r
 208     else\r
 209     {\r
 210         /* TLV structure initialisation */\r
 211         NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;\r
 212         NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 213         NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 214         NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 215         NdefMap->TLVStruct.prevLenByteValue = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 216         NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 217         NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 218         NdefMap->TLVStruct.ActualSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 219         NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 220         NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 221 \r
 222         /* Mifare UL container initialisation */\r
 223         NdefMap->MifareULContainer.ByteNumber = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 224         NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 225         NdefMap->MifareULContainer.CurrentSector = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 226         NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 227         NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 228         NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 229         NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 230         NdefMap->MifareULContainer.RemainingSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 231 \r
 232         /* Fill all the structure related buffer to ZERO */\r
 233         (void)memset(NdefMap->TLVStruct.NdefTLVBuffer, \r
 234                     PH_FRINFC_NDEFMAP_MFUL_VAL0, \r
 235                     PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
 236         (void)memset(NdefMap->MifareULContainer.Buffer, \r
 237                     PH_FRINFC_NDEFMAP_MFUL_VAL0, \r
 238                     PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
 239         (void)memset(NdefMap->MifareULContainer.InternalBuf, \r
 240                     PH_FRINFC_NDEFMAP_MFUL_VAL0, \r
 241                     PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
 242         (void)memset(NdefMap->MifareULContainer.ReadBuf, \r
 243                     PH_FRINFC_NDEFMAP_MFUL_VAL0, \r
 244                     PH_FRINFC_NDEFMAP_MFUL_VAL64);\r
 245     }\r
 246     return Result;\r
 247 }\r
 248 \r
 249 /*!\r
 250  * \brief Initiates Reading of NDEF information from the Mifare UL.\r
 251  *\r
 252  * It performs a reset of the state and starts the action (state machine).\r
 253  * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action\r
 254  * has been triggered.\r
 255  */\r
 256 \r
 257 NFCSTATUS phFriNfc_MifareUL_RdNdef( phFriNfc_NdefMap_t  *NdefMap,\r
 258                                     uint8_t             *PacketData,\r
 259                                     uint32_t            *PacketDataLength,\r
 260                                     uint8_t             Offset)\r
 261 {\r
 262     NFCSTATUS                   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\r
 263                                                     NFCSTATUS_INVALID_PARAMETER);\r
 264     \r
 265     if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) && \r
 266         (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) && \r
 267         (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) && \r
 268         (NdefMap->CompletionRoutine->CompletionRoutine != NULL) && \r
 269         (NdefMap->CompletionRoutine->Context != NULL ) && \r
 270         ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INITIALIZED) && \r
 271         (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))\r
 272     {\r
 273         /*Register PacketData to Data Buffer of NdefMap */\r
 274         NdefMap->ApduBuffer = PacketData;\r
 275         /*Register PacketDataLength to Data Length of NdefMap */\r
 276         NdefMap->ApduBufferSize = *PacketDataLength ;\r
 277         /*  To return actual number of bytes read to the caller */\r
 278         NdefMap->NumOfBytesRead = PacketDataLength ;\r
 279         *NdefMap->NumOfBytesRead = 0;\r
 280         \r
 281         if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == \r
 282             PH_FRINFC_NDEFMAP_WRITE_OPE))\r
 283         {\r
 284             NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
 285             NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 286             NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 287             NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
 288             NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;\r
 289             NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 290             NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 291             NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 292             NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 293         }\r
 294         \r
 295         NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;\r
 296         NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;\r
 297 \r
 298         if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&\r
 299             (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==\r
 300                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1))\r
 301         {\r
 302             /*  No space on card for reading : we have already\r
 303                 reached the end of file !\r
 304                 Offset is set to Continue Operation */  \r
 305             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\r
 306                             NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);\r
 307         }\r
 308         else\r
 309         {\r
 310             NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && \r
 311                                 ( NdefMap->PrevOperation != PH_FRINFC_NDEFMAP_READ_OPE))?\r
 312                                 PH_FRINFC_NDEFMAP_SEEK_BEGIN:\r
 313                                 Offset);\r
 314 \r
 315             Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?\r
 316             phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, NdefMap->MifareULContainer.CurrentBlock):\r
 317             phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap));\r
 318         }\r
 319     }\r
 320     return Result;\r
 321 }\r
 322 \r
 323 \r
 324 /*!\r
 325  * \brief Initiates writing of NDEF information to the Mifare UL.\r
 326  *\r
 327  * The function initiates the writing of NDEF information to a Mifare UL.\r
 328  * It performs a reset of the state and starts the action (state machine).\r
 329  * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action\r
 330  * has been triggered.\r
 331  */\r
 332 \r
 333 NFCSTATUS phFriNfc_MifareUL_WrNdef( phFriNfc_NdefMap_t  *NdefMap,\r
 334                                     uint8_t             *PacketData,\r
 335                                     uint32_t            *PacketDataLength,\r
 336                                     uint8_t             Offset)\r
 337 {\r
 338       NFCSTATUS                   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\r
 339                                                     NFCSTATUS_INVALID_PARAMETER);\r
 340     \r
 341     \r
 342     \r
 343         if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) && \r
 344             (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) && \r
 345             (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) && \r
 346             (NdefMap->CompletionRoutine->CompletionRoutine != NULL) && \r
 347             (NdefMap->CompletionRoutine->Context != NULL ) && \r
 348             ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY) && \r
 349             (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))\r
 350         {\r
 351             NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;\r
 352             /*Register PacketData to Data Buffer of NdefMap */\r
 353             NdefMap->ApduBuffer = PacketData;\r
 354             /*Register PacketDataLength to Data Length of NdefMap */\r
 355             NdefMap->ApduBufferSize = *PacketDataLength ;\r
 356             /*  To return actual number of bytes read to the caller */\r
 357             NdefMap->WrNdefPacketLength = PacketDataLength ;\r
 358             *NdefMap->WrNdefPacketLength = 0;\r
 359 \r
 360             if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == \r
 361                 PH_FRINFC_NDEFMAP_READ_OPE))\r
 362             {\r
 363                 NdefMap->MifareULContainer.CurrentSector = NdefMap->TLVStruct.NdefTLVSector;\r
 364                 NdefMap->MifareULContainer.CurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;\r
 365                 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 366                 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 367                 NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 368                 NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 369                 NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 370                 NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 371                 NdefMap->MifareULContainer.RemainingSize = \r
 372                                     (NdefMap->CardMemSize - \r
 373                                     (((NdefMap->TLVStruct.NdefTLVBlock - \r
 374                                     PH_FRINFC_NDEFMAP_MFUL_BYTE4) * \r
 375                                     PH_FRINFC_NDEFMAP_MFUL_BYTE4) + \r
 376                                     NdefMap->TLVStruct.NdefTLVByte + \r
 377                                     PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
 378             }\r
 379             NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;\r
 380             NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;\r
 381 \r
 382             if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&\r
 383                 (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==\r
 384                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1))\r
 385             {\r
 386                 /*  No space on card for reading : we have already\r
 387                     reached the end of file !\r
 388                     Offset is set to Continue Operation */  \r
 389                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\r
 390                                 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);\r
 391             }\r
 392             else\r
 393             {\r
 394                 NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && \r
 395                                     ( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))?\r
 396                                     PH_FRINFC_NDEFMAP_SEEK_BEGIN:\r
 397                                     Offset);\r
 398 \r
 399                 if (NdefMap->TLVStruct.NdefTLVSector == 1)\r
 400                 {\r
 401                     NdefMap->MifareULContainer.CurrentSector = 1;\r
 402 \r
 403                     /* Change to sector 1 */\r
 404                     Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 405                     NdefMap->MifareULContainer.CurrentSector, 1, \r
 406                     PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1);\r
 407 \r
 408                 }\r
 409                 else \r
 410                 {\r
 411                     Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?\r
 412                         phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):\r
 413                         phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));\r
 414                 }\r
 415             }\r
 416         }\r
 417     \r
 418 \r
 419     return Result;\r
 420 }\r
 421 \r
 422 \r
 423 \r
 424 /*!\r
 425  * \brief Check whether a particular Mifare UL is NDEF compliant.\r
 426  *\r
 427  * The function checks whether the peer device is NDEF compliant.\r
 428  *\r
 429  */\r
 430 \r
 431 NFCSTATUS phFriNfc_MifareUL_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)\r
 432 {\r
 433     NFCSTATUS                   status =    NFCSTATUS_PENDING;\r
 434     uint8_t                     index=0,\r
 435                                 pSensRes[2] = {0};\r
 436 \r
 437     /* set the data for additional data exchange*/\r
 438     NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;\r
 439     NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;\r
 440     NdefMap->psDepAdditionalInfo.NAD = 0;\r
 441 \r
 442     /*\r
 443      *  Changed \r
 444      *  Description: CardInfo106 replase \r
 445      */\r
 446 \r
 447     /* retrive remote card information */\r
 448     pSensRes[0]  = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0];\r
 449                    \r
 450     NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;\r
 451 #ifdef LOCK_BITS_CHECK_ENABLE\r
 452     NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK2;\r
 453 #else\r
 454     NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK3;\r
 455 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
 456     NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;\r
 457         \r
 458     /* Check for Mifare Bit information  */\r
 459     if (((pSensRes[0] & PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP) == PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP))\r
 460     {\r
 461         NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;\r
 462         /* set the offset*/\r
 463         NdefMap->SendRecvBuf[index] = NdefMap->MifareULContainer.CurrentBlock;\r
 464         \r
 465         /*set the send length*/\r
 466         NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_MAX_SEND_BUF_TO_READ; \r
 467                                         \r
 468         /* Change the state to check ndef compliancy */\r
 469         NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP;\r
 470         \r
 471         /* Set the card type as Mifare UL */\r
 472         NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;\r
 473 \r
 474         /* set the cmd to mifare read*/\r
 475         /* \r
 476          * Changed \r
 477          * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead\r
 478          */ \r
 479         NdefMap->Cmd.MfCmd = phHal_eMifareRead;\r
 480         \r
 481         /* Set the CR and context for Mifare operations*/\r
 482         NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;\r
 483         NdefMap->MapCompletionInfo.Context = NdefMap;\r
 484 \r
 485         /*Set the Length*/\r
 486         *NdefMap->SendRecvLength = PH_FRINFC_NDEFMAP_MF_READ_BLOCK_SIZE;\r
 487         \r
 488 \r
 489         /*Call the Overlapped HAL Transceive function */ \r
 490         status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,\r
 491                                             &NdefMap->MapCompletionInfo,\r
 492                                             NdefMap->psRemoteDevInfo,\r
 493                                             NdefMap->Cmd,\r
 494                                             &NdefMap->psDepAdditionalInfo,\r
 495                                             NdefMap->SendRecvBuf,\r
 496                                             NdefMap->SendLength,\r
 497                                             NdefMap->SendRecvBuf,\r
 498                                             NdefMap->SendRecvLength);\r
 499     }\r
 500     else\r
 501     {\r
 502         status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);\r
 503     }\r
 504     return status;\r
 505 }\r
 506 \r
 507 static void\r
 508 phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap)\r
 509 {\r
 510     uint8_t     i = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 511     uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 512         \r
 513 \r
 514     for (i = 0; i < 16; i++)\r
 515     {\r
 516         if ((NdefMap->MifareULContainer.ReadBuf[i] ==\r
 517         PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) && \r
 518         ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==\r
 519         NdefMap->TLVStruct.ActualSize) || \r
 520         (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))\r
 521         {\r
 522             if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)\r
 523             {\r
 524                 TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |\r
 525                 ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);\r
 526 \r
 527                 if (TemLength == NdefMap->TLVStruct.ActualSize)\r
 528                 {\r
 529                     NdefMap->MifareULContainer.ByteNumber = i + 1;\r
 530                     break;\r
 531                 }\r
 532             }\r
 533             else\r
 534             {   \r
 535                 NdefMap->MifareULContainer.ByteNumber = i + 1;\r
 536                 break;\r
 537             }\r
 538         }\r
 539      }\r
 540 \r
 541     return;\r
 542 }\r
 543 \r
 544 \r
 545 #ifdef LOCK_BITS_CHECK_ENABLE \r
 546 \r
 547 #define MIF_UL_LOCK_BIT_CHECK           0xFF\r
 548 #define MIF_UL_LOCK_BIT_0_VALUE         0x0F\r
 549 #define MIF_UL_LOCK_BIT_1_VALUE         0x00\r
 550 \r
 551 static \r
 552 void\r
 553 phFriNfc_MfUL_H_ChkLockBits (\r
 554     phFriNfc_NdefMap_t *NdefMap)\r
 555 {\r
 556     uint8_t         index = 2;\r
 557 \r
 558     if (((NdefMap->SendRecvBuf[index] & \r
 559         MIF_UL_LOCK_BIT_CHECK) > MIF_UL_LOCK_BIT_0_VALUE) ||  \r
 560         (MIF_UL_LOCK_BIT_1_VALUE != \r
 561         (NdefMap->SendRecvBuf[(index + 1)] & MIF_UL_LOCK_BIT_CHECK)))\r
 562     {\r
 563         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;\r
 564     }\r
 565 }\r
 566 \r
 567 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE  */\r
 568 \r
 569 /*!\r
 570  * \brief Completion Routine, Processing function, needed to avoid long \r
 571  * blocking.\r
 572  * \note The lower (Overlapped HAL) layer must register a pointer to \r
 573  *  this function as a Completion\r
 574  *  Routine in order to be able to notify the component that an I/O \r
 575  *  has finished and data are ready to be processed.\r
 576  *            \r
 577  */\r
 578 \r
 579 void phFriNfc_MifareUL_Process( void        *Context,\r
 580                                 NFCSTATUS   Status)\r
 581 \r
 582 {\r
 583     \r
 584     uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
 585                 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 586     phFriNfc_NdefMap_t          *NdefMap;\r
 587     uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 588     /*uint16_t                    TempByte = PH_FRINFC_NDEFMAP_MFUL_VAL0; */\r
 589     static uint8_t                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 590 \r
 591     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 592 \r
 593     /* set the context to Map module */\r
 594 \r
 595     NdefMap = (phFriNfc_NdefMap_t *)Context;    \r
 596 \r
 597     if ( Status == NFCSTATUS_SUCCESS )\r
 598     {\r
 599         switch (NdefMap->State)\r
 600         {\r
 601             case PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP:\r
 602                 if (*NdefMap->SendRecvLength == \r
 603                     PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
 604                 {\r
 605                     /* Checks for the Ndef Compliency and validy of the memory size*/ \r
 606                     Status = phFriNfc_MfUL_H_ChkCCBytes(NdefMap);\r
 607                     CRFlag = (uint8_t)((Status != NFCSTATUS_SUCCESS)?\r
 608                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 609                                 PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 610 \r
 611 #ifdef LOCK_BITS_CHECK_ENABLE\r
 612 \r
 613                     /* Check for lock bits */\r
 614                     if (NFCSTATUS_SUCCESS == Status)\r
 615                     {\r
 616                         phFriNfc_MfUL_H_ChkLockBits(NdefMap);\r
 617                     }\r
 618 \r
 619 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
 620 \r
 621                     /* Find the NDEF TLV */\r
 622                     NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
 623                     Status = ((Status != NFCSTATUS_SUCCESS)?\r
 624                                 Status:\r
 625                                 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, \r
 626                                             NdefMap->MifareULContainer.CurrentBlock));\r
 627                     CRFlag = (uint8_t)(((Status != NFCSTATUS_PENDING ) || \r
 628                                 (CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1))?\r
 629                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 630                                 PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 631 \r
 632 #ifdef PH_HAL4_ENABLE\r
 633                     if ((Status != NFCSTATUS_PENDING ) && \r
 634                         (Status != NFCSTATUS_SUCCESS))\r
 635                     {\r
 636                         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;\r
 637                     }\r
 638 #endif /* #ifdef PH_HAL4_ENABLE */\r
 639                 }               \r
 640             break;\r
 641 \r
 642 \r
 643             case PH_FRINFC_NDEFMAP_MFUL_STATE_READ:\r
 644                 /* check the received bytes size equals 16 bytes*/\r
 645                 if (*NdefMap->SendRecvLength == \r
 646                     PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
 647                 {\r
 648                     if(NdefMap->MifareULContainer.ReadBufIndex < \r
 649                         (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock - \r
 650                                                 PH_FRINFC_NDEFMAP_MFUL_BLOCK4) \r
 651                             * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))\r
 652 \r
 653                     {\r
 654                         Status = phFriNfc_MfUL_H_CopyRdBytes(NdefMap);\r
 655                     }\r
 656 \r
 657                     if (Status == NFCSTATUS_SUCCESS)\r
 658                     {\r
 659                         if(NdefMap->MifareULContainer.ReadBufIndex >= \r
 660                             (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock - \r
 661                                                         PH_FRINFC_NDEFMAP_MFUL_BLOCK4) \r
 662                             * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))\r
 663                         {\r
 664 \r
 665                             phFriNfc_MfUL_CalcByteNum(NdefMap);\r
 666 #if 0\r
 667                             for (i = 0; i < 16; i++)\r
 668                             {\r
 669                                 if ((NdefMap->MifareULContainer.ReadBuf[i] ==\r
 670                                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) && \r
 671                                     ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==\r
 672                                     NdefMap->TLVStruct.ActualSize) || \r
 673                                     (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))\r
 674                                 {\r
 675                                     if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)\r
 676                                     {\r
 677                                         TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |\r
 678                                             ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);\r
 679  \r
 680                                         if (TemLength == NdefMap->TLVStruct.ActualSize)\r
 681                                         {\r
 682                                             NdefMap->MifareULContainer.ByteNumber = i + 1;\r
 683                                             break;\r
 684                                         }\r
 685                                     }\r
 686                                     else\r
 687                                     {   \r
 688                                         NdefMap->MifareULContainer.ByteNumber = i + 1;\r
 689                                         break;\r
 690                                     }\r
 691                                 }\r
 692                             }\r
 693 #endif                          \r
 694  \r
 695                             if (NdefMap->MifareULContainer.ReadBuf\r
 696                                 [NdefMap->MifareULContainer.ByteNumber] == 0xFF)\r
 697                             {\r
 698                                 NdefMap->MifareULContainer.ByteNumber =\r
 699                                     NdefMap->MifareULContainer.ByteNumber + 3;\r
 700                             }\r
 701                             else\r
 702                             {\r
 703                                 NdefMap->MifareULContainer.ByteNumber =\r
 704                                     NdefMap->MifareULContainer.ByteNumber + 1;\r
 705                             }\r
 706                         \r
 707                             Status = phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap);\r
 708                             if (NdefMap->MifareULContainer.CurrentSector > 0)\r
 709                             {\r
 710                                 NdefMap->MifareULContainer.CurrentSector = 0;\r
 711                                 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;\r
 712                                     \r
 713                                 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 714                                     NdefMap->MifareULContainer.CurrentSector, 1,\r
 715                                     PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);\r
 716                                 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?\r
 717                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 718                                     PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 719                             }\r
 720                             else\r
 721                             {\r
 722                                 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 723                             }\r
 724                         }\r
 725                         else\r
 726                         {\r
 727                             Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);\r
 728                             CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 729                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 730                                     PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 731                         }\r
 732                     }\r
 733                     else\r
 734                     {\r
 735                         \r
 736                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 737                     }\r
 738                 }\r
 739                 else\r
 740                 {\r
 741                     /* read error */\r
 742                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 743                                         NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
 744                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 745                 }\r
 746             break;\r
 747 \r
 748             case PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE:\r
 749                 Status = phFriNfc_MfUL_H_ProWrittenBytes(NdefMap);\r
 750                 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 751                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 752                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 753             break;\r
 754             \r
 755             case PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP: \r
 756                 if (*NdefMap->SendRecvLength == \r
 757                     PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
 758                 {\r
 759                     switch(NdefMap->PrevOperation)\r
 760                     {\r
 761                     case PH_FRINFC_NDEFMAP_CHECK_OPE:\r
 762                     case PH_FRINFC_NDEFMAP_READ_OPE:\r
 763                             CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 764                             if(NdefMap->TLVStruct.NoLbytesinTLV > \r
 765                                 PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
 766                             {\r
 767                                 Status = phFriNfc_MfUL_H_ChkRemainTLV(NdefMap, &CRFlag);\r
 768                             }\r
 769                             else\r
 770                             {\r
 771                                 if(NdefMap->TLVStruct.NdefTLVFoundFlag != \r
 772                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
 773                                 {\r
 774                                     /* Find the NDEF TLV */\r
 775                                     Status = phFriNfc_MfUL_H_findNDEFTLV(NdefMap, &CRFlag);\r
 776                                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?\r
 777                                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 778                                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 779                                 }\r
 780                             }\r
 781                             if((NdefMap->TLVStruct.NdefTLVFoundFlag == \r
 782                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1) && \r
 783                                 (NdefMap->TLVStruct.NoLbytesinTLV == \r
 784                                 PH_FRINFC_NDEFMAP_MFUL_VAL0))\r
 785                             {\r
 786                                 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 787                                 /* Ndef TLV found, so call the next function depending on the \r
 788                                     check/read/write ndef operation */\r
 789 \r
 790                                 if (NdefMap->MifareULContainer.CurrentSector > 0)\r
 791                                 {\r
 792                                     NdefMap->MifareULContainer.CurrentSector = 0;\r
 793                                     NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;\r
 794                                     \r
 795                                     Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 796                                         NdefMap->MifareULContainer.CurrentSector, 1,\r
 797                                         PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);\r
 798                                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?\r
 799                                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 800                                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 801                                 }\r
 802                                 else \r
 803                                 {\r
 804                                     /* Sector is 0 no need to send sector select */\r
 805                                     Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);\r
 806                                 }\r
 807                             }\r
 808 \r
 809 #ifdef PH_HAL4_ENABLE\r
 810                             if ((Status != NFCSTATUS_PENDING ) && \r
 811                                 (Status != NFCSTATUS_SUCCESS) && \r
 812                                 (PH_FRINFC_NDEFMAP_CHECK_OPE == \r
 813                                 NdefMap->PrevOperation))\r
 814                             {\r
 815                                 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;\r
 816                             }\r
 817 #endif /* #ifdef PH_HAL4_ENABLE */\r
 818                         break;\r
 819 \r
 820                     case PH_FRINFC_NDEFMAP_WRITE_OPE:\r
 821                         /* Remove UpdateWrLen */\r
 822                         Status = ((NdefMap->TLVStruct.WrLenFlag == \r
 823                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1)?\r
 824                                     phFriNfc_MfUL_H_UpdateWrLen(NdefMap):\r
 825                                     phFriNfc_MfUL_H_CallWrOp(NdefMap));\r
 826                         CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 827                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 828                                 PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 829                         break;\r
 830 \r
 831                     default:\r
 832                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 833                                 NFCSTATUS_INVALID_REMOTE_DEVICE);\r
 834                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 835                         break;\r
 836 \r
 837                     }\r
 838                 }\r
 839             break;\r
 840 \r
 841             case PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV:\r
 842                 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);\r
 843                 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 844                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 845                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 846             break;\r
 847 \r
 848             case PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV:\r
 849                 if(((((NdefMap->TLVStruct.NdefTLVByte - \r
 850                     PH_FRINFC_NDEFMAP_MFUL_VAL1) == \r
 851                     PH_FRINFC_NDEFMAP_MFUL_VAL3) && \r
 852                     (NdefMap->MifareULContainer.CurrentBlock == \r
 853                     (NdefMap->TLVStruct.NdefTLVBlock + \r
 854                     PH_FRINFC_NDEFMAP_MFUL_VAL1))) || \r
 855                     (((NdefMap->TLVStruct.NdefTLVByte - \r
 856                         PH_FRINFC_NDEFMAP_MFUL_VAL1) < \r
 857                     PH_FRINFC_NDEFMAP_MFUL_VAL3) && (\r
 858                     NdefMap->MifareULContainer.CurrentBlock == \r
 859                     NdefMap->TLVStruct.NdefTLVBlock))))\r
 860                 {\r
 861                     (void)memcpy(NdefMap->MifareULContainer.InternalBuf, \r
 862                                 NdefMap->MifareULContainer.Buffer,\r
 863                                 NdefMap->MifareULContainer.InternalLength);             \r
 864                 }\r
 865                 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, \r
 866                             NdefMap->MifareULContainer.Buffer,\r
 867                             PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
 868 \r
 869                 NdefMap->CardState =(uint8_t) ((NdefMap->CardState == \r
 870                                     PH_NDEFMAP_CARD_STATE_INITIALIZED)?\r
 871                                     PH_NDEFMAP_CARD_STATE_READ_WRITE:\r
 872                                     NdefMap->CardState);\r
 873                 NdefMap->ApduBuffIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 874                 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
 875 \r
 876                 if (NdefMap->MifareULContainer.CurrentSector > 0)\r
 877                 {\r
 878                     /* Reset sector */\r
 879                     NdefMap->MifareULContainer.CurrentSector = 0;\r
 880                     NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;\r
 881                                                 \r
 882                     Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 883                             NdefMap->MifareULContainer.CurrentSector, 1,\r
 884                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);\r
 885                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 886                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 887                                     PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 888                 }\r
 889                 else\r
 890                 {\r
 891                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 892                 }\r
 893                 \r
 894             break;\r
 895 \r
 896             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1:\r
 897                  /* check the received bytes size equals 1 byte*/\r
 898                 if (*NdefMap->SendRecvLength == \r
 899                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
 900                 {\r
 901                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
 902                     {\r
 903                         /* Send second command */\r
 904                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 905                             NdefMap->MifareULContainer.CurrentSector, 2, \r
 906                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2);\r
 907                     }\r
 908                     else\r
 909                     {\r
 910                         /* read error */\r
 911                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 912                                 NFCSTATUS_INVALID_FORMAT);\r
 913                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 914                     }\r
 915                 }\r
 916                 else\r
 917                 {\r
 918                     /* read error */\r
 919                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 920                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
 921                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 922 \r
 923                 }\r
 924             break;\r
 925 \r
 926             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2:\r
 927                 {\r
 928                     NdefMap->MifareULContainer.CurrentBlock += \r
 929                                 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
 930                     \r
 931                     Status = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
 932                                 NdefMap->MifareULContainer.CurrentBlock);\r
 933                 }\r
 934             break;  \r
 935 \r
 936             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1:\r
 937                  /* check the received bytes size equals 1 byte*/\r
 938                 if (*NdefMap->SendRecvLength == \r
 939                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
 940                 {\r
 941                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
 942                     {\r
 943                         /* Send second command */\r
 944                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 945                             NdefMap->MifareULContainer.CurrentSector, 2, \r
 946                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2);\r
 947                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;\r
 948                     }\r
 949                     else\r
 950                     {\r
 951                         /* read error */\r
 952                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 953                                 NFCSTATUS_INVALID_FORMAT);\r
 954                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 955                     }\r
 956                 }\r
 957                 else\r
 958                 {\r
 959                     /* read error */\r
 960                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
 961                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
 962                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
 963 \r
 964                 }\r
 965             break;\r
 966 \r
 967             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2:\r
 968                 {\r
 969                     if (NdefMap->MifareULContainer.CurrentBlock == 0xFF)\r
 970                     {\r
 971                         NdefMap->MifareULContainer.CurrentBlock = 0;\r
 972                     }\r
 973                     else \r
 974                     {\r
 975                         NdefMap->MifareULContainer.CurrentBlock = \r
 976                             (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;\r
 977                     }\r
 978                     \r
 979                     Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);\r
 980                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
 981                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
 982                                     PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
 983                 }\r
 984             break;  \r
 985 \r
 986             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1:\r
 987                  /* check the received bytes size equals 1 byte*/\r
 988                 if (*NdefMap->SendRecvLength == \r
 989                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
 990                 {\r
 991                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
 992                     {\r
 993                         /* Send second command */\r
 994                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
 995                             NdefMap->MifareULContainer.CurrentSector, 2, \r
 996                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2);\r
 997                     }\r
 998                     else\r
 999                     {\r
1000                         /* read error */\r
1001                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1002                                 NFCSTATUS_INVALID_FORMAT);\r
1003                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1004                     }\r
1005                 }\r
1006                 else\r
1007                 {\r
1008                     /* read error */\r
1009                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1010                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
1011                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1012 \r
1013                 }\r
1014             break;\r
1015 \r
1016             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2:\r
1017                 {\r
1018                     NdefMap->MifareULContainer.CurrentBlock = 0;\r
1019                     Status = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);\r
1020                     \r
1021                     if((Status == NFCSTATUS_SUCCESS) && \r
1022                         (NdefMap->TLVStruct.SetTermTLVFlag != \r
1023                             PH_FRINFC_NDEFMAP_MFUL_FLAG1) && \r
1024                             (NdefMap->MifareULContainer.RemainingSize > \r
1025                             PH_FRINFC_NDEFMAP_MFUL_VAL0))\r
1026                     {\r
1027                         Status = phFriNfc_MfUL_H_WrTermTLV(NdefMap);\r
1028                     }\r
1029                     else \r
1030                     {\r
1031                         if((Status == NFCSTATUS_SUCCESS) && \r
1032                             (NdefMap->TLVStruct.SetTermTLVFlag == \r
1033                             PH_FRINFC_NDEFMAP_MFUL_FLAG1))\r
1034                         {\r
1035                             Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);\r
1036                         }\r
1037                     }                   \r
1038 \r
1039                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
1040                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
1041                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
1042                 }\r
1043             break;  \r
1044 \r
1045             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1:\r
1046                  /* check the received bytes size equals 1 byte*/\r
1047                 if (*NdefMap->SendRecvLength == \r
1048                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
1049                 {\r
1050                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
1051                     {\r
1052                         /* Send second command */\r
1053                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
1054                             NdefMap->MifareULContainer.CurrentSector, 2, \r
1055                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2);\r
1056                     }\r
1057                     else\r
1058                     {\r
1059                         /* read error */\r
1060                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1061                                 NFCSTATUS_INVALID_FORMAT);\r
1062                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1063                     }\r
1064                 }\r
1065                 else\r
1066                 {\r
1067                     /* read error */\r
1068                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1069                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
1070                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1071 \r
1072                 }\r
1073             break;\r
1074 \r
1075             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2:\r
1076                 {\r
1077                     Status = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?\r
1078                         phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):\r
1079                         phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));\r
1080                     \r
1081                     \r
1082                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
1083                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
1084                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
1085                 }\r
1086             break;  \r
1087 \r
1088 \r
1089             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1:\r
1090                  /* check the received bytes size equals 1 byte*/\r
1091                 if (*NdefMap->SendRecvLength == \r
1092                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
1093                 {\r
1094                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
1095                     {\r
1096                         /* Send second command */\r
1097                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
1098                             NdefMap->MifareULContainer.CurrentSector, 2, \r
1099                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2);\r
1100                     }\r
1101                     else\r
1102                     {\r
1103                         /* read error */\r
1104                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1105                                 NFCSTATUS_INVALID_FORMAT);\r
1106                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1107                     }\r
1108                 }\r
1109                 else\r
1110                 {\r
1111                     /* read error */\r
1112                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1113                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
1114                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1115 \r
1116                 }\r
1117             break;\r
1118 \r
1119             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2:\r
1120                 {\r
1121                     NdefMap->MifareULContainer.CurrentBlock = 0;\r
1122 \r
1123                     NdefMap->SendRecvBuf[index] = \r
1124                                         NdefMap->MifareULContainer.CurrentBlock;\r
1125                     index++;\r
1126                     NdefMap->SendRecvBuf[index] = \r
1127                                             PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
1128                     index++;        \r
1129 \r
1130                     if((((NdefMap->TLVStruct.NdefTLVByte - \r
1131                             PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || \r
1132                             ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) \r
1133                             == PH_FRINFC_NDEFMAP_MFUL_VAL3)))\r
1134                         {\r
1135                             /* Length to know how many bytes has to be written to the card */\r
1136                         TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == \r
1137                                         PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
1138                                         PH_FRINFC_NDEFMAP_MFUL_VAL2:\r
1139                                         PH_FRINFC_NDEFMAP_MFUL_VAL3);\r
1140 \r
1141                         if(NdefMap->ApduBufferSize >= TemLength)\r
1142                         {\r
1143                             /* Prepare the receive buffer */\r
1144                             (void)memcpy(&(NdefMap->SendRecvBuf[ \r
1145                                             index]),\r
1146                                             &(NdefMap->ApduBuffer[ \r
1147                                             NdefMap->ApduBuffIndex]),\r
1148                                             TemLength);\r
1149 \r
1150                             /* Number of bytes written to the card from user buffer */\r
1151                             NdefMap->NumOfBytesWritten = TemLength;\r
1152 \r
1153                             index = index+(uint8_t)TemLength;\r
1154                             /* Exact number of bytes written in the card including TLV */\r
1155                             *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1156                         }\r
1157                         else\r
1158                         {\r
1159                             /* Prepare the receive buffer */\r
1160                             (void)memcpy(&(NdefMap->SendRecvBuf[ \r
1161                                             index]),\r
1162                                             &(NdefMap->ApduBuffer[ \r
1163                                             NdefMap->ApduBuffIndex]),\r
1164                                             (uint16_t)NdefMap->ApduBufferSize);\r
1165 \r
1166                             /* Number of bytes written to the card from user buffer */\r
1167                             NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;\r
1168 \r
1169                             index= index +(uint8_t)NdefMap->ApduBufferSize;\r
1170                             /* Exact number of bytes written in the card including TLV */\r
1171                             *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1172 \r
1173                             for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)\r
1174                             {\r
1175                                 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?\r
1176                                         PH_FRINFC_NDEFMAP_MFUL_TERMTLV:\r
1177                                         PH_FRINFC_NDEFMAP_MFUL_NULLTLV);\r
1178                                 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1179                             }\r
1180                         }\r
1181 \r
1182                         /* store the bytes in buffer till the bytes are \r
1183                             written in a block */\r
1184                         (void)memcpy(NdefMap->MifareULContainer.Buffer,\r
1185                                         &(NdefMap->SendRecvBuf[ \r
1186                                         PH_FRINFC_NDEFMAP_MFUL_VAL1]), \r
1187                                         (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - \r
1188                                         PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
1189 \r
1190                         (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,\r
1191                                     NdefMap->MifareULContainer.Buffer,\r
1192                                     (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - \r
1193                                         PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
1194                         \r
1195                         /* Change the state to check ndef compliancy */\r
1196                         NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
1197 \r
1198                         Status = phFriNfc_MfUL_H_Wr4bytes(NdefMap);                 \r
1199                     }\r
1200 \r
1201                     \r
1202                     CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
1203                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
1204                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
1205                 }\r
1206             break;  \r
1207 \r
1208             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1:\r
1209                  /* check the received bytes size equals 1 byte*/\r
1210                 if (*NdefMap->SendRecvLength == \r
1211                     PH_FRINFC_NDEFMAP_MFUL_VAL1)\r
1212                 {\r
1213                     if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)\r
1214                     {\r
1215                         /* Send second command */\r
1216                         Status = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
1217                             NdefMap->MifareULContainer.CurrentSector, 2, \r
1218                             PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2);\r
1219                     }\r
1220                     else\r
1221                     {\r
1222                         /* read error */\r
1223                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1224                                 NFCSTATUS_INVALID_FORMAT);\r
1225                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1226                     }\r
1227                 }\r
1228                 else\r
1229                 {\r
1230                     /* read error */\r
1231                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1232                             NFCSTATUS_INVALID_RECEIVE_LENGTH);\r
1233                     CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1234 \r
1235                 }\r
1236             break;\r
1237 \r
1238             case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2:\r
1239                 {\r
1240                     if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP)\r
1241                     {\r
1242                         Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);\r
1243                     }\r
1244                     else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_READ)\r
1245                     {\r
1246                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1247                     }\r
1248                     else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE)\r
1249                     {\r
1250                         Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);\r
1251                         CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?\r
1252                             PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
1253                             PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
1254                     }\r
1255                     else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV)\r
1256                     {\r
1257                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1258                     }\r
1259                     else\r
1260                     {\r
1261                         /* read error */\r
1262                         Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1263                                     NFCSTATUS_READ_FAILED);\r
1264                         CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1265 \r
1266                     }\r
1267                 }\r
1268             break;  \r
1269 \r
1270             default:\r
1271                 /*set the invalid state*/\r
1272                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);\r
1273                 phFriNfc_MifareUL_H_Complete(NdefMap, Status);\r
1274             break;\r
1275         }\r
1276         if(CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
1277         {\r
1278             /* call the CR routine*/\r
1279             phFriNfc_MifareUL_H_Complete(NdefMap, Status);\r
1280         }\r
1281     }\r
1282     else\r
1283     {\r
1284         phFriNfc_MifareUL_H_Complete(NdefMap,Status);\r
1285     }\r
1286 }\r
1287 \r
1288 static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t  *NdefMap )\r
1289 {\r
1290     NFCSTATUS Result = PHNFCSTVAL(  CID_FRI_NFC_NDEF_MAP, \r
1291                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
1292     \r
1293 #ifdef LOCK_BITS_CHECK_ENABLE        \r
1294         switch(NdefMap->SendRecvBuf[7])     \r
1295 #else\r
1296         switch(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE3])        \r
1297 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ \r
1298         {\r
1299             case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RW:\r
1300                 /* This state can be either INITIALISED or READWRITE. but default \r
1301                     is INITIALISED */\r
1302                 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;\r
1303                 break;\r
1304 \r
1305             case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RO:\r
1306                 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;\r
1307                 break;\r
1308 \r
1309             default :\r
1310                 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;\r
1311         }\r
1312 \r
1313 \r
1314         \r
1315         /* Check for Ndef compliancy : 0 and 1 byte spcifies the ndef compliancy\r
1316            2 byte specifies the version of the MF UL tag*/\r
1317 #ifdef LOCK_BITS_CHECK_ENABLE\r
1318         if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE4] ==  \r
1319 #else\r
1320         if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE0] ==         \r
1321 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ \r
1322             PH_FRINFC_NDEFMAP_MFUL_CC_BYTE0) && (\r
1323             (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED) || \r
1324             (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)))\r
1325         {\r
1326             /* Check the version number */\r
1327             Result =phFriNfc_MapTool_ChkSpcVer( NdefMap,\r
1328 #ifdef LOCK_BITS_CHECK_ENABLE\r
1329                                                 5);\r
1330 \r
1331 #else\r
1332                                                 PH_FRINFC_NDEFMAP_MFUL_BYTE1);\r
1333 \r
1334 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ \r
1335 #if 0\r
1336 #ifdef PH_NDEF_MIFARE_ULC\r
1337             if (Result == NFCSTATUS_SUCCESS)\r
1338             {\r
1339 #ifdef LOCK_BITS_CHECK_ENABLE\r
1340 \r
1341                 if (NdefMap->SendRecvBuf[6] == 0x06)\r
1342                 {\r
1343                     NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   \r
1344                 } \r
1345                 else if (NdefMap->SendRecvBuf[6] == 0x12)\r
1346                 {\r
1347 //                  NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;\r
1348                     NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   \r
1349                 }               \r
1350 \r
1351 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1352 \r
1353                 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x06)\r
1354                 {\r
1355                     NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   \r
1356                 } \r
1357                 else if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x12)\r
1358                 {\r
1359 //                  NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;\r
1360                     NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;   \r
1361                 }\r
1362 \r
1363 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1364                 else\r
1365                 {\r
1366                     Result = PHNFCSTVAL(  CID_FRI_NFC_NDEF_MAP, \r
1367                                                         NFCSTATUS_INVALID_REMOTE_DEVICE);\r
1368                 }\r
1369             }\r
1370 #else   \r
1371             \r
1372         /*  Check the CC header size: Only valid ones are\r
1373                 0x06 for 48 bytes. */\r
1374 #ifdef LOCK_BITS_CHECK_ENABLE\r
1375             Result = ((( NdefMap->SendRecvBuf[6] != \r
1376 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1377             Result = ((( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] != \r
1378 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1379                         PH_FRINFC_NDEFMAP_MFUL_CC_BYTE2) || (Result != \r
1380                         NFCSTATUS_SUCCESS))?\r
1381                         (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1382                         NFCSTATUS_INVALID_REMOTE_DEVICE)):\r
1383                         Result);\r
1384 #endif /* #ifdef PH_NDEF_MIFARE_ULC */\r
1385 #endif\r
1386             NdefMap->MifareULContainer.RemainingSize = \r
1387             NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)?\r
1388 #ifdef LOCK_BITS_CHECK_ENABLE\r
1389                                     (NdefMap->SendRecvBuf[6] * \r
1390 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1391                                     (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] * \r
1392 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */\r
1393                                     PH_FRINFC_NDEFMAP_MFUL_MUL8):\r
1394                                     NdefMap->CardMemSize);\r
1395 \r
1396             if (NdefMap->CardMemSize > 256)\r
1397             {\r
1398                 NdefMap->CardMemSize = NdefMap->CardMemSize - 2;\r
1399                 NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;\r
1400             }\r
1401                 \r
1402         }\r
1403         else\r
1404         {\r
1405             NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;\r
1406         }\r
1407 \r
1408     \r
1409     return Result;\r
1410 }\r
1411 \r
1412 /*!\r
1413  * \brief this shall notify the integration software with respective\r
1414  *  success/error status along with the completion routines.\r
1415  *\r
1416  *  This routine is called from the mifareul process function.\r
1417  *\r
1418  */\r
1419 \r
1420 static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t  *NdefMap,\r
1421                                         NFCSTATUS            Status)\r
1422 {\r
1423     if(NdefMap!=NULL)\r
1424     {\r
1425         if((PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE   ==  NdefMap->State)\r
1426             &&  (NFCSTATUS_SUCCESS !=  Status))\r
1427         {\r
1428             *NdefMap->WrNdefPacketLength    =   0;\r
1429         }\r
1430         /* set the state back to the Reset_Init state*/\r
1431         NdefMap->State =  PH_FRINFC_NDEFMAP_STATE_RESET_INIT;\r
1432 \r
1433         /* set the completion routine*/\r
1434         NdefMap->CompletionRoutine[NdefMap->MifareULContainer.CRindex].\r
1435             CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);\r
1436     }\r
1437 }\r
1438 \r
1439 static NFCSTATUS   phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t  *NdefMap)\r
1440 {\r
1441     NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1442                     NFCSTATUS_INVALID_PARAMETER);\r
1443 \r
1444     NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;\r
1445 \r
1446     /*  Set the previous operation flag to read. */\r
1447     NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;\r
1448 \r
1449     /*  Have we already read the entire file? */\r
1450     if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)\r
1451     {\r
1452         /* set the data for additional data exchange */\r
1453         NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
1454         NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
1455         NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
1456         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = \r
1457                                 NdefMap->MifareULContainer.CurrentBlock;\r
1458         NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1459         *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;\r
1460         /*\r
1461          * Changed \r
1462          * Description: replace with  phHal_eMifareRead\r
1463          */\r
1464 \r
1465         NdefMap->Cmd.MfCmd =  phHal_eMifareRead;\r
1466         \r
1467         /* Call the overlapped HAL Transceive function */ \r
1468         Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,\r
1469                                                 &NdefMap->MapCompletionInfo,\r
1470                                                 NdefMap->psRemoteDevInfo,\r
1471                                                 NdefMap->Cmd,\r
1472                                                 &NdefMap->psDepAdditionalInfo,\r
1473                                                 NdefMap->SendRecvBuf,\r
1474                                                 NdefMap->SendLength,\r
1475                                                 NdefMap->SendRecvBuf,\r
1476                                                 NdefMap->SendRecvLength);\r
1477     }\r
1478     return Result;\r
1479 }\r
1480 \r
1481 static NFCSTATUS   phFriNfc_MfUL_H_Wr4bytes(  phFriNfc_NdefMap_t  *NdefMap)\r
1482 {\r
1483     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
1484 \r
1485     /* set the receive length*/\r
1486     *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;\r
1487                                     \r
1488     NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;\r
1489     \r
1490     /*\r
1491      * Changed\r
1492      * Description: phHal_eMifareCmdListMifareWrite4 replace with phHal_eMifareWrite4\r
1493      */\r
1494     /* set the cmd to mifare read*/\r
1495     NdefMap->Cmd.MfCmd = phHal_eMifareWrite4;\r
1496     \r
1497     /* Set the CR and context for Mifare operations*/\r
1498     NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;\r
1499     NdefMap->MapCompletionInfo.Context = NdefMap;\r
1500 \r
1501     NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK;\r
1502     /*Call the Overlapped HAL Transceive function */ \r
1503     Result = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,\r
1504                                         &NdefMap->MapCompletionInfo,\r
1505                                         NdefMap->psRemoteDevInfo,\r
1506                                         NdefMap->Cmd,\r
1507                                         &NdefMap->psDepAdditionalInfo,\r
1508                                         NdefMap->SendRecvBuf,\r
1509                                         NdefMap->SendLength,\r
1510                                         NdefMap->SendRecvBuf,\r
1511                                         NdefMap->SendRecvLength);\r
1512     return Result;\r
1513 }\r
1514 \r
1515 static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t     *NdefMap, \r
1516                                             uint8_t                 *CRFlag)\r
1517 {\r
1518     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
1519     uint16_t    ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
1520                 TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
1521                 Temp16Bytes = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
1522     Temp16Bytes = ((NdefMap->TLVStruct.NdefTLVByte > PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
1523                     (NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1):\r
1524                     NdefMap->TLVStruct.NdefTLVByte);\r
1525     for(;;)\r
1526     {\r
1527         if(NdefMap->SendRecvBuf[Temp16Bytes] == \r
1528                         PH_FRINFC_NDEFMAP_MFUL_NULLTLV)\r
1529         {\r
1530             NdefMap->MifareULContainer.RemainingSize -= \r
1531                         PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1532 #ifdef PH_HAL4_ENABLE\r
1533             /* This check is added to know the remaining size in \r
1534             the card is not 0, if this is 0, then complete card has \r
1535             been read */\r
1536             if (NdefMap->MifareULContainer.RemainingSize == \r
1537                         PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
1538             {\r
1539                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1540                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
1541                 break;\r
1542             }\r
1543             else\r
1544             {\r
1545                 Result = NFCSTATUS_SUCCESS;                \r
1546             }\r
1547 #else\r
1548             Result = ((NdefMap->MifareULContainer.RemainingSize == \r
1549                         PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
1550                         (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1551                                     NFCSTATUS_NO_NDEF_SUPPORT)):\r
1552                         NFCSTATUS_SUCCESS);\r
1553 #endif /* #ifdef PH_HAL4_ENABLE */\r
1554             Temp16Bytes++;\r
1555 #ifdef PH_HAL4_ENABLE\r
1556             /* This code is added to read next 16 bytes. This means previous \r
1557             16 bytes read contains only NULL TLV, so read further to get the \r
1558             NDEF TLV */\r
1559             Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1560                                                 Temp16Bytes);\r
1561             if(NFCSTATUS_SUCCESS != Result)\r
1562             {\r
1563                 NdefMap->TLVStruct.NdefTLVBlock = \r
1564                     NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL4;\r
1565                 break;\r
1566             }\r
1567 #endif /* #ifdef PH_HAL4_ENABLE */\r
1568         }\r
1569         else\r
1570         {\r
1571             Result = ((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1572                         PH_FRINFC_NDEFMAP_MFUL_TERMTLV)?\r
1573                         (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1574                                     NFCSTATUS_NO_NDEF_SUPPORT)):\r
1575                         NFCSTATUS_SUCCESS);\r
1576 \r
1577             if(Result != NFCSTATUS_SUCCESS)\r
1578             {\r
1579                 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1580                 break;\r
1581             }\r
1582             \r
1583 #ifdef PH_NDEF_MIFARE_ULC\r
1584             if ((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1585                         PH_FRINFC_NDEFMAP_MFUL_LOCK_CTRL_TLV) ||\r
1586                         (NdefMap->SendRecvBuf[Temp16Bytes] == \r
1587                         PH_FRINFC_NDEFMAP_MFUL_MEM_CTRL_TLV) )  \r
1588             {\r
1589 \r
1590                  NdefMap->TLVStruct.NdefTLVByte = \r
1591                                     ((Temp16Bytes % \r
1592                                     PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
1593                                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1594             \r
1595                  Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1596                                                 Temp16Bytes);\r
1597                 if(Result != NFCSTATUS_SUCCESS)\r
1598                 {\r
1599                     NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1600                                             PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1601                     NdefMap->TLVStruct.NoLbytesinTLV = \r
1602                                             PH_FRINFC_NDEFMAP_MFUL_VAL3;\r
1603                     break;\r
1604                 }\r
1605                 Temp16Bytes++;\r
1606                 NdefMap->MifareULContainer.RemainingSize -= \r
1607                                 PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1608 \r
1609                 if(NdefMap->MifareULContainer.RemainingSize == \r
1610                   PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
1611                 {\r
1612                     Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1613                                         NFCSTATUS_NO_NDEF_SUPPORT));\r
1614                     break;\r
1615                 }\r
1616                 \r
1617                 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1618                                                     Temp16Bytes);\r
1619                 if(Result != NFCSTATUS_SUCCESS)\r
1620                 {\r
1621                     NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1622                                         PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1623                     NdefMap->TLVStruct.NoLbytesinTLV = \r
1624                                         PH_FRINFC_NDEFMAP_MFUL_VAL3;\r
1625                     break;\r
1626                 }\r
1627 \r
1628 \r
1629                  /* If the value of the Length(L) in TLV is FF then enter else\r
1630                             check for the card memory */\r
1631                 if((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1632                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || \r
1633                     ((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1634                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && \r
1635                     (NdefMap->TLVStruct.NdefTLVFoundFlag != \r
1636                     PH_FRINFC_NDEFMAP_MFUL_FLAG1)))\r
1637                 {\r
1638                     /* In the present case, the card space is not greater \r
1639                         than 0xFF */\r
1640                     Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1641                                         NFCSTATUS_NO_NDEF_SUPPORT);\r
1642 \r
1643                     *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1644                     break;\r
1645                 }\r
1646                 else\r
1647                 {\r
1648                     NdefMap->TLVStruct.BytesRemainLinTLV = \r
1649                                     NdefMap->SendRecvBuf[Temp16Bytes];\r
1650 \r
1651                     NdefMap->TLVStruct.ActualSize = \r
1652                                     NdefMap->SendRecvBuf[Temp16Bytes];\r
1653 \r
1654                     if((NdefMap->MifareULContainer.RemainingSize < \r
1655                         NdefMap->SendRecvBuf[Temp16Bytes]) || \r
1656                         (NdefMap->MifareULContainer.RemainingSize < \r
1657                         PH_FRINFC_NDEFMAP_MFUL_VAL2) || \r
1658                         (NdefMap->TLVStruct.BytesRemainLinTLV > \r
1659                         (NdefMap->MifareULContainer.RemainingSize)) || \r
1660                         ((NdefMap->TLVStruct.BytesRemainLinTLV == \r
1661                         PH_FRINFC_NDEFMAP_MFUL_VAL0) && \r
1662                         (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))\r
1663                     {\r
1664                         /* No NDEF TLV found */\r
1665                         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1666                                             NFCSTATUS_NO_NDEF_SUPPORT);\r
1667                         *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1668                         break;\r
1669                     }\r
1670                     \r
1671                     if(NdefMap->TLVStruct.NdefTLVFoundFlag != \r
1672                         PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
1673                     {\r
1674                         NdefMap->TLVStruct.NdefTLVByte = \r
1675                                         (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +\r
1676                                         NdefMap->SendRecvBuf[Temp16Bytes]) % \r
1677                                         PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
1678                                         PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1679 #if 0                       \r
1680                         NdefMap->TLVStruct.NdefTLVBlock = \r
1681                                         (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock \r
1682                                         + ((Temp16Bytes + \r
1683                                         NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ \r
1684                                         PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
1685 #endif\r
1686                         NdefMap->TLVStruct.NdefTLVBlock = \r
1687                                         (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock / PH_FRINFC_NDEFMAP_MFUL_VAL4) * \r
1688                                             PH_FRINFC_NDEFMAP_MFUL_VAL4)\r
1689                                             + ((Temp16Bytes + NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ \r
1690                                             PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
1691 \r
1692 \r
1693                         TemLength = (Temp16Bytes + \r
1694                                 NdefMap->SendRecvBuf[Temp16Bytes]);\r
1695 \r
1696                         NdefMap->MifareULContainer.RemainingSize = \r
1697                                         (NdefMap->MifareULContainer.RemainingSize -\r
1698                                         (NdefMap->SendRecvBuf[Temp16Bytes]\r
1699                                         + PH_FRINFC_NDEFMAP_MFUL_VAL1)); \r
1700 \r
1701                         /* If the Length (L) in TLV < 16 bytes */\r
1702                         Temp16Bytes = ((TemLength >= \r
1703                                 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?\r
1704                                 PH_FRINFC_NDEFMAP_MFUL_VAL0:\r
1705                                 (TemLength + \r
1706                                 PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
1707 \r
1708                         Result = ((TemLength >= \r
1709                                 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?\r
1710                                 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
1711                                             NdefMap->TLVStruct.NdefTLVBlock):\r
1712                                 NFCSTATUS_SUCCESS);\r
1713                         \r
1714                         if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
1715                         {\r
1716                             break;\r
1717                         }\r
1718                         TemLength = Temp16Bytes;\r
1719                     }\r
1720                 }\r
1721 \r
1722 \r
1723 \r
1724 \r
1725 #if 0   \r
1726             \r
1727                  NdefMap->MifareULContainer.RemainingSize = \r
1728                                     (NdefMap->MifareULContainer.RemainingSize -\r
1729                                     (NdefMap->SendRecvBuf[Temp16Bytes + 1]\r
1730                                     + PH_FRINFC_NDEFMAP_MFUL_VAL2)); \r
1731 \r
1732                 NdefMap->TLVStruct.NdefTLVBlock = \r
1733                                     (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock \r
1734                                     + ((Temp16Bytes + \r
1735                                     NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2)/ \r
1736                                     PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
1737 \r
1738                 \r
1739                 Temp16Bytes = Temp16Bytes + \r
1740                         NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2;\r
1741 #endif                \r
1742             }\r
1743 #endif /* #ifdef PH_NDEF_MIFARE_ULC */\r
1744             else {\r
1745                 \r
1746             /* Check the byte for 0x03 Type of NDEF TLV */\r
1747             NdefMap->TLVStruct.NdefTLVFoundFlag = \r
1748                     ((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1749                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T)?\r
1750                     PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
1751                     PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
1752 \r
1753             if(NdefMap->TLVStruct.NdefTLVFoundFlag == \r
1754                 PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
1755             {\r
1756                 ShiftLength = (Temp16Bytes + \r
1757                                     NdefMap->SendRecvBuf[Temp16Bytes]);\r
1758 \r
1759                  NdefMap->TLVStruct.NdefTLVByte = \r
1760                                     ((Temp16Bytes % \r
1761                                     PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
1762                                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1763 \r
1764                 NdefMap->TLVStruct.NdefTLVBlock = \r
1765                                     (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock /4) * 4)\r
1766                                     + (Temp16Bytes)/ \r
1767                                     PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
1768                 \r
1769                 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;\r
1770                 \r
1771             }            \r
1772 #ifdef PH_HAL4_ENABLE\r
1773             else\r
1774             {\r
1775                 /* if the Type of the NDEF TLV is not found, then return  \r
1776                     error saying no ndef TLV found*/\r
1777                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1778                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
1779                 break;\r
1780 #if 0\r
1781                 /* This change is added to continue the loop, if the Type of the \r
1782                     NDEF TLV is not found \r
1783                     16 bytes are read, so for each byte, there is a check for the \r
1784                     Type (T) of the TLV, if T != 0x03, then increment the byte \r
1785                     count and restart the loop, till the T = 0x03 is found or all \r
1786                     the bytes in the card is completely read.\r
1787                 */\r
1788                 Temp16Bytes = (uint16_t)(Temp16Bytes + 1);\r
1789                 NdefMap->MifareULContainer.RemainingSize -= \r
1790                         PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1791                 if (NdefMap->MifareULContainer.RemainingSize == \r
1792                             PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
1793                 {                    \r
1794                     Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1795                                         NFCSTATUS_NO_NDEF_SUPPORT);\r
1796                     break;\r
1797                 }\r
1798                 else\r
1799                 {\r
1800                     Result = NFCSTATUS_SUCCESS;\r
1801                     Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1802                                                 Temp16Bytes);\r
1803                     if(NFCSTATUS_PENDING == Result)\r
1804                     {\r
1805                         break;\r
1806                     }\r
1807                     continue;                    \r
1808                 }\r
1809 #endif /* #if 0 */\r
1810             }\r
1811 #endif /* #ifdef PH_HAL4_ENABLE */\r
1812 \r
1813             Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1814                                                 Temp16Bytes);\r
1815             if(Result != NFCSTATUS_SUCCESS)\r
1816             {\r
1817                 NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1818                                         PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1819                 NdefMap->TLVStruct.NoLbytesinTLV = \r
1820                                         PH_FRINFC_NDEFMAP_MFUL_VAL3;\r
1821                 break;\r
1822             }\r
1823             Temp16Bytes++;\r
1824             NdefMap->MifareULContainer.RemainingSize -= \r
1825                             PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1826 \r
1827             if(NdefMap->MifareULContainer.RemainingSize == \r
1828               PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
1829             {\r
1830                 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1831                                     NFCSTATUS_NO_NDEF_SUPPORT));\r
1832                 break;\r
1833             }\r
1834             \r
1835             Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1836                                                 Temp16Bytes);\r
1837             if(Result != NFCSTATUS_SUCCESS)\r
1838             {\r
1839                 NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1840                                     PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1841                 NdefMap->TLVStruct.NoLbytesinTLV = \r
1842                                     PH_FRINFC_NDEFMAP_MFUL_VAL3;\r
1843                 break;\r
1844             }\r
1845             \r
1846             /* If the value of the Length(L) in TLV is FF then enter else\r
1847                 check for the card memory */\r
1848             if((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1849                 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || \r
1850                 ((NdefMap->SendRecvBuf[Temp16Bytes] == \r
1851                 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && \r
1852                 (NdefMap->TLVStruct.NdefTLVFoundFlag != \r
1853                 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))\r
1854             {\r
1855                 /* In the present case, the card space is not greater \r
1856                     than 0xFF */\r
1857                 /*\r
1858                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1859                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
1860 \r
1861                 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1862                 break;\r
1863                 */\r
1864 \r
1865                 Temp16Bytes++;\r
1866                 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1867                                                     Temp16Bytes);\r
1868                 if(Result != NFCSTATUS_SUCCESS)\r
1869                 {\r
1870                     NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1871                                             PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1872                     NdefMap->TLVStruct.NoLbytesinTLV = \r
1873                                             PH_FRINFC_NDEFMAP_MFUL_VAL2;\r
1874                     \r
1875                     break;\r
1876                 }\r
1877                 \r
1878                 ShiftLength = (uint16_t) NdefMap->SendRecvBuf[Temp16Bytes];\r
1879                 NdefMap->MifareULContainer.RemainingSize--;\r
1880 \r
1881                 Temp16Bytes++;\r
1882                 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,\r
1883                                                     Temp16Bytes);\r
1884                 if(Result != NFCSTATUS_SUCCESS)\r
1885                 {\r
1886                     NdefMap->TLVStruct.TcheckedinTLVFlag = \r
1887                                             PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1888                     NdefMap->TLVStruct.NoLbytesinTLV = \r
1889                                             PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
1890                     NdefMap->TLVStruct.prevLenByteValue = \r
1891                                     NdefMap->SendRecvBuf[Temp16Bytes - 1];\r
1892                     break;\r
1893                 }\r
1894 \r
1895 \r
1896                 ShiftLength = \r
1897                     (uint16_t) (NdefMap->SendRecvBuf[Temp16Bytes]\r
1898                          | (ShiftLength << PH_FRINFC_NDEFMAP_MFUL_SHIFT8));\r
1899 \r
1900     //          NdefMap->MifareULContainer.RemainingSize--;\r
1901 \r
1902                 if(ShiftLength > (NdefMap->MifareULContainer.RemainingSize))\r
1903                 {\r
1904                     // Size in the Length(L) of TLV is greater \r
1905                     //than the actual size of the card \r
1906                     Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1907                                         NFCSTATUS_INVALID_PARAMETER);\r
1908                     *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1909                     break;\r
1910                 }\r
1911 \r
1912         //      NdefMap->MifareULContainer.RemainingSize--;\r
1913                 /*\r
1914                 NdefMap->TLVStruct.NdefTLVByte = \r
1915                                     (NdefMap->SendRecvBuf[Temp16Bytes] % \r
1916                                     PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
1917                 \r
1918                 NdefMap->TLVStruct.NdefTLVBlock = \r
1919                                 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock \r
1920                             + (Temp16Bytes/PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
1921                 */  \r
1922                 \r
1923                 NdefMap->TLVStruct.ActualSize = \r
1924                     NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;\r
1925                     \r
1926                 NdefMap->TLVStruct.NdefTLVFoundFlag = 1;\r
1927                 \r
1928                 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;\r
1929 \r
1930                 \r
1931                 Result = ((NdefMap->TLVStruct.NoLbytesinTLV == \r
1932                                     PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
1933                                     phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):\r
1934                                     Result);\r
1935 /*  \r
1936                 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
1937                                                     NdefMap->TLVStruct.NdefTLVBlock);\r
1938 */\r
1939                 break;\r
1940             }\r
1941             else\r
1942             {\r
1943                 NdefMap->TLVStruct.BytesRemainLinTLV = \r
1944                                 NdefMap->SendRecvBuf[Temp16Bytes];\r
1945 \r
1946                 NdefMap->TLVStruct.ActualSize = \r
1947                                 NdefMap->SendRecvBuf[Temp16Bytes];\r
1948 \r
1949                 if((NdefMap->MifareULContainer.RemainingSize < \r
1950                     NdefMap->SendRecvBuf[Temp16Bytes]) || \r
1951                     (NdefMap->MifareULContainer.RemainingSize < \r
1952                     PH_FRINFC_NDEFMAP_MFUL_VAL2) || \r
1953                     (NdefMap->TLVStruct.BytesRemainLinTLV > \r
1954                     (NdefMap->MifareULContainer.RemainingSize)) || \r
1955                     ((NdefMap->TLVStruct.BytesRemainLinTLV == \r
1956                     PH_FRINFC_NDEFMAP_MFUL_VAL0) && \r
1957                     (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))\r
1958                 {\r
1959                     /* No NDEF TLV found */\r
1960                     Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
1961                                         NFCSTATUS_NO_NDEF_SUPPORT);\r
1962                     *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
1963                     break;\r
1964                 }\r
1965                 \r
1966                 if(NdefMap->TLVStruct.NdefTLVFoundFlag != \r
1967                     PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
1968                 {\r
1969                     NdefMap->TLVStruct.NdefTLVByte = \r
1970                                     (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +\r
1971                                     NdefMap->SendRecvBuf[Temp16Bytes]) % \r
1972                                     PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
1973                                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
1974                     NdefMap->TLVStruct.NdefTLVBlock = \r
1975                                     (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock \r
1976                                     + ((Temp16Bytes + \r
1977                                     NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ \r
1978                                     PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
1979 \r
1980                     TemLength = (Temp16Bytes + \r
1981                             NdefMap->SendRecvBuf[Temp16Bytes]);\r
1982 \r
1983                     NdefMap->MifareULContainer.RemainingSize = \r
1984                                     (NdefMap->MifareULContainer.RemainingSize -\r
1985                                     (NdefMap->SendRecvBuf[Temp16Bytes]\r
1986                                     + PH_FRINFC_NDEFMAP_MFUL_VAL1)); \r
1987 \r
1988                     /* If the Length (L) in TLV < 16 bytes */\r
1989                     Temp16Bytes = ((TemLength >= \r
1990                             PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?\r
1991                             PH_FRINFC_NDEFMAP_MFUL_VAL0:\r
1992                             (TemLength + \r
1993                             PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
1994 \r
1995                     Result = ((TemLength >= \r
1996                             PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?\r
1997                             phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
1998                                         NdefMap->TLVStruct.NdefTLVBlock):\r
1999                             NFCSTATUS_SUCCESS);\r
2000                     \r
2001                     if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
2002                     {\r
2003                         break;\r
2004                     }\r
2005                     TemLength = Temp16Bytes;\r
2006                 }\r
2007             }\r
2008             if(NdefMap->TLVStruct.NdefTLVFoundFlag == \r
2009                         PH_FRINFC_NDEFMAP_MFUL_FLAG1)\r
2010             {\r
2011 #if 0\r
2012                 NdefMap->TLVStruct.NdefTLVBlock = \r
2013                                     (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock \r
2014                                     + ((Temp16Bytes + 1)/ \r
2015                                     PH_FRINFC_NDEFMAP_MFUL_VAL4)) - 1;\r
2016 #endif\r
2017                 NdefMap->MifareULContainer.RemainingSize = \r
2018                                     (NdefMap->MifareULContainer.RemainingSize -\r
2019                                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2020                     ShiftLength = NdefMap->SendRecvBuf[Temp16Bytes];\r
2021                     Result = ((NdefMap->TLVStruct.NoLbytesinTLV == \r
2022                             PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
2023                             phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):\r
2024                             Result);\r
2025 \r
2026                 break;\r
2027             }\r
2028         }\r
2029         }   \r
2030     }\r
2031 \r
2032     return Result;\r
2033 }\r
2034 \r
2035 \r
2036 static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t   *NdefMap,\r
2037                                             uint16_t             TempLength)\r
2038 {\r
2039     uint16_t localCurrentBlock;\r
2040     \r
2041     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2042     if(TempLength == PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)\r
2043     {\r
2044         localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock +\r
2045                             PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
2046 \r
2047         if (localCurrentBlock < 256)\r
2048         {\r
2049             NdefMap->MifareULContainer.CurrentBlock += \r
2050                                 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;\r
2051                         \r
2052             Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
2053                             NdefMap->MifareULContainer.CurrentBlock);\r
2054         }\r
2055         else \r
2056         {\r
2057             /* Go to next sector */\r
2058             NdefMap->MifareULContainer.CurrentSector++;\r
2059 \r
2060             Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
2061                 NdefMap->MifareULContainer.CurrentSector, 1, \r
2062                 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1);\r
2063         }\r
2064     }\r
2065 \r
2066     return Result;\r
2067 }\r
2068 \r
2069 \r
2070 static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch, \r
2071                                           uint16_t *lpwCrc )\r
2072 {\r
2073     ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF));\r
2074     ch = (ch^(ch<<4));\r
2075     *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^ \\r
2076                 ((uint16_t)ch<<3)^((uint16_t)ch>>4);\r
2077     \r
2078     return;\r
2079 }\r
2080 \r
2081 static void phFriNfc_MfUL_H_ComputeCrc( int      CRCType, \r
2082                                  uint8_t  *Data, \r
2083                                  int      Length,\r
2084                                  uint8_t  *TransmitFirst, \r
2085                                  uint8_t  *TransmitSecond\r
2086                                  )\r
2087 {\r
2088     uint8_t chBlock;\r
2089     uint16_t wCrc;\r
2090     switch(CRCType) \r
2091     {\r
2092     case CRC_A:\r
2093         wCrc = 0x6363; /* ITU-V.41 */\r
2094         break;\r
2095     case CRC_B:\r
2096         wCrc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */\r
2097         break;\r
2098     default:\r
2099         return;\r
2100     }\r
2101 \r
2102     do \r
2103     {\r
2104         chBlock = *Data++;\r
2105         phFriNfc_MfUL_H_UpdateCrc(chBlock, &wCrc);\r
2106     } while (--Length);\r
2107     *TransmitFirst = (uint8_t) (wCrc & 0xFF);\r
2108     *TransmitSecond = (uint8_t) ((wCrc >> 8) & 0xFF);\r
2109     return;\r
2110 }\r
2111 \r
2112 \r
2113 \r
2114 static NFCSTATUS  phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t  *NdefMap,\r
2115                                                    uint8_t              SectorNo,\r
2116                                                    uint8_t              CmdNo,\r
2117                                                    uint8_t              NextState)\r
2118 {\r
2119     \r
2120     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2121 \r
2122     /* set the data for additional data exchange */\r
2123     NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2124     NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2125     NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2126 \r
2127     NdefMap->State = NextState;\r
2128 \r
2129     if (CmdNo == 1)\r
2130     {\r
2131         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;\r
2132         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;\r
2133         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0xC2;\r
2134         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0xFF;\r
2135         NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL4;                                               \r
2136     }\r
2137     else\r
2138     {\r
2139         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;\r
2140         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;\r
2141         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = SectorNo;\r
2142         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0;\r
2143         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL4] = 0;\r
2144         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL5] = 0;\r
2145         NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL5 + 1;\r
2146     }\r
2147     \r
2148     /* Calculate CRC */\r
2149 \r
2150     phFriNfc_MfUL_H_ComputeCrc(CRC_A, &NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2], \r
2151             NdefMap->SendLength - 2, \r
2152             &NdefMap->SendRecvBuf[NdefMap->SendLength], \r
2153             &NdefMap->SendRecvBuf[NdefMap->SendLength + 1]);\r
2154     \r
2155     NdefMap->SendLength += PH_FRINFC_NDEFMAP_MFUL_VAL2; \r
2156 \r
2157     \r
2158     *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;\r
2159      \r
2160     NdefMap->Cmd.MfCmd = phHal_eMifareRaw;\r
2161      \r
2162     /* Call the overlapped HAL Transceive function */ \r
2163     Result = phFriNfc_OvrHal_Transceive(     NdefMap->LowerDevice,\r
2164                                              &NdefMap->MapCompletionInfo,\r
2165                                              NdefMap->psRemoteDevInfo,\r
2166                                              NdefMap->Cmd,\r
2167                                              &NdefMap->psDepAdditionalInfo,\r
2168                                              NdefMap->SendRecvBuf,\r
2169                                              NdefMap->SendLength,\r
2170                                              NdefMap->SendRecvBuf,\r
2171                                              NdefMap->SendRecvLength);\r
2172      return Result;\r
2173 }\r
2174 \r
2175 \r
2176 static NFCSTATUS   phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t  *NdefMap,\r
2177                                                    uint8_t              BlockNo)\r
2178 {\r
2179     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2180     NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;\r
2181     /* set the data for additional data exchange */\r
2182     NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2183     NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2184     NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2185     NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = \r
2186                                                     BlockNo;\r
2187     NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
2188     *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;\r
2189     \r
2190     /* \r
2191      * Changed \r
2192      * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead\r
2193      */\r
2194     NdefMap->Cmd.MfCmd = phHal_eMifareRead;\r
2195     \r
2196     /* Call the overlapped HAL Transceive function */ \r
2197     Result = phFriNfc_OvrHal_Transceive(    NdefMap->LowerDevice,\r
2198                                             &NdefMap->MapCompletionInfo,\r
2199                                             NdefMap->psRemoteDevInfo,\r
2200                                             NdefMap->Cmd,\r
2201                                             &NdefMap->psDepAdditionalInfo,\r
2202                                             NdefMap->SendRecvBuf,\r
2203                                             NdefMap->SendLength,\r
2204                                             NdefMap->SendRecvBuf,\r
2205                                             NdefMap->SendRecvLength);\r
2206     return Result;\r
2207 }\r
2208 \r
2209 static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t  *NdefMap,\r
2210                                               uint8_t             *CRFlag)\r
2211 {\r
2212     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2213     uint16_t    TempLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
2214                 ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2215 \r
2216     switch(NdefMap->TLVStruct.NoLbytesinTLV)\r
2217     {\r
2218         case PH_FRINFC_NDEFMAP_MFUL_VAL1:\r
2219         case PH_FRINFC_NDEFMAP_MFUL_VAL2:\r
2220             ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == \r
2221                             PH_FRINFC_NDEFMAP_MFUL_VAL1)?\r
2222                             NdefMap->TLVStruct.prevLenByteValue:\r
2223                             NdefMap->SendRecvBuf[TempLength]);\r
2224             ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == \r
2225                             PH_FRINFC_NDEFMAP_MFUL_VAL1)?\r
2226                             (((uint16_t)(NdefMap->SendRecvBuf[TempLength]) << \r
2227                             PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | \r
2228                             ShiftLength):\r
2229                             (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + \r
2230                             PH_FRINFC_NDEFMAP_MFUL_VAL1)]) << \r
2231                             PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | \r
2232                             ShiftLength));\r
2233 \r
2234             NdefMap->MifareULContainer.RemainingSize -= \r
2235                                             PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
2236 \r
2237             NdefMap->TLVStruct.ActualSize = \r
2238             NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;\r
2239 \r
2240             /* Check for remaining free space in the card with the \r
2241                 length (L) of TLV OR length(L) of TLV is less than \r
2242                 255 bytes (The length (L) of TLV for 3 byte should not \r
2243                 be less than 255) */ \r
2244             Result = ((((NdefMap->MifareULContainer.RemainingSize)<= \r
2245                         ShiftLength) || (ShiftLength < \r
2246                         PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF))?\r
2247                         (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2248                         NFCSTATUS_INVALID_PARAMETER)):\r
2249                         Result);\r
2250 \r
2251             \r
2252             Result = ((Result == NFCSTATUS_SUCCESS)?\r
2253                             phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):\r
2254                             Result);\r
2255 \r
2256             *CRFlag = (uint8_t)((Result == (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2257                         NFCSTATUS_INVALID_PARAMETER)))?\r
2258                         PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
2259                         PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
2260 \r
2261 \r
2262             if(Result == NFCSTATUS_SUCCESS)\r
2263             {\r
2264 \r
2265                 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-\r
2266                     NdefMap->TLVStruct.NoLbytesinTLV;\r
2267 /*              \r
2268                 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% \r
2269                         PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
2270                         PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2271                        \r
2272                 NdefMap->TLVStruct.NdefTLVBlock = \r
2273                         (uint8_t)(NdefMap->MifareULContainer.CurrentBlock \r
2274                         + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
2275                 NdefMap->MifareULContainer.CurrentBlock = \r
2276                                 NdefMap->TLVStruct.NdefTLVBlock;\r
2277 \r
2278                 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, \r
2279                                                 NdefMap->TLVStruct.NdefTLVBlock);\r
2280                                                 */\r
2281             }\r
2282             break;      \r
2283 \r
2284         default:\r
2285             if((NdefMap->SendRecvBuf[TempLength] == \r
2286                 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || \r
2287                 ((NdefMap->SendRecvBuf[TempLength] == \r
2288                 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && \r
2289                 (NdefMap->TLVStruct.NdefTLVFoundFlag != \r
2290                 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))\r
2291             {\r
2292                 /* In the present case, the card space is not greater \r
2293                     than 0xFF */\r
2294 /*                    \r
2295                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2296                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
2297 \r
2298                 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
2299                 \r
2300 */\r
2301             \r
2302                 ShiftLength = NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL1)];\r
2303                 ShiftLength = (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL2)]) \r
2304                                 << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | \r
2305                                 ShiftLength);\r
2306                 Result = ((ShiftLength > (NdefMap->MifareULContainer.RemainingSize))?\r
2307                             (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2308                             NFCSTATUS_INVALID_PARAMETER)):\r
2309                             Result);\r
2310 \r
2311                             \r
2312                 Result = ((Result == NFCSTATUS_SUCCESS)?\r
2313                                             phFriNfc_MapTool_SetCardState(  NdefMap, ShiftLength):\r
2314                                             Result);\r
2315 \r
2316                 NdefMap->TLVStruct.ActualSize = \r
2317                     NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;\r
2318                 \r
2319                 if(Result == NFCSTATUS_SUCCESS)\r
2320                 {\r
2321                     \r
2322                     NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-\r
2323                     NdefMap->TLVStruct.NoLbytesinTLV;\r
2324 /*                  \r
2325                     NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% \r
2326                         PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
2327                         PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2328                         \r
2329                     NdefMap->TLVStruct.NdefTLVBlock = \r
2330                         (uint8_t)(NdefMap->MifareULContainer.CurrentBlock \r
2331                         + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
2332 \r
2333                     NdefMap->MifareULContainer.CurrentBlock = \r
2334                                 NdefMap->TLVStruct.NdefTLVBlock;\r
2335 \r
2336                     Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
2337                                                         NdefMap->TLVStruct.NdefTLVBlock);\r
2338 */\r
2339                 }\r
2340             }\r
2341             else\r
2342             {\r
2343                 /* length (L) value in TLV shall not be greater than \r
2344                     remaining free space in the card */\r
2345                 Result = ((NdefMap->SendRecvBuf[TempLength] > \r
2346                     NdefMap->MifareULContainer.RemainingSize)?\r
2347                         (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2348                         NFCSTATUS_INVALID_PARAMETER)):\r
2349                         Result);\r
2350 \r
2351                 NdefMap->TLVStruct.ActualSize = \r
2352                 NdefMap->TLVStruct.BytesRemainLinTLV = \r
2353                                 NdefMap->SendRecvBuf[TempLength];\r
2354                 NdefMap->MifareULContainer.RemainingSize--;\r
2355 \r
2356                 if((Result == NFCSTATUS_SUCCESS) && \r
2357                     (NdefMap->TLVStruct.NdefTLVFoundFlag != \r
2358                     PH_FRINFC_NDEFMAP_MFUL_FLAG1))\r
2359                 {\r
2360                     phFriNfc_MfUL_H_UpdateLen(NdefMap, \r
2361                                 (uint16_t)NdefMap->SendRecvBuf[TempLength]);\r
2362                     \r
2363                     NdefMap->MifareULContainer.CurrentBlock =  \r
2364                                         NdefMap->TLVStruct.NdefTLVBlock;\r
2365                     TempLength=TempLength+(NdefMap->SendRecvBuf[TempLength]);\r
2366                     Result =((TempLength < PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?\r
2367                             phFriNfc_MfUL_H_findNDEFTLV(NdefMap, CRFlag):\r
2368                             phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,\r
2369                                     NdefMap->TLVStruct.NdefTLVBlock));\r
2370                 }\r
2371             }\r
2372             break;\r
2373     }\r
2374     NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2375 \r
2376     Result = phFriNfc_MapTool_SetCardState(  NdefMap, NdefMap->TLVStruct.ActualSize);\r
2377 \r
2378     return Result;\r
2379 }\r
2380 \r
2381 static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t        *NdefMap,\r
2382                                       uint16_t                  DataLen) \r
2383 {\r
2384     NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-DataLen;\r
2385     NdefMap->TLVStruct.NdefTLVByte = ((DataLen % \r
2386                         PH_FRINFC_NDEFMAP_MFUL_VAL4) + \r
2387                         PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2388     NdefMap->TLVStruct.NdefTLVBlock = \r
2389                         (uint8_t)(NdefMap->MifareULContainer.CurrentBlock \r
2390                         + (DataLen/PH_FRINFC_NDEFMAP_MFUL_VAL4));\r
2391 }\r
2392 \r
2393  static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t       *NdefMap,\r
2394                                        uint8_t                  *CRFlag)\r
2395 {\r
2396     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2397   \r
2398     switch(NdefMap->PrevOperation)\r
2399     {\r
2400         case PH_FRINFC_NDEFMAP_CHECK_OPE:\r
2401             *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
2402                         /* Fix to check if the actual size in the TLV is greater than card */\r
2403             if (NdefMap->TLVStruct.ActualSize > (NdefMap->CardMemSize - 2))\r
2404             {\r
2405                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2406                                     NFCSTATUS_NO_NDEF_SUPPORT);\r
2407             }\r
2408             break;\r
2409 \r
2410         case PH_FRINFC_NDEFMAP_READ_OPE:\r
2411             if (NdefMap->TLVStruct.NdefTLVSector == 1)\r
2412             {\r
2413                 /* Goto sector 1 */\r
2414                 NdefMap->MifareULContainer.CurrentSector = 1;\r
2415                 NdefMap->MifareULContainer.CurrentBlock = 0;\r
2416                 \r
2417                 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
2418                         NdefMap->MifareULContainer.CurrentSector, 1, \r
2419                         PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1); \r
2420             }\r
2421             else\r
2422             {\r
2423                 NdefMap->MifareULContainer.CurrentBlock = (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;\r
2424 \r
2425                 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);\r
2426             }\r
2427 #if 0           \r
2428             NdefMap->MifareULContainer.CurrentBlock = \r
2429                 PH_FRINFC_NDEFMAP_MFUL_VAL4;\r
2430 \r
2431              Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);\r
2432 #endif\r
2433       \r
2434 \r
2435             *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)?\r
2436                         PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
2437                         PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
2438             break;\r
2439 \r
2440         case PH_FRINFC_NDEFMAP_WRITE_OPE:\r
2441             break;\r
2442 \r
2443         default:\r
2444             break;\r
2445     }\r
2446     return Result;\r
2447 }\r
2448 \r
2449 \r
2450 \r
2451 static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t  *NdefMap)\r
2452 {\r
2453     NFCSTATUS Result = NFCSTATUS_SUCCESS;\r
2454     uint16_t localCurrentBlock;\r
2455 \r
2456 #ifndef NDEF_READ_CHANGE\r
2457         uint16_t                        v_field_byte = 0;\r
2458 \r
2459         if (NdefMap->MifareULContainer.CurrentBlock \r
2460                 == NdefMap->TLVStruct.NdefTLVBlock)\r
2461         {\r
2462                 if (NdefMap->CardMemSize > (0x12 * PH_FRINFC_NDEFMAP_MFUL_MUL8))\r
2463                 {\r
2464                         v_field_byte = NdefMap->TLVStruct.NdefTLVByte;\r
2465                 }\r
2466 \r
2467                 /* Calculate the Value field of the TLV to read */\r
2468                 if (NdefMap->TLVStruct.ActualSize >= 0xFF)\r
2469                 {\r
2470                         \r
2471                         /* here \r
2472                                 3 is the 3 LENGTH bytes to skip  \r
2473                                 4 is the block size\r
2474                                 1 is to increment the byte number\r
2475                         */\r
2476                         v_field_byte = (uint16_t)\r
2477                                                         (((v_field_byte + 3) % 4) + 1);\r
2478                 }\r
2479                 else\r
2480                 {\r
2481                         /* less than 0xFF */\r
2482 #if 0\r
2483                         if ((0x03 == v_field_byte) \r
2484                                 || (0x04 == v_field_byte))\r
2485                         {\r
2486                                 /*\r
2487                                         here \r
2488                                         1 is the 1 LENGTH byte to skip  \r
2489                                         4 is the block size\r
2490                                         1 is to increment the byte number\r
2491                                 */\r
2492                                 v_field_byte = (uint16_t)\r
2493                                                                 (((v_field_byte + 1) % 4) + 1);\r
2494                         }\r
2495                         else\r
2496                         {\r
2497                                 v_field_byte = (uint16_t)\r
2498                                                                 (v_field_byte + 1);\r
2499                         }       \r
2500 #endif /* #if 0 */\r
2501                 }\r
2502         }\r
2503 #endif /* #ifndef NDEF_READ_CHANGE */\r
2504 \r
2505 #ifndef NDEF_READ_CHANGE\r
2506         (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[ \r
2507                 NdefMap->MifareULContainer.ReadBufIndex]),\r
2508                 (void *)(NdefMap->SendRecvBuf + v_field_byte),\r
2509                 (*NdefMap->SendRecvLength - v_field_byte));\r
2510 \r
2511         NdefMap->MifareULContainer.ReadBufIndex = (uint16_t)\r
2512                 (NdefMap->MifareULContainer.ReadBufIndex + \r
2513                 (*NdefMap->SendRecvLength - v_field_byte));\r
2514 #else /* #ifndef NDEF_READ_CHANGE */\r
2515 \r
2516     (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[ \r
2517                 NdefMap->MifareULContainer.ReadBufIndex]),\r
2518                 NdefMap->SendRecvBuf,\r
2519                 *NdefMap->SendRecvLength);\r
2520 \r
2521     NdefMap->MifareULContainer.ReadBufIndex=NdefMap->MifareULContainer.ReadBufIndex +*NdefMap->SendRecvLength;\r
2522 #endif /* #ifndef NDEF_READ_CHANGE */\r
2523 \r
2524     localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock+\r
2525                             (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != \r
2526                             NdefMap->CardMemSize)?\r
2527                             PH_FRINFC_NDEFMAP_MFUL_BLOCK4:\r
2528                             PH_FRINFC_NDEFMAP_MFUL_VAL0);\r
2529     if (localCurrentBlock < 256)\r
2530     {\r
2531         NdefMap->MifareULContainer.CurrentBlock =  NdefMap->MifareULContainer.CurrentBlock+\r
2532                             (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != \r
2533                             NdefMap->CardMemSize)?\r
2534                             PH_FRINFC_NDEFMAP_MFUL_BLOCK4:\r
2535                             PH_FRINFC_NDEFMAP_MFUL_VAL0);\r
2536     }\r
2537     else \r
2538     {\r
2539         /* Go to next sector */\r
2540         if (NdefMap->MifareULContainer.CurrentSector == 0)\r
2541         {\r
2542             NdefMap->MifareULContainer.CurrentSector++;\r
2543             NdefMap->MifareULContainer.CurrentBlock = 0xff;\r
2544             \r
2545             Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
2546                     NdefMap->MifareULContainer.CurrentSector, 1, \r
2547                     PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);\r
2548         }\r
2549     }\r
2550    \r
2551     return Result;\r
2552 }\r
2553 \r
2554 static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap)\r
2555 {\r
2556     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2557     \r
2558     /* Check the user buffer size with the \r
2559     L value of TLV */\r
2560     if(NdefMap->ApduBufferSize >=\r
2561         NdefMap->TLVStruct.BytesRemainLinTLV)\r
2562     {\r
2563         (void)memcpy(NdefMap->ApduBuffer,\r
2564             &(NdefMap->MifareULContainer.ReadBuf[ \r
2565             NdefMap->MifareULContainer.ByteNumber]),\r
2566             NdefMap->TLVStruct.BytesRemainLinTLV);\r
2567 \r
2568         *(NdefMap->NumOfBytesRead) = \r
2569                     NdefMap->TLVStruct.BytesRemainLinTLV;\r
2570         NdefMap->MifareULContainer.ByteNumber = \r
2571                                 PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2572         NdefMap->MifareULContainer.ReadWriteCompleteFlag = \r
2573                                 PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
2574         NdefMap->MifareULContainer.RemainingSize =  NdefMap->MifareULContainer.RemainingSize-\r
2575                                                     NdefMap->TLVStruct.BytesRemainLinTLV;\r
2576         NdefMap->TLVStruct.BytesRemainLinTLV = \r
2577                                 PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2578     }\r
2579     else\r
2580     {\r
2581         (void)memcpy(NdefMap->ApduBuffer,\r
2582             &(NdefMap->MifareULContainer.ReadBuf[ \r
2583             NdefMap->MifareULContainer.ByteNumber]),\r
2584             NdefMap->ApduBufferSize);\r
2585 \r
2586         *(NdefMap->NumOfBytesRead) = \r
2587                     NdefMap->ApduBufferSize;\r
2588         NdefMap->MifareULContainer.ByteNumber = NdefMap->MifareULContainer.ByteNumber+\r
2589                                                 (uint16_t)NdefMap->ApduBufferSize;\r
2590         NdefMap->MifareULContainer.RemainingSize=NdefMap->MifareULContainer.RemainingSize-\r
2591                                                      (uint16_t)NdefMap->ApduBufferSize;\r
2592         NdefMap->TLVStruct.BytesRemainLinTLV =  NdefMap->TLVStruct.BytesRemainLinTLV-\r
2593                     (uint16_t)NdefMap->ApduBufferSize;\r
2594     }\r
2595     return Result;\r
2596 }\r
2597 \r
2598 static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t       *NdefMap)\r
2599 {\r
2600     uint16_t localCurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;\r
2601 \r
2602     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2603     uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
2604                 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2605     /*            BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;*/\r
2606     uint16_t    TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2607     \r
2608     switch((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1))\r
2609     {\r
2610         case PH_FRINFC_NDEFMAP_MFUL_VAL0:\r
2611             /* go the NDEF TLV block to start write */\r
2612             NdefMap->MifareULContainer.CurrentBlock = \r
2613                 NdefMap->TLVStruct.NdefTLVBlock;\r
2614             /* fill send buffer for write */\r
2615             NdefMap->SendRecvBuf[index] = \r
2616                                 NdefMap->MifareULContainer.CurrentBlock;\r
2617             index++;\r
2618             NdefMap->SendRecvBuf[index] = \r
2619                                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T;\r
2620             index++;\r
2621             if (NdefMap->ApduBufferSize > 254)\r
2622             {\r
2623                 NdefMap->SendRecvBuf[index] = 0xFF;\r
2624                 index++;\r
2625                 NdefMap->SendRecvBuf[index] = \r
2626                                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2627                 index++;\r
2628                 NdefMap->SendRecvBuf[index] = \r
2629                                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2630                 index++;\r
2631             }\r
2632             else\r
2633             {\r
2634                 NdefMap->SendRecvBuf[index] = \r
2635                                     PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2636                 index++;    \r
2637             }\r
2638             \r
2639 \r
2640             break;\r
2641 \r
2642         case PH_FRINFC_NDEFMAP_MFUL_VAL1:\r
2643         case PH_FRINFC_NDEFMAP_MFUL_VAL2:\r
2644             /* read to get the previous bytes */\r
2645             Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, \r
2646                             NdefMap->TLVStruct.NdefTLVBlock);\r
2647             break;\r
2648 \r
2649         case PH_FRINFC_NDEFMAP_MFUL_VAL3:\r
2650             \r
2651             localCurrentBlock = (NdefMap->MifareULContainer.CurrentBlock + \r
2652                                 PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2653 \r
2654             if (localCurrentBlock < 256)\r
2655             {\r
2656             \r
2657                 NdefMap->MifareULContainer.CurrentBlock = \r
2658                             (NdefMap->MifareULContainer.CurrentBlock + \r
2659                                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2660                 NdefMap->SendRecvBuf[index] = \r
2661                                     NdefMap->MifareULContainer.CurrentBlock;\r
2662                 index++;\r
2663 \r
2664                 if (NdefMap->ApduBufferSize > 254)\r
2665                 {\r
2666                     NdefMap->SendRecvBuf[index] = 0xFF;\r
2667                     index++;\r
2668                     NdefMap->SendRecvBuf[index] = \r
2669                                         PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2670                     index++;\r
2671                     NdefMap->SendRecvBuf[index] = \r
2672                                         PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2673                     index++;\r
2674                 }\r
2675                 else\r
2676                 {\r
2677                     NdefMap->SendRecvBuf[index] = \r
2678                                         PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2679                     index++;    \r
2680                 }\r
2681             }\r
2682             else\r
2683             {\r
2684                 /* Go to next sector */\r
2685                 NdefMap->MifareULContainer.CurrentSector++;\r
2686 \r
2687                 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
2688                     NdefMap->MifareULContainer.CurrentSector, 1, \r
2689                     PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1);\r
2690             }\r
2691             break;\r
2692 \r
2693         default:\r
2694             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2695                                 NFCSTATUS_INVALID_REMOTE_DEVICE);\r
2696             break;\r
2697     }\r
2698 \r
2699     if((((NdefMap->TLVStruct.NdefTLVByte - \r
2700         PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || \r
2701         ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) \r
2702         == PH_FRINFC_NDEFMAP_MFUL_VAL3)) && localCurrentBlock < 256)\r
2703     {\r
2704         /* Length to know how many bytes has to be written to the card */\r
2705         TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == \r
2706                         PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
2707                         PH_FRINFC_NDEFMAP_MFUL_VAL2:\r
2708                         PH_FRINFC_NDEFMAP_MFUL_VAL3);\r
2709 \r
2710         if (NdefMap->ApduBufferSize > 254)\r
2711         {\r
2712             TemLength -= 2;\r
2713         }\r
2714 \r
2715         if(NdefMap->ApduBufferSize >= TemLength)\r
2716         {\r
2717             /* Prepare the receive buffer */\r
2718             (void)memcpy(&(NdefMap->SendRecvBuf[ \r
2719                             index]),\r
2720                             &(NdefMap->ApduBuffer[ \r
2721                             NdefMap->ApduBuffIndex]),\r
2722                             TemLength);\r
2723 \r
2724             /* Number of bytes written to the card from user buffer */\r
2725             NdefMap->NumOfBytesWritten = TemLength;\r
2726 \r
2727             index = index+(uint8_t)TemLength;\r
2728             /* Exact number of bytes written in the card including TLV */\r
2729             if (index >= 1)\r
2730             {\r
2731                 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2732             }\r
2733             else\r
2734             {\r
2735                 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2736                                 NFCSTATUS_INVALID_REMOTE_DEVICE);\r
2737             }\r
2738         }\r
2739         else\r
2740         {\r
2741             /* Prepare the receive buffer */\r
2742             (void)memcpy(&(NdefMap->SendRecvBuf[ \r
2743                             index]),\r
2744                             &(NdefMap->ApduBuffer[ \r
2745                             NdefMap->ApduBuffIndex]),\r
2746                             (uint16_t)NdefMap->ApduBufferSize);\r
2747 \r
2748             /* Number of bytes written to the card from user buffer */\r
2749             NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;\r
2750 \r
2751             index= index +(uint8_t)NdefMap->ApduBufferSize;\r
2752             /* Exact number of bytes written in the card including TLV */\r
2753             *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2754 \r
2755             for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)\r
2756             {\r
2757                 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?\r
2758                         PH_FRINFC_NDEFMAP_MFUL_TERMTLV:\r
2759                         PH_FRINFC_NDEFMAP_MFUL_NULLTLV);\r
2760                 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
2761             }\r
2762         }\r
2763 \r
2764         /* store the bytes in buffer till the bytes are \r
2765             written in a block */\r
2766         (void)memcpy(NdefMap->MifareULContainer.Buffer,\r
2767                         &(NdefMap->SendRecvBuf[ \r
2768                         PH_FRINFC_NDEFMAP_MFUL_VAL1]), \r
2769                         (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - \r
2770                         PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
2771 \r
2772         (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,\r
2773                     NdefMap->MifareULContainer.Buffer,\r
2774                     (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - \r
2775                         PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
2776         \r
2777         /* Change the state to check ndef compliancy */\r
2778         NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
2779 \r
2780         Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);\r
2781     }\r
2782     return Result;\r
2783 }\r
2784 \r
2785 static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t        *NdefMap)\r
2786 {\r
2787     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2788    /* uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL1;*/\r
2789     \r
2790     \r
2791     NdefMap->MifareULContainer.CurrentBlock = \r
2792                         NdefMap->TLVStruct.NdefTLVBlock;\r
2793         \r
2794     (void)memcpy(&(NdefMap->SendRecvBuf[ \r
2795                 PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
2796                 NdefMap->SendRecvBuf,\r
2797                 PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
2798 \r
2799     NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = \r
2800                             NdefMap->MifareULContainer.CurrentBlock;\r
2801 \r
2802     if (NdefMap->ApduBufferSize > 254)\r
2803     {\r
2804          NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + \r
2805                             PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 0xFF;\r
2806                             \r
2807 \r
2808         if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < \r
2809             PH_FRINFC_NDEFMAP_MFUL_VAL4)\r
2810         {\r
2811             NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + \r
2812                             PH_FRINFC_NDEFMAP_MFUL_VAL2 )] = 0x00;\r
2813 \r
2814             NdefMap->NumOfLReminWrite = 1;\r
2815 \r
2816         }\r
2817         else\r
2818         {\r
2819             NdefMap->NumOfLReminWrite = 2;\r
2820         }\r
2821         NdefMap->NumOfBytesWritten = 0; \r
2822     }\r
2823     else\r
2824     {\r
2825         /* Write the length value = 0 */\r
2826         NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + \r
2827                                 PH_FRINFC_NDEFMAP_MFUL_VAL1)] = \r
2828                                 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;\r
2829 \r
2830         if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < \r
2831             PH_FRINFC_NDEFMAP_MFUL_VAL4)\r
2832         {\r
2833             /* Only one byte  */\r
2834             (void)memcpy(&(NdefMap->SendRecvBuf[ \r
2835                     PH_FRINFC_NDEFMAP_MFUL_VAL4]),\r
2836                     &(NdefMap->ApduBuffer[ \r
2837                     NdefMap->ApduBuffIndex]),\r
2838                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2839             /* Number of bytes written to the card from user buffer */\r
2840             NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
2841         }\r
2842     }\r
2843 \r
2844     (void)memcpy(NdefMap->MifareULContainer.Buffer,\r
2845                 &(NdefMap->SendRecvBuf[ \r
2846                 PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
2847                 PH_FRINFC_NDEFMAP_MFUL_VAL4);\r
2848 \r
2849     /* Copy the Ndef TLV buffer to send buffer */\r
2850     (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,\r
2851                 NdefMap->MifareULContainer.Buffer,\r
2852                 PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
2853 \r
2854     /* Exact number of bytes written in the card including TLV */\r
2855     *NdefMap->DataCount = PH_FRINFC_NDEFMAP_MFUL_VAL4;\r
2856 \r
2857     /* Change the state to check ndef compliancy */\r
2858     NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
2859 \r
2860     Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);\r
2861     \r
2862     return Result;\r
2863 }\r
2864 \r
2865 static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap)\r
2866 {\r
2867     uint16_t localCurrentBlock;\r
2868     NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, \r
2869                         NFCSTATUS_INVALID_REMOTE_DEVICE);\r
2870     \r
2871     if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)\r
2872     {\r
2873         NdefMap->ApduBuffIndex =  NdefMap->ApduBuffIndex+NdefMap->NumOfBytesWritten;\r
2874         if(*NdefMap->DataCount < \r
2875             PH_FRINFC_NDEFMAP_MFUL_VAL4)\r
2876         {\r
2877             (void)memcpy(NdefMap->MifareULContainer.InternalBuf,\r
2878                         NdefMap->MifareULContainer.Buffer,\r
2879                         *NdefMap->DataCount);\r
2880 \r
2881             NdefMap->MifareULContainer.InternalLength = *NdefMap->DataCount;\r
2882         }\r
2883         else\r
2884         {\r
2885             NdefMap->MifareULContainer.InternalLength = \r
2886                                 PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2887         }\r
2888 \r
2889         NdefMap->MifareULContainer.RemainingSize=  NdefMap->MifareULContainer.RemainingSize-\r
2890                                             NdefMap->NumOfBytesWritten;\r
2891         if((NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize) || \r
2892             (NdefMap->MifareULContainer.RemainingSize == \r
2893             PH_FRINFC_NDEFMAP_MFUL_VAL0))\r
2894         {\r
2895             Result = NFCSTATUS_SUCCESS;\r
2896             NdefMap->MifareULContainer.ReadWriteCompleteFlag = \r
2897                 (uint8_t)((NdefMap->MifareULContainer.RemainingSize == \r
2898                 PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
2899                 PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
2900                 PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
2901 \r
2902                 NdefMap->TLVStruct.SetTermTLVFlag = \r
2903                 (uint8_t)(((NdefMap->MifareULContainer.RemainingSize == \r
2904                 PH_FRINFC_NDEFMAP_MFUL_VAL0) || \r
2905                 (NdefMap->TLVStruct.SetTermTLVFlag == \r
2906                 PH_FRINFC_NDEFMAP_MFUL_FLAG1))?\r
2907                 PH_FRINFC_NDEFMAP_MFUL_FLAG1:\r
2908                 PH_FRINFC_NDEFMAP_MFUL_FLAG0);\r
2909 \r
2910                 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+\r
2911                     (uint8_t)((NdefMap->MifareULContainer.InternalLength != \r
2912                     PH_FRINFC_NDEFMAP_MFUL_VAL0)?\r
2913                     PH_FRINFC_NDEFMAP_MFUL_VAL0:\r
2914                     PH_FRINFC_NDEFMAP_MFUL_VAL1);\r
2915 \r
2916             *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;\r
2917         }\r
2918         else\r
2919         {\r
2920             localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 1;\r
2921             if (localCurrentBlock < 256)\r
2922             {\r
2923                 NdefMap->MifareULContainer.CurrentBlock++;\r
2924                 Result = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);\r
2925             }\r
2926             else\r
2927             {\r
2928                 /* Go to next sector */\r
2929                 NdefMap->MifareULContainer.CurrentSector++;\r
2930 \r
2931                 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
2932                     NdefMap->MifareULContainer.CurrentSector, 1, \r
2933                     PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1);\r
2934             }\r
2935         }\r
2936     }\r
2937 \r
2938     if((Result == NFCSTATUS_SUCCESS) && \r
2939         (NdefMap->TLVStruct.SetTermTLVFlag != \r
2940         PH_FRINFC_NDEFMAP_MFUL_FLAG1) && \r
2941         (NdefMap->MifareULContainer.RemainingSize > \r
2942         PH_FRINFC_NDEFMAP_MFUL_VAL0))\r
2943     {\r
2944         Result = phFriNfc_MfUL_H_WrTermTLV(NdefMap);\r
2945     }\r
2946     else \r
2947     {\r
2948         if((Result == NFCSTATUS_SUCCESS) && \r
2949             (NdefMap->TLVStruct.SetTermTLVFlag == \r
2950             PH_FRINFC_NDEFMAP_MFUL_FLAG1))\r
2951         {\r
2952             Result = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);\r
2953         }\r
2954     }\r
2955     return Result;\r
2956 }\r
2957 static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap)\r
2958 {\r
2959     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
2960     uint16_t    RemainingBytes = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
2961                 BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2962     uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
2963     \r
2964     RemainingBytes = (uint16_t)(( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= \r
2965                         NdefMap->MifareULContainer.RemainingSize)?\r
2966                         (uint16_t)(NdefMap->ApduBufferSize - \r
2967                         NdefMap->ApduBuffIndex):\r
2968                         NdefMap->MifareULContainer.RemainingSize);\r
2969 \r
2970     NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = \r
2971                         NdefMap->MifareULContainer.CurrentBlock;\r
2972     \r
2973     /* Get the number of bytes that can be written after copying \r
2974         the internal buffer */\r
2975     BytesToWrite = ((RemainingBytes < \r
2976                     (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - \r
2977                     NdefMap->MifareULContainer.InternalLength))? \r
2978                     RemainingBytes:\r
2979                     (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - \r
2980                     NdefMap->MifareULContainer.InternalLength));\r
2981 \r
2982     if (NdefMap->NumOfBytesWritten == 0 && NdefMap->NumOfLReminWrite > 0)\r
2983     {\r
2984         BytesToWrite = BytesToWrite - NdefMap->NumOfLReminWrite;\r
2985 \r
2986         if (NdefMap->NumOfLReminWrite == 1)\r
2987         {\r
2988             NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; \r
2989         }\r
2990         else\r
2991         {\r
2992             NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;\r
2993             NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0x00;\r
2994         }\r
2995     }   \r
2996 \r
2997     if(NdefMap->MifareULContainer.InternalLength > \r
2998         PH_FRINFC_NDEFMAP_MFUL_VAL0)\r
2999     {\r
3000         /* copy the internal buffer to the send buffer */\r
3001         (void)memcpy(&(NdefMap->SendRecvBuf[ \r
3002                     PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
3003                     NdefMap->MifareULContainer.InternalBuf,\r
3004                     NdefMap->MifareULContainer.InternalLength);\r
3005 \r
3006     }\r
3007 \r
3008     /* Copy Bytes to write in the send buffer */\r
3009     (void)memcpy(&(NdefMap->SendRecvBuf[ \r
3010                 (PH_FRINFC_NDEFMAP_MFUL_VAL1 + \r
3011                 NdefMap->MifareULContainer.InternalLength) + \r
3012                 NdefMap->NumOfLReminWrite]),\r
3013                 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]),\r
3014                 BytesToWrite);\r
3015     \r
3016     /* update number of bytes written from the user buffer */\r
3017     NdefMap->NumOfBytesWritten = BytesToWrite;\r
3018     \r
3019     /* check the exact number of bytes written to a block including the \r
3020         internal length */\r
3021     *NdefMap->DataCount = \r
3022             (BytesToWrite + NdefMap->MifareULContainer.InternalLength +\r
3023                     NdefMap->NumOfLReminWrite);\r
3024 \r
3025 \r
3026     /* if total bytes to write in the card is less than 4 bytes then \r
3027     pad zeroes till 4 bytes */\r
3028     if((BytesToWrite + NdefMap->MifareULContainer.InternalLength + \r
3029         NdefMap->NumOfLReminWrite) \r
3030             < PH_FRINFC_NDEFMAP_MFUL_BYTE4)\r
3031     {\r
3032         for(index = (uint8_t)((BytesToWrite + NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + \r
3033                     PH_FRINFC_NDEFMAP_MFUL_VAL1); \r
3034             index < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; \r
3035             index++)\r
3036             {\r
3037                 NdefMap->SendRecvBuf[index] = (uint8_t)((index == \r
3038                                     ((BytesToWrite + \r
3039                                     NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + \r
3040                                     PH_FRINFC_NDEFMAP_MFUL_VAL1))?\r
3041                                     PH_FRINFC_NDEFMAP_MFUL_TERMTLV:\r
3042                                     PH_FRINFC_NDEFMAP_MFUL_NULLTLV);\r
3043 \r
3044                 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;\r
3045             }\r
3046     }\r
3047 \r
3048     /* A temporary buffer to hold four bytes of data that is \r
3049         written to the card */\r
3050     (void)memcpy(NdefMap->MifareULContainer.Buffer,\r
3051                 &(NdefMap->SendRecvBuf[ \r
3052                 PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
3053                 PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3054 \r
3055     \r
3056     \r
3057         if((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) < \r
3058         PH_FRINFC_NDEFMAP_MFUL_VAL3)\r
3059         {\r
3060             if ((NdefMap->TLVStruct.NdefTLVSector == \r
3061                 NdefMap->MifareULContainer.CurrentSector))\r
3062             {\r
3063                 if(NdefMap->MifareULContainer.CurrentBlock == \r
3064                         NdefMap->TLVStruct.NdefTLVBlock)\r
3065                 {\r
3066                     (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,\r
3067                         NdefMap->MifareULContainer.Buffer,\r
3068                         PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3069                 }                                   \r
3070             }\r
3071             \r
3072             if ((NdefMap->TLVStruct.NdefTLVSector == \r
3073                 NdefMap->MifareULContainer.CurrentSector) ||\r
3074                 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))\r
3075             {\r
3076                 if(NdefMap->MifareULContainer.CurrentBlock == \r
3077                     (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL1))\r
3078                 {\r
3079                     (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,\r
3080                     NdefMap->MifareULContainer.Buffer,\r
3081                     PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3082                 }\r
3083             }\r
3084         }\r
3085         else\r
3086         {\r
3087             if ((NdefMap->TLVStruct.NdefTLVSector == \r
3088                 NdefMap->MifareULContainer.CurrentSector))\r
3089             {\r
3090                 if(NdefMap->MifareULContainer.CurrentBlock == \r
3091                     (NdefMap->TLVStruct.NdefTLVBlock + \r
3092                     PH_FRINFC_NDEFMAP_MFUL_VAL1))\r
3093                 {\r
3094                     (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,\r
3095                                 NdefMap->MifareULContainer.Buffer,\r
3096                                 PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3097                 }\r
3098             }\r
3099             \r
3100             if ((NdefMap->TLVStruct.NdefTLVSector == \r
3101                 NdefMap->MifareULContainer.CurrentSector)||\r
3102                 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))\r
3103             {\r
3104                 if(NdefMap->MifareULContainer.CurrentBlock == \r
3105                     (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL2))\r
3106                 {\r
3107                     (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,\r
3108                                 NdefMap->MifareULContainer.Buffer,\r
3109                                 PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3110                 }             \r
3111             }\r
3112         }\r
3113     \r
3114 \r
3115     /* Change the state to check ndef compliancy */\r
3116     NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
3117 \r
3118     NdefMap->NumOfLReminWrite = 0;\r
3119     \r
3120     /* Start writing to the current block */\r
3121     Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);\r
3122 \r
3123     return Result; \r
3124 }\r
3125 static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t   *NdefMap)\r
3126 {\r
3127     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
3128     uint8_t     index = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
3129                 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
3130 \r
3131     /* Change the state to check ndef compliancy */\r
3132     NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;\r
3133     \r
3134     NdefMap->SendRecvBuf[index] = \r
3135                         (NdefMap->MifareULContainer.CurrentBlock + \r
3136                         PH_FRINFC_NDEFMAP_MFUL_VAL0);\r
3137     index++;\r
3138     NdefMap->SendRecvBuf[index] = PH_FRINFC_NDEFMAP_MFUL_TERMTLV;\r
3139     index++;\r
3140 \r
3141     for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_VAL4; i++)\r
3142     {\r
3143         NdefMap->SendRecvBuf[i] = PH_FRINFC_NDEFMAP_MFUL_NULLTLV;\r
3144     }\r
3145     \r
3146     Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);\r
3147     return Result;\r
3148 }\r
3149 \r
3150 static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap)\r
3151 {\r
3152     NFCSTATUS   Result = NFCSTATUS_SUCCESS;\r
3153     uint16_t    BlockNo = PH_FRINFC_NDEFMAP_MFUL_VAL0,\r
3154                 ByteNo = PH_FRINFC_NDEFMAP_MFUL_VAL0;\r
3155 \r
3156     if ((NdefMap->TLVStruct.NdefTLVSector == \r
3157         NdefMap->MifareULContainer.CurrentSector) ||\r
3158         ((NdefMap->TLVStruct.NdefTLVBlock == 0xFF) &&\r
3159         (NdefMap->TLVStruct.NdefTLVByte == 4) &&\r
3160         (NdefMap->TLVStruct.NdefTLVSector == 0)))\r
3161     {\r
3162         BlockNo = (((NdefMap->TLVStruct.NdefTLVByte - \r
3163                     PH_FRINFC_NDEFMAP_MFUL_VAL1) != \r
3164                     PH_FRINFC_NDEFMAP_MFUL_VAL3)?\r
3165                     NdefMap->TLVStruct.NdefTLVBlock:\r
3166                     (NdefMap->TLVStruct.NdefTLVBlock + \r
3167                     PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
3168 \r
3169         ByteNo = (((NdefMap->TLVStruct.NdefTLVByte - \r
3170                     PH_FRINFC_NDEFMAP_MFUL_VAL1) == \r
3171                     PH_FRINFC_NDEFMAP_MFUL_VAL3)?\r
3172                     PH_FRINFC_NDEFMAP_MFUL_VAL1:\r
3173                     (NdefMap->TLVStruct.NdefTLVByte + \r
3174                     PH_FRINFC_NDEFMAP_MFUL_VAL1));\r
3175 \r
3176         if (NdefMap->NumOfLReminWrite > 0)\r
3177         {\r
3178             BlockNo++;\r
3179 \r
3180             /* Copy the Ndef TLV buffer to send buffer */\r
3181             (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
3182                         NdefMap->TLVStruct.NdefTLVBuffer1,\r
3183                         PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3184 \r
3185             if (NdefMap->NumOfLReminWrite == 1)\r
3186             {\r
3187                 /* NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); */\r
3188                                 NdefMap->SendRecvBuf[1] = (uint8_t) NdefMap->ApduBuffIndex;\r
3189                 \r
3190             }\r
3191             else if (NdefMap->NumOfLReminWrite == 2)\r
3192             {\r
3193                                 NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);\r
3194                 NdefMap->SendRecvBuf[2]= (uint8_t) (NdefMap->ApduBuffIndex);\r
3195                 \r
3196             }\r
3197             else\r
3198             {\r
3199 \r
3200             }\r
3201             NdefMap->NumOfLReminWrite = 0;\r
3202         }\r
3203         else \r
3204         {\r
3205             /* Copy the Ndef TLV buffer to send buffer */\r
3206             (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
3207                         NdefMap->TLVStruct.NdefTLVBuffer,\r
3208                         PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3209 \r
3210 \r
3211             if (NdefMap->ApduBuffIndex > 254)\r
3212             {\r
3213                 ByteNo++;\r
3214                 if  ((ByteNo == 3) || (ByteNo == 2))\r
3215                 {\r
3216                     NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);\r
3217                     ByteNo++;\r
3218                     NdefMap->SendRecvBuf[ByteNo] = (uint8_t) (NdefMap->ApduBuffIndex);\r
3219                     ByteNo++;\r
3220                     NdefMap->NumOfLReminWrite = 0;\r
3221                 }\r
3222                 else if (ByteNo == 4)\r
3223                 {\r
3224                     /* NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); */\r
3225                                         NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);\r
3226                     ByteNo++;\r
3227                     NdefMap->NumOfLReminWrite = 1;\r
3228                 }\r
3229                 else\r
3230                 {\r
3231                     NdefMap->NumOfLReminWrite = 2;\r
3232                 }\r
3233             }\r
3234             else \r
3235             {\r
3236                 NdefMap->SendRecvBuf[ByteNo]= \r
3237                                     (uint8_t)((NdefMap->Offset == \r
3238                                     PH_FRINFC_NDEFMAP_SEEK_BEGIN)?\r
3239                                     (uint8_t)NdefMap->ApduBuffIndex:\r
3240                                     (NdefMap->ApduBuffIndex + \r
3241                                     NdefMap->SendRecvBuf[ByteNo]));\r
3242             }\r
3243         }\r
3244 \r
3245         (void)memcpy(NdefMap->MifareULContainer.Buffer,\r
3246                     &(NdefMap->SendRecvBuf[ \r
3247                     PH_FRINFC_NDEFMAP_MFUL_VAL1]),\r
3248                     PH_FRINFC_NDEFMAP_MFUL_BYTE4);\r
3249         \r
3250         NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = (uint8_t)BlockNo;\r
3251         Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);\r
3252 \r
3253         if (NdefMap->NumOfLReminWrite == 0)\r
3254         {\r
3255             NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;\r
3256         }\r
3257         else \r
3258         {\r
3259             NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;\r
3260         }\r
3261     }\r
3262     else if (NdefMap->TLVStruct.NdefTLVSector == 0)\r
3263     {\r
3264         /* Reset sector */\r
3265         NdefMap->MifareULContainer.CurrentSector = 0;\r
3266         NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
3267                                     \r
3268         Result = phFriNfc_MfUL_H_SelectSector(NdefMap, \r
3269                 NdefMap->MifareULContainer.CurrentSector, 1,\r
3270                 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);\r
3271 \r
3272     }\r
3273     else\r
3274     {\r
3275         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);\r
3276     }\r
3277     \r
3278         \r
3279     return Result;\r
3280 }\r
3281 #ifdef UNIT_TEST\r
3282 extern void phFriNfc_MifareUL_UnitTest(void *Context,uint32_t Length)\r
3283 {\r
3284         uint8_t value=10;\r
3285         uint8_t* CrFlag=&value;\r
3286         phFriNfc_NdefMap_t *pNdefMap=(phFriNfc_NdefMap_t*)Context;\r
3287         phFriNfc_MfUL_H_UpdateLen(pNdefMap,(uint16_t) Length);\r
3288         phFriNfc_MfUL_H_WrTermTLV(pNdefMap);\r
3289         phFriNfc_MfUL_H_CallWrOp(pNdefMap);\r
3290         phFriNfc_MfUL_H_UpdateWrLen(pNdefMap);\r
3291         phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);\r
3292         phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);\r
3293         \r
3294         pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_READ_OPE;\r
3295         phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);\r
3296         \r
3297         pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_WRITE_OPE;\r
3298         phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);\r
3299 \r
3300         pNdefMap->TLVStruct.NoLbytesinTLV=PH_FRINFC_NDEFMAP_MFUL_VAL1;\r
3301         phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);\r
3302 \r
3303         pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;\r
3304         phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);\r
3305         \r
3306 \r
3307         pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;\r
3308         phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);\r
3309 \r
3310         \r
3311         phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);\r
3312         pNdefMap->TLVStruct.NdefTLVByte=1;\r
3313         phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);\r
3314         \r
3315         pNdefMap->TLVStruct.NdefTLVByte=3;\r
3316         phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);\r
3317 \r
3318         pNdefMap->TLVStruct.NdefTLVByte=4;\r
3319         phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);\r
3320 \r
3321 \r
3322         phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);\r
3323         phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);\r
3324         phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);\r
3325         pNdefMap->State=PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;\r
3326         phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);\r
3327 \r
3328         phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);\r
3329         phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);\r
3330         phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);\r
3331         \r
3332         *pNdefMap->DataCount=0x3;\r
3333         phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);\r
3334 \r
3335         pNdefMap->ApduBuffIndex=0x31;\r
3336         phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);\r
3337             \r
3338         \r
3339                 \r
3340 }\r
3341 \r
3342 #endif\r
3343 #endif  /* PH_FRINFC_MAP_MIFAREUL_DISABLED */\r
3344 \r