src/phFriNfc_MifareULMap.c

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