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