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.35 $ 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 - PH_FRINFC_NDEFMAP_MFUL_BLOCK4) 650 * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4))) 651 { 652 Status = phFriNfc_MfUL_H_CopyRdBytes(NdefMap); 653 } 654 655 if (Status == NFCSTATUS_SUCCESS) 656 { 657 if(NdefMap->MifareULContainer.ReadBufIndex >= 658 (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock - PH_FRINFC_NDEFMAP_MFUL_BLOCK4) 659 * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4))) 660 { 661 662 phFriNfc_MfUL_CalcByteNum(NdefMap); 663 #if 0 664 for (i = 0; i < 16; i++) 665 { 666 if ((NdefMap->MifareULContainer.ReadBuf[i] == 667 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) && 668 ((NdefMap->MifareULContainer.ReadBuf[i + 1] == 669 NdefMap->TLVStruct.ActualSize) || 670 (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF))) 671 { 672 if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF) 673 { 674 TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] | 675 ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8); 676 677 if (TemLength == NdefMap->TLVStruct.ActualSize) 678 { 679 NdefMap->MifareULContainer.ByteNumber = i + 1; 680 break; 681 } 682 } 683 else 684 { 685 NdefMap->MifareULContainer.ByteNumber = i + 1; 686 break; 687 } 688 } 689 } 690 #endif 691 692 if (NdefMap->MifareULContainer.ReadBuf 693 [NdefMap->MifareULContainer.ByteNumber] == 0xFF) 694 { 695 NdefMap->MifareULContainer.ByteNumber = 696 NdefMap->MifareULContainer.ByteNumber + 3; 697 } 698 else 699 { 700 NdefMap->MifareULContainer.ByteNumber = 701 NdefMap->MifareULContainer.ByteNumber + 1; 702 } 703 704 Status = phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap); 705 if (NdefMap->MifareULContainer.CurrentSector > 0) 706 { 707 NdefMap->MifareULContainer.CurrentSector = 0; 708 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_READ; 709 710 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 711 NdefMap->MifareULContainer.CurrentSector, 1, 712 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1); 713 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )? 714 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 715 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 716 } 717 else 718 { 719 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 720 } 721 } 722 else 723 { 724 Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap); 725 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 726 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 727 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 728 } 729 } 730 else 731 { 732 733 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0; 734 } 735 } 736 else 737 { 738 /* read error */ 739 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 740 NFCSTATUS_INVALID_RECEIVE_LENGTH); 741 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 742 } 743 break; 744 745 case PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE: 746 Status = phFriNfc_MfUL_H_ProWrittenBytes(NdefMap); 747 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 748 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 749 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 750 break; 751 752 case PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP: 753 if (*NdefMap->SendRecvLength == 754 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16) 755 { 756 switch(NdefMap->PrevOperation) 757 { 758 case PH_FRINFC_NDEFMAP_CHECK_OPE: 759 case PH_FRINFC_NDEFMAP_READ_OPE: 760 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0; 761 if(NdefMap->TLVStruct.NoLbytesinTLV > 762 PH_FRINFC_NDEFMAP_MFUL_VAL0) 763 { 764 Status = phFriNfc_MfUL_H_ChkRemainTLV(NdefMap, &CRFlag); 765 } 766 else 767 { 768 if(NdefMap->TLVStruct.NdefTLVFoundFlag != 769 PH_FRINFC_NDEFMAP_MFUL_FLAG1) 770 { 771 /* Find the NDEF TLV */ 772 Status = phFriNfc_MfUL_H_findNDEFTLV(NdefMap, &CRFlag); 773 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )? 774 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 775 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 776 } 777 } 778 if((NdefMap->TLVStruct.NdefTLVFoundFlag == 779 PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 780 (NdefMap->TLVStruct.NoLbytesinTLV == 781 PH_FRINFC_NDEFMAP_MFUL_VAL0)) 782 { 783 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0; 784 /* Ndef TLV found, so call the next function depending on the 785 check/read/write ndef operation */ 786 787 if (NdefMap->MifareULContainer.CurrentSector > 0) 788 { 789 NdefMap->MifareULContainer.CurrentSector = 0; 790 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP; 791 792 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 793 NdefMap->MifareULContainer.CurrentSector, 1, 794 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1); 795 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )? 796 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 797 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 798 } 799 else 800 { 801 /* Sector is 0 no need to send sector select */ 802 Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag); 803 } 804 } 805 806 #ifdef PH_HAL4_ENABLE 807 if ((Status != NFCSTATUS_PENDING ) && 808 (Status != NFCSTATUS_SUCCESS) && 809 (PH_FRINFC_NDEFMAP_CHECK_OPE == 810 NdefMap->PrevOperation)) 811 { 812 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 813 } 814 #endif /* #ifdef PH_HAL4_ENABLE */ 815 break; 816 817 case PH_FRINFC_NDEFMAP_WRITE_OPE: 818 /* Remove UpdateWrLen */ 819 Status = ((NdefMap->TLVStruct.WrLenFlag == 820 PH_FRINFC_NDEFMAP_MFUL_FLAG1)? 821 phFriNfc_MfUL_H_UpdateWrLen(NdefMap): 822 phFriNfc_MfUL_H_CallWrOp(NdefMap)); 823 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 824 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 825 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 826 break; 827 828 default: 829 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 830 NFCSTATUS_INVALID_REMOTE_DEVICE); 831 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 832 break; 833 834 } 835 } 836 break; 837 838 case PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV: 839 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap); 840 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 841 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 842 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 843 break; 844 845 case PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV: 846 if(((((NdefMap->TLVStruct.NdefTLVByte - 847 PH_FRINFC_NDEFMAP_MFUL_VAL1) == 848 PH_FRINFC_NDEFMAP_MFUL_VAL3) && 849 (NdefMap->MifareULContainer.CurrentBlock == 850 (NdefMap->TLVStruct.NdefTLVBlock + 851 PH_FRINFC_NDEFMAP_MFUL_VAL1))) || 852 (((NdefMap->TLVStruct.NdefTLVByte - 853 PH_FRINFC_NDEFMAP_MFUL_VAL1) < 854 PH_FRINFC_NDEFMAP_MFUL_VAL3) && ( 855 NdefMap->MifareULContainer.CurrentBlock == 856 NdefMap->TLVStruct.NdefTLVBlock)))) 857 { 858 (void)memcpy(NdefMap->MifareULContainer.InternalBuf, 859 NdefMap->MifareULContainer.Buffer, 860 NdefMap->MifareULContainer.InternalLength); 861 } 862 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 863 NdefMap->MifareULContainer.Buffer, 864 PH_FRINFC_NDEFMAP_MFUL_VAL4); 865 866 NdefMap->CardState =(uint8_t) ((NdefMap->CardState == 867 PH_NDEFMAP_CARD_STATE_INITIALIZED)? 868 PH_NDEFMAP_CARD_STATE_READ_WRITE: 869 NdefMap->CardState); 870 NdefMap->ApduBuffIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0; 871 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL0; 872 873 if (NdefMap->MifareULContainer.CurrentSector > 0) 874 { 875 /* Reset sector */ 876 NdefMap->MifareULContainer.CurrentSector = 0; 877 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV; 878 879 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 880 NdefMap->MifareULContainer.CurrentSector, 1, 881 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1); 882 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 883 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 884 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 885 } 886 else 887 { 888 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 889 } 890 891 break; 892 893 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1: 894 /* check the received bytes size equals 1 byte*/ 895 if (*NdefMap->SendRecvLength == 896 PH_FRINFC_NDEFMAP_MFUL_VAL1) 897 { 898 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 899 { 900 /* Send second command */ 901 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 902 NdefMap->MifareULContainer.CurrentSector, 2, 903 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2); 904 } 905 else 906 { 907 /* read error */ 908 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 909 NFCSTATUS_INVALID_FORMAT); 910 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 911 } 912 } 913 else 914 { 915 /* read error */ 916 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 917 NFCSTATUS_INVALID_RECEIVE_LENGTH); 918 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 919 920 } 921 break; 922 923 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2: 924 { 925 NdefMap->MifareULContainer.CurrentBlock += 926 PH_FRINFC_NDEFMAP_MFUL_BLOCK4; 927 928 Status = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 929 NdefMap->MifareULContainer.CurrentBlock); 930 } 931 break; 932 933 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1: 934 /* check the received bytes size equals 1 byte*/ 935 if (*NdefMap->SendRecvLength == 936 PH_FRINFC_NDEFMAP_MFUL_VAL1) 937 { 938 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 939 { 940 /* Send second command */ 941 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 942 NdefMap->MifareULContainer.CurrentSector, 2, 943 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2); 944 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0; 945 } 946 else 947 { 948 /* read error */ 949 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 950 NFCSTATUS_INVALID_FORMAT); 951 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 952 } 953 } 954 else 955 { 956 /* read error */ 957 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 958 NFCSTATUS_INVALID_RECEIVE_LENGTH); 959 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 960 961 } 962 break; 963 964 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2: 965 { 966 if (NdefMap->MifareULContainer.CurrentBlock == 0xFF) 967 { 968 NdefMap->MifareULContainer.CurrentBlock = 0; 969 } 970 else 971 { 972 NdefMap->MifareULContainer.CurrentBlock = 973 (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4; 974 } 975 976 Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap); 977 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 978 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 979 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 980 } 981 break; 982 983 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1: 984 /* check the received bytes size equals 1 byte*/ 985 if (*NdefMap->SendRecvLength == 986 PH_FRINFC_NDEFMAP_MFUL_VAL1) 987 { 988 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 989 { 990 /* Send second command */ 991 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 992 NdefMap->MifareULContainer.CurrentSector, 2, 993 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2); 994 } 995 else 996 { 997 /* read error */ 998 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 999 NFCSTATUS_INVALID_FORMAT); 1000 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1001 } 1002 } 1003 else 1004 { 1005 /* read error */ 1006 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1007 NFCSTATUS_INVALID_RECEIVE_LENGTH); 1008 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1009 1010 } 1011 break; 1012 1013 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2: 1014 { 1015 NdefMap->MifareULContainer.CurrentBlock = 0; 1016 Status = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap); 1017 1018 if((Status == NFCSTATUS_SUCCESS) && 1019 (NdefMap->TLVStruct.SetTermTLVFlag != 1020 PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 1021 (NdefMap->MifareULContainer.RemainingSize > 1022 PH_FRINFC_NDEFMAP_MFUL_VAL0)) 1023 { 1024 Status = phFriNfc_MfUL_H_WrTermTLV(NdefMap); 1025 } 1026 else 1027 { 1028 if((Status == NFCSTATUS_SUCCESS) && 1029 (NdefMap->TLVStruct.SetTermTLVFlag == 1030 PH_FRINFC_NDEFMAP_MFUL_FLAG1)) 1031 { 1032 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap); 1033 } 1034 } 1035 1036 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1037 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 1038 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 1039 } 1040 break; 1041 1042 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1: 1043 /* check the received bytes size equals 1 byte*/ 1044 if (*NdefMap->SendRecvLength == 1045 PH_FRINFC_NDEFMAP_MFUL_VAL1) 1046 { 1047 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 1048 { 1049 /* Send second command */ 1050 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 1051 NdefMap->MifareULContainer.CurrentSector, 2, 1052 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2); 1053 } 1054 else 1055 { 1056 /* read error */ 1057 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1058 NFCSTATUS_INVALID_FORMAT); 1059 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1060 } 1061 } 1062 else 1063 { 1064 /* read error */ 1065 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1066 NFCSTATUS_INVALID_RECEIVE_LENGTH); 1067 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1068 1069 } 1070 break; 1071 1072 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2: 1073 { 1074 Status = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)? 1075 phFriNfc_MfUL_H_RdBeforeWrite(NdefMap): 1076 phFriNfc_MfUL_H_fillSendBufToWr(NdefMap)); 1077 1078 1079 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1080 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 1081 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 1082 } 1083 break; 1084 1085 1086 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1: 1087 /* check the received bytes size equals 1 byte*/ 1088 if (*NdefMap->SendRecvLength == 1089 PH_FRINFC_NDEFMAP_MFUL_VAL1) 1090 { 1091 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 1092 { 1093 /* Send second command */ 1094 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 1095 NdefMap->MifareULContainer.CurrentSector, 2, 1096 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2); 1097 } 1098 else 1099 { 1100 /* read error */ 1101 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1102 NFCSTATUS_INVALID_FORMAT); 1103 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1104 } 1105 } 1106 else 1107 { 1108 /* read error */ 1109 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1110 NFCSTATUS_INVALID_RECEIVE_LENGTH); 1111 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1112 1113 } 1114 break; 1115 1116 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2: 1117 { 1118 NdefMap->MifareULContainer.CurrentBlock = 0; 1119 1120 NdefMap->SendRecvBuf[index] = 1121 NdefMap->MifareULContainer.CurrentBlock; 1122 index++; 1123 NdefMap->SendRecvBuf[index] = 1124 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 1125 index++; 1126 1127 if((((NdefMap->TLVStruct.NdefTLVByte - 1128 PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || 1129 ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) 1130 == PH_FRINFC_NDEFMAP_MFUL_VAL3))) 1131 { 1132 /* Length to know how many bytes has to be written to the card */ 1133 TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == 1134 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 1135 PH_FRINFC_NDEFMAP_MFUL_VAL2: 1136 PH_FRINFC_NDEFMAP_MFUL_VAL3); 1137 1138 if(NdefMap->ApduBufferSize >= TemLength) 1139 { 1140 /* Prepare the receive buffer */ 1141 (void)memcpy(&(NdefMap->SendRecvBuf[ 1142 index]), 1143 &(NdefMap->ApduBuffer[ 1144 NdefMap->ApduBuffIndex]), 1145 TemLength); 1146 1147 /* Number of bytes written to the card from user buffer */ 1148 NdefMap->NumOfBytesWritten = TemLength; 1149 1150 index = index+(uint8_t)TemLength; 1151 /* Exact number of bytes written in the card including TLV */ 1152 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1); 1153 } 1154 else 1155 { 1156 /* Prepare the receive buffer */ 1157 (void)memcpy(&(NdefMap->SendRecvBuf[ 1158 index]), 1159 &(NdefMap->ApduBuffer[ 1160 NdefMap->ApduBuffIndex]), 1161 (uint16_t)NdefMap->ApduBufferSize); 1162 1163 /* Number of bytes written to the card from user buffer */ 1164 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize; 1165 1166 index= index +(uint8_t)NdefMap->ApduBufferSize; 1167 /* Exact number of bytes written in the card including TLV */ 1168 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1); 1169 1170 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++) 1171 { 1172 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)? 1173 PH_FRINFC_NDEFMAP_MFUL_TERMTLV: 1174 PH_FRINFC_NDEFMAP_MFUL_NULLTLV); 1175 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1176 } 1177 } 1178 1179 /* store the bytes in buffer till the bytes are 1180 written in a block */ 1181 (void)memcpy(NdefMap->MifareULContainer.Buffer, 1182 &(NdefMap->SendRecvBuf[ 1183 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 1184 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 1185 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1186 1187 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 1188 NdefMap->MifareULContainer.Buffer, 1189 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 1190 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1191 1192 /* Change the state to check ndef compliancy */ 1193 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 1194 1195 Status = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 1196 } 1197 1198 1199 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1200 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 1201 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 1202 } 1203 break; 1204 1205 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1: 1206 /* check the received bytes size equals 1 byte*/ 1207 if (*NdefMap->SendRecvLength == 1208 PH_FRINFC_NDEFMAP_MFUL_VAL1) 1209 { 1210 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A) 1211 { 1212 /* Send second command */ 1213 Status = phFriNfc_MfUL_H_SelectSector(NdefMap, 1214 NdefMap->MifareULContainer.CurrentSector, 2, 1215 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2); 1216 } 1217 else 1218 { 1219 /* read error */ 1220 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1221 NFCSTATUS_INVALID_FORMAT); 1222 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1223 } 1224 } 1225 else 1226 { 1227 /* read error */ 1228 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1229 NFCSTATUS_INVALID_RECEIVE_LENGTH); 1230 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1231 1232 } 1233 break; 1234 1235 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2: 1236 { 1237 if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP) 1238 { 1239 Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag); 1240 } 1241 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_READ) 1242 { 1243 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1244 } 1245 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE) 1246 { 1247 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap); 1248 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1249 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 1250 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 1251 } 1252 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV) 1253 { 1254 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1255 } 1256 else 1257 { 1258 /* read error */ 1259 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1260 NFCSTATUS_READ_FAILED); 1261 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1262 1263 } 1264 } 1265 break; 1266 1267 default: 1268 /*set the invalid state*/ 1269 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 1270 phFriNfc_MifareUL_H_Complete(NdefMap, Status); 1271 break; 1272 } 1273 if(CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1) 1274 { 1275 /* call the CR routine*/ 1276 phFriNfc_MifareUL_H_Complete(NdefMap, Status); 1277 } 1278 } 1279 else 1280 { 1281 phFriNfc_MifareUL_H_Complete(NdefMap,Status); 1282 } 1283 } 1284 1285 static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap ) 1286 { 1287 NFCSTATUS Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 1288 NFCSTATUS_NO_NDEF_SUPPORT); 1289 1290 #ifdef LOCK_BITS_CHECK_ENABLE 1291 switch(NdefMap->SendRecvBuf[7]) 1292 #else 1293 switch(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE3]) 1294 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1295 { 1296 case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RW: 1297 /* This state can be either INITIALISED or READWRITE. but default 1298 is INITIALISED */ 1299 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED; 1300 break; 1301 1302 case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RO: 1303 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY; 1304 break; 1305 1306 default : 1307 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 1308 } 1309 1310 1311 1312 /* Check for Ndef compliancy : 0 and 1 byte spcifies the ndef compliancy 1313 2 byte specifies the version of the MF UL tag*/ 1314 #ifdef LOCK_BITS_CHECK_ENABLE 1315 if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE4] == 1316 #else 1317 if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE0] == 1318 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1319 PH_FRINFC_NDEFMAP_MFUL_CC_BYTE0) && ( 1320 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED) || 1321 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY))) 1322 { 1323 /* Check the version number */ 1324 Result =phFriNfc_MapTool_ChkSpcVer( NdefMap, 1325 #ifdef LOCK_BITS_CHECK_ENABLE 1326 5); 1327 1328 #else 1329 PH_FRINFC_NDEFMAP_MFUL_BYTE1); 1330 1331 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1332 #if 0 1333 #ifdef PH_NDEF_MIFARE_ULC 1334 if (Result == NFCSTATUS_SUCCESS) 1335 { 1336 #ifdef LOCK_BITS_CHECK_ENABLE 1337 1338 if (NdefMap->SendRecvBuf[6] == 0x06) 1339 { 1340 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD; 1341 } 1342 else if (NdefMap->SendRecvBuf[6] == 0x12) 1343 { 1344 // NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD; 1345 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD; 1346 } 1347 1348 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1349 1350 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x06) 1351 { 1352 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD; 1353 } 1354 else if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x12) 1355 { 1356 // NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD; 1357 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD; 1358 } 1359 1360 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1361 else 1362 { 1363 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 1364 NFCSTATUS_INVALID_REMOTE_DEVICE); 1365 } 1366 } 1367 #else 1368 1369 /* Check the CC header size: Only valid ones are 1370 0x06 for 48 bytes. */ 1371 #ifdef LOCK_BITS_CHECK_ENABLE 1372 Result = ((( NdefMap->SendRecvBuf[6] != 1373 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1374 Result = ((( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] != 1375 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1376 PH_FRINFC_NDEFMAP_MFUL_CC_BYTE2) || (Result != 1377 NFCSTATUS_SUCCESS))? 1378 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1379 NFCSTATUS_INVALID_REMOTE_DEVICE)): 1380 Result); 1381 #endif /* #ifdef PH_NDEF_MIFARE_ULC */ 1382 #endif 1383 NdefMap->MifareULContainer.RemainingSize = 1384 NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)? 1385 #ifdef LOCK_BITS_CHECK_ENABLE 1386 (NdefMap->SendRecvBuf[6] * 1387 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1388 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] * 1389 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */ 1390 PH_FRINFC_NDEFMAP_MFUL_MUL8): 1391 NdefMap->CardMemSize); 1392 1393 if (NdefMap->CardMemSize > 256) 1394 { 1395 NdefMap->CardMemSize = NdefMap->CardMemSize - 2; 1396 NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize; 1397 } 1398 1399 } 1400 else 1401 { 1402 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 1403 } 1404 1405 1406 return Result; 1407 } 1408 1409 /*! 1410 * \brief this shall notify the integration software with respective 1411 * success/error status along with the completion routines. 1412 * 1413 * This routine is called from the mifareul process function. 1414 * 1415 */ 1416 1417 static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t *NdefMap, 1418 NFCSTATUS Status) 1419 { 1420 if(NdefMap!=NULL) 1421 { 1422 if((PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE == NdefMap->State) 1423 && (NFCSTATUS_SUCCESS != Status)) 1424 { 1425 *NdefMap->WrNdefPacketLength = 0; 1426 } 1427 /* set the state back to the Reset_Init state*/ 1428 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT; 1429 1430 /* set the completion routine*/ 1431 NdefMap->CompletionRoutine[NdefMap->MifareULContainer.CRindex]. 1432 CompletionRoutine(NdefMap->CompletionRoutine->Context, Status); 1433 } 1434 } 1435 1436 static NFCSTATUS phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t *NdefMap) 1437 { 1438 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1439 NFCSTATUS_INVALID_PARAMETER); 1440 1441 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_READ; 1442 1443 /* Set the previous operation flag to read. */ 1444 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 1445 1446 /* Have we already read the entire file? */ 1447 if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize) 1448 { 1449 /* set the data for additional data exchange */ 1450 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0; 1451 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0; 1452 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0; 1453 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 1454 NdefMap->MifareULContainer.CurrentBlock; 1455 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1; 1456 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1457 /* 1458 * Changed 1459 * Description: replace with phHal_eMifareRead 1460 */ 1461 1462 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 1463 1464 /* Call the overlapped HAL Transceive function */ 1465 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 1466 &NdefMap->MapCompletionInfo, 1467 NdefMap->psRemoteDevInfo, 1468 NdefMap->Cmd, 1469 &NdefMap->psDepAdditionalInfo, 1470 NdefMap->SendRecvBuf, 1471 NdefMap->SendLength, 1472 NdefMap->SendRecvBuf, 1473 NdefMap->SendRecvLength); 1474 } 1475 return Result; 1476 } 1477 1478 static NFCSTATUS phFriNfc_MfUL_H_Wr4bytes( phFriNfc_NdefMap_t *NdefMap) 1479 { 1480 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1481 1482 /* set the receive length*/ 1483 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1484 1485 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 1486 1487 /* 1488 * Changed 1489 * Description: phHal_eMifareCmdListMifareWrite4 replace with phHal_eMifareWrite4 1490 */ 1491 /* set the cmd to mifare read*/ 1492 NdefMap->Cmd.MfCmd = phHal_eMifareWrite4; 1493 1494 /* Set the CR and context for Mifare operations*/ 1495 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process; 1496 NdefMap->MapCompletionInfo.Context = NdefMap; 1497 1498 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; 1499 /*Call the Overlapped HAL Transceive function */ 1500 Result = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice, 1501 &NdefMap->MapCompletionInfo, 1502 NdefMap->psRemoteDevInfo, 1503 NdefMap->Cmd, 1504 &NdefMap->psDepAdditionalInfo, 1505 NdefMap->SendRecvBuf, 1506 NdefMap->SendLength, 1507 NdefMap->SendRecvBuf, 1508 NdefMap->SendRecvLength); 1509 return Result; 1510 } 1511 1512 static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap, 1513 uint8_t *CRFlag) 1514 { 1515 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1516 uint16_t ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0, 1517 TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0, 1518 Temp16Bytes = PH_FRINFC_NDEFMAP_MFUL_VAL0; 1519 Temp16Bytes = ((NdefMap->TLVStruct.NdefTLVByte > PH_FRINFC_NDEFMAP_MFUL_VAL0)? 1520 (NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1): 1521 NdefMap->TLVStruct.NdefTLVByte); 1522 for(;;) 1523 { 1524 if(NdefMap->SendRecvBuf[Temp16Bytes] == 1525 PH_FRINFC_NDEFMAP_MFUL_NULLTLV) 1526 { 1527 NdefMap->MifareULContainer.RemainingSize -= 1528 PH_FRINFC_NDEFMAP_MFUL_VAL1; 1529 #ifdef PH_HAL4_ENABLE 1530 /* This check is added to know the remaining size in 1531 the card is not 0, if this is 0, then complete card has 1532 been read */ 1533 if (NdefMap->MifareULContainer.RemainingSize == 1534 PH_FRINFC_NDEFMAP_MFUL_VAL0) 1535 { 1536 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1537 NFCSTATUS_NO_NDEF_SUPPORT); 1538 break; 1539 } 1540 else 1541 { 1542 Result = NFCSTATUS_SUCCESS; 1543 } 1544 #else 1545 Result = ((NdefMap->MifareULContainer.RemainingSize == 1546 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 1547 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1548 NFCSTATUS_NO_NDEF_SUPPORT)): 1549 NFCSTATUS_SUCCESS); 1550 #endif /* #ifdef PH_HAL4_ENABLE */ 1551 Temp16Bytes++; 1552 #ifdef PH_HAL4_ENABLE 1553 /* This code is added to read next 16 bytes. This means previous 1554 16 bytes read contains only NULL TLV, so read further to get the 1555 NDEF TLV */ 1556 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1557 Temp16Bytes); 1558 if(NFCSTATUS_SUCCESS != Result) 1559 { 1560 NdefMap->TLVStruct.NdefTLVBlock = 1561 NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL4; 1562 break; 1563 } 1564 #endif /* #ifdef PH_HAL4_ENABLE */ 1565 } 1566 else 1567 { 1568 Result = ((NdefMap->SendRecvBuf[Temp16Bytes] == 1569 PH_FRINFC_NDEFMAP_MFUL_TERMTLV)? 1570 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1571 NFCSTATUS_NO_NDEF_SUPPORT)): 1572 NFCSTATUS_SUCCESS); 1573 1574 if(Result != NFCSTATUS_SUCCESS) 1575 { 1576 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1577 break; 1578 } 1579 1580 #ifdef PH_NDEF_MIFARE_ULC 1581 if ((NdefMap->SendRecvBuf[Temp16Bytes] == 1582 PH_FRINFC_NDEFMAP_MFUL_LOCK_CTRL_TLV) || 1583 (NdefMap->SendRecvBuf[Temp16Bytes] == 1584 PH_FRINFC_NDEFMAP_MFUL_MEM_CTRL_TLV) ) 1585 { 1586 1587 NdefMap->TLVStruct.NdefTLVByte = 1588 ((Temp16Bytes % 1589 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 1590 PH_FRINFC_NDEFMAP_MFUL_VAL1); 1591 1592 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1593 Temp16Bytes); 1594 if(Result != NFCSTATUS_SUCCESS) 1595 { 1596 NdefMap->TLVStruct.TcheckedinTLVFlag = 1597 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1598 NdefMap->TLVStruct.NoLbytesinTLV = 1599 PH_FRINFC_NDEFMAP_MFUL_VAL3; 1600 break; 1601 } 1602 Temp16Bytes++; 1603 NdefMap->MifareULContainer.RemainingSize -= 1604 PH_FRINFC_NDEFMAP_MFUL_VAL1; 1605 1606 if(NdefMap->MifareULContainer.RemainingSize == 1607 PH_FRINFC_NDEFMAP_MFUL_VAL0) 1608 { 1609 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1610 NFCSTATUS_NO_NDEF_SUPPORT)); 1611 break; 1612 } 1613 1614 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1615 Temp16Bytes); 1616 if(Result != NFCSTATUS_SUCCESS) 1617 { 1618 NdefMap->TLVStruct.TcheckedinTLVFlag = 1619 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1620 NdefMap->TLVStruct.NoLbytesinTLV = 1621 PH_FRINFC_NDEFMAP_MFUL_VAL3; 1622 break; 1623 } 1624 1625 1626 /* If the value of the Length(L) in TLV is FF then enter else 1627 check for the card memory */ 1628 if((NdefMap->SendRecvBuf[Temp16Bytes] == 1629 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 1630 ((NdefMap->SendRecvBuf[Temp16Bytes] == 1631 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 1632 (NdefMap->TLVStruct.NdefTLVFoundFlag != 1633 PH_FRINFC_NDEFMAP_MFUL_FLAG1))) 1634 { 1635 /* In the present case, the card space is not greater 1636 than 0xFF */ 1637 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1638 NFCSTATUS_NO_NDEF_SUPPORT); 1639 1640 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1641 break; 1642 } 1643 else 1644 { 1645 NdefMap->TLVStruct.BytesRemainLinTLV = 1646 NdefMap->SendRecvBuf[Temp16Bytes]; 1647 1648 NdefMap->TLVStruct.ActualSize = 1649 NdefMap->SendRecvBuf[Temp16Bytes]; 1650 1651 if((NdefMap->MifareULContainer.RemainingSize < 1652 NdefMap->SendRecvBuf[Temp16Bytes]) || 1653 (NdefMap->MifareULContainer.RemainingSize < 1654 PH_FRINFC_NDEFMAP_MFUL_VAL2) || 1655 (NdefMap->TLVStruct.BytesRemainLinTLV > 1656 (NdefMap->MifareULContainer.RemainingSize)) || 1657 ((NdefMap->TLVStruct.BytesRemainLinTLV == 1658 PH_FRINFC_NDEFMAP_MFUL_VAL0) && 1659 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))) 1660 { 1661 /* No NDEF TLV found */ 1662 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1663 NFCSTATUS_NO_NDEF_SUPPORT); 1664 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1665 break; 1666 } 1667 1668 if(NdefMap->TLVStruct.NdefTLVFoundFlag != 1669 PH_FRINFC_NDEFMAP_MFUL_FLAG1) 1670 { 1671 NdefMap->TLVStruct.NdefTLVByte = 1672 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 + 1673 NdefMap->SendRecvBuf[Temp16Bytes]) % 1674 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 1675 PH_FRINFC_NDEFMAP_MFUL_VAL1); 1676 #if 0 1677 NdefMap->TLVStruct.NdefTLVBlock = 1678 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 1679 + ((Temp16Bytes + 1680 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 1681 PH_FRINFC_NDEFMAP_MFUL_VAL4)); 1682 #endif 1683 NdefMap->TLVStruct.NdefTLVBlock = 1684 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock / PH_FRINFC_NDEFMAP_MFUL_VAL4) * 1685 PH_FRINFC_NDEFMAP_MFUL_VAL4) 1686 + ((Temp16Bytes + NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 1687 PH_FRINFC_NDEFMAP_MFUL_VAL4)); 1688 1689 1690 TemLength = (Temp16Bytes + 1691 NdefMap->SendRecvBuf[Temp16Bytes]); 1692 1693 NdefMap->MifareULContainer.RemainingSize = 1694 (NdefMap->MifareULContainer.RemainingSize - 1695 (NdefMap->SendRecvBuf[Temp16Bytes] 1696 + PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1697 1698 /* If the Length (L) in TLV < 16 bytes */ 1699 Temp16Bytes = ((TemLength >= 1700 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)? 1701 PH_FRINFC_NDEFMAP_MFUL_VAL0: 1702 (TemLength + 1703 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1704 1705 Result = ((TemLength >= 1706 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)? 1707 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 1708 NdefMap->TLVStruct.NdefTLVBlock): 1709 NFCSTATUS_SUCCESS); 1710 1711 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16) 1712 { 1713 break; 1714 } 1715 TemLength = Temp16Bytes; 1716 } 1717 } 1718 1719 1720 1721 1722 #if 0 1723 1724 NdefMap->MifareULContainer.RemainingSize = 1725 (NdefMap->MifareULContainer.RemainingSize - 1726 (NdefMap->SendRecvBuf[Temp16Bytes + 1] 1727 + PH_FRINFC_NDEFMAP_MFUL_VAL2)); 1728 1729 NdefMap->TLVStruct.NdefTLVBlock = 1730 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 1731 + ((Temp16Bytes + 1732 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2)/ 1733 PH_FRINFC_NDEFMAP_MFUL_VAL4)); 1734 1735 1736 Temp16Bytes = Temp16Bytes + 1737 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2; 1738 #endif 1739 } 1740 #endif /* #ifdef PH_NDEF_MIFARE_ULC */ 1741 else { 1742 1743 /* Check the byte for 0x03 Type of NDEF TLV */ 1744 NdefMap->TLVStruct.NdefTLVFoundFlag = 1745 ((NdefMap->SendRecvBuf[Temp16Bytes] == 1746 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T)? 1747 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 1748 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 1749 1750 if(NdefMap->TLVStruct.NdefTLVFoundFlag == 1751 PH_FRINFC_NDEFMAP_MFUL_FLAG1) 1752 { 1753 ShiftLength = (Temp16Bytes + 1754 NdefMap->SendRecvBuf[Temp16Bytes]); 1755 1756 NdefMap->TLVStruct.NdefTLVByte = 1757 ((Temp16Bytes % 1758 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 1759 PH_FRINFC_NDEFMAP_MFUL_VAL1); 1760 1761 NdefMap->TLVStruct.NdefTLVBlock = 1762 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock /4) * 4) 1763 + (Temp16Bytes)/ 1764 PH_FRINFC_NDEFMAP_MFUL_VAL4); 1765 1766 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector; 1767 1768 } 1769 #ifdef PH_HAL4_ENABLE 1770 else 1771 { 1772 /* if the Type of the NDEF TLV is not found, then return 1773 error saying no ndef TLV found*/ 1774 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1775 NFCSTATUS_NO_NDEF_SUPPORT); 1776 break; 1777 #if 0 1778 /* This change is added to continue the loop, if the Type of the 1779 NDEF TLV is not found 1780 16 bytes are read, so for each byte, there is a check for the 1781 Type (T) of the TLV, if T != 0x03, then increment the byte 1782 count and restart the loop, till the T = 0x03 is found or all 1783 the bytes in the card is completely read. 1784 */ 1785 Temp16Bytes = (uint16_t)(Temp16Bytes + 1); 1786 NdefMap->MifareULContainer.RemainingSize -= 1787 PH_FRINFC_NDEFMAP_MFUL_VAL1; 1788 if (NdefMap->MifareULContainer.RemainingSize == 1789 PH_FRINFC_NDEFMAP_MFUL_VAL0) 1790 { 1791 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1792 NFCSTATUS_NO_NDEF_SUPPORT); 1793 break; 1794 } 1795 else 1796 { 1797 Result = NFCSTATUS_SUCCESS; 1798 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1799 Temp16Bytes); 1800 if(NFCSTATUS_PENDING == Result) 1801 { 1802 break; 1803 } 1804 continue; 1805 } 1806 #endif /* #if 0 */ 1807 } 1808 #endif /* #ifdef PH_HAL4_ENABLE */ 1809 1810 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1811 Temp16Bytes); 1812 if(Result != NFCSTATUS_SUCCESS) 1813 { 1814 NdefMap->TLVStruct.TcheckedinTLVFlag = 1815 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1816 NdefMap->TLVStruct.NoLbytesinTLV = 1817 PH_FRINFC_NDEFMAP_MFUL_VAL3; 1818 break; 1819 } 1820 Temp16Bytes++; 1821 NdefMap->MifareULContainer.RemainingSize -= 1822 PH_FRINFC_NDEFMAP_MFUL_VAL1; 1823 1824 if(NdefMap->MifareULContainer.RemainingSize == 1825 PH_FRINFC_NDEFMAP_MFUL_VAL0) 1826 { 1827 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1828 NFCSTATUS_NO_NDEF_SUPPORT)); 1829 break; 1830 } 1831 1832 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1833 Temp16Bytes); 1834 if(Result != NFCSTATUS_SUCCESS) 1835 { 1836 NdefMap->TLVStruct.TcheckedinTLVFlag = 1837 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1838 NdefMap->TLVStruct.NoLbytesinTLV = 1839 PH_FRINFC_NDEFMAP_MFUL_VAL3; 1840 break; 1841 } 1842 1843 /* If the value of the Length(L) in TLV is FF then enter else 1844 check for the card memory */ 1845 if((NdefMap->SendRecvBuf[Temp16Bytes] == 1846 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 1847 ((NdefMap->SendRecvBuf[Temp16Bytes] == 1848 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 1849 (NdefMap->TLVStruct.NdefTLVFoundFlag != 1850 PH_FRINFC_NDEFMAP_MFUL_FLAG1))) 1851 { 1852 /* In the present case, the card space is not greater 1853 than 0xFF */ 1854 /* 1855 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1856 NFCSTATUS_NO_NDEF_SUPPORT); 1857 1858 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1859 break; 1860 */ 1861 1862 Temp16Bytes++; 1863 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1864 Temp16Bytes); 1865 if(Result != NFCSTATUS_SUCCESS) 1866 { 1867 NdefMap->TLVStruct.TcheckedinTLVFlag = 1868 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1869 NdefMap->TLVStruct.NoLbytesinTLV = 1870 PH_FRINFC_NDEFMAP_MFUL_VAL2; 1871 1872 break; 1873 } 1874 1875 ShiftLength = (uint16_t) NdefMap->SendRecvBuf[Temp16Bytes]; 1876 NdefMap->MifareULContainer.RemainingSize--; 1877 1878 Temp16Bytes++; 1879 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap, 1880 Temp16Bytes); 1881 if(Result != NFCSTATUS_SUCCESS) 1882 { 1883 NdefMap->TLVStruct.TcheckedinTLVFlag = 1884 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1885 NdefMap->TLVStruct.NoLbytesinTLV = 1886 PH_FRINFC_NDEFMAP_MFUL_VAL1; 1887 NdefMap->TLVStruct.prevLenByteValue = 1888 NdefMap->SendRecvBuf[Temp16Bytes - 1]; 1889 break; 1890 } 1891 1892 1893 ShiftLength = 1894 (((uint16_t) (NdefMap->SendRecvBuf[Temp16Bytes]) 1895 << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 1896 ShiftLength); 1897 1898 // NdefMap->MifareULContainer.RemainingSize--; 1899 1900 if(ShiftLength > (NdefMap->MifareULContainer.RemainingSize)) 1901 { 1902 // Size in the Length(L) of TLV is greater 1903 //than the actual size of the card 1904 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1905 NFCSTATUS_INVALID_PARAMETER); 1906 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1907 break; 1908 } 1909 1910 // NdefMap->MifareULContainer.RemainingSize--; 1911 /* 1912 NdefMap->TLVStruct.NdefTLVByte = 1913 (NdefMap->SendRecvBuf[Temp16Bytes] % 1914 PH_FRINFC_NDEFMAP_MFUL_VAL4); 1915 1916 NdefMap->TLVStruct.NdefTLVBlock = 1917 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 1918 + (Temp16Bytes/PH_FRINFC_NDEFMAP_MFUL_VAL4)); 1919 */ 1920 1921 NdefMap->TLVStruct.ActualSize = 1922 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 1923 1924 NdefMap->TLVStruct.NdefTLVFoundFlag = 1; 1925 1926 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector; 1927 1928 1929 Result = ((NdefMap->TLVStruct.NoLbytesinTLV == 1930 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 1931 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength): 1932 Result); 1933 /* 1934 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 1935 NdefMap->TLVStruct.NdefTLVBlock); 1936 */ 1937 break; 1938 } 1939 else 1940 { 1941 NdefMap->TLVStruct.BytesRemainLinTLV = 1942 NdefMap->SendRecvBuf[Temp16Bytes]; 1943 1944 NdefMap->TLVStruct.ActualSize = 1945 NdefMap->SendRecvBuf[Temp16Bytes]; 1946 1947 if((NdefMap->MifareULContainer.RemainingSize < 1948 NdefMap->SendRecvBuf[Temp16Bytes]) || 1949 (NdefMap->MifareULContainer.RemainingSize < 1950 PH_FRINFC_NDEFMAP_MFUL_VAL2) || 1951 (NdefMap->TLVStruct.BytesRemainLinTLV > 1952 (NdefMap->MifareULContainer.RemainingSize)) || 1953 ((NdefMap->TLVStruct.BytesRemainLinTLV == 1954 PH_FRINFC_NDEFMAP_MFUL_VAL0) && 1955 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))) 1956 { 1957 /* No NDEF TLV found */ 1958 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1959 NFCSTATUS_NO_NDEF_SUPPORT); 1960 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 1961 break; 1962 } 1963 1964 if(NdefMap->TLVStruct.NdefTLVFoundFlag != 1965 PH_FRINFC_NDEFMAP_MFUL_FLAG1) 1966 { 1967 NdefMap->TLVStruct.NdefTLVByte = 1968 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 + 1969 NdefMap->SendRecvBuf[Temp16Bytes]) % 1970 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 1971 PH_FRINFC_NDEFMAP_MFUL_VAL1); 1972 NdefMap->TLVStruct.NdefTLVBlock = 1973 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 1974 + ((Temp16Bytes + 1975 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/ 1976 PH_FRINFC_NDEFMAP_MFUL_VAL4)); 1977 1978 TemLength = (Temp16Bytes + 1979 NdefMap->SendRecvBuf[Temp16Bytes]); 1980 1981 NdefMap->MifareULContainer.RemainingSize = 1982 (NdefMap->MifareULContainer.RemainingSize - 1983 (NdefMap->SendRecvBuf[Temp16Bytes] 1984 + PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1985 1986 /* If the Length (L) in TLV < 16 bytes */ 1987 Temp16Bytes = ((TemLength >= 1988 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)? 1989 PH_FRINFC_NDEFMAP_MFUL_VAL0: 1990 (TemLength + 1991 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 1992 1993 Result = ((TemLength >= 1994 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)? 1995 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 1996 NdefMap->TLVStruct.NdefTLVBlock): 1997 NFCSTATUS_SUCCESS); 1998 1999 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16) 2000 { 2001 break; 2002 } 2003 TemLength = Temp16Bytes; 2004 } 2005 } 2006 if(NdefMap->TLVStruct.NdefTLVFoundFlag == 2007 PH_FRINFC_NDEFMAP_MFUL_FLAG1) 2008 { 2009 #if 0 2010 NdefMap->TLVStruct.NdefTLVBlock = 2011 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock 2012 + ((Temp16Bytes + 1)/ 2013 PH_FRINFC_NDEFMAP_MFUL_VAL4)) - 1; 2014 #endif 2015 NdefMap->MifareULContainer.RemainingSize = 2016 (NdefMap->MifareULContainer.RemainingSize - 2017 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2018 ShiftLength = NdefMap->SendRecvBuf[Temp16Bytes]; 2019 Result = ((NdefMap->TLVStruct.NoLbytesinTLV == 2020 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 2021 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength): 2022 Result); 2023 2024 break; 2025 } 2026 } 2027 } 2028 } 2029 2030 return Result; 2031 } 2032 2033 2034 static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap, 2035 uint16_t TempLength) 2036 { 2037 uint16_t localCurrentBlock; 2038 2039 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2040 if(TempLength == PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16) 2041 { 2042 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 2043 PH_FRINFC_NDEFMAP_MFUL_BLOCK4; 2044 2045 if (localCurrentBlock < 256) 2046 { 2047 NdefMap->MifareULContainer.CurrentBlock += 2048 PH_FRINFC_NDEFMAP_MFUL_BLOCK4; 2049 2050 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 2051 NdefMap->MifareULContainer.CurrentBlock); 2052 } 2053 else 2054 { 2055 /* Go to next sector */ 2056 NdefMap->MifareULContainer.CurrentSector++; 2057 2058 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 2059 NdefMap->MifareULContainer.CurrentSector, 1, 2060 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1); 2061 } 2062 } 2063 2064 return Result; 2065 } 2066 2067 2068 static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch, 2069 uint16_t *lpwCrc ) 2070 { 2071 ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF)); 2072 ch = (ch^(ch<<4)); 2073 *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^ \ 2074 ((uint16_t)ch<<3)^((uint16_t)ch>>4); 2075 2076 return; 2077 } 2078 2079 static void phFriNfc_MfUL_H_ComputeCrc( int CRCType, 2080 uint8_t *Data, 2081 int Length, 2082 uint8_t *TransmitFirst, 2083 uint8_t *TransmitSecond 2084 ) 2085 { 2086 uint8_t chBlock; 2087 uint16_t wCrc; 2088 switch(CRCType) 2089 { 2090 case CRC_A: 2091 wCrc = 0x6363; /* ITU-V.41 */ 2092 break; 2093 case CRC_B: 2094 wCrc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */ 2095 break; 2096 default: 2097 return; 2098 } 2099 2100 do 2101 { 2102 chBlock = *Data++; 2103 phFriNfc_MfUL_H_UpdateCrc(chBlock, &wCrc); 2104 } while (--Length); 2105 *TransmitFirst = (uint8_t) (wCrc & 0xFF); 2106 *TransmitSecond = (uint8_t) ((wCrc >> 8) & 0xFF); 2107 return; 2108 } 2109 2110 2111 2112 static NFCSTATUS phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t *NdefMap, 2113 uint8_t SectorNo, 2114 uint8_t CmdNo, 2115 uint8_t NextState) 2116 { 2117 2118 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2119 2120 /* set the data for additional data exchange */ 2121 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2122 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2123 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2124 2125 NdefMap->State = NextState; 2126 2127 if (CmdNo == 1) 2128 { 2129 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00; 2130 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; 2131 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0xC2; 2132 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0xFF; 2133 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL4; 2134 } 2135 else 2136 { 2137 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00; 2138 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; 2139 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = SectorNo; 2140 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0; 2141 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL4] = 0; 2142 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL5] = 0; 2143 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL5 + 1; 2144 } 2145 2146 /* Calculate CRC */ 2147 2148 phFriNfc_MfUL_H_ComputeCrc(CRC_A, &NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2], 2149 NdefMap->SendLength - 2, 2150 &NdefMap->SendRecvBuf[NdefMap->SendLength], 2151 &NdefMap->SendRecvBuf[NdefMap->SendLength + 1]); 2152 2153 NdefMap->SendLength += PH_FRINFC_NDEFMAP_MFUL_VAL2; 2154 2155 2156 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 2157 2158 NdefMap->Cmd.MfCmd = phHal_eMifareRaw; 2159 2160 /* Call the overlapped HAL Transceive function */ 2161 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 2162 &NdefMap->MapCompletionInfo, 2163 NdefMap->psRemoteDevInfo, 2164 NdefMap->Cmd, 2165 &NdefMap->psDepAdditionalInfo, 2166 NdefMap->SendRecvBuf, 2167 NdefMap->SendLength, 2168 NdefMap->SendRecvBuf, 2169 NdefMap->SendRecvLength); 2170 return Result; 2171 } 2172 2173 2174 static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t *NdefMap, 2175 uint8_t BlockNo) 2176 { 2177 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2178 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP; 2179 /* set the data for additional data exchange */ 2180 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2181 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2182 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2183 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 2184 BlockNo; 2185 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1; 2186 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 2187 2188 /* 2189 * Changed 2190 * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead 2191 */ 2192 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 2193 2194 /* Call the overlapped HAL Transceive function */ 2195 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 2196 &NdefMap->MapCompletionInfo, 2197 NdefMap->psRemoteDevInfo, 2198 NdefMap->Cmd, 2199 &NdefMap->psDepAdditionalInfo, 2200 NdefMap->SendRecvBuf, 2201 NdefMap->SendLength, 2202 NdefMap->SendRecvBuf, 2203 NdefMap->SendRecvLength); 2204 return Result; 2205 } 2206 2207 static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t *NdefMap, 2208 uint8_t *CRFlag) 2209 { 2210 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2211 uint16_t TempLength = PH_FRINFC_NDEFMAP_MFUL_VAL0, 2212 ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2213 2214 switch(NdefMap->TLVStruct.NoLbytesinTLV) 2215 { 2216 case PH_FRINFC_NDEFMAP_MFUL_VAL1: 2217 case PH_FRINFC_NDEFMAP_MFUL_VAL2: 2218 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == 2219 PH_FRINFC_NDEFMAP_MFUL_VAL1)? 2220 NdefMap->TLVStruct.prevLenByteValue: 2221 NdefMap->SendRecvBuf[TempLength]); 2222 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == 2223 PH_FRINFC_NDEFMAP_MFUL_VAL1)? 2224 (((uint16_t)(NdefMap->SendRecvBuf[TempLength]) << 2225 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 2226 ShiftLength): 2227 (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + 2228 PH_FRINFC_NDEFMAP_MFUL_VAL1)]) << 2229 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 2230 ShiftLength)); 2231 2232 NdefMap->MifareULContainer.RemainingSize -= 2233 PH_FRINFC_NDEFMAP_MFUL_VAL1; 2234 2235 NdefMap->TLVStruct.ActualSize = 2236 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 2237 2238 /* Check for remaining free space in the card with the 2239 length (L) of TLV OR length(L) of TLV is less than 2240 255 bytes (The length (L) of TLV for 3 byte should not 2241 be less than 255) */ 2242 Result = ((((NdefMap->MifareULContainer.RemainingSize)<= 2243 ShiftLength) || (ShiftLength < 2244 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF))? 2245 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2246 NFCSTATUS_INVALID_PARAMETER)): 2247 Result); 2248 2249 2250 Result = ((Result == NFCSTATUS_SUCCESS)? 2251 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength): 2252 Result); 2253 2254 *CRFlag = (uint8_t)((Result == (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2255 NFCSTATUS_INVALID_PARAMETER)))? 2256 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 2257 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 2258 2259 2260 if(Result == NFCSTATUS_SUCCESS) 2261 { 2262 2263 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize- 2264 NdefMap->TLVStruct.NoLbytesinTLV; 2265 /* 2266 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% 2267 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 2268 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2269 2270 NdefMap->TLVStruct.NdefTLVBlock = 2271 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 2272 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4)); 2273 NdefMap->MifareULContainer.CurrentBlock = 2274 NdefMap->TLVStruct.NdefTLVBlock; 2275 2276 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 2277 NdefMap->TLVStruct.NdefTLVBlock); 2278 */ 2279 } 2280 break; 2281 2282 default: 2283 if((NdefMap->SendRecvBuf[TempLength] == 2284 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) || 2285 ((NdefMap->SendRecvBuf[TempLength] == 2286 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) && 2287 (NdefMap->TLVStruct.NdefTLVFoundFlag != 2288 PH_FRINFC_NDEFMAP_MFUL_FLAG1))) 2289 { 2290 /* In the present case, the card space is not greater 2291 than 0xFF */ 2292 /* 2293 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2294 NFCSTATUS_NO_NDEF_SUPPORT); 2295 2296 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 2297 2298 */ 2299 2300 ShiftLength = NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL1)]; 2301 ShiftLength = (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL2)]) 2302 << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) | 2303 ShiftLength); 2304 Result = ((ShiftLength > (NdefMap->MifareULContainer.RemainingSize))? 2305 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2306 NFCSTATUS_INVALID_PARAMETER)): 2307 Result); 2308 2309 2310 Result = ((Result == NFCSTATUS_SUCCESS)? 2311 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength): 2312 Result); 2313 2314 NdefMap->TLVStruct.ActualSize = 2315 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 2316 2317 if(Result == NFCSTATUS_SUCCESS) 2318 { 2319 2320 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize- 2321 NdefMap->TLVStruct.NoLbytesinTLV; 2322 /* 2323 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength% 2324 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 2325 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2326 2327 NdefMap->TLVStruct.NdefTLVBlock = 2328 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 2329 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4)); 2330 2331 NdefMap->MifareULContainer.CurrentBlock = 2332 NdefMap->TLVStruct.NdefTLVBlock; 2333 2334 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 2335 NdefMap->TLVStruct.NdefTLVBlock); 2336 */ 2337 } 2338 } 2339 else 2340 { 2341 /* length (L) value in TLV shall not be greater than 2342 remaining free space in the card */ 2343 Result = ((NdefMap->SendRecvBuf[TempLength] > 2344 NdefMap->MifareULContainer.RemainingSize)? 2345 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2346 NFCSTATUS_INVALID_PARAMETER)): 2347 Result); 2348 2349 NdefMap->TLVStruct.ActualSize = 2350 NdefMap->TLVStruct.BytesRemainLinTLV = 2351 NdefMap->SendRecvBuf[TempLength]; 2352 NdefMap->MifareULContainer.RemainingSize--; 2353 2354 if((Result == NFCSTATUS_SUCCESS) && 2355 (NdefMap->TLVStruct.NdefTLVFoundFlag != 2356 PH_FRINFC_NDEFMAP_MFUL_FLAG1)) 2357 { 2358 phFriNfc_MfUL_H_UpdateLen(NdefMap, 2359 (uint16_t)NdefMap->SendRecvBuf[TempLength]); 2360 2361 NdefMap->MifareULContainer.CurrentBlock = 2362 NdefMap->TLVStruct.NdefTLVBlock; 2363 TempLength=TempLength+(NdefMap->SendRecvBuf[TempLength]); 2364 Result =((TempLength < PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)? 2365 phFriNfc_MfUL_H_findNDEFTLV(NdefMap, CRFlag): 2366 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 2367 NdefMap->TLVStruct.NdefTLVBlock)); 2368 } 2369 } 2370 break; 2371 } 2372 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2373 2374 Result = phFriNfc_MapTool_SetCardState( NdefMap, NdefMap->TLVStruct.ActualSize); 2375 2376 return Result; 2377 } 2378 2379 static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t *NdefMap, 2380 uint16_t DataLen) 2381 { 2382 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-DataLen; 2383 NdefMap->TLVStruct.NdefTLVByte = ((DataLen % 2384 PH_FRINFC_NDEFMAP_MFUL_VAL4) + 2385 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2386 NdefMap->TLVStruct.NdefTLVBlock = 2387 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock 2388 + (DataLen/PH_FRINFC_NDEFMAP_MFUL_VAL4)); 2389 } 2390 2391 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t *NdefMap, 2392 uint8_t *CRFlag) 2393 { 2394 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2395 2396 switch(NdefMap->PrevOperation) 2397 { 2398 case PH_FRINFC_NDEFMAP_CHECK_OPE: 2399 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 2400 break; 2401 2402 case PH_FRINFC_NDEFMAP_READ_OPE: 2403 if (NdefMap->TLVStruct.NdefTLVSector == 1) 2404 { 2405 /* Goto sector 1 */ 2406 NdefMap->MifareULContainer.CurrentSector = 1; 2407 NdefMap->MifareULContainer.CurrentBlock = 0; 2408 2409 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 2410 NdefMap->MifareULContainer.CurrentSector, 1, 2411 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1); 2412 } 2413 else 2414 { 2415 NdefMap->MifareULContainer.CurrentBlock = (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4; 2416 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap); 2417 } 2418 #if 0 2419 NdefMap->MifareULContainer.CurrentBlock = 2420 PH_FRINFC_NDEFMAP_MFUL_VAL4; 2421 2422 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap); 2423 #endif 2424 2425 2426 *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)? 2427 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 2428 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 2429 break; 2430 2431 case PH_FRINFC_NDEFMAP_WRITE_OPE: 2432 break; 2433 2434 default: 2435 break; 2436 } 2437 return Result; 2438 } 2439 2440 2441 2442 static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t *NdefMap) 2443 { 2444 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2445 uint16_t localCurrentBlock; 2446 2447 (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[ 2448 NdefMap->MifareULContainer.ReadBufIndex]), 2449 NdefMap->SendRecvBuf, 2450 *NdefMap->SendRecvLength); 2451 NdefMap->MifareULContainer.ReadBufIndex=NdefMap->MifareULContainer.ReadBufIndex +*NdefMap->SendRecvLength; 2452 2453 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock+ 2454 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != 2455 NdefMap->CardMemSize)? 2456 PH_FRINFC_NDEFMAP_MFUL_BLOCK4: 2457 PH_FRINFC_NDEFMAP_MFUL_VAL0); 2458 if (localCurrentBlock < 256) 2459 { 2460 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+ 2461 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex != 2462 NdefMap->CardMemSize)? 2463 PH_FRINFC_NDEFMAP_MFUL_BLOCK4: 2464 PH_FRINFC_NDEFMAP_MFUL_VAL0); 2465 } 2466 else 2467 { 2468 /* Go to next sector */ 2469 if (NdefMap->MifareULContainer.CurrentSector == 0) 2470 { 2471 NdefMap->MifareULContainer.CurrentSector++; 2472 NdefMap->MifareULContainer.CurrentBlock = 0xff; 2473 2474 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 2475 NdefMap->MifareULContainer.CurrentSector, 1, 2476 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1); 2477 } 2478 } 2479 2480 return Result; 2481 } 2482 2483 static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap) 2484 { 2485 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2486 2487 /* Check the user buffer size with the 2488 L value of TLV */ 2489 if(NdefMap->ApduBufferSize >= 2490 NdefMap->TLVStruct.BytesRemainLinTLV) 2491 { 2492 (void)memcpy(NdefMap->ApduBuffer, 2493 &(NdefMap->MifareULContainer.ReadBuf[ 2494 NdefMap->MifareULContainer.ByteNumber]), 2495 NdefMap->TLVStruct.BytesRemainLinTLV); 2496 2497 *(NdefMap->NumOfBytesRead) = 2498 NdefMap->TLVStruct.BytesRemainLinTLV; 2499 NdefMap->MifareULContainer.ByteNumber = 2500 PH_FRINFC_NDEFMAP_MFUL_VAL0; 2501 NdefMap->MifareULContainer.ReadWriteCompleteFlag = 2502 PH_FRINFC_NDEFMAP_MFUL_FLAG1; 2503 NdefMap->MifareULContainer.RemainingSize = NdefMap->MifareULContainer.RemainingSize- 2504 NdefMap->TLVStruct.BytesRemainLinTLV; 2505 NdefMap->TLVStruct.BytesRemainLinTLV = 2506 PH_FRINFC_NDEFMAP_MFUL_VAL0; 2507 } 2508 else 2509 { 2510 (void)memcpy(NdefMap->ApduBuffer, 2511 &(NdefMap->MifareULContainer.ReadBuf[ 2512 NdefMap->MifareULContainer.ByteNumber]), 2513 NdefMap->ApduBufferSize); 2514 2515 *(NdefMap->NumOfBytesRead) = 2516 NdefMap->ApduBufferSize; 2517 NdefMap->MifareULContainer.ByteNumber = NdefMap->MifareULContainer.ByteNumber+ 2518 (uint16_t)NdefMap->ApduBufferSize; 2519 NdefMap->MifareULContainer.RemainingSize=NdefMap->MifareULContainer.RemainingSize- 2520 (uint16_t)NdefMap->ApduBufferSize; 2521 NdefMap->TLVStruct.BytesRemainLinTLV = NdefMap->TLVStruct.BytesRemainLinTLV- 2522 (uint16_t)NdefMap->ApduBufferSize; 2523 } 2524 return Result; 2525 } 2526 2527 static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t *NdefMap) 2528 { 2529 uint16_t localCurrentBlock = NdefMap->TLVStruct.NdefTLVBlock; 2530 2531 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2532 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0, 2533 i = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2534 /* BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;*/ 2535 uint16_t TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2536 2537 switch((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1)) 2538 { 2539 case PH_FRINFC_NDEFMAP_MFUL_VAL0: 2540 /* go the NDEF TLV block to start write */ 2541 NdefMap->MifareULContainer.CurrentBlock = 2542 NdefMap->TLVStruct.NdefTLVBlock; 2543 /* fill send buffer for write */ 2544 NdefMap->SendRecvBuf[index] = 2545 NdefMap->MifareULContainer.CurrentBlock; 2546 index++; 2547 NdefMap->SendRecvBuf[index] = 2548 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T; 2549 index++; 2550 if (NdefMap->ApduBufferSize > 254) 2551 { 2552 NdefMap->SendRecvBuf[index] = 0xFF; 2553 index++; 2554 NdefMap->SendRecvBuf[index] = 2555 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2556 index++; 2557 NdefMap->SendRecvBuf[index] = 2558 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2559 index++; 2560 } 2561 else 2562 { 2563 NdefMap->SendRecvBuf[index] = 2564 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2565 index++; 2566 } 2567 2568 2569 break; 2570 2571 case PH_FRINFC_NDEFMAP_MFUL_VAL1: 2572 case PH_FRINFC_NDEFMAP_MFUL_VAL2: 2573 /* read to get the previous bytes */ 2574 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, 2575 NdefMap->TLVStruct.NdefTLVBlock); 2576 break; 2577 2578 case PH_FRINFC_NDEFMAP_MFUL_VAL3: 2579 2580 localCurrentBlock = (NdefMap->MifareULContainer.CurrentBlock + 2581 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2582 2583 if (localCurrentBlock < 256) 2584 { 2585 2586 NdefMap->MifareULContainer.CurrentBlock = 2587 (NdefMap->MifareULContainer.CurrentBlock + 2588 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2589 NdefMap->SendRecvBuf[index] = 2590 NdefMap->MifareULContainer.CurrentBlock; 2591 index++; 2592 2593 if (NdefMap->ApduBufferSize > 254) 2594 { 2595 NdefMap->SendRecvBuf[index] = 0xFF; 2596 index++; 2597 NdefMap->SendRecvBuf[index] = 2598 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2599 index++; 2600 NdefMap->SendRecvBuf[index] = 2601 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2602 index++; 2603 } 2604 else 2605 { 2606 NdefMap->SendRecvBuf[index] = 2607 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2608 index++; 2609 } 2610 } 2611 else 2612 { 2613 /* Go to next sector */ 2614 NdefMap->MifareULContainer.CurrentSector++; 2615 2616 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 2617 NdefMap->MifareULContainer.CurrentSector, 1, 2618 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1); 2619 } 2620 break; 2621 2622 default: 2623 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2624 NFCSTATUS_INVALID_REMOTE_DEVICE); 2625 break; 2626 } 2627 2628 if((((NdefMap->TLVStruct.NdefTLVByte - 2629 PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) || 2630 ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) 2631 == PH_FRINFC_NDEFMAP_MFUL_VAL3)) && localCurrentBlock < 256) 2632 { 2633 /* Length to know how many bytes has to be written to the card */ 2634 TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) == 2635 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 2636 PH_FRINFC_NDEFMAP_MFUL_VAL2: 2637 PH_FRINFC_NDEFMAP_MFUL_VAL3); 2638 2639 if (NdefMap->ApduBufferSize > 254) 2640 { 2641 TemLength -= 2; 2642 } 2643 2644 if(NdefMap->ApduBufferSize >= TemLength) 2645 { 2646 /* Prepare the receive buffer */ 2647 (void)memcpy(&(NdefMap->SendRecvBuf[ 2648 index]), 2649 &(NdefMap->ApduBuffer[ 2650 NdefMap->ApduBuffIndex]), 2651 TemLength); 2652 2653 /* Number of bytes written to the card from user buffer */ 2654 NdefMap->NumOfBytesWritten = TemLength; 2655 2656 index = index+(uint8_t)TemLength; 2657 /* Exact number of bytes written in the card including TLV */ 2658 if (index >= 1) 2659 { 2660 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1); 2661 } 2662 else 2663 { 2664 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2665 NFCSTATUS_INVALID_REMOTE_DEVICE); 2666 } 2667 } 2668 else 2669 { 2670 /* Prepare the receive buffer */ 2671 (void)memcpy(&(NdefMap->SendRecvBuf[ 2672 index]), 2673 &(NdefMap->ApduBuffer[ 2674 NdefMap->ApduBuffIndex]), 2675 (uint16_t)NdefMap->ApduBufferSize); 2676 2677 /* Number of bytes written to the card from user buffer */ 2678 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize; 2679 2680 index= index +(uint8_t)NdefMap->ApduBufferSize; 2681 /* Exact number of bytes written in the card including TLV */ 2682 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1); 2683 2684 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++) 2685 { 2686 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)? 2687 PH_FRINFC_NDEFMAP_MFUL_TERMTLV: 2688 PH_FRINFC_NDEFMAP_MFUL_NULLTLV); 2689 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 2690 } 2691 } 2692 2693 /* store the bytes in buffer till the bytes are 2694 written in a block */ 2695 (void)memcpy(NdefMap->MifareULContainer.Buffer, 2696 &(NdefMap->SendRecvBuf[ 2697 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 2698 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 2699 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 2700 2701 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 2702 NdefMap->MifareULContainer.Buffer, 2703 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK - 2704 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 2705 2706 /* Change the state to check ndef compliancy */ 2707 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 2708 2709 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 2710 } 2711 return Result; 2712 } 2713 2714 static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t *NdefMap) 2715 { 2716 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2717 /* uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL1;*/ 2718 2719 2720 NdefMap->MifareULContainer.CurrentBlock = 2721 NdefMap->TLVStruct.NdefTLVBlock; 2722 2723 (void)memcpy(&(NdefMap->SendRecvBuf[ 2724 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 2725 NdefMap->SendRecvBuf, 2726 PH_FRINFC_NDEFMAP_MFUL_VAL4); 2727 2728 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 2729 NdefMap->MifareULContainer.CurrentBlock; 2730 2731 if (NdefMap->ApduBufferSize > 254) 2732 { 2733 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 2734 PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 0xFF; 2735 2736 2737 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < 2738 PH_FRINFC_NDEFMAP_MFUL_VAL4) 2739 { 2740 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 2741 PH_FRINFC_NDEFMAP_MFUL_VAL2 )] = 0x00; 2742 2743 NdefMap->NumOfLReminWrite = 1; 2744 2745 } 2746 else 2747 { 2748 NdefMap->NumOfLReminWrite = 2; 2749 } 2750 NdefMap->NumOfBytesWritten = 0; 2751 } 2752 else 2753 { 2754 /* Write the length value = 0 */ 2755 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte + 2756 PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 2757 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L; 2758 2759 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) < 2760 PH_FRINFC_NDEFMAP_MFUL_VAL4) 2761 { 2762 /* Only one byte */ 2763 (void)memcpy(&(NdefMap->SendRecvBuf[ 2764 PH_FRINFC_NDEFMAP_MFUL_VAL4]), 2765 &(NdefMap->ApduBuffer[ 2766 NdefMap->ApduBuffIndex]), 2767 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2768 /* Number of bytes written to the card from user buffer */ 2769 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL1; 2770 } 2771 } 2772 2773 (void)memcpy(NdefMap->MifareULContainer.Buffer, 2774 &(NdefMap->SendRecvBuf[ 2775 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 2776 PH_FRINFC_NDEFMAP_MFUL_VAL4); 2777 2778 /* Copy the Ndef TLV buffer to send buffer */ 2779 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 2780 NdefMap->MifareULContainer.Buffer, 2781 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 2782 2783 /* Exact number of bytes written in the card including TLV */ 2784 *NdefMap->DataCount = PH_FRINFC_NDEFMAP_MFUL_VAL4; 2785 2786 /* Change the state to check ndef compliancy */ 2787 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 2788 2789 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 2790 2791 return Result; 2792 } 2793 2794 static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap) 2795 { 2796 uint16_t localCurrentBlock; 2797 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2798 NFCSTATUS_INVALID_REMOTE_DEVICE); 2799 2800 if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize) 2801 { 2802 NdefMap->ApduBuffIndex = NdefMap->ApduBuffIndex+NdefMap->NumOfBytesWritten; 2803 if(*NdefMap->DataCount < 2804 PH_FRINFC_NDEFMAP_MFUL_VAL4) 2805 { 2806 (void)memcpy(NdefMap->MifareULContainer.InternalBuf, 2807 NdefMap->MifareULContainer.Buffer, 2808 *NdefMap->DataCount); 2809 2810 NdefMap->MifareULContainer.InternalLength = *NdefMap->DataCount; 2811 } 2812 else 2813 { 2814 NdefMap->MifareULContainer.InternalLength = 2815 PH_FRINFC_NDEFMAP_MFUL_VAL0; 2816 } 2817 2818 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize- 2819 NdefMap->NumOfBytesWritten; 2820 if((NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize) || 2821 (NdefMap->MifareULContainer.RemainingSize == 2822 PH_FRINFC_NDEFMAP_MFUL_VAL0)) 2823 { 2824 Result = NFCSTATUS_SUCCESS; 2825 NdefMap->MifareULContainer.ReadWriteCompleteFlag = 2826 (uint8_t)((NdefMap->MifareULContainer.RemainingSize == 2827 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 2828 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 2829 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 2830 2831 NdefMap->TLVStruct.SetTermTLVFlag = 2832 (uint8_t)(((NdefMap->MifareULContainer.RemainingSize == 2833 PH_FRINFC_NDEFMAP_MFUL_VAL0) || 2834 (NdefMap->TLVStruct.SetTermTLVFlag == 2835 PH_FRINFC_NDEFMAP_MFUL_FLAG1))? 2836 PH_FRINFC_NDEFMAP_MFUL_FLAG1: 2837 PH_FRINFC_NDEFMAP_MFUL_FLAG0); 2838 2839 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+ 2840 (uint8_t)((NdefMap->MifareULContainer.InternalLength != 2841 PH_FRINFC_NDEFMAP_MFUL_VAL0)? 2842 PH_FRINFC_NDEFMAP_MFUL_VAL0: 2843 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2844 2845 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 2846 } 2847 else 2848 { 2849 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 1; 2850 if (localCurrentBlock < 256) 2851 { 2852 NdefMap->MifareULContainer.CurrentBlock++; 2853 Result = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap); 2854 } 2855 else 2856 { 2857 /* Go to next sector */ 2858 NdefMap->MifareULContainer.CurrentSector++; 2859 2860 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 2861 NdefMap->MifareULContainer.CurrentSector, 1, 2862 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1); 2863 } 2864 } 2865 } 2866 2867 if((Result == NFCSTATUS_SUCCESS) && 2868 (NdefMap->TLVStruct.SetTermTLVFlag != 2869 PH_FRINFC_NDEFMAP_MFUL_FLAG1) && 2870 (NdefMap->MifareULContainer.RemainingSize > 2871 PH_FRINFC_NDEFMAP_MFUL_VAL0)) 2872 { 2873 Result = phFriNfc_MfUL_H_WrTermTLV(NdefMap); 2874 } 2875 else 2876 { 2877 if((Result == NFCSTATUS_SUCCESS) && 2878 (NdefMap->TLVStruct.SetTermTLVFlag == 2879 PH_FRINFC_NDEFMAP_MFUL_FLAG1)) 2880 { 2881 Result = phFriNfc_MfUL_H_UpdateWrLen(NdefMap); 2882 } 2883 } 2884 return Result; 2885 } 2886 static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap) 2887 { 2888 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2889 uint16_t RemainingBytes = PH_FRINFC_NDEFMAP_MFUL_VAL0, 2890 BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2891 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0; 2892 2893 RemainingBytes = (uint16_t)(( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= 2894 NdefMap->MifareULContainer.RemainingSize)? 2895 (uint16_t)(NdefMap->ApduBufferSize - 2896 NdefMap->ApduBuffIndex): 2897 NdefMap->MifareULContainer.RemainingSize); 2898 2899 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 2900 NdefMap->MifareULContainer.CurrentBlock; 2901 2902 /* Get the number of bytes that can be written after copying 2903 the internal buffer */ 2904 BytesToWrite = ((RemainingBytes < 2905 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - 2906 NdefMap->MifareULContainer.InternalLength))? 2907 RemainingBytes: 2908 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 - 2909 NdefMap->MifareULContainer.InternalLength)); 2910 2911 if (NdefMap->NumOfBytesWritten == 0 && NdefMap->NumOfLReminWrite > 0) 2912 { 2913 BytesToWrite = BytesToWrite - NdefMap->NumOfLReminWrite; 2914 2915 if (NdefMap->NumOfLReminWrite == 1) 2916 { 2917 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; 2918 } 2919 else 2920 { 2921 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00; 2922 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0x00; 2923 } 2924 } 2925 2926 if(NdefMap->MifareULContainer.InternalLength > 2927 PH_FRINFC_NDEFMAP_MFUL_VAL0) 2928 { 2929 /* copy the internal buffer to the send buffer */ 2930 (void)memcpy(&(NdefMap->SendRecvBuf[ 2931 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 2932 NdefMap->MifareULContainer.InternalBuf, 2933 NdefMap->MifareULContainer.InternalLength); 2934 2935 } 2936 2937 /* Copy Bytes to write in the send buffer */ 2938 (void)memcpy(&(NdefMap->SendRecvBuf[ 2939 (PH_FRINFC_NDEFMAP_MFUL_VAL1 + 2940 NdefMap->MifareULContainer.InternalLength) + 2941 NdefMap->NumOfLReminWrite]), 2942 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2943 BytesToWrite); 2944 2945 /* update number of bytes written from the user buffer */ 2946 NdefMap->NumOfBytesWritten = BytesToWrite; 2947 2948 /* check the exact number of bytes written to a block including the 2949 internal length */ 2950 *NdefMap->DataCount = 2951 (BytesToWrite + NdefMap->MifareULContainer.InternalLength + 2952 NdefMap->NumOfLReminWrite); 2953 2954 2955 /* if total bytes to write in the card is less than 4 bytes then 2956 pad zeroes till 4 bytes */ 2957 if((BytesToWrite + NdefMap->MifareULContainer.InternalLength + 2958 NdefMap->NumOfLReminWrite) 2959 < PH_FRINFC_NDEFMAP_MFUL_BYTE4) 2960 { 2961 for(index = (uint8_t)((BytesToWrite + NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + 2962 PH_FRINFC_NDEFMAP_MFUL_VAL1); 2963 index < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; 2964 index++) 2965 { 2966 NdefMap->SendRecvBuf[index] = (uint8_t)((index == 2967 ((BytesToWrite + 2968 NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) + 2969 PH_FRINFC_NDEFMAP_MFUL_VAL1))? 2970 PH_FRINFC_NDEFMAP_MFUL_TERMTLV: 2971 PH_FRINFC_NDEFMAP_MFUL_NULLTLV); 2972 2973 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1; 2974 } 2975 } 2976 2977 /* A temporary buffer to hold four bytes of data that is 2978 written to the card */ 2979 (void)memcpy(NdefMap->MifareULContainer.Buffer, 2980 &(NdefMap->SendRecvBuf[ 2981 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 2982 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 2983 2984 2985 2986 if((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) < 2987 PH_FRINFC_NDEFMAP_MFUL_VAL3) 2988 { 2989 if ((NdefMap->TLVStruct.NdefTLVSector == 2990 NdefMap->MifareULContainer.CurrentSector)) 2991 { 2992 if(NdefMap->MifareULContainer.CurrentBlock == 2993 NdefMap->TLVStruct.NdefTLVBlock) 2994 { 2995 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 2996 NdefMap->MifareULContainer.Buffer, 2997 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 2998 } 2999 } 3000 3001 if ((NdefMap->TLVStruct.NdefTLVSector == 3002 NdefMap->MifareULContainer.CurrentSector) || 3003 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF)) 3004 { 3005 if(NdefMap->MifareULContainer.CurrentBlock == 3006 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL1)) 3007 { 3008 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1, 3009 NdefMap->MifareULContainer.Buffer, 3010 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3011 } 3012 } 3013 } 3014 else 3015 { 3016 if ((NdefMap->TLVStruct.NdefTLVSector == 3017 NdefMap->MifareULContainer.CurrentSector)) 3018 { 3019 if(NdefMap->MifareULContainer.CurrentBlock == 3020 (NdefMap->TLVStruct.NdefTLVBlock + 3021 PH_FRINFC_NDEFMAP_MFUL_VAL1)) 3022 { 3023 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer, 3024 NdefMap->MifareULContainer.Buffer, 3025 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3026 } 3027 } 3028 3029 if ((NdefMap->TLVStruct.NdefTLVSector == 3030 NdefMap->MifareULContainer.CurrentSector)|| 3031 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF)) 3032 { 3033 if(NdefMap->MifareULContainer.CurrentBlock == 3034 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL2)) 3035 { 3036 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1, 3037 NdefMap->MifareULContainer.Buffer, 3038 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3039 } 3040 } 3041 } 3042 3043 3044 /* Change the state to check ndef compliancy */ 3045 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 3046 3047 NdefMap->NumOfLReminWrite = 0; 3048 3049 /* Start writing to the current block */ 3050 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 3051 3052 return Result; 3053 } 3054 static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap) 3055 { 3056 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3057 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0, 3058 i = PH_FRINFC_NDEFMAP_MFUL_VAL0; 3059 3060 /* Change the state to check ndef compliancy */ 3061 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV; 3062 3063 NdefMap->SendRecvBuf[index] = 3064 (NdefMap->MifareULContainer.CurrentBlock + 3065 PH_FRINFC_NDEFMAP_MFUL_VAL0); 3066 index++; 3067 NdefMap->SendRecvBuf[index] = PH_FRINFC_NDEFMAP_MFUL_TERMTLV; 3068 index++; 3069 3070 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_VAL4; i++) 3071 { 3072 NdefMap->SendRecvBuf[i] = PH_FRINFC_NDEFMAP_MFUL_NULLTLV; 3073 } 3074 3075 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 3076 return Result; 3077 } 3078 3079 static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap) 3080 { 3081 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3082 uint16_t BlockNo = PH_FRINFC_NDEFMAP_MFUL_VAL0, 3083 ByteNo = PH_FRINFC_NDEFMAP_MFUL_VAL0; 3084 3085 if ((NdefMap->TLVStruct.NdefTLVSector == 3086 NdefMap->MifareULContainer.CurrentSector) || 3087 ((NdefMap->TLVStruct.NdefTLVBlock == 0xFF) && 3088 (NdefMap->TLVStruct.NdefTLVByte == 4) && 3089 (NdefMap->TLVStruct.NdefTLVSector == 0))) 3090 { 3091 BlockNo = (((NdefMap->TLVStruct.NdefTLVByte - 3092 PH_FRINFC_NDEFMAP_MFUL_VAL1) != 3093 PH_FRINFC_NDEFMAP_MFUL_VAL3)? 3094 NdefMap->TLVStruct.NdefTLVBlock: 3095 (NdefMap->TLVStruct.NdefTLVBlock + 3096 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 3097 3098 ByteNo = (((NdefMap->TLVStruct.NdefTLVByte - 3099 PH_FRINFC_NDEFMAP_MFUL_VAL1) == 3100 PH_FRINFC_NDEFMAP_MFUL_VAL3)? 3101 PH_FRINFC_NDEFMAP_MFUL_VAL1: 3102 (NdefMap->TLVStruct.NdefTLVByte + 3103 PH_FRINFC_NDEFMAP_MFUL_VAL1)); 3104 3105 if (NdefMap->NumOfLReminWrite > 0) 3106 { 3107 BlockNo++; 3108 3109 /* Copy the Ndef TLV buffer to send buffer */ 3110 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]), 3111 NdefMap->TLVStruct.NdefTLVBuffer1, 3112 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3113 3114 if (NdefMap->NumOfLReminWrite == 1) 3115 { 3116 NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); 3117 3118 } 3119 else if (NdefMap->NumOfLReminWrite == 2) 3120 { 3121 NdefMap->SendRecvBuf[1]= (uint8_t) (NdefMap->ApduBuffIndex); 3122 NdefMap->SendRecvBuf[2] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); 3123 } 3124 else 3125 { 3126 3127 } 3128 NdefMap->NumOfLReminWrite = 0; 3129 } 3130 else 3131 { 3132 /* Copy the Ndef TLV buffer to send buffer */ 3133 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]), 3134 NdefMap->TLVStruct.NdefTLVBuffer, 3135 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3136 3137 3138 if (NdefMap->ApduBuffIndex > 254) 3139 { 3140 ByteNo++; 3141 if ((ByteNo == 3) || (ByteNo == 2)) 3142 { 3143 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); 3144 ByteNo++; 3145 NdefMap->SendRecvBuf[ByteNo] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); 3146 ByteNo++; 3147 NdefMap->NumOfLReminWrite = 0; 3148 } 3149 else if (ByteNo == 4) 3150 { 3151 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); 3152 ByteNo++; 3153 NdefMap->NumOfLReminWrite = 1; 3154 } 3155 else 3156 { 3157 NdefMap->NumOfLReminWrite = 2; 3158 } 3159 } 3160 else 3161 { 3162 NdefMap->SendRecvBuf[ByteNo]= 3163 (uint8_t)((NdefMap->Offset == 3164 PH_FRINFC_NDEFMAP_SEEK_BEGIN)? 3165 (uint8_t)NdefMap->ApduBuffIndex: 3166 (NdefMap->ApduBuffIndex + 3167 NdefMap->SendRecvBuf[ByteNo])); 3168 } 3169 } 3170 3171 (void)memcpy(NdefMap->MifareULContainer.Buffer, 3172 &(NdefMap->SendRecvBuf[ 3173 PH_FRINFC_NDEFMAP_MFUL_VAL1]), 3174 PH_FRINFC_NDEFMAP_MFUL_BYTE4); 3175 3176 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = (uint8_t)BlockNo; 3177 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap); 3178 3179 if (NdefMap->NumOfLReminWrite == 0) 3180 { 3181 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV; 3182 } 3183 else 3184 { 3185 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV; 3186 } 3187 } 3188 else if (NdefMap->TLVStruct.NdefTLVSector == 0) 3189 { 3190 /* Reset sector */ 3191 NdefMap->MifareULContainer.CurrentSector = 0; 3192 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 3193 3194 Result = phFriNfc_MfUL_H_SelectSector(NdefMap, 3195 NdefMap->MifareULContainer.CurrentSector, 1, 3196 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1); 3197 3198 } 3199 else 3200 { 3201 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 3202 } 3203 3204 3205 return Result; 3206 } 3207 #ifdef UNIT_TEST 3208 extern void phFriNfc_MifareUL_UnitTest(void *Context,uint32_t Length) 3209 { 3210 uint8_t value=10; 3211 uint8_t* CrFlag=&value; 3212 phFriNfc_NdefMap_t *pNdefMap=(phFriNfc_NdefMap_t*)Context; 3213 phFriNfc_MfUL_H_UpdateLen(pNdefMap,(uint16_t) Length); 3214 phFriNfc_MfUL_H_WrTermTLV(pNdefMap); 3215 phFriNfc_MfUL_H_CallWrOp(pNdefMap); 3216 phFriNfc_MfUL_H_UpdateWrLen(pNdefMap); 3217 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag); 3218 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap); 3219 3220 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_READ_OPE; 3221 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag); 3222 3223 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_WRITE_OPE; 3224 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag); 3225 3226 pNdefMap->TLVStruct.NoLbytesinTLV=PH_FRINFC_NDEFMAP_MFUL_VAL1; 3227 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag); 3228 3229 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV; 3230 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag); 3231 3232 3233 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV; 3234 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag); 3235 3236 3237 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap); 3238 pNdefMap->TLVStruct.NdefTLVByte=1; 3239 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap); 3240 3241 pNdefMap->TLVStruct.NdefTLVByte=3; 3242 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap); 3243 3244 pNdefMap->TLVStruct.NdefTLVByte=4; 3245 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap); 3246 3247 3248 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS); 3249 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS); 3250 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS); 3251 pNdefMap->State=PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE; 3252 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS); 3253 3254 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED); 3255 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS); 3256 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED); 3257 3258 *pNdefMap->DataCount=0x3; 3259 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap); 3260 3261 pNdefMap->ApduBuffIndex=0x31; 3262 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap); 3263 3264 3265 3266 } 3267 3268 #endif 3269 #endif /* PH_FRINFC_MAP_MIFAREUL_DISABLED */ 3270 3271
