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_MifareStdMap.c 19 * \brief NFC Ndef Mapping For Remote Devices. 20 * 21 * Project: NFC-FRI 22 * 23 * $Date: Thu May 6 10:01:55 2010 $ 24 * $Author: ing02260 $ 25 * $Revision: 1.22 $ 26 * $Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $ 27 * 28 */ 29 30 #ifndef PH_FRINFC_MAP_MIFARESTD_DISABLED 31 32 #include <phFriNfc_MifareStdMap.h> 33 #include <phFriNfc_OvrHal.h> 34 35 #ifndef PH_HAL4_ENABLE 36 #include <phFriNfc_OvrHalCmd.h> 37 #endif 38 39 #include <phFriNfc_MapTools.h> 40 41 /*! \ingroup grp_file_attributes 42 * \name NDEF Mapping 43 * 44 * File: \ref phFriNfcNdefMap.c 45 * 46 */ 47 /*@{*/ 48 #define PHFRINFCMIFARESTDMAP_FILEREVISION "$Revision: 1.22 $" 49 #define PHFRINFCMIFARESTDMAP_FILEALIASES "$Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $" 50 /*@}*/ 51 /*@}*/ 52 53 /*! 54 * \name Mifare Standard Mapping - Helper Functions 55 * 56 */ 57 /*@{*/ 58 59 /*! 60 * \brief \copydoc page_ovr Helper function for Mifare Std. This function Reads 61 * a block from the card. 62 */ 63 static NFCSTATUS phFriNfc_MifStd_H_RdABlock(phFriNfc_NdefMap_t *NdefMap); 64 65 /*! 66 * \brief \copydoc page_ovr Helper function for Mifare Std. This function writes 67 * into a block of the card. 68 */ 69 static NFCSTATUS phFriNfc_MifStd_H_WrABlock(phFriNfc_NdefMap_t *NdefMap); 70 71 /*! 72 * \brief \copydoc page_ovr Helper function for Mifare Std. This function authenticates 73 * one sector at a time. 74 */ 75 static NFCSTATUS phFriNfc_MifStd_H_AuthSector(phFriNfc_NdefMap_t *NdefMap); 76 77 /*! 78 * \brief \copydoc page_ovr Helper function for Mifare 4k Check Ndef to 79 * get the next AID blocks 80 */ 81 static NFCSTATUS phFriNfc_MifStd4k_H_CheckNdef(phFriNfc_NdefMap_t *NdefMap); 82 83 /*! 84 * \brief \copydoc page_ovr Helper function for Check Ndef to store the AIDs 85 */ 86 static void phFriNfc_MifStd_H_fillAIDarray(phFriNfc_NdefMap_t *NdefMap); 87 88 /*! 89 * \brief \copydoc page_ovr Helper function to get the Sector from the current block 90 */ 91 static uint8_t phFriNfc_MifStd_H_GetSect(uint8_t BlockNumber); 92 93 /*! 94 * \brief \copydoc page_ovr Helper function to check the Ndef compliance of the 95 * current block, if the block is not Ndef Compliant, increment the block till 96 * the next Ndef compliant block using the Get Sector Helper function 97 */ 98 static NFCSTATUS phFriNfc_MifStd_H_BlkChk(phFriNfc_NdefMap_t *NdefMap); 99 100 /*! 101 * \brief \copydoc page_ovr Helper function to read the access bits of each sector 102 */ 103 static NFCSTATUS phFriNfc_MifStd_H_RdAcsBit(phFriNfc_NdefMap_t *NdefMap); 104 105 /*! 106 * \brief \copydoc page_ovr Helper function to check the access bits of each sector 107 */ 108 static NFCSTATUS phFriNfc_MifStd_H_ChkAcsBit(phFriNfc_NdefMap_t *NdefMap); 109 110 /*! 111 * \brief \copydoc page_ovr Helper function for read access bits, depending 112 * on the read/write/check ndef function called 113 */ 114 static NFCSTATUS phFriNfc_MifStd_H_ChkRdWr(phFriNfc_NdefMap_t *NdefMap); 115 116 /*! 117 * \brief \copydoc page_ovr Helper function for check ndef to check the 118 * ndef compliant sectors 119 */ 120 static void phFriNfc_MifStd_H_ChkNdefCmpltSects(phFriNfc_NdefMap_t *NdefMap); 121 122 #if 0 123 /*! 124 * \brief \copydoc page_ovr Helper function for read ndef to check the 125 * the length L of the ndef TLV 126 */ 127 static uint8_t phFriNfc_MifStd_H_ChkNdefLen(phFriNfc_NdefMap_t *NdefMap, 128 uint8_t NDEFlength, 129 uint8_t *CRFlag); 130 131 /*! 132 * \brief \copydoc page_ovr Helper function for read ndef to copy the 133 * card data to the user buffer 134 */ 135 static NFCSTATUS phFriNfc_MifStd_H_RdNdefTLV(phFriNfc_NdefMap_t *NdefMap, 136 uint8_t *Temp16Bytes); 137 138 #endif 139 140 /*! 141 * \brief \copydoc page_ovr Helper function for read ndef to process the 142 * remaining bytes of length (L) in the TLV 143 */ 144 static NFCSTATUS phFriNfc_MifStd_H_RemainTLV(phFriNfc_NdefMap_t *NdefMap, 145 uint8_t *Flag, 146 uint8_t *Temp16Bytes); 147 148 /*! 149 * \brief \copydoc page_ovr Helper function for read ndef to process the 150 * internal bytes 151 */ 152 static NFCSTATUS phFriNfc_MifStd_H_ChkIntLen(phFriNfc_NdefMap_t *NdefMap); 153 154 /*! 155 * \brief \copydoc page_ovr Helper function for read ndef to check the 156 * internal bytes without ndef tlv flag 157 */ 158 static NFCSTATUS phFriNfc_MifStd_H_IntLenWioutNdef(phFriNfc_NdefMap_t *NdefMap, 159 uint8_t *Flag, 160 uint8_t *TempintBytes); 161 #if 0 162 /*! 163 * \brief \copydoc page_ovr Helper function for read ndef to check the 164 * internal bytes without ndef tlv flag 165 */ 166 static NFCSTATUS phFriNfc_MifStd_H_IntLenWithNdef(phFriNfc_NdefMap_t *NdefMap, 167 uint8_t *TempintBytes); 168 #endif 169 /*! 170 * \brief \copydoc page_ovr Helper function for write ndef to add the TLV 171 * structure 172 */ 173 static uint8_t phFriNfc_MifStd_H_UpdateTLV(phFriNfc_NdefMap_t *NdefMap); 174 175 /*! 176 * \brief \copydoc page_ovr Helper function for write ndef to write the Length TLV 177 * 178 */ 179 static NFCSTATUS phFriNfc_MifStd_H_WriteNdefLen(phFriNfc_NdefMap_t *NdefMap); 180 #if 0 181 /*! 182 * \brief \copydoc page_ovr Helper function for check ndef to check the ndef 183 * compliant blocks is 0 184 */ 185 static NFCSTATUS phFriNfc_MifStd_H_ChkNdefCmpltBlocks(phFriNfc_NdefMap_t *NdefMap); 186 #endif 187 /*! 188 * \brief \copydoc page_ovr Helper function to set the authentication flag 189 * for the ndef TLV block 190 */ 191 static void phFriNfc_MifStd_H_SetNdefBlkAuth(phFriNfc_NdefMap_t *NdefMap); 192 193 /*! 194 * \brief \copydoc page_ovr Helper function to reset ndef TLV values. This is 195 * used when the offset is BEGIN 196 */ 197 static void phFriNfc_MifStd_H_RdWrReset(phFriNfc_NdefMap_t *NdefMap); 198 199 /*! 200 * \brief \copydoc page_ovr Helper function to read the first ndef compliant block to 201 * change the length 202 */ 203 static NFCSTATUS phFriNfc_MifStd_H_RdtoWrNdefLen(phFriNfc_NdefMap_t *NdefMap); 204 205 /*! 206 * \brief \copydoc page_ovr Helper function to get the actual length of card 207 * 208 */ 209 static NFCSTATUS phFriNfc_MifStd_H_GetActCardLen(phFriNfc_NdefMap_t *NdefMap); 210 211 /*! 212 * \brief \copydoc page_ovr Helper function to check all the TLVs 213 * 214 */ 215 static NFCSTATUS phFriNfc_MifStd_H_ChkTLVs(phFriNfc_NdefMap_t *NdefMap, 216 uint8_t *CRFlag); 217 218 /*! 219 * \brief \copydoc page_ovr Helper function to get the next TLV 220 * 221 */ 222 static NFCSTATUS phFriNfc_MifStd_H_GetNxtTLV(phFriNfc_NdefMap_t *NdefMap, 223 uint16_t *TempLength, 224 uint8_t *TL4bytesFlag); 225 226 /*! 227 * \brief \copydoc page_ovr Helper function to know whether the read 228 * 16 bytes are parsed completely 229 */ 230 static NFCSTATUS phFriNfc_MifStd_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap, 231 uint16_t TempLength); 232 233 /*! 234 * \brief \copydoc page_ovr Helper function to know whether the read 235 * 16 bytes are parsed completely 236 */ 237 static NFCSTATUS phFriNfc_MifStd_H_ChkRemainTLVs(phFriNfc_NdefMap_t *NdefMap, 238 uint8_t *CRFlag, 239 uint8_t *NDEFFlag); 240 241 /*! 242 * \brief \copydoc page_ovr Helper function to call the Completion Routine 243 * 244 */ 245 static void phFriNfc_MifStd_H_Complete(phFriNfc_NdefMap_t *NdefMap, 246 NFCSTATUS Result); 247 248 /*! 249 * \brief \copydoc page_ovr Helper function to get the Mifare 1k Sector Trailer 250 * 251 */ 252 static void phFriNfc_MifStd_H_Get1kStTrail(phFriNfc_NdefMap_t *NdefMap); 253 254 /*! 255 * \brief \copydoc page_ovr Helper function to get the Mifare 4k Sector Trailer 256 * 257 */ 258 static void phFriNfc_MifStd_H_Get4kStTrail(phFriNfc_NdefMap_t *NdefMap); 259 260 /*! 261 * \brief \copydoc page_ovr Helper function to process the check ndef call 262 * 263 */ 264 static NFCSTATUS phFriNfc_MifStd_H_ProChkNdef(phFriNfc_NdefMap_t *NdefMap); 265 266 /*! 267 * \brief \copydoc page_ovr Helper function to process the authentication of a sector 268 * 269 */ 270 static NFCSTATUS phFriNfc_MifStd_H_ProAuth(phFriNfc_NdefMap_t *NdefMap); 271 272 /*! 273 * \brief \copydoc page_ovr Helper function to read 16 bytes from a specifed block no. 274 * 275 */ 276 static NFCSTATUS phFriNfc_MifStd_H_Rd16Bytes(phFriNfc_NdefMap_t *NdefMap, 277 uint8_t BlockNo); 278 279 /*! 280 * \brief \copydoc page_ovr Helper function to process access bits of the 281 * sector trailer 282 */ 283 static NFCSTATUS phFriNfc_MifStd_H_ProAcsBits(phFriNfc_NdefMap_t *NdefMap); 284 285 /*! 286 * \brief \copydoc page_ovr Helper function to check the GPB bytes 287 */ 288 static NFCSTATUS phFriNfc_MifStd_H_GPBChk(phFriNfc_NdefMap_t *NdefMap); 289 290 /*! 291 * \brief \copydoc page_ovr Helper function to check for the different 292 * status value in the process because of proprietary forum sector 293 */ 294 static NFCSTATUS phFriNfc_MifStd_H_ProStatNotValid(phFriNfc_NdefMap_t *NdefMap, 295 NFCSTATUS status); 296 297 /*! 298 * \brief \copydoc page_ovr Helper function to read the NDEF TLV block 299 */ 300 static NFCSTATUS phFriNfc_MifStd_H_RdBeforeWr(phFriNfc_NdefMap_t *NdefMap); 301 302 /*! 303 * \brief \copydoc page_ovr Helper function to process the NDEF TLV block 304 * read bytes to start write from the NDEF TLV 305 */ 306 static NFCSTATUS phFriNfc_MifStd_H_ProBytesToWr(phFriNfc_NdefMap_t *NdefMap); 307 308 /*! 309 * \brief \copydoc page_ovr Helper function to fill the send buffer to write 310 */ 311 static NFCSTATUS phFriNfc_MifStd_H_fillSendBuf(phFriNfc_NdefMap_t *NdefMap, 312 uint8_t Length); 313 314 /*! 315 * \brief \copydoc page_ovr Helper function to write 16 bytes in a block 316 */ 317 static NFCSTATUS phFriNfc_MifStd_H_WrTLV(phFriNfc_NdefMap_t *NdefMap); 318 319 /*! 320 * \brief \copydoc page_ovr Helper function to process the write TLV bytes in a block 321 */ 322 static NFCSTATUS phFriNfc_MifStd_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap); 323 324 /*! 325 * \brief \copydoc page_ovr Helper function to update the remaining TLV 326 */ 327 static uint8_t phFriNfc_MifStd_H_UpdRemTLV(phFriNfc_NdefMap_t *NdefMap); 328 329 /*! 330 * \brief \copydoc page_ovr Helper function to update the length field if more than one 331 * NULL TLVs exists before of the NDEF TLV 332 */ 333 static void phFriNfc_MifStd_H_fillTLV1(phFriNfc_NdefMap_t *NdefMap); 334 335 /*! 336 * \brief \copydoc page_ovr Helper function to update the length field if more than one 337 * NULL TLVs does not exists before the TLV 338 */ 339 static void phFriNfc_MifStd_H_fillTLV2(phFriNfc_NdefMap_t *NdefMap); 340 341 /*! 342 * \brief \copydoc page_ovr Helper function to increment/decrement the ndef tlv block 343 * and read the block 344 */ 345 static NFCSTATUS phFriNfc_MifStd_H_CallWrNdefLen(phFriNfc_NdefMap_t *NdefMap); 346 347 /*! 348 * \brief \copydoc page_ovr Helper function to check the current block is valid or not 349 * if not valid decrement the current block till the valid block 350 */ 351 static NFCSTATUS phFriNfc_MifStd_H_BlkChk_1(phFriNfc_NdefMap_t *NdefMap); 352 353 /*! 354 * \brief \copydoc page_ovr Helper function update the length of the TLV if NULL TLVs 355 * greater than or equal to 2 356 */ 357 static void phFriNfc_MifStd_H_fillTLV1_1(phFriNfc_NdefMap_t *NdefMap); 358 359 /*! 360 * \brief \copydoc page_ovr Helper function update the length of the TLV if NULL TLVs 361 * less than 2 362 */ 363 static void phFriNfc_MifStd_H_fillTLV2_1(phFriNfc_NdefMap_t *NdefMap); 364 365 /*! 366 * \brief \copydoc page_ovr Helper function to read the TLV block 367 */ 368 static NFCSTATUS phFriNfc_MifStd_H_RdTLV(phFriNfc_NdefMap_t *NdefMap); 369 370 /*! 371 * \brief \copydoc page_ovr Helper function to process the read TLV block 372 */ 373 static NFCSTATUS phFriNfc_MifStd_H_ProRdTLV(phFriNfc_NdefMap_t *NdefMap); 374 375 /*! 376 * \brief \copydoc page_ovr Helper function to write the terminator TLV 377 */ 378 static NFCSTATUS phFriNfc_MifStd_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap); 379 380 /*! 381 * \brief \copydoc page_ovr Helper function to process the write a block function 382 */ 383 static NFCSTATUS phFriNfc_MifStd_H_ProWrABlock(phFriNfc_NdefMap_t *NdefMap); 384 385 #ifndef PH_HAL4_ENABLE 386 /*! 387 * \brief \copydoc page_ovr Helper function to call poll function after the 388 * authentication has failed 389 */ 390 static NFCSTATUS phFriNfc_MifStd_H_CallPoll(phFriNfc_NdefMap_t *NdefMap); 391 #endif 392 393 /*! 394 * \brief \copydoc page_ovr Helper function to call connect function after the 395 * authentication has failed 396 */ 397 static NFCSTATUS phFriNfc_MifStd_H_CallConnect(phFriNfc_NdefMap_t *NdefMap); 398 399 /*! 400 * \brief \copydoc page_ovr Helper function to call disconnect function after the 401 * authentication has failed 402 */ 403 static NFCSTATUS phFriNfc_MifStd_H_CallDisCon(phFriNfc_NdefMap_t *NdefMap); 404 405 /*! 406 * \brief \copydoc page_ovr Helper function to call know the ndef compliant block using 407 */ 408 static void phFriNfc_MifStd1k_H_BlkChk(phFriNfc_NdefMap_t *NdefMap, 409 uint8_t SectorID, 410 uint8_t *callbreak); 411 412 /*@}*/ 413 /** 414 * \name Mifare Standard Mapping - Constants. 415 * 416 */ 417 /*@{*/ 418 /* As per the spec, the value of this macro 419 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT1 shall be 0xA0 */ 420 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT1 0xA0 /**< \internal Authenticate Command for MAD Sector */ 421 422 /* As per the spec, the value of this macro 423 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT2 shall be 0xA1 */ 424 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT2 0xA1 /**< \internal Authenticate Command for MAD Sector */ 425 426 /* As per the spec, the value of this macro 427 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT3 shall be 0xA2 */ 428 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT3 0xA2 /**< \internal Authenticate Command for MAD Sector */ 429 430 /* As per the spec, the value of this macro 431 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT4 shall be 0xA3 */ 432 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT4 0xA3 /**< \internal Authenticate Command for MAD Sector */ 433 434 /* As per the spec, the value of this macro 435 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT5 shall be 0xA4 */ 436 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT5 0xA4 /**< \internal Authenticate Command for MAD Sector */ 437 438 /* As per the spec, the value of this macro 439 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT6 shall be 0xA5 */ 440 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT6 0xA5 /**< \internal Authenticate Command for MAD Sector */ 441 442 /* As per the spec, the value of this macro 443 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1 shall be 0xD3 */ 444 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1 0xD3 /**< \internal Authenticate Command for NDEF Sectors 1 */ 445 446 /* As per the spec, the value of this macro 447 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2 shall be 0xF7 */ 448 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2 0xF7 /**< \internal Authenticate Command for NDEF Sectors 2 */ 449 #define PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL2 0x03 /**< \internal Ndef Compliant command 1 */ 450 #define PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL1 0xE1 /**< \internal Ndef Compliant command 2 */ 451 452 /* Enable access bits check for the MAD sector 453 #define ENABLE_ACS_BIT_CHK_FOR_MAD */ 454 /*@}*/ 455 456 NFCSTATUS phFriNfc_MifareStdMap_H_Reset(phFriNfc_NdefMap_t *NdefMap) 457 { 458 NFCSTATUS status = NFCSTATUS_SUCCESS; 459 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 460 if ( NdefMap == NULL) 461 { 462 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 463 } 464 else 465 { 466 /* Current Block stores the present block accessed in the card */ 467 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_VAL0; 468 469 for(index = PH_FRINFC_MIFARESTD_VAL0; index < 470 PH_FRINFC_NDEFMAP_MIFARESTD_ST15_BYTES; index++) 471 { 472 /* internal buffer to store the odd bytes of length < 15 */ 473 NdefMap->StdMifareContainer.internalBuf[index] = PH_FRINFC_MIFARESTD_VAL0; 474 } 475 /* odd bytes length stored in the internal buffer */ 476 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 477 478 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED; 479 480 /* Flag to get that last few bytes are taken from the user buffer */ 481 NdefMap->StdMifareContainer.RemainingBufFlag = PH_FRINFC_MIFARESTD_FLAG0; 482 483 /* Flag to find that the read/write operation has reached the end of the card. 484 Further reading/writing is not possible */ 485 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 486 487 /* Flag to get that last few bytes are taken from the internal buffer */ 488 NdefMap->StdMifareContainer.internalBufFlag = PH_FRINFC_MIFARESTD_FLAG0; 489 490 /* Authentication Flag for every sector */ 491 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 492 493 /* Used in Check Ndef for storing the sector ID */ 494 NdefMap->StdMifareContainer.SectorIndex = PH_FRINFC_MIFARESTD_VAL0; 495 496 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL0; 497 498 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = PH_FRINFC_MIFARESTD_VAL0; 499 500 NdefMap->StdMifareContainer.ReadAcsBitFlag = PH_FRINFC_MIFARESTD_FLAG0; 501 502 NdefMap->StdMifareContainer.remSizeUpdFlag = PH_FRINFC_MIFARESTD_FLAG0; 503 504 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 505 506 NdefMap->TLVStruct.prevLenByteValue = PH_FRINFC_MIFARESTD_VAL0; 507 508 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 509 510 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_MIFARESTD_VAL0; 511 512 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 513 514 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 515 516 NdefMap->StdMifareContainer.remainingSize = PH_FRINFC_MIFARESTD_VAL0; 517 518 NdefMap->StdMifareContainer.ReadNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 519 520 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 521 522 NdefMap->StdMifareContainer.ChkNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 523 524 NdefMap->StdMifareContainer.aidCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 525 526 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 527 528 NdefMap->StdMifareContainer.ProprforumSectFlag = PH_FRINFC_MIFARESTD_PROP_1ST_CONFIG; 529 530 NdefMap->StdMifareContainer.ReadCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 531 532 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 533 534 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL1; 535 536 NdefMap->StdMifareContainer.ChkNdefCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 537 } 538 539 return status; 540 } 541 542 /*! 543 * \brief Check whether a particular Remote Device is NDEF compliant. 544 * 545 * The function checks whether the peer device is NDEF compliant. 546 * 547 * \param[in] NdefMap Pointer to a valid instance of the \ref phFriNfc_NdefMap_t 548 * structure describing the component context. 549 * 550 * \retval NFCSTATUS_PENDING The action has been successfully triggered. 551 * \retval Others An error has occurred. 552 * 553 */ 554 555 NFCSTATUS phFriNfc_MifareStdMap_ChkNdef( phFriNfc_NdefMap_t *NdefMap) 556 { 557 NFCSTATUS status = NFCSTATUS_PENDING; 558 uint8_t atq, 559 sak; 560 561 if ( NdefMap == NULL) 562 { 563 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 564 } 565 else 566 { 567 /* set the data for additional data exchange*/ 568 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 569 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 570 NdefMap->psDepAdditionalInfo.NAD = 0; 571 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE; 572 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF; 573 574 /* Get the Select Response and Sense Response to get 575 the exact Card Type either Mifare 1k or 4k */ 576 #ifndef PH_HAL4_ENABLE 577 sak = NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo106. 578 Startup106.SelRes; 579 atq = NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo106. 580 Startup106.SensRes[0]; 581 #else 582 sak = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak; 583 atq = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0]; 584 PHNFC_UNUSED_VARIABLE(atq); 585 #endif 586 587 if (0x08 == (sak & 0x18)) 588 { 589 /* Total Number of Blocks in Mifare 1k Card */ 590 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 591 PH_FRINFC_NDEFMAP_MIFARESTD_1KNDEF_COMPBLOCK; 592 NdefMap->StdMifareContainer.remainingSize = 593 ((NdefMap->CardType == PH_FRINFC_MIFARESTD_VAL0)? 594 (PH_FRINFC_NDEFMAP_MIFARESTD_1KNDEF_COMPBLOCK * 595 PH_FRINFC_MIFARESTD_BLOCK_BYTES): 596 NdefMap->StdMifareContainer.remainingSize); 597 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD; 598 } 599 else 600 { 601 /* Total Number of Blocks in Mifare 4k Card */ 602 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 603 PH_FRINFC_NDEFMAP_MIFARESTD_4KNDEF_COMPBLOCK; 604 NdefMap->StdMifareContainer.remainingSize = 605 ((NdefMap->CardType == PH_FRINFC_MIFARESTD_VAL0)? 606 (PH_FRINFC_NDEFMAP_MIFARESTD_4KNDEF_COMPBLOCK * 607 PH_FRINFC_MIFARESTD_BLOCK_BYTES): 608 NdefMap->StdMifareContainer.remainingSize); 609 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD; 610 } 611 612 613 /* phFriNfc_MifareStdMap_ChkNdef should be called only 614 when currentBlock is 0 OR 64,65 and 66 (for Mifare 4k). 615 Otherwise return error */ 616 /* and also Check the Authentication Flag */ 617 if((NdefMap->StdMifareContainer.currentBlock != 0) && 618 (NdefMap->StdMifareContainer.currentBlock != 1) && 619 (NdefMap->StdMifareContainer.currentBlock != 2) && 620 (NdefMap->StdMifareContainer.currentBlock != 64) && 621 (NdefMap->StdMifareContainer.currentBlock != 65) && 622 (NdefMap->StdMifareContainer.currentBlock != 66) ) 623 { 624 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 625 } 626 else if( NdefMap->StdMifareContainer.AuthDone == 0) 627 { 628 /* Block 0 contains Manufacturer information and 629 also other informaton. So go for block 1 which 630 contains AIDs. Authenticating any of the block 631 in a sector, Authenticates the whole sector */ 632 if(NdefMap->StdMifareContainer.currentBlock == 0) 633 { 634 NdefMap->StdMifareContainer.currentBlock = 1; 635 } 636 637 status = phFriNfc_MifStd_H_AuthSector(NdefMap); 638 } 639 else 640 { 641 /* Mifare 1k, sak = 0x08 atq = 0x04 642 Mifare 4k, sak = 0x38 atq = 0x02 */ 643 if ((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) || 644 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) 645 { 646 /* Change the state to Check Ndef Compliant */ 647 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_CHK_NDEF_COMP; 648 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE; 649 NdefMap->StdMifareContainer.ChkNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 650 651 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 652 NdefMap->MapCompletionInfo.Context = NdefMap; 653 654 #ifndef PH_HAL4_ENABLE 655 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareRead; 656 #else 657 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 658 #endif 659 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 660 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 661 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 662 663 /* Call the Overlapped HAL Transceive function */ 664 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 665 &NdefMap->MapCompletionInfo, 666 NdefMap->psRemoteDevInfo, 667 NdefMap->Cmd, 668 &NdefMap->psDepAdditionalInfo, 669 NdefMap->SendRecvBuf, 670 NdefMap->SendLength, 671 NdefMap->SendRecvBuf, 672 NdefMap->SendRecvLength); 673 } 674 else 675 { 676 /* Since we have decided temporarily not to go 677 for any new error codes we are using 678 NFCSTATUS_INVALID_PARAMETER even though it is not 679 the relevant error code here TBD */ 680 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 681 } 682 } 683 } 684 return status; 685 } 686 687 688 /*! 689 * \brief Initiates Reading of NDEF information from the Remote Device. 690 * 691 * The function initiates the reading of NDEF information from a Remote Device. 692 * It performs a reset of the state and starts the action (state machine). 693 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action 694 * has been triggered. 695 */ 696 NFCSTATUS phFriNfc_MifareStdMap_RdNdef( phFriNfc_NdefMap_t *NdefMap, 697 uint8_t *PacketData, 698 uint32_t *PacketDataLength, 699 uint8_t Offset) 700 { 701 NFCSTATUS status = NFCSTATUS_PENDING; 702 703 NdefMap->ApduBufferSize = *PacketDataLength; 704 NdefMap->NumOfBytesRead = PacketDataLength; 705 *NdefMap->NumOfBytesRead = 0; 706 NdefMap->ApduBuffIndex = 0; 707 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 708 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_RD_NDEF; 709 710 if((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 711 || (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED)) 712 { 713 /* Card state is not correct */ 714 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 715 NFCSTATUS_INVALID_PARAMETER); 716 } 717 else 718 { 719 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation == 720 PH_FRINFC_NDEFMAP_WRITE_OPE)) 721 { 722 phFriNfc_MifStd_H_RdWrReset(NdefMap); 723 NdefMap->StdMifareContainer.ReadNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 724 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 725 } 726 /* Offset = Current, but the read has reached the End of Card */ 727 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 728 (NdefMap->StdMifareContainer.ReadWriteCompleteFlag == 729 PH_FRINFC_MIFARESTD_FLAG1)) 730 { 731 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 732 } 733 else 734 { 735 NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 736 ( NdefMap->PrevOperation == 737 PH_FRINFC_NDEFMAP_WRITE_OPE))? 738 PH_FRINFC_NDEFMAP_SEEK_BEGIN: 739 Offset); 740 status = phFriNfc_MifStd_H_BlkChk(NdefMap); 741 if(status == NFCSTATUS_SUCCESS) 742 { 743 NdefMap->ApduBuffer = PacketData; 744 745 /* Read Operation in Progress */ 746 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 747 748 /* Check Authentication Flag */ 749 status = 750 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1)? 751 phFriNfc_MifStd_H_RdABlock(NdefMap): 752 phFriNfc_MifStd_H_AuthSector(NdefMap)); 753 } 754 } 755 } 756 return status; 757 } 758 759 /*! 760 * \brief Initiates Writing of NDEF information to the Remote Device. 761 * 762 * The function initiates the writing of NDEF information to a Remote Device. 763 * It performs a reset of the state and starts the action (state machine). 764 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action 765 * has been triggered. 766 */ 767 NFCSTATUS phFriNfc_MifareStdMap_WrNdef( phFriNfc_NdefMap_t *NdefMap, 768 uint8_t *PacketData, 769 uint32_t *PacketDataLength, 770 uint8_t Offset) 771 { 772 NFCSTATUS status = NFCSTATUS_PENDING; 773 774 NdefMap->ApduBuffer = PacketData; 775 NdefMap->ApduBufferSize = *PacketDataLength; 776 NdefMap->ApduBuffIndex = PH_FRINFC_MIFARESTD_VAL0; 777 NdefMap->WrNdefPacketLength = PacketDataLength; 778 *NdefMap->WrNdefPacketLength = PH_FRINFC_MIFARESTD_VAL0; 779 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 780 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_WR_NDEF; 781 782 if((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 783 || (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)) 784 { 785 /* Card state is not correct */ 786 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 787 NFCSTATUS_INVALID_PARAMETER); 788 } 789 else 790 { 791 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || 792 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)) 793 { 794 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 795 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 796 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 797 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 798 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 799 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 800 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 801 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 802 NdefMap->TLVStruct.NdefTLVAuthFlag = PH_FRINFC_MIFARESTD_FLAG0; 803 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 804 NdefMap->StdMifareContainer.remainingSize = 805 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks * 806 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 807 NdefMap->StdMifareContainer.currentBlock = 808 PH_FRINFC_MIFARESTD_BLK4; 809 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL1; 810 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 811 /* This macro is added, to be compliant with the previous HAL 2.0 812 For HAL 2.0, polling is done before writing data to the mifare 813 std (if the offset is BEGIN), because if an error is reported 814 during read or write and again write is called, the PN531 state is 815 unchanged (so write will fail), to bring the PN531 to the correct 816 state, polling is done. 817 Changed on 13th Jan 2009 818 */ 819 #ifdef PH_HAL4_ENABLE 820 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG0; 821 #else 822 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG1; 823 #endif /* #ifdef PH_HAL4_ENABLE */ 824 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL0; 825 NdefMap->StdMifareContainer.FirstWriteFlag = PH_FRINFC_MIFARESTD_FLAG1; 826 } 827 828 if(((Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 829 (NdefMap->StdMifareContainer.ReadWriteCompleteFlag == 830 PH_FRINFC_MIFARESTD_FLAG1)) || ((NdefMap->StdMifareContainer.PollFlag == 831 PH_FRINFC_MIFARESTD_FLAG1) && (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR))) 832 { 833 /* Offset = Current, but the read has reached the End of Card */ 834 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 835 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 836 } 837 else 838 { 839 NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 840 ( NdefMap->PrevOperation == 841 PH_FRINFC_NDEFMAP_READ_OPE))? 842 PH_FRINFC_NDEFMAP_SEEK_BEGIN: 843 Offset); 844 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 845 status = phFriNfc_MifStd_H_BlkChk(NdefMap); 846 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 847 if(status == NFCSTATUS_SUCCESS) 848 { 849 if(NdefMap->StdMifareContainer.PollFlag == 850 PH_FRINFC_MIFARESTD_FLAG1) 851 { 852 /* if poll flag is set then call disconnect because the authentication 853 has failed so reactivation of card is required */ 854 status = phFriNfc_MifStd_H_CallDisCon(NdefMap); 855 } 856 /* Check Authentication Flag */ 857 else if(NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 858 { 859 status = ((NdefMap->Offset == 860 PH_FRINFC_NDEFMAP_SEEK_BEGIN)? 861 phFriNfc_MifStd_H_RdBeforeWr(NdefMap): 862 phFriNfc_MifStd_H_WrABlock(NdefMap)); 863 } 864 else 865 { 866 status = phFriNfc_MifStd_H_AuthSector(NdefMap); 867 } 868 } 869 } 870 } 871 return status; 872 } 873 874 875 /*! 876 * \brief Completion Routine, Processing function, needed to avoid long blocking. 877 * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion 878 * Routine in order to be able to notify the component that an I/O has finished and data are 879 * ready to be processed. 880 * 881 */ 882 883 void phFriNfc_MifareStdMap_Process( void *Context, 884 NFCSTATUS Status) 885 { 886 887 phFriNfc_NdefMap_t *NdefMap; 888 889 uint8_t NDEFFlag = 0, 890 CRFlag = 0, 891 Temp16Bytes = 0, 892 i = 0; 893 894 895 NdefMap = (phFriNfc_NdefMap_t *)Context; 896 897 898 if((Status & PHNFCSTBLOWER) == (NFCSTATUS_SUCCESS & PHNFCSTBLOWER)) 899 { 900 switch(NdefMap->State) 901 { 902 case PH_FRINFC_NDEFMAP_STATE_CHK_NDEF_COMP: 903 Status = phFriNfc_MifStd_H_ProChkNdef(NdefMap); 904 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 905 PH_FRINFC_MIFARESTD_FLAG1: 906 PH_FRINFC_MIFARESTD_FLAG0); 907 break; 908 909 case PH_FRINFC_NDEFMAP_STATE_READ: 910 911 /* Receive Length for read shall always be equal to 16 */ 912 if((*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) && 913 (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize)) 914 { 915 Temp16Bytes = PH_FRINFC_MIFARESTD_VAL0; 916 NDEFFlag = (uint8_t)PH_FRINFC_MIFARESTD_FLAG1; 917 if(NdefMap->TLVStruct.BytesRemainLinTLV != 0) 918 { 919 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 920 CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 921 /* To read the remaining length (L) in TLV */ 922 Status = phFriNfc_MifStd_H_RemainTLV(NdefMap, &NDEFFlag, &Temp16Bytes); 923 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 924 PH_FRINFC_MIFARESTD_FLAG1: 925 PH_FRINFC_MIFARESTD_FLAG0); 926 } 927 928 /* check the NDEFFlag is set. if this is not set, then 929 in the above RemainTLV function all the 16 bytes has been 930 read */ 931 #if 0 932 if((NDEFFlag == PH_FRINFC_MIFARESTD_FLAG1) && 933 (NdefMap->TLVStruct.NdefTLVFoundFlag == 934 PH_FRINFC_MIFARESTD_FLAG1)) 935 { 936 /* if the block is NDEF TLV then get data from here */ 937 Status = phFriNfc_MifStd_H_RdNdefTLV(NdefMap, &Temp16Bytes); 938 } 939 #endif 940 } 941 else 942 { 943 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_RECEIVE_LENGTH); 944 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 945 } 946 break; 947 948 case PH_FRINFC_NDEFMAP_STATE_WRITE: 949 Status = phFriNfc_MifStd_H_ProWrABlock(NdefMap); 950 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 951 PH_FRINFC_MIFARESTD_FLAG1: 952 PH_FRINFC_MIFARESTD_FLAG0); 953 954 /* Call Completion Routine if CR Flag is Set to 1 */ 955 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 956 { 957 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 958 } 959 break; 960 961 case PH_FRINFC_NDEFMAP_STATE_AUTH: 962 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 963 Status = phFriNfc_MifStd_H_ProAuth(NdefMap); 964 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 965 PH_FRINFC_MIFARESTD_FLAG1: 966 PH_FRINFC_MIFARESTD_FLAG0); 967 break; 968 969 case PH_FRINFC_NDEFMAP_STATE_RD_ACS_BIT: 970 Status = phFriNfc_MifStd_H_ProAcsBits(NdefMap); 971 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 972 PH_FRINFC_MIFARESTD_FLAG1: 973 PH_FRINFC_MIFARESTD_FLAG0); 974 break; 975 976 case PH_FRINFC_NDEFMAP_STATE_WR_NDEF_LEN: 977 if(NdefMap->StdMifareContainer.RdAfterWrFlag == 978 PH_FRINFC_MIFARESTD_FLAG1) 979 { 980 Status = phFriNfc_MifStd_H_CallWrNdefLen(NdefMap); 981 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 982 PH_FRINFC_MIFARESTD_FLAG1: 983 PH_FRINFC_MIFARESTD_FLAG0); 984 } 985 else 986 { 987 /* Check this */ 988 if(NdefMap->StdMifareContainer.TempBlockNo == 989 NdefMap->StdMifareContainer.currentBlock) 990 { 991 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 992 NdefMap->StdMifareContainer.Buffer, 993 NdefMap->StdMifareContainer.internalLength); 994 } 995 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 996 NdefMap->StdMifareContainer.currentBlock = 997 NdefMap->StdMifareContainer.TempBlockNo; 998 NdefMap->CardState = (uint8_t)((NdefMap->CardState == 999 PH_NDEFMAP_CARD_STATE_INITIALIZED)? 1000 PH_NDEFMAP_CARD_STATE_READ_WRITE: 1001 NdefMap->CardState); 1002 CRFlag = (uint8_t)PH_FRINFC_MIFARESTD_FLAG1; 1003 } 1004 /*NdefMap->StdMifareContainer.remainingSize -= 1005 (((NdefMap->ApduBufferSize) > (PH_FRINFC_MIFARESTD_NDEFTLV_L - 1006 PH_FRINFC_MIFARESTD_VAL1))? 1007 ((uint16_t)(*NdefMap->WrNdefPacketLength + 1008 PH_FRINFC_MIFARESTD_VAL4)): 1009 ((uint16_t)(*NdefMap->WrNdefPacketLength + 1010 PH_FRINFC_MIFARESTD_VAL2)));*/ 1011 break; 1012 1013 case PH_FRINFC_NDEFMAP_STATE_RD_TO_WR_NDEF_LEN: 1014 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1015 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1016 NFCSTATUS_INVALID_DEVICE_REQUEST); 1017 if(*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) 1018 { 1019 /* Size of NdefMap->SendRecvBuf is set by phLibNfc_Gen_NdefMapReset to PH_LIBNFC_GEN_MAX_BUFFER */ 1020 /* We don't have to check memory here */ 1021 for (i = PH_FRINFC_MIFARESTD_BYTES_READ; i > 0; i--) 1022 { 1023 NdefMap->SendRecvBuf[i] = NdefMap->SendRecvBuf[i-1]; 1024 } 1025 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1026 NdefMap->StdMifareContainer.currentBlock; 1027 Status = phFriNfc_MifStd_H_WriteNdefLen(NdefMap); 1028 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1029 PH_FRINFC_MIFARESTD_FLAG1: 1030 PH_FRINFC_MIFARESTD_FLAG0); 1031 } 1032 break; 1033 1034 case PH_FRINFC_NDEFMAP_STATE_GET_ACT_CARDSIZE: 1035 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 1036 if(NdefMap->TLVStruct.NoLbytesinTLV > PH_FRINFC_MIFARESTD_VAL0) 1037 { 1038 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 1039 Status = phFriNfc_MifStd_H_ChkRemainTLVs(NdefMap, &CRFlag, &NDEFFlag); 1040 NdefMap->TLVStruct.NoLbytesinTLV = 1041 PH_FRINFC_MIFARESTD_VAL0; 1042 } 1043 if((NDEFFlag == PH_FRINFC_MIFARESTD_FLAG1) && 1044 (CRFlag != PH_FRINFC_MIFARESTD_FLAG1)) 1045 { 1046 Status = phFriNfc_MifStd_H_ChkTLVs(NdefMap, &CRFlag); 1047 } 1048 if(((NdefMap->StdMifareContainer.ReadNdefFlag == 1049 PH_FRINFC_MIFARESTD_FLAG1) || 1050 (NdefMap->StdMifareContainer.WrNdefFlag == 1051 PH_FRINFC_MIFARESTD_FLAG1))&& 1052 (Status != NFCSTATUS_PENDING)) 1053 { 1054 NdefMap->StdMifareContainer.NFCforumSectFlag = 1055 PH_FRINFC_MIFARESTD_FLAG1; 1056 CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 1057 /* if the card state has changed to initialised and 1058 read ndef is called then error is returned */ 1059 if(((NdefMap->StdMifareContainer.WrNdefFlag == 1060 PH_FRINFC_MIFARESTD_FLAG1) && 1061 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)) || 1062 ((NdefMap->StdMifareContainer.ReadNdefFlag == 1063 PH_FRINFC_MIFARESTD_FLAG1) && 1064 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED))) 1065 { 1066 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1067 NFCSTATUS_NO_NDEF_SUPPORT); 1068 } 1069 if(NdefMap->StdMifareContainer.AuthDone == 1070 PH_FRINFC_MIFARESTD_FLAG0) 1071 { 1072 Status = phFriNfc_MifStd_H_AuthSector(NdefMap); 1073 } 1074 else 1075 { 1076 Status = ((NdefMap->StdMifareContainer.ReadNdefFlag == 1077 PH_FRINFC_MIFARESTD_FLAG1)? 1078 phFriNfc_MifStd_H_RdTLV(NdefMap): 1079 phFriNfc_MifStd_H_RdBeforeWr(NdefMap)); 1080 } 1081 NdefMap->StdMifareContainer.ReadNdefFlag = 1082 PH_FRINFC_MIFARESTD_FLAG0; 1083 NdefMap->StdMifareContainer.WrNdefFlag = 1084 PH_FRINFC_MIFARESTD_FLAG0; 1085 1086 } 1087 if(NdefMap->StdMifareContainer.ChkNdefFlag == 1088 PH_FRINFC_MIFARESTD_FLAG1) 1089 { 1090 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1091 PH_FRINFC_MIFARESTD_FLAG1: 1092 PH_FRINFC_MIFARESTD_FLAG0); 1093 } 1094 break; 1095 1096 case PH_FRINFC_NDEFMAP_STATE_RD_BEF_WR: 1097 /* Read flag says that already part of TLV has been written */ 1098 Status = phFriNfc_MifStd_H_ProBytesToWr(NdefMap); 1099 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1100 PH_FRINFC_MIFARESTD_FLAG1: 1101 PH_FRINFC_MIFARESTD_FLAG0); 1102 break; 1103 1104 case PH_FRINFC_NDEFMAP_STATE_WR_TLV: 1105 Status = phFriNfc_MifStd_H_ProWrTLV(NdefMap); 1106 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1107 PH_FRINFC_MIFARESTD_FLAG1: 1108 PH_FRINFC_MIFARESTD_FLAG0); 1109 break; 1110 1111 case PH_FRINFC_NDEFMAP_STATE_RD_TLV: 1112 Status = phFriNfc_MifStd_H_ProRdTLV(NdefMap); 1113 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1114 PH_FRINFC_MIFARESTD_FLAG1: 1115 PH_FRINFC_MIFARESTD_FLAG0); 1116 break; 1117 1118 case PH_FRINFC_NDEFMAP_STATE_TERM_TLV: 1119 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 1120 NdefMap->StdMifareContainer.currentBlock = 1121 NdefMap->TLVStruct.NdefTLVBlock; 1122 Status = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 1123 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1124 PH_FRINFC_MIFARESTD_FLAG1: 1125 PH_FRINFC_MIFARESTD_FLAG0); 1126 break; 1127 1128 case PH_FRINFC_NDEFMAP_STATE_DISCONNECT: 1129 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG0; 1130 1131 #ifndef PH_HAL4_ENABLE 1132 Status = phFriNfc_MifStd_H_CallPoll(NdefMap); 1133 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1134 PH_FRINFC_MIFARESTD_FLAG1: 1135 PH_FRINFC_MIFARESTD_FLAG0); 1136 break; 1137 1138 case PH_FRINFC_NDEFMAP_STATE_POLL: 1139 #endif 1140 Status = phFriNfc_MifStd_H_CallConnect(NdefMap); 1141 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1142 PH_FRINFC_MIFARESTD_FLAG1: 1143 PH_FRINFC_MIFARESTD_FLAG0); 1144 break; 1145 1146 case PH_FRINFC_NDEFMAP_STATE_CONNECT: 1147 if(NdefMap->StdMifareContainer.FirstReadFlag == PH_FRINFC_MIFARESTD_FLAG1) 1148 { 1149 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 1150 Status = phFriNfc_MifStd_H_AuthSector(NdefMap); 1151 } 1152 else 1153 { 1154 Status = ((((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 1155 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE)) || 1156 (NdefMap->StdMifareContainer.WrLength > 1157 PH_FRINFC_MIFARESTD_VAL0))? 1158 phFriNfc_MifStd_H_ProStatNotValid(NdefMap, Status): 1159 phFriNfc_MifStd_H_AuthSector(NdefMap)); 1160 } 1161 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1162 PH_FRINFC_MIFARESTD_FLAG1: 1163 PH_FRINFC_MIFARESTD_FLAG0); 1164 break; 1165 1166 default: 1167 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1168 NFCSTATUS_INVALID_DEVICE_REQUEST); 1169 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1170 break; 1171 } 1172 } 1173 else if(NdefMap->State == PH_FRINFC_NDEFMAP_STATE_AUTH) 1174 { 1175 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG1; 1176 if(NdefMap->StdMifareContainer.FirstWriteFlag == 1177 PH_FRINFC_MIFARESTD_FLAG1) 1178 { 1179 NdefMap->StdMifareContainer.FirstWriteFlag = 1180 PH_FRINFC_MIFARESTD_FLAG0; 1181 NdefMap->StdMifareContainer.WrLength = 1182 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 1183 PH_FRINFC_MIFARESTD_FLAG0)? 1184 PH_FRINFC_MIFARESTD_VAL1: 1185 NdefMap->StdMifareContainer.WrLength); 1186 } 1187 /*if(NdefMap->StdMifareContainer.WrLength != PH_FRINFC_MIFARESTD_VAL0) 1188 { 1189 Status = NFCSTATUS_SUCCESS; 1190 NdefMap->StdMifareContainer.ReadCompleteFlag = 1191 PH_FRINFC_MIFARESTD_FLAG1; 1192 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 1193 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1194 } 1195 else*/ if(NdefMap->StdMifareContainer.WrLength == PH_FRINFC_MIFARESTD_VAL0) 1196 { 1197 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1198 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 1199 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1200 } 1201 else 1202 { 1203 /* Authentication has failed */ 1204 Status = phFriNfc_MifStd_H_CallDisCon(NdefMap); 1205 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)? 1206 PH_FRINFC_MIFARESTD_FLAG1: 1207 PH_FRINFC_MIFARESTD_FLAG0); 1208 } 1209 } 1210 else 1211 { 1212 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1213 NFCSTATUS_INVALID_DEVICE_REQUEST); 1214 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1215 } 1216 /* Call Completion Routine if CR Flag is Set to 1 */ 1217 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 1218 { 1219 phFriNfc_MifStd_H_Complete(NdefMap, Status); 1220 } 1221 } 1222 1223 static NFCSTATUS phFriNfc_MifStd_H_RdABlock(phFriNfc_NdefMap_t *NdefMap) 1224 { 1225 NFCSTATUS status = NFCSTATUS_PENDING; 1226 1227 /* set the data for additional data exchange*/ 1228 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 1229 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 1230 NdefMap->psDepAdditionalInfo.NAD = 0; 1231 1232 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_READ; 1233 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 1234 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 1235 NdefMap->MapCompletionInfo.Context = NdefMap; 1236 1237 if( NdefMap->ApduBuffIndex < 1238 (uint16_t)NdefMap->ApduBufferSize) 1239 { 1240 1241 if(NdefMap->StdMifareContainer.internalLength > PH_FRINFC_MIFARESTD_VAL0) 1242 { 1243 status = phFriNfc_MifStd_H_ChkIntLen(NdefMap); 1244 }/* internal Length Check */ 1245 else 1246 { 1247 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1248 NdefMap->StdMifareContainer.currentBlock; 1249 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 1250 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1251 1252 #ifndef PH_HAL4_ENABLE 1253 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareRead; 1254 #else 1255 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 1256 #endif 1257 /* Call the Overlapped HAL Transceive function */ 1258 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 1259 &NdefMap->MapCompletionInfo, 1260 NdefMap->psRemoteDevInfo, 1261 NdefMap->Cmd, 1262 &NdefMap->psDepAdditionalInfo, 1263 NdefMap->SendRecvBuf, 1264 NdefMap->SendLength, 1265 NdefMap->SendRecvBuf, 1266 NdefMap->SendRecvLength); 1267 } 1268 } 1269 else 1270 { 1271 /* Check for the Card Size */ 1272 if((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 1273 NdefMap->StdMifareContainer.NdefBlocks) * 1274 PH_FRINFC_MIFARESTD_BYTES_READ) == 0) || 1275 (NdefMap->ApduBufferSize == NdefMap->ApduBuffIndex)) 1276 { 1277 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 1278 (uint8_t)((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 1279 NdefMap->StdMifareContainer.NdefBlocks) * 1280 PH_FRINFC_MIFARESTD_BYTES_READ) == 0)? 1281 PH_FRINFC_MIFARESTD_FLAG1: 1282 PH_FRINFC_MIFARESTD_FLAG0); 1283 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 1284 status = PHNFCSTVAL(CID_NFC_NONE, 1285 NFCSTATUS_SUCCESS); 1286 } 1287 else 1288 { 1289 /*Error: The control should not ideally come here. 1290 Return Error.*/ 1291 #ifndef PH_HAL4_ENABLE 1292 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_CMD_ABORTED); 1293 #else 1294 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_FAILED); 1295 #endif 1296 } 1297 } 1298 return status; 1299 } 1300 1301 1302 static NFCSTATUS phFriNfc_MifStd_H_WrABlock(phFriNfc_NdefMap_t *NdefMap) 1303 { 1304 NFCSTATUS status = NFCSTATUS_PENDING; 1305 1306 uint16_t RemainingBytes = 0, 1307 BytesRemained = 0, 1308 index = 0; 1309 1310 uint8_t Temp16Bytes = 0; 1311 1312 /* set the data for additional data exchange*/ 1313 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 1314 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 1315 NdefMap->psDepAdditionalInfo.NAD = 0; 1316 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 1317 NdefMap->MapCompletionInfo.Context = NdefMap; 1318 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 1319 1320 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WRITE; 1321 1322 /* User Buffer Check */ 1323 if( NdefMap->ApduBuffIndex < 1324 (uint16_t)NdefMap->ApduBufferSize) 1325 { 1326 RemainingBytes = (((uint16_t)(NdefMap->ApduBufferSize - 1327 NdefMap->ApduBuffIndex) < 1328 NdefMap->StdMifareContainer.remainingSize )? 1329 (uint16_t)(NdefMap->ApduBufferSize - 1330 NdefMap->ApduBuffIndex): 1331 NdefMap->StdMifareContainer.remainingSize); 1332 1333 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 1334 Temp16Bytes += PH_FRINFC_MIFARESTD_INC_1; 1335 /* Check for internal bytes */ 1336 1337 if(NdefMap->StdMifareContainer.internalLength > 0) 1338 { 1339 /* copy the bytes previously written in the internal Buffer */ 1340 (void)memcpy(&( NdefMap->SendRecvBuf[Temp16Bytes]), 1341 NdefMap->StdMifareContainer.internalBuf, 1342 NdefMap->StdMifareContainer.internalLength); 1343 1344 Temp16Bytes += (uint8_t)(NdefMap->StdMifareContainer.internalLength); 1345 if(RemainingBytes >= ( MIFARE_MAX_SEND_BUF_TO_WRITE - 1346 Temp16Bytes)) 1347 { 1348 /* Copy the Remaining bytes from the user buffer to make the send 1349 data and length = 16 */ 1350 (void)memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), 1351 NdefMap->ApduBuffer, 1352 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)); 1353 1354 NdefMap->NumOfBytesWritten = 1355 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1356 Temp16Bytes += (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1357 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1358 } 1359 else 1360 { 1361 (void)memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), 1362 NdefMap->ApduBuffer, 1363 RemainingBytes); 1364 1365 NdefMap->StdMifareContainer.internalBufFlag = PH_FRINFC_MIFARESTD_FLAG1; 1366 NdefMap->NumOfBytesWritten = RemainingBytes; 1367 Temp16Bytes += (uint8_t)(RemainingBytes); 1368 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1369 1370 BytesRemained = (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1371 /* Pad empty bytes with Zeroes to complete 16 bytes*/ 1372 for(index = 0; index < BytesRemained; index++) 1373 { 1374 NdefMap->SendRecvBuf[(Temp16Bytes + index)] = 1375 (uint8_t)((index == PH_FRINFC_MIFARESTD_VAL0)? 1376 PH_FRINFC_MIFARESTD_TERMTLV_T: 1377 PH_FRINFC_MIFARESTD_NULLTLV_T); 1378 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 1379 } 1380 Temp16Bytes += (uint8_t)(BytesRemained); 1381 } 1382 } 1383 else 1384 { 1385 if(RemainingBytes >= (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)) 1386 { 1387 /* Bytes left to write < 16 1388 copy remaining bytes */ 1389 (void)memcpy( &(NdefMap->SendRecvBuf[ 1390 Temp16Bytes]), 1391 &(NdefMap->ApduBuffer[ 1392 NdefMap->ApduBuffIndex]), 1393 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)); 1394 1395 NdefMap->NumOfBytesWritten = (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1396 Temp16Bytes += (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1397 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1398 } 1399 else 1400 { 1401 /* Bytes left to write < 16 1402 copy remaining bytes */ 1403 (void)memcpy(&(NdefMap->SendRecvBuf[ 1404 Temp16Bytes]), 1405 &(NdefMap->ApduBuffer[ 1406 NdefMap->ApduBuffIndex]), 1407 RemainingBytes); 1408 1409 NdefMap->StdMifareContainer.RemainingBufFlag = PH_FRINFC_MIFARESTD_FLAG1; 1410 NdefMap->NumOfBytesWritten = RemainingBytes; 1411 Temp16Bytes += (uint8_t)(RemainingBytes); 1412 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1413 1414 1415 /* Pad empty bytes with Zeroes to complete 16 bytes*/ 1416 for(index = Temp16Bytes; index < MIFARE_MAX_SEND_BUF_TO_WRITE; index++) 1417 { 1418 NdefMap->SendRecvBuf[index] = (uint8_t)((index == 1419 Temp16Bytes)? 1420 PH_FRINFC_MIFARESTD_TERMTLV_T: 1421 PH_FRINFC_MIFARESTD_NULLTLV_T); 1422 1423 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 1424 } 1425 } 1426 } 1427 /* Buffer to store 16 bytes which is writing to the present block */ 1428 (void)memcpy( NdefMap->StdMifareContainer.Buffer, 1429 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_INC_1]), 1430 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 1431 1432 /* Write from here */ 1433 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 1434 #ifndef PH_HAL4_ENABLE 1435 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite16; 1436 #else 1437 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 1438 #endif 1439 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1440 /* Call the Overlapped HAL Transceive function */ 1441 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 1442 &NdefMap->MapCompletionInfo, 1443 NdefMap->psRemoteDevInfo, 1444 NdefMap->Cmd, 1445 &NdefMap->psDepAdditionalInfo, 1446 NdefMap->SendRecvBuf, 1447 NdefMap->SendLength, 1448 NdefMap->SendRecvBuf, 1449 NdefMap->SendRecvLength); 1450 } 1451 else/* Check User Buffer */ 1452 { 1453 if(NdefMap->StdMifareContainer.NdefBlocks > 1454 NdefMap->StdMifareContainer.NoOfNdefCompBlocks) 1455 { 1456 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 1457 PH_FRINFC_MIFARESTD_FLAG1; 1458 status = PHNFCSTVAL(CID_NFC_NONE, 1459 NFCSTATUS_SUCCESS); 1460 } 1461 else if( NdefMap->ApduBuffIndex == 1462 (uint16_t)NdefMap->ApduBufferSize) 1463 { 1464 status = PHNFCSTVAL(CID_NFC_NONE, 1465 NFCSTATUS_SUCCESS); 1466 } 1467 else 1468 { 1469 /*Error: The control should not ideally come here. 1470 Return Error.*/ 1471 #ifndef PH_HAL4_ENABLE 1472 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_CMD_ABORTED); 1473 #else 1474 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_FAILED); 1475 #endif 1476 } 1477 } 1478 return status; 1479 } 1480 1481 static NFCSTATUS phFriNfc_MifStd_H_AuthSector(phFriNfc_NdefMap_t *NdefMap) 1482 { 1483 NFCSTATUS status = NFCSTATUS_PENDING; 1484 1485 /* set the data for additional data exchange*/ 1486 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 1487 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 1488 NdefMap->psDepAdditionalInfo.NAD = 0; 1489 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 1490 NdefMap->MapCompletionInfo.Context = NdefMap; 1491 1492 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1493 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_AUTH; 1494 1495 /* Authenticate */ 1496 #ifndef PH_HAL4_ENABLE 1497 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareAuthentA; 1498 #else 1499 NdefMap->Cmd.MfCmd = phHal_eMifareAuthentA; 1500 #endif 1501 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1502 ((NdefMap->TLVStruct.NdefTLVAuthFlag == 1503 PH_FRINFC_MIFARESTD_FLAG1)? 1504 NdefMap->TLVStruct.NdefTLVBlock: 1505 NdefMap->StdMifareContainer.currentBlock); 1506 1507 /* if MAD blocks then authentication key is 1508 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 else 1509 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7 */ 1510 if(( (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK0) && 1511 (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK1) && 1512 (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK2) && 1513 (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK64) && 1514 (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK65) && 1515 (NdefMap->StdMifareContainer.currentBlock != PH_FRINFC_MIFARESTD_MAD_BLK66)) || 1516 (NdefMap->TLVStruct.NdefTLVAuthFlag == 1517 (uint8_t)PH_FRINFC_MIFARESTD_FLAG1)) 1518 { 1519 NdefMap->SendRecvBuf[1] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1520 NdefMap->SendRecvBuf[2] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1521 NdefMap->SendRecvBuf[3] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1522 NdefMap->SendRecvBuf[4] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1523 NdefMap->SendRecvBuf[5] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1524 NdefMap->SendRecvBuf[6] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1525 } 1526 else 1527 { 1528 NdefMap->SendRecvBuf[1] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT1; /* 0xA0 */ 1529 NdefMap->SendRecvBuf[2] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT2; /* 0xA1 */ 1530 NdefMap->SendRecvBuf[3] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT3; /* 0xA2 */ 1531 NdefMap->SendRecvBuf[4] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT4; /* 0xA3 */ 1532 NdefMap->SendRecvBuf[5] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT5; /* 0xA4 */ 1533 NdefMap->SendRecvBuf[6] = PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT6; /* 0xA5 */ 1534 } 1535 1536 NdefMap->SendLength = MIFARE_AUTHENTICATE_CMD_LENGTH; 1537 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1538 /* Call the Overlapped HAL Transceive function */ 1539 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 1540 &NdefMap->MapCompletionInfo, 1541 NdefMap->psRemoteDevInfo, 1542 NdefMap->Cmd, 1543 &NdefMap->psDepAdditionalInfo, 1544 NdefMap->SendRecvBuf, 1545 NdefMap->SendLength, 1546 NdefMap->SendRecvBuf, 1547 NdefMap->SendRecvLength); 1548 1549 return status; 1550 } 1551 1552 static void phFriNfc_MifStd_H_Complete(phFriNfc_NdefMap_t *NdefMap, 1553 NFCSTATUS Result) 1554 { 1555 /* set the state back to the Reset_Init state*/ 1556 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT; 1557 1558 /* set the completion routine*/ 1559 NdefMap->CompletionRoutine[NdefMap->StdMifareContainer.CRIndex]. 1560 CompletionRoutine(NdefMap->CompletionRoutine->Context, Result); 1561 } 1562 1563 static NFCSTATUS phFriNfc_MifStd4k_H_CheckNdef(phFriNfc_NdefMap_t *NdefMap) 1564 { 1565 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1566 1567 /* Get the AID Block */ 1568 if(NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK2) 1569 { 1570 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK64; 1571 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 1572 } 1573 else if(NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK64) 1574 { 1575 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK65; 1576 } 1577 else 1578 { 1579 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK66; 1580 } 1581 1582 Result = phFriNfc_MifareStdMap_ChkNdef(NdefMap); 1583 1584 return Result; 1585 1586 } 1587 1588 static void phFriNfc_MifStd_H_fillAIDarray(phFriNfc_NdefMap_t *NdefMap) 1589 { 1590 uint8_t byteindex = 0; 1591 1592 if( (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK1) || 1593 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK64)) 1594 { 1595 /* The First Two Bytes in Receive Buffer 1596 are CRC bytes so it is not copied 1597 instead, 0 is copied in AID[0] & AID[1] */ 1598 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1599 PH_FRINFC_MIFARESTD_NDEF_COMP; 1600 NdefMap->StdMifareContainer.SectorIndex++; 1601 byteindex = 2; 1602 } 1603 1604 while(byteindex < PH_FRINFC_MIFARESTD_BYTES_READ) 1605 { 1606 if((NdefMap->SendRecvBuf[byteindex] == PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL2) && 1607 (NdefMap->SendRecvBuf[(byteindex + 1)] == PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL1)) 1608 { 1609 /* This flag is set when a NFC forum sector is found in a 1610 MAD block for the first time*/ 1611 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG1; 1612 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1613 PH_FRINFC_MIFARESTD_NDEF_COMP; 1614 NdefMap->StdMifareContainer.SectorIndex++; 1615 } 1616 else 1617 { 1618 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1619 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1620 NdefMap->StdMifareContainer.SectorIndex++; 1621 /* AID complete flag is set when a non NFC forum sector is found in a 1622 MAD block after the NFC forum sector. After setting this, all other 1623 values are ignored and are NOT NDEF compliant */ 1624 NdefMap->StdMifareContainer.aidCompleteFlag = 1625 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 1626 PH_FRINFC_MIFARESTD_FLAG1)? 1627 PH_FRINFC_MIFARESTD_FLAG1: 1628 PH_FRINFC_MIFARESTD_FLAG0); 1629 1630 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 1631 if(NdefMap->StdMifareContainer.aidCompleteFlag == PH_FRINFC_MIFARESTD_FLAG1) 1632 { 1633 break; 1634 } 1635 } 1636 byteindex += 2; 1637 } 1638 1639 /* If "aidCompleteFlag" is set then the remaining sectors are made NOT 1640 NDEF compliant */ 1641 if((NdefMap->StdMifareContainer.aidCompleteFlag == PH_FRINFC_MIFARESTD_FLAG1) && 1642 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) 1643 { 1644 /* for Mifare 1k there are 16 sectors, till this number all sectors 1645 are made NOT NDEF compliant */ 1646 for(byteindex = NdefMap->StdMifareContainer.SectorIndex; 1647 byteindex < PH_FRINFC_MIFARESTD1K_TOTAL_SECTOR; 1648 byteindex++) 1649 { 1650 NdefMap->StdMifareContainer.aid[byteindex] = 1651 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1652 } 1653 } 1654 else 1655 { 1656 /* for Mifare 4k there are 40 sectors, till this number all sectors 1657 are made NOT NDEF compliant */ 1658 if((NdefMap->StdMifareContainer.aidCompleteFlag == PH_FRINFC_MIFARESTD_FLAG1) && 1659 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) 1660 { 1661 for(byteindex = NdefMap->StdMifareContainer.SectorIndex; 1662 byteindex < PH_FRINFC_MIFARESTD4K_TOTAL_SECTOR; 1663 byteindex++) 1664 { 1665 NdefMap->StdMifareContainer.aid[byteindex] = 1666 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1667 } 1668 } 1669 } 1670 } 1671 1672 static NFCSTATUS phFriNfc_MifStd_H_BlkChk(phFriNfc_NdefMap_t *NdefMap) 1673 { 1674 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1675 uint8_t SectorID = 0, callbreak = 0; 1676 1677 for(;;) 1678 { 1679 /* Get a Sector ID for the Current Block */ 1680 SectorID = phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 1681 /* Check the card Type 1k or 4k */ 1682 /* enter if Mifare 1k card. For Mifare 4k go to else */ 1683 if(NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD) 1684 { 1685 /* if Sector Id > 15 No Sectors to write */ 1686 if(SectorID > 15) 1687 { 1688 SectorID = phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 1689 /*Error: No Ndef Compliant Sectors present.*/ 1690 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1691 NFCSTATUS_INVALID_PARAMETER); 1692 callbreak = 1; 1693 } 1694 else 1695 { 1696 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1697 } 1698 } /* End of if */ /* End of Mifare 1k check */ 1699 else /* Mifare 4k check starts here */ 1700 { 1701 /* Sector > 39 no ndef compliant sectors found*/ 1702 if(SectorID > PH_FRINFC_MIFARESTD_SECTOR_NO39) 1703 { 1704 /*Error: No Ndef Compliant Sectors present.*/ 1705 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1706 NFCSTATUS_INVALID_PARAMETER); 1707 callbreak = 1; 1708 } 1709 else if(NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK64) 1710 { 1711 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1712 } 1713 else if(SectorID < PH_FRINFC_MIFARESTD_SECTOR_NO32) /* sector < 32 contains 4 blocks in each sector */ 1714 { 1715 /* If the block checked is 63, the 3 blocks after this 1716 are AID(MAD) blocks so its need to be skipped */ 1717 if(NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK63) 1718 { 1719 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1720 } 1721 else 1722 { 1723 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1724 } 1725 } 1726 else 1727 { 1728 /* every last block of a sector needs to be skipped */ 1729 if(((NdefMap->StdMifareContainer.currentBlock + 1) % 1730 PH_FRINFC_MIFARESTD_BLOCK_BYTES) == 0) 1731 { 1732 NdefMap->StdMifareContainer.currentBlock++; 1733 } 1734 else 1735 { 1736 if(NdefMap->StdMifareContainer.aid[SectorID] == 1737 PH_FRINFC_MIFARESTD_NDEF_COMP) 1738 { 1739 /* Check whether the block is first block of a (next)new sector and 1740 also check if it is first block then internal length is zero 1741 or not. Because once Authentication is done for the sector again 1742 we should not authenticate it again */ 1743 /* In this case 32 sectors contains 4 blocks and next remaining 8 sectors 1744 contains 16 blocks that is why (32 * 4) + (sectorID - 32) *16*/ 1745 if((NdefMap->StdMifareContainer.currentBlock == 1746 ((PH_FRINFC_MIFARESTD_SECTOR_NO32 * PH_FRINFC_MIFARESTD_BLK4) + 1747 ((SectorID - PH_FRINFC_MIFARESTD_SECTOR_NO32) * PH_FRINFC_MIFARESTD_BLOCK_BYTES))) && 1748 (NdefMap->StdMifareContainer.internalLength == 0)) 1749 { 1750 NdefMap->StdMifareContainer.AuthDone = 0; 1751 } 1752 callbreak = 1; 1753 } 1754 else 1755 { 1756 NdefMap->StdMifareContainer.currentBlock += 16; 1757 } 1758 } 1759 } 1760 } 1761 if(callbreak == 1) 1762 { 1763 break; 1764 } 1765 } 1766 1767 return Result; 1768 } 1769 1770 static uint8_t phFriNfc_MifStd_H_GetSect(uint8_t BlockNumber) 1771 { 1772 uint8_t SectorID = 0; 1773 1774 if(BlockNumber >= PH_FRINFC_MIFARESTD4K_BLK128) 1775 { 1776 SectorID = (uint8_t)(PH_FRINFC_MIFARESTD_SECTOR_NO32 + 1777 ((BlockNumber - PH_FRINFC_MIFARESTD4K_BLK128)/ 1778 PH_FRINFC_MIFARESTD_BLOCK_BYTES)); 1779 } 1780 else 1781 { 1782 SectorID = (BlockNumber/PH_FRINFC_MIFARESTD_BLK4); 1783 } 1784 return SectorID; 1785 } 1786 1787 static NFCSTATUS phFriNfc_MifStd_H_RdAcsBit(phFriNfc_NdefMap_t *NdefMap) 1788 { 1789 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1790 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_ACS_BIT; 1791 1792 if(NdefMap->StdMifareContainer.ReadAcsBitFlag == PH_FRINFC_MIFARESTD_FLAG1) 1793 { 1794 /* Get the sector trailer */ 1795 ((NdefMap->StdMifareContainer.currentBlock > 127)? 1796 phFriNfc_MifStd_H_Get4kStTrail(NdefMap): 1797 phFriNfc_MifStd_H_Get1kStTrail(NdefMap)); 1798 } 1799 else 1800 { 1801 /* Give the current block to read */ 1802 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1803 NdefMap->StdMifareContainer.currentBlock; 1804 } 1805 1806 Result = phFriNfc_MifStd_H_Rd16Bytes(NdefMap, 1807 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0]); 1808 1809 return Result; 1810 } 1811 1812 static NFCSTATUS phFriNfc_MifStd_H_ChkAcsBit(phFriNfc_NdefMap_t *NdefMap) 1813 { 1814 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1815 1816 /* Blocks from 0 to 3 and from 64 to 67(MAD blocks) */ 1817 if((NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK0) || 1818 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK1) || 1819 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK2) || 1820 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK3) || 1821 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK64) || 1822 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK65) || 1823 (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_MAD_BLK66) ) 1824 { 1825 /* Access bits check removed for the MAD blocks */ 1826 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1827 1828 if(((NdefMap->SendRecvBuf[ 1829 PH_FRINFC_MIFARESTD_VAL6] & 1830 PH_FRINFC_MIFARESTD_MASK_FF) == 1831 PH_FRINFC_MIFARESTD_MADSECT_ACS_BYTE6) && 1832 ((NdefMap->SendRecvBuf[ 1833 PH_FRINFC_MIFARESTD_VAL7] & 1834 PH_FRINFC_MIFARESTD_MASK_FF) == 1835 PH_FRINFC_MIFARESTD_MADSECT_ACS_BYTE7) && 1836 ((NdefMap->SendRecvBuf[ 1837 PH_FRINFC_MIFARESTD_VAL8] & 1838 PH_FRINFC_MIFARESTD_MASK_FF) == 1839 PH_FRINFC_MIFARESTD_ACS_BYTE8)) 1840 { 1841 NdefMap->StdMifareContainer.WriteFlag = 1842 PH_FRINFC_MIFARESTD_FLAG0; 1843 NdefMap->StdMifareContainer.ReadFlag = 1844 PH_FRINFC_MIFARESTD_FLAG1; 1845 } 1846 else 1847 { 1848 NdefMap->StdMifareContainer.WriteFlag = 1849 PH_FRINFC_MIFARESTD_FLAG0; 1850 NdefMap->StdMifareContainer.ReadFlag = 1851 PH_FRINFC_MIFARESTD_FLAG0; 1852 } 1853 1854 #else /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1855 1856 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED; 1857 1858 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1859 } 1860 else 1861 { 1862 /* Check for Access bytes 6, 7 and 8 value = 1863 0x7F, 0x07, 0x88 NFC forum sectors*/ 1864 if(((NdefMap->SendRecvBuf[ 1865 PH_FRINFC_MIFARESTD_VAL6] & 1866 PH_FRINFC_MIFARESTD_MASK_FF) == 1867 PH_FRINFC_MIFARESTD_NFCSECT_ACS_BYTE6) && 1868 ((NdefMap->SendRecvBuf[ 1869 PH_FRINFC_MIFARESTD_VAL7] & 1870 PH_FRINFC_MIFARESTD_MASK_FF) == 1871 PH_FRINFC_MIFARESTD_NFCSECT_ACS_BYTE7) && 1872 ((NdefMap->SendRecvBuf[ 1873 PH_FRINFC_MIFARESTD_VAL8] & 1874 PH_FRINFC_MIFARESTD_MASK_FF) == 1875 PH_FRINFC_MIFARESTD_ACS_BYTE8)) 1876 { 1877 NdefMap->StdMifareContainer.WriteFlag = 1878 PH_FRINFC_MIFARESTD_FLAG1; 1879 NdefMap->StdMifareContainer.ReadFlag = 1880 PH_FRINFC_MIFARESTD_FLAG1; 1881 } 1882 else if(((NdefMap->SendRecvBuf[ 1883 PH_FRINFC_MIFARESTD_VAL6] & 1884 PH_FRINFC_MIFARESTD_MASK_FF) == 1885 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE6) && 1886 ((NdefMap->SendRecvBuf[ 1887 PH_FRINFC_MIFARESTD_VAL7] & 1888 PH_FRINFC_MIFARESTD_MASK_FF) == 1889 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE7) && 1890 ((NdefMap->SendRecvBuf[ 1891 PH_FRINFC_MIFARESTD_VAL8] & 1892 PH_FRINFC_MIFARESTD_MASK_FF) == 1893 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE8)) 1894 { 1895 /* Read Only state */ 1896 /* Check for Access bytes 6, 7 and 8 value = 1897 0x55, 0xAD, 0x2A NFC forum Sectors*/ 1898 NdefMap->StdMifareContainer.WriteFlag = 1899 PH_FRINFC_MIFARESTD_FLAG0; 1900 NdefMap->StdMifareContainer.ReadFlag = 1901 PH_FRINFC_MIFARESTD_FLAG1; 1902 } 1903 else 1904 { 1905 NdefMap->StdMifareContainer.WriteFlag = 1906 PH_FRINFC_MIFARESTD_FLAG0; 1907 NdefMap->StdMifareContainer.ReadFlag = 1908 PH_FRINFC_MIFARESTD_FLAG0; 1909 } 1910 1911 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1912 1913 /* Do nothing */ 1914 1915 #else /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1916 1917 Result = phFriNfc_MifStd_H_GPBChk(NdefMap); 1918 1919 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1920 1921 } 1922 1923 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1924 1925 Result = phFriNfc_MifStd_H_GPBChk(NdefMap); 1926 1927 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1928 1929 return Result; 1930 } 1931 1932 static NFCSTATUS phFriNfc_MifStd_H_ChkRdWr(phFriNfc_NdefMap_t *NdefMap) 1933 { 1934 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1935 switch(NdefMap->PrevOperation) 1936 { 1937 case PH_FRINFC_NDEFMAP_CHECK_OPE: 1938 if(NdefMap->CardState == 1939 PH_NDEFMAP_CARD_STATE_INVALID) 1940 { 1941 /* No permission to read */ 1942 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 1943 NFCSTATUS_READ_FAILED); 1944 } 1945 else if((NdefMap->StdMifareContainer.currentBlock > 3) && 1946 (NdefMap->StdMifareContainer.ChkNdefCompleteFlag == 1947 PH_FRINFC_MIFARESTD_FLAG1) && 1948 (NdefMap->StdMifareContainer.currentBlock != 1949 PH_FRINFC_MIFARESTD_MAD_BLK65) && 1950 (NdefMap->StdMifareContainer.currentBlock != 1951 PH_FRINFC_MIFARESTD_MAD_BLK66)) 1952 { 1953 /* NdefMap->StdMifareContainer.currentBlock = 1954 ((NdefMap->StdMifareContainer.ReadCompleteFlag == 1955 PH_FRINFC_MIFARESTD_FLAG1)? 1956 NdefMap->StdMifareContainer.currentBlock: 1957 (NdefMap->StdMifareContainer.currentBlock + 1958 PH_FRINFC_MIFARESTD_VAL4)); 1959 NdefMap->StdMifareContainer.currentBlock = 1960 ((NdefMap->StdMifareContainer.currentBlock == 1961 PH_FRINFC_MIFARESTD_MAD_BLK64)? 1962 (NdefMap->StdMifareContainer.currentBlock + 1963 PH_FRINFC_MIFARESTD_VAL4): 1964 NdefMap->StdMifareContainer.currentBlock);*/ 1965 1966 Result = ((NdefMap->StdMifareContainer.ReadAcsBitFlag == 1967 PH_FRINFC_MIFARESTD_FLAG0)? 1968 phFriNfc_MifStd_H_RdAcsBit(NdefMap): 1969 phFriNfc_MifStd_H_AuthSector(NdefMap)); 1970 } 1971 else 1972 { 1973 Result = phFriNfc_MifareStdMap_ChkNdef(NdefMap); 1974 } 1975 break; 1976 1977 case PH_FRINFC_NDEFMAP_READ_OPE: 1978 if(NdefMap->CardState == 1979 PH_NDEFMAP_CARD_STATE_INVALID) 1980 { 1981 /* No permission to Read */ 1982 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 1983 NFCSTATUS_READ_FAILED); 1984 } 1985 else if(NdefMap->StdMifareContainer.ReadNdefFlag == 1986 PH_FRINFC_MIFARESTD_FLAG1) 1987 { 1988 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 1989 } 1990 else 1991 { 1992 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 1993 } 1994 break; 1995 1996 case PH_FRINFC_NDEFMAP_WRITE_OPE: 1997 if((NdefMap->CardState == 1998 PH_NDEFMAP_CARD_STATE_INVALID) || 1999 (NdefMap->CardState == 2000 PH_NDEFMAP_CARD_STATE_READ_ONLY)) 2001 { 2002 /* No permission to Read */ 2003 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 2004 NFCSTATUS_WRITE_FAILED); 2005 } 2006 else if(NdefMap->StdMifareContainer.WrNdefFlag == 2007 PH_FRINFC_MIFARESTD_FLAG1) 2008 { 2009 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2010 } 2011 else if(NdefMap->StdMifareContainer.RdBeforeWrFlag == 2012 PH_FRINFC_MIFARESTD_FLAG1) 2013 { 2014 /*NdefMap->StdMifareContainer.ReadFlag = 2015 PH_FRINFC_MIFARESTD_FLAG0;*/ 2016 Result = phFriNfc_MifStd_H_RdBeforeWr(NdefMap); 2017 } 2018 else if(NdefMap->StdMifareContainer.RdAfterWrFlag == 2019 PH_FRINFC_MIFARESTD_FLAG1) 2020 { 2021 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 2022 } 2023 else 2024 { 2025 Result = (((NdefMap->TLVStruct.NdefTLVBlock == 2026 NdefMap->StdMifareContainer.currentBlock) && 2027 (NdefMap->Offset == 2028 PH_FRINFC_NDEFMAP_SEEK_BEGIN))? 2029 phFriNfc_MifStd_H_RdBeforeWr(NdefMap): 2030 phFriNfc_MifStd_H_WrABlock(NdefMap)); 2031 } 2032 break; 2033 2034 case PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE: 2035 Result = ((NdefMap->StdMifareContainer.ReadFlag == 2036 PH_FRINFC_MIFARESTD_FLAG0)? 2037 (PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 2038 NFCSTATUS_READ_FAILED)): 2039 phFriNfc_MifStd_H_GetActCardLen(NdefMap)); 2040 break; 2041 2042 default: 2043 /* Operation is not correct */ 2044 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 2045 NFCSTATUS_INVALID_PARAMETER); 2046 2047 break; 2048 } 2049 return Result; 2050 } 2051 2052 static void phFriNfc_MifStd_H_ChkNdefCmpltSects(phFriNfc_NdefMap_t *NdefMap) 2053 { 2054 uint8_t index = 0; 2055 if(NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) 2056 { 2057 for(index = 0; index < PH_FRINFC_MIFARESTD4K_TOTAL_SECTOR; index++) 2058 { 2059 /* For Mifare 4k, Block 0 to 31 contains 4 blocks */ 2060 /* sector 0 and 15 are aid blocks */ 2061 if(index != PH_FRINFC_MIFARESTD_SECTOR_NO16) 2062 { 2063 if(( (index < 32) && (index != PH_FRINFC_MIFARESTD_SECTOR_NO0)) 2064 && (NdefMap->StdMifareContainer.aid[index] == 2065 PH_FRINFC_MIFARESTD_NON_NDEF_COMP)) 2066 { 2067 /* Only 3 blocks can be read/written till sector 31 */ 2068 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 2069 PH_FRINFC_MIFARESTD_MAD_BLK3; 2070 2071 } 2072 else 2073 { 2074 /* For Mifare 4k, Block 32 to 39 contains 16 blocks */ 2075 if(NdefMap->StdMifareContainer.aid[index] == 2076 PH_FRINFC_MIFARESTD_NON_NDEF_COMP) 2077 { 2078 /* Only 15 blocks can be read/written from sector 31 */ 2079 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 2080 PH_FRINFC_MIFARESTD_BLK15; 2081 } 2082 } 2083 } 2084 } /* For index > 40 */ 2085 } 2086 else 2087 { 2088 for(index = PH_FRINFC_MIFARESTD_SECTOR_NO1; 2089 index < PH_FRINFC_MIFARESTD_SECTOR_NO16; index++) 2090 { 2091 if(NdefMap->StdMifareContainer.aid[index] == 2092 PH_FRINFC_MIFARESTD_NON_NDEF_COMP) 2093 { 2094 /* Only three blocks can be read/written in 2095 a sector. So if a sector is non-ndef 2096 compliant, decrement 3 */ 2097 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 2098 PH_FRINFC_MIFARESTD_MAD_BLK3; 2099 } 2100 } 2101 } 2102 } 2103 2104 #if 0 2105 static uint8_t phFriNfc_MifStd_H_ChkNdefLen(phFriNfc_NdefMap_t *NdefMap, 2106 uint8_t NDEFlength, 2107 uint8_t *CRFlag) 2108 { 2109 uint8_t NoLengthBytesinTLV = 0, 2110 TempBuffer[16] = {0}; 2111 uint16_t TempLength = 0; 2112 2113 TempLength = ((NdefMap->StdMifareContainer.internalLength > 0)? 2114 NdefMap->StdMifareContainer.internalLength : 2115 PH_FRINFC_MIFARESTD_BYTES_READ); 2116 2117 if(NdefMap->StdMifareContainer.internalLength > 0) 2118 { 2119 (void)memcpy( TempBuffer, 2120 NdefMap->StdMifareContainer.internalBuf, 2121 TempLength); 2122 } 2123 else 2124 { 2125 (void)memcpy( TempBuffer, 2126 NdefMap->SendRecvBuf, 2127 TempLength); 2128 } 2129 2130 /* if number of bytes for length (L) in TLV is greater than 0*/ 2131 if(NdefMap->TLVStruct.NoLbytesinTLV != PH_FRINFC_MIFARESTD_VAL0) 2132 { 2133 switch(NdefMap->TLVStruct.NoLbytesinTLV) 2134 { 2135 /* there are two bytes remaining in the length (L) of TLV */ 2136 case PH_FRINFC_MIFARESTD_VAL2: 2137 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES2; 2138 /* Get the value of the length (L) of the TLV */ 2139 NdefMap->TLVStruct.BytesRemainLinTLV = *TempBuffer; 2140 NdefMap->TLVStruct.BytesRemainLinTLV = 2141 ((NdefMap->TLVStruct.BytesRemainLinTLV 2142 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + (TempBuffer[ 2143 PH_FRINFC_MIFARESTD_INC_1])); 2144 2145 *CRFlag = (uint8_t)((NdefMap->TLVStruct.BytesRemainLinTLV < 2146 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 2147 PH_FRINFC_MIFARESTD_FLAG1 : 2148 PH_FRINFC_MIFARESTD_FLAG0); 2149 NdefMap->TLVStruct.BytesRemainLinTLV = ((*CRFlag == 2150 PH_FRINFC_MIFARESTD_FLAG1)? 2151 PH_FRINFC_MIFARESTD_VAL0: 2152 NdefMap->TLVStruct.BytesRemainLinTLV); 2153 break; 2154 2155 /* there is only one byte remaining in the length (L) of TLV */ 2156 case PH_FRINFC_MIFARESTD_VAL1: 2157 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES1; 2158 /* Get the value of the length (L) of the TLV */ 2159 NdefMap->TLVStruct.BytesRemainLinTLV = 2160 NdefMap->TLVStruct.prevLenByteValue; 2161 2162 NdefMap->TLVStruct.BytesRemainLinTLV = 2163 ((NdefMap->TLVStruct.BytesRemainLinTLV 2164 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + (*TempBuffer)); 2165 *CRFlag = (uint8_t)((NdefMap->TLVStruct.BytesRemainLinTLV < 2166 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 2167 PH_FRINFC_MIFARESTD_FLAG1 : 2168 PH_FRINFC_MIFARESTD_FLAG0); 2169 2170 NdefMap->TLVStruct.BytesRemainLinTLV = ((*CRFlag == 2171 PH_FRINFC_MIFARESTD_FLAG1)? 2172 PH_FRINFC_MIFARESTD_VAL0: 2173 NdefMap->TLVStruct.BytesRemainLinTLV); 2174 break; 2175 2176 default: 2177 break; 2178 } 2179 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2180 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2181 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2182 } 2183 else if(TempBuffer[NDEFlength] < 2184 PH_FRINFC_MIFARESTD_NDEFTLV_L) 2185 { 2186 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES1; 2187 /* Get the value of the length (L) of the TLV */ 2188 NdefMap->TLVStruct.BytesRemainLinTLV = 2189 TempBuffer[NDEFlength]; 2190 2191 /* if NDEFLength has reached 16 bytes, then the next coming byte is not of type in TLV */ 2192 NdefMap->TLVStruct.TcheckedinTLVFlag = (((NDEFlength + PH_FRINFC_MIFARESTD_INC_1) 2193 == PH_FRINFC_MIFARESTD_BYTES_READ)? 2194 PH_FRINFC_MIFARESTD_FLAG1 : 2195 PH_FRINFC_MIFARESTD_FLAG0); 2196 /* if NDEFLength has reached 16 bytes, then the next coming byte is not of length in TLV */ 2197 NdefMap->TLVStruct.LcheckedinTLVFlag = (((NDEFlength + PH_FRINFC_MIFARESTD_INC_1) 2198 == PH_FRINFC_MIFARESTD_BYTES_READ)? 2199 PH_FRINFC_MIFARESTD_FLAG1 : 2200 PH_FRINFC_MIFARESTD_FLAG0); 2201 } 2202 else 2203 { 2204 if((NDEFlength + PH_FRINFC_MIFARESTD_INC_1) 2205 == PH_FRINFC_MIFARESTD_BYTES_READ) 2206 { 2207 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES1; 2208 /* Number of bytes left for length (L) field in TLV */ 2209 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL2; 2210 /* if NDEFLength has reached 16 bytes, then the next coming byte is not of type in TLV */ 2211 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2212 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2213 } 2214 else if((NDEFlength + PH_FRINFC_MIFARESTD_INC_2) 2215 == PH_FRINFC_MIFARESTD_BYTES_READ) 2216 { 2217 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES2; 2218 /* Number of bytes left for length (L) field in TLV */ 2219 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL1; 2220 /* if NDEFLength has reached 16 bytes, then the next byte is not of type in TLV */ 2221 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2222 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2223 /* copy the value of the length field */ 2224 NdefMap->TLVStruct.prevLenByteValue = 2225 NdefMap->SendRecvBuf[(NDEFlength + PH_FRINFC_MIFARESTD_INC_1)]; 2226 } 2227 else 2228 { 2229 /* if NDEFLength has reached 16 bytes, then the next byte is not of type in TLV */ 2230 NdefMap->TLVStruct.TcheckedinTLVFlag = (((NDEFlength + PH_FRINFC_MIFARESTD_INC_3) 2231 == PH_FRINFC_MIFARESTD_BYTES_READ)? 2232 PH_FRINFC_MIFARESTD_FLAG1 : 2233 PH_FRINFC_MIFARESTD_FLAG0); 2234 2235 /* if NDEFLength has reached 16 bytes, then the next byte is not of length in TLV */ 2236 NdefMap->TLVStruct.LcheckedinTLVFlag = (((NDEFlength + PH_FRINFC_MIFARESTD_INC_1) 2237 == PH_FRINFC_MIFARESTD_BYTES_READ)? 2238 PH_FRINFC_MIFARESTD_FLAG1 : 2239 PH_FRINFC_MIFARESTD_FLAG0); 2240 2241 /* Number of bytes left for length (L) field in TLV */ 2242 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 2243 2244 NoLengthBytesinTLV = PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES3; 2245 /* Get the value of the length (L) of the TLV */ 2246 NdefMap->TLVStruct.BytesRemainLinTLV = 2247 TempBuffer[(NDEFlength + 2248 PH_FRINFC_MIFARESTD_INC_1)]; 2249 2250 NdefMap->TLVStruct.BytesRemainLinTLV = 2251 ((NdefMap->TLVStruct.BytesRemainLinTLV 2252 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + TempBuffer[ 2253 (NDEFlength +PH_FRINFC_MIFARESTD_INC_2)]); 2254 2255 *CRFlag = (uint8_t)((NdefMap->TLVStruct.BytesRemainLinTLV < 2256 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 2257 PH_FRINFC_MIFARESTD_FLAG1 : 2258 PH_FRINFC_MIFARESTD_FLAG0); 2259 } 2260 } 2261 return NoLengthBytesinTLV; 2262 } 2263 #endif 2264 #if 0 2265 static NFCSTATUS phFriNfc_MifStd_H_RdNdefTLV(phFriNfc_NdefMap_t *NdefMap, 2266 uint8_t *Temp16Bytes) 2267 { 2268 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2269 uint8_t NDEFlength = 0, 2270 RdFlag = 0, 2271 CRFlag = 0; 2272 uint16_t RemainingBytes = 0; 2273 2274 while(PH_FRINFC_MIFARESTD_FLAG1 == NdefMap->TLVStruct.NdefTLVFoundFlag) 2275 { 2276 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - 2277 NdefMap->ApduBuffIndex); 2278 if(((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2279 NdefMap->StdMifareContainer.NdefBlocks) * 2280 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 2281 PH_FRINFC_MIFARESTD_BLOCK_BYTES) < 2282 RemainingBytes) 2283 { 2284 /* If the user Buffer is greater than the Card Size 2285 set LastBlockFlag = 1. This Flag is used to read bytes 2286 till the end of the card only */ 2287 RemainingBytes = ((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2288 NdefMap->StdMifareContainer.NdefBlocks) * 16) + 2289 NdefMap->StdMifareContainer.internalLength); 2290 2291 } 2292 /* Ndef TLV flag to 0 */ 2293 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 2294 2295 if((NdefMap->TLVStruct.TcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 2296 (NdefMap->TLVStruct.LcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 2297 (NdefMap->TLVStruct.NoLbytesinTLV != PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0)) 2298 { 2299 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2300 break; 2301 } 2302 2303 /* if type (T) of TLV flag is not set then only the below check is valid 2304 because, for eg. assume, type (T) of TLV flag is set then this means 2305 that it is already checked from the previous 16 bytes data (T is the 2306 last byte of 16 bytes */ 2307 if(NdefMap->TLVStruct.TcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) 2308 { 2309 CRFlag = ((NdefMap->SendRecvBuf[(*Temp16Bytes)]!= 2310 PH_FRINFC_MIFARESTD_NDEFTLV_T)? 2311 PH_FRINFC_MIFARESTD_FLAG1: 2312 PH_FRINFC_MIFARESTD_FLAG0); 2313 2314 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 2315 { 2316 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 2317 PH_FRINFC_MIFARESTD_FLAG1; 2318 RdFlag = PH_FRINFC_MIFARESTD_FLAG1; 2319 break; 2320 } 2321 /* skip Type T of the TLV */ 2322 *Temp16Bytes += PH_FRINFC_MIFARESTD_INC_1; 2323 } 2324 else 2325 { 2326 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2327 } 2328 2329 if((*Temp16Bytes + PH_FRINFC_MIFARESTD_VAL1) == PH_FRINFC_MIFARESTD_BYTES_READ) 2330 { 2331 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2332 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2333 /* 16 bytes completed */ 2334 NdefMap->StdMifareContainer.currentBlock++; 2335 NdefMap->StdMifareContainer.NdefBlocks++; 2336 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2337 if(Result == NFCSTATUS_SUCCESS) 2338 { 2339 if(NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2340 { 2341 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 2342 } 2343 else 2344 { 2345 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 2346 } 2347 } 2348 break; 2349 } 2350 /* skip number of bytes taken by L in TLV, if L is already read */ 2351 if(NdefMap->TLVStruct.LcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) 2352 { 2353 /*CRFlag = (((*(NdefMap->SendRecvBuf + *Temp16Bytes) == 2354 PH_FRINFC_MIFARESTD_NDEFTLV_L0) && 2355 (NdefMap->TLVStruct.NoLbytesinTLV == 2356 PH_FRINFC_MIFARESTD_VAL0))? 2357 PH_FRINFC_MIFARESTD_FLAG1: 2358 PH_FRINFC_MIFARESTD_FLAG0);*/ 2359 2360 NDEFlength = *Temp16Bytes; 2361 *Temp16Bytes += phFriNfc_MifStd_H_ChkNdefLen(NdefMap, 2362 NDEFlength, 2363 &CRFlag); 2364 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 2365 { 2366 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 2367 PH_FRINFC_MIFARESTD_FLAG1; 2368 break; 2369 } 2370 2371 } 2372 else 2373 { 2374 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2375 } 2376 2377 if(*Temp16Bytes == PH_FRINFC_MIFARESTD_BYTES_READ) 2378 { 2379 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2380 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2381 /* 16 bytes completed */ 2382 NdefMap->StdMifareContainer.currentBlock++; 2383 NdefMap->StdMifareContainer.NdefBlocks++; 2384 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2385 if(Result == NFCSTATUS_SUCCESS) 2386 { 2387 if(NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2388 { 2389 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 2390 } 2391 else 2392 { 2393 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 2394 } 2395 } 2396 break; 2397 } 2398 2399 if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2400 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)) && 2401 (RemainingBytes <= 2402 NdefMap->TLVStruct.BytesRemainLinTLV)) 2403 { 2404 /* Copy data to user buffer */ 2405 (void)memcpy(&(NdefMap->ApduBuffer[ 2406 NdefMap->ApduBuffIndex]), 2407 &(NdefMap->SendRecvBuf[ 2408 (*Temp16Bytes)]), 2409 RemainingBytes); 2410 NdefMap->ApduBuffIndex += RemainingBytes; 2411 *Temp16Bytes += ((uint8_t)RemainingBytes); 2412 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2413 2414 if(NdefMap->TLVStruct.BytesRemainLinTLV == 0) 2415 { 2416 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2417 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2418 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2419 } 2420 else 2421 { 2422 /* copy the bytes to internal buffer that are read, 2423 but not used for the user buffer */ 2424 (void)memcpy(NdefMap->StdMifareContainer.internalBuf, 2425 &(NdefMap->SendRecvBuf[(*Temp16Bytes)]), 2426 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)); 2427 2428 /* TempLength of the internal buffer */ 2429 NdefMap->StdMifareContainer.internalLength = 2430 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes); 2431 } 2432 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2433 break; 2434 } 2435 else if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2436 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)) && 2437 (RemainingBytes > 2438 NdefMap->TLVStruct.BytesRemainLinTLV)) 2439 { 2440 /* Copy data to user buffer */ 2441 (void)memcpy(&(NdefMap->ApduBuffer[ 2442 NdefMap->ApduBuffIndex]), 2443 &(NdefMap->SendRecvBuf[ 2444 (*Temp16Bytes)]), 2445 NdefMap->TLVStruct.BytesRemainLinTLV); 2446 /* increment the user buffer index */ 2447 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 2448 *Temp16Bytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 2449 NdefMap->TLVStruct.BytesRemainLinTLV = 0; 2450 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2451 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2452 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2453 2454 /* check for 16 bytes of data been used */ 2455 if(*Temp16Bytes == PH_FRINFC_MIFARESTD_BYTES_READ) 2456 { 2457 /* 16 bytes completed */ 2458 NdefMap->StdMifareContainer.currentBlock++; 2459 NdefMap->StdMifareContainer.NdefBlocks++; 2460 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2461 if(Result == NFCSTATUS_SUCCESS) 2462 { 2463 if(NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2464 { 2465 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 2466 } 2467 else 2468 { 2469 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 2470 } 2471 } 2472 break; 2473 } 2474 } 2475 else if((NdefMap->TLVStruct.BytesRemainLinTLV > 2476 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)) && 2477 (RemainingBytes <= 2478 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes))) 2479 { 2480 /* Copy data to user buffer */ 2481 (void)memcpy(&(NdefMap->ApduBuffer[ 2482 NdefMap->ApduBuffIndex]), 2483 &(NdefMap->SendRecvBuf[ 2484 (*Temp16Bytes)]), 2485 RemainingBytes); 2486 NdefMap->ApduBuffIndex += RemainingBytes; 2487 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2488 if(RemainingBytes == (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)) 2489 { 2490 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2491 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2492 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2493 PH_FRINFC_MIFARESTD_FLAG1: 2494 PH_FRINFC_MIFARESTD_FLAG0); 2495 2496 /* 16 bytes completed */ 2497 NdefMap->StdMifareContainer.currentBlock++; 2498 NdefMap->StdMifareContainer.NdefBlocks++; 2499 } 2500 else 2501 { 2502 /* copy the bytes to internal buffer, that are read, 2503 but not used for the user buffer */ 2504 (void)memcpy(NdefMap->StdMifareContainer.internalBuf, 2505 &(NdefMap->SendRecvBuf[((*Temp16Bytes) + RemainingBytes)]), 2506 (PH_FRINFC_MIFARESTD_BYTES_READ - 2507 (*Temp16Bytes + RemainingBytes))); 2508 2509 /* Length of the internal buffer */ 2510 NdefMap->StdMifareContainer.internalLength = 2511 (PH_FRINFC_MIFARESTD_BYTES_READ - 2512 (*Temp16Bytes + RemainingBytes)); 2513 } 2514 *Temp16Bytes += ((uint8_t)RemainingBytes); 2515 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2516 break; 2517 } 2518 else 2519 { 2520 if((NdefMap->TLVStruct.BytesRemainLinTLV > 2521 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)) && 2522 (RemainingBytes > 2523 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes))) 2524 { 2525 /* Copy data to user buffer */ 2526 (void)memcpy(&(NdefMap->ApduBuffer[ 2527 NdefMap->ApduBuffIndex]), 2528 &(NdefMap->SendRecvBuf[ 2529 (*Temp16Bytes)]), 2530 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes)); 2531 NdefMap->ApduBuffIndex += (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes); 2532 NdefMap->TLVStruct.BytesRemainLinTLV -= 2533 (PH_FRINFC_MIFARESTD_BYTES_READ - *Temp16Bytes); 2534 *Temp16Bytes = PH_FRINFC_MIFARESTD_BYTES_READ; 2535 2536 2537 /* 16 bytes completed */ 2538 NdefMap->StdMifareContainer.currentBlock++; 2539 NdefMap->StdMifareContainer.NdefBlocks++; 2540 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2541 if(Result == NFCSTATUS_SUCCESS) 2542 { 2543 Result = ((NdefMap->StdMifareContainer.AuthDone == 2544 PH_FRINFC_MIFARESTD_FLAG1)? 2545 phFriNfc_MifStd_H_RdABlock(NdefMap): 2546 phFriNfc_MifStd_H_AuthSector(NdefMap)); 2547 } 2548 break; 2549 } 2550 } 2551 } 2552 2553 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 2554 { 2555 Result = (((RdFlag == PH_FRINFC_MIFARESTD_FLAG1) && 2556 (NdefMap->ApduBuffIndex == PH_FRINFC_MIFARESTD_VAL0))? 2557 (PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 2558 NFCSTATUS_EOF_CARD_REACHED)): 2559 Result); 2560 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 2561 phFriNfc_MifStd_H_Complete(NdefMap, Result); 2562 } 2563 return Result; 2564 } 2565 #endif 2566 2567 static NFCSTATUS phFriNfc_MifStd_H_RemainTLV(phFriNfc_NdefMap_t *NdefMap, 2568 uint8_t *Flag, 2569 uint8_t *Temp16Bytes) 2570 { 2571 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2572 uint8_t CRFlag = 0; 2573 uint16_t RemainingBytes = 0; 2574 2575 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - 2576 NdefMap->ApduBuffIndex); 2577 2578 if(NdefMap->StdMifareContainer.remainingSize < 2579 RemainingBytes) 2580 { 2581 /* If the user Buffer is greater than the Card Size 2582 set LastBlockFlag = 1. This Flag is used to read bytes 2583 till the end of the card only */ 2584 RemainingBytes = NdefMap->StdMifareContainer.remainingSize; 2585 } 2586 2587 /* Remaining Bytes of length (L) in TLV <= 16 */ 2588 if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2589 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 2590 (RemainingBytes <= NdefMap->TLVStruct.BytesRemainLinTLV)) 2591 { 2592 /* Copy data to user buffer */ 2593 (void)memcpy(&(NdefMap->ApduBuffer[ 2594 NdefMap->ApduBuffIndex]), 2595 &(NdefMap->SendRecvBuf[ 2596 (*Temp16Bytes)]), 2597 RemainingBytes); 2598 NdefMap->ApduBuffIndex += RemainingBytes; 2599 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 2600 2601 /* copy the bytes to internal buffer, that are read, 2602 but not used for the user buffer */ 2603 if(RemainingBytes != NdefMap->TLVStruct.BytesRemainLinTLV) 2604 { 2605 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 2606 #ifdef PH_HAL4_ENABLE 2607 &(NdefMap->SendRecvBuf[((*Temp16Bytes) + RemainingBytes)]), 2608 #else 2609 &(NdefMap->SendRecvBuf[RemainingBytes]), 2610 #endif /* #ifdef PH_HAL4_ENABLE */ 2611 ((PH_FRINFC_MIFARESTD_BYTES_READ - 2612 (*Temp16Bytes)) - RemainingBytes)); 2613 2614 /* internal buffer length */ 2615 NdefMap->StdMifareContainer.internalLength = 2616 ((PH_FRINFC_MIFARESTD_BYTES_READ - 2617 (*Temp16Bytes)) - RemainingBytes); 2618 } 2619 *Temp16Bytes += ((uint8_t)RemainingBytes); 2620 /* Remaining Bytes of length value in TLV */ 2621 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2622 2623 if(NdefMap->StdMifareContainer.internalLength == PH_FRINFC_MIFARESTD_VAL0) 2624 { 2625 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2626 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2627 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2628 PH_FRINFC_MIFARESTD_FLAG1: 2629 PH_FRINFC_MIFARESTD_FLAG0); 2630 2631 /* internal length bytes completed */ 2632 NdefMap->StdMifareContainer.currentBlock++; 2633 NdefMap->StdMifareContainer.NdefBlocks++; 2634 } 2635 2636 if(NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0) 2637 { 2638 /* Remaining Bytes of length (L) in TLV is Zero means that the next 2639 coming bytes are containing type (T), length (L) in TLV */ 2640 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2641 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2642 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2643 } 2644 /* call completion routine */ 2645 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2646 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2647 } 2648 else if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2649 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 2650 (RemainingBytes > NdefMap->TLVStruct.BytesRemainLinTLV)) 2651 { 2652 /* Copy data to user buffer */ 2653 (void)memcpy(&(NdefMap->ApduBuffer[ 2654 NdefMap->ApduBuffIndex]), 2655 &(NdefMap->SendRecvBuf[ 2656 (*Temp16Bytes)]), 2657 NdefMap->TLVStruct.BytesRemainLinTLV); 2658 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 2659 NdefMap->StdMifareContainer.remainingSize -= 2660 NdefMap->TLVStruct.BytesRemainLinTLV; 2661 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2662 *Temp16Bytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 2663 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 2664 2665 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 2666 2667 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2668 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2669 /* 16 bytes completed */ 2670 if(NdefMap->TLVStruct.BytesRemainLinTLV == 2671 PH_FRINFC_MIFARESTD_BYTES_READ) 2672 { 2673 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2674 NdefMap->TLVStruct.BytesRemainLinTLV = 2675 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2676 NdefMap->StdMifareContainer.currentBlock++; 2677 NdefMap->StdMifareContainer.NdefBlocks++; 2678 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2679 if(Result == NFCSTATUS_SUCCESS) 2680 { 2681 if(NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2682 { 2683 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 2684 } 2685 else 2686 { 2687 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 2688 } 2689 } 2690 } 2691 else 2692 { 2693 NdefMap->TLVStruct.BytesRemainLinTLV = 2694 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2695 /* The read operation has finished. so, completion routine 2696 can be called. set the Completion routine(CR) flag */ 2697 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2698 } 2699 } 2700 else if((NdefMap->TLVStruct.BytesRemainLinTLV > 2701 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 2702 (RemainingBytes <= (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)))) 2703 { 2704 /* Copy data to user buffer */ 2705 (void)memcpy(&(NdefMap->ApduBuffer[ 2706 NdefMap->ApduBuffIndex]), 2707 &(NdefMap->SendRecvBuf[ 2708 (*Temp16Bytes)]), 2709 RemainingBytes); 2710 NdefMap->ApduBuffIndex += RemainingBytes; 2711 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 2712 2713 /* Remaining Bytes of length (L) in TLV */ 2714 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2715 /* 2716 The below macro PH_HAL4_ENABLE is added because, 2717 there is an error with the following sequence 2718 Read begin (for ex : with 10 bytes) 2719 Read current (for ex : with 10 bytes). Here error buffer 2720 is returned 2721 Reason : During first read, internal buffer is updated 2722 with the wrong buffer values 2723 Actually, if we read the first block (means TLV block), it 2724 contains even the TLV structure. so to copy the actual buffer, 2725 the TLV shall be excluded 2726 */ 2727 #ifdef PH_HAL4_ENABLE 2728 /* copy the bytes to internal buffer, that are read, 2729 but not used for the user buffer */ 2730 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 2731 &(NdefMap->SendRecvBuf[(RemainingBytes + (*Temp16Bytes))]), 2732 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) 2733 - RemainingBytes)); 2734 2735 /* internal buffer length */ 2736 NdefMap->StdMifareContainer.internalLength = 2737 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes); 2738 #else 2739 /* copy the bytes to internal buffer, that are read, 2740 but not used for the user buffer */ 2741 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 2742 &(NdefMap->SendRecvBuf[RemainingBytes]), 2743 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) 2744 - RemainingBytes)); 2745 2746 /* internal buffer length */ 2747 NdefMap->StdMifareContainer.internalLength = 2748 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes); 2749 #endif /* #ifdef PH_HAL4_ENABLE */ 2750 2751 if(RemainingBytes == (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) 2752 { 2753 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2754 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2755 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2756 PH_FRINFC_MIFARESTD_FLAG1: 2757 PH_FRINFC_MIFARESTD_FLAG0); 2758 2759 /* internal length bytes completed */ 2760 NdefMap->StdMifareContainer.currentBlock++; 2761 NdefMap->StdMifareContainer.NdefBlocks++; 2762 } 2763 *Temp16Bytes += ((uint8_t)RemainingBytes); 2764 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 2765 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2766 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2767 } 2768 else 2769 { 2770 if((NdefMap->TLVStruct.BytesRemainLinTLV > 2771 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 2772 (RemainingBytes > (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)))) 2773 { 2774 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2775 /* Copy data to user buffer */ 2776 (void)memcpy(&(NdefMap->ApduBuffer 2777 [NdefMap->ApduBuffIndex]), 2778 &(NdefMap->SendRecvBuf[ 2779 (*Temp16Bytes)]), 2780 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))); 2781 NdefMap->ApduBuffIndex += (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 2782 NdefMap->StdMifareContainer.remainingSize -= 2783 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 2784 NdefMap->TLVStruct.BytesRemainLinTLV -= (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 2785 *Temp16Bytes += (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 2786 if(NdefMap->TLVStruct.BytesRemainLinTLV != PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0) 2787 { 2788 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 2789 } 2790 /* 16 bytes completed */ 2791 NdefMap->StdMifareContainer.currentBlock++; 2792 NdefMap->StdMifareContainer.NdefBlocks++; 2793 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2794 if(Result == NFCSTATUS_SUCCESS) 2795 { 2796 Result = ((NdefMap->StdMifareContainer.AuthDone == 2797 PH_FRINFC_MIFARESTD_FLAG1)? 2798 phFriNfc_MifStd_H_RdABlock(NdefMap): 2799 phFriNfc_MifStd_H_AuthSector(NdefMap)); 2800 } 2801 } 2802 } 2803 2804 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 2805 { 2806 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 2807 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2808 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2809 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2810 PH_FRINFC_MIFARESTD_FLAG1: 2811 PH_FRINFC_MIFARESTD_FLAG0); 2812 } 2813 2814 return Result; 2815 } 2816 2817 static NFCSTATUS phFriNfc_MifStd_H_ChkIntLen(phFriNfc_NdefMap_t *NdefMap) 2818 { 2819 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2820 uint8_t NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 2821 uint8_t TempintBytes = 0; 2822 2823 if(NdefMap->TLVStruct.BytesRemainLinTLV != 0) 2824 { 2825 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2826 /* To read the remaining length (L) in TLV */ 2827 Result = phFriNfc_MifStd_H_IntLenWioutNdef(NdefMap, &NDEFFlag, &TempintBytes); 2828 } 2829 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2830 /* check the NDEFFlag is set. if this is not set, then 2831 in the above RemainTLV function all the 16 bytes has been 2832 read */ 2833 #if 0 2834 if((NDEFFlag == PH_FRINFC_MIFARESTD_FLAG1) && 2835 (NdefMap->TLVStruct.NdefTLVFoundFlag == 2836 PH_FRINFC_MIFARESTD_FLAG1)) 2837 { 2838 /* if the block is NDEF TLV then get data from here */ 2839 Result = phFriNfc_MifStd_H_IntLenWithNdef(NdefMap, &TempintBytes); 2840 } 2841 #endif 2842 return Result; 2843 } 2844 2845 static NFCSTATUS phFriNfc_MifStd_H_IntLenWioutNdef(phFriNfc_NdefMap_t *NdefMap, 2846 uint8_t *Flag, 2847 uint8_t *TempintBytes) 2848 { 2849 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2850 uint8_t CRFlag = 0; 2851 uint16_t RemainingBytes = 0; 2852 2853 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - 2854 NdefMap->ApduBuffIndex); 2855 2856 if(NdefMap->StdMifareContainer.remainingSize < 2857 RemainingBytes) 2858 { 2859 /* If the user Buffer is greater than the Card Size 2860 set LastBlockFlag = 1. This Flag is used to read bytes 2861 till the end of the card only */ 2862 RemainingBytes = NdefMap->StdMifareContainer.remainingSize; 2863 } 2864 2865 /* Remaining Bytes of length (L) in TLV <= internal length */ 2866 if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2867 NdefMap->StdMifareContainer.internalLength) && 2868 (RemainingBytes <= NdefMap->TLVStruct.BytesRemainLinTLV)) 2869 { 2870 (void)memcpy(&(NdefMap->ApduBuffer[ 2871 NdefMap->ApduBuffIndex]), 2872 &(NdefMap->StdMifareContainer.internalBuf[ 2873 (*TempintBytes)]), 2874 RemainingBytes); 2875 NdefMap->ApduBuffIndex += RemainingBytes; 2876 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 2877 *TempintBytes += ((uint8_t)RemainingBytes); 2878 2879 /* copy the bytes to internal buffer, that are read, 2880 but not used for the user buffer */ 2881 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 2882 &(NdefMap->StdMifareContainer.internalBuf[RemainingBytes]), 2883 (NdefMap->StdMifareContainer.internalLength - RemainingBytes)); 2884 2885 /* internal buffer length */ 2886 NdefMap->StdMifareContainer.internalLength -= RemainingBytes; 2887 2888 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2889 if(NdefMap->StdMifareContainer.internalLength == PH_FRINFC_MIFARESTD_VAL0) 2890 { 2891 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2892 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2893 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2894 PH_FRINFC_MIFARESTD_FLAG1: 2895 PH_FRINFC_MIFARESTD_FLAG0); 2896 2897 /* internal length bytes completed */ 2898 NdefMap->StdMifareContainer.currentBlock++; 2899 NdefMap->StdMifareContainer.NdefBlocks++; 2900 } 2901 2902 /* Remaining Bytes of length value in TLV */ 2903 if(NdefMap->TLVStruct.BytesRemainLinTLV == 0) 2904 { 2905 /* Remaining Bytes of length (L) in TLV is Zero means that the next 2906 coming bytes are containing type (T), length (L) in TLV */ 2907 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2908 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2909 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2910 } 2911 /* call completion routine */ 2912 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2913 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2914 } 2915 else if((NdefMap->TLVStruct.BytesRemainLinTLV <= 2916 NdefMap->StdMifareContainer.internalLength) && 2917 (RemainingBytes > NdefMap->TLVStruct.BytesRemainLinTLV)) 2918 { 2919 (void)memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2920 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2921 NdefMap->TLVStruct.BytesRemainLinTLV); 2922 2923 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 2924 NdefMap->StdMifareContainer.remainingSize -= 2925 NdefMap->TLVStruct.BytesRemainLinTLV; 2926 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2927 2928 *TempintBytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 2929 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 2930 2931 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2932 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2933 2934 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 2935 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 2936 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 2937 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 2938 PH_FRINFC_MIFARESTD_FLAG1: 2939 PH_FRINFC_MIFARESTD_FLAG0); 2940 #ifdef PH_HAL4_ENABLE 2941 2942 if (PH_FRINFC_MIFARESTD_FLAG1 == 2943 NdefMap->StdMifareContainer.ReadWriteCompleteFlag) 2944 { 2945 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2946 } 2947 2948 #endif /* #ifdef PH_HAL4_ENABLE */ 2949 2950 if( NdefMap->TLVStruct.BytesRemainLinTLV == 2951 NdefMap->StdMifareContainer.internalLength) 2952 { 2953 /* Remaining Bytes in Length (L) field of TLV is 0 */ 2954 NdefMap->TLVStruct.BytesRemainLinTLV = 2955 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2956 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 2957 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2958 /* internal length bytes completed */ 2959 NdefMap->StdMifareContainer.currentBlock++; 2960 NdefMap->StdMifareContainer.NdefBlocks++; 2961 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2962 if(Result == NFCSTATUS_SUCCESS) 2963 { 2964 Result = 2965 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1)? 2966 phFriNfc_MifStd_H_RdABlock(NdefMap): 2967 phFriNfc_MifStd_H_AuthSector(NdefMap)); 2968 } 2969 } 2970 else 2971 { 2972 /* Remaining Bytes in Length (L) field of TLV is 0 */ 2973 NdefMap->TLVStruct.BytesRemainLinTLV = 2974 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2975 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 2976 } 2977 } 2978 else if((NdefMap->TLVStruct.BytesRemainLinTLV > 2979 NdefMap->StdMifareContainer.internalLength) && 2980 (RemainingBytes <= NdefMap->StdMifareContainer.internalLength)) 2981 { 2982 (void)memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2983 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2984 RemainingBytes); 2985 2986 NdefMap->ApduBuffIndex += RemainingBytes; 2987 NdefMap->StdMifareContainer.remainingSize -= 2988 RemainingBytes; 2989 *TempintBytes += ((uint8_t)RemainingBytes); 2990 /* Remaining Bytes of length (L) in TLV */ 2991 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2992 2993 /* copy the bytes to internal buffer, that are read, 2994 but not used for the user buffer */ 2995 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 2996 &(NdefMap->StdMifareContainer.internalBuf[RemainingBytes]), 2997 (NdefMap->StdMifareContainer.internalLength - RemainingBytes)); 2998 2999 /* internal buffer length */ 3000 NdefMap->StdMifareContainer.internalLength -= RemainingBytes; 3001 if(NdefMap->StdMifareContainer.internalLength == PH_FRINFC_MIFARESTD_VAL0) 3002 { 3003 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 3004 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 3005 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 3006 PH_FRINFC_MIFARESTD_FLAG1: 3007 PH_FRINFC_MIFARESTD_FLAG0); 3008 3009 /* internal length bytes completed */ 3010 NdefMap->StdMifareContainer.currentBlock++; 3011 NdefMap->StdMifareContainer.NdefBlocks++; 3012 } 3013 3014 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 3015 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3016 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 3017 } 3018 else 3019 { 3020 if((NdefMap->TLVStruct.BytesRemainLinTLV > 3021 NdefMap->StdMifareContainer.internalLength) && 3022 (RemainingBytes > NdefMap->StdMifareContainer.internalLength)) 3023 { 3024 (void)memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 3025 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 3026 NdefMap->StdMifareContainer.internalLength); 3027 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 3028 NdefMap->ApduBuffIndex += NdefMap->StdMifareContainer.internalLength; 3029 NdefMap->StdMifareContainer.remainingSize -= 3030 NdefMap->StdMifareContainer.internalLength; 3031 NdefMap->TLVStruct.BytesRemainLinTLV -= NdefMap->StdMifareContainer.internalLength; 3032 3033 if(NdefMap->TLVStruct.BytesRemainLinTLV != PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0) 3034 { 3035 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 3036 } 3037 3038 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 3039 /* internal length bytes completed */ 3040 NdefMap->StdMifareContainer.currentBlock++; 3041 NdefMap->StdMifareContainer.NdefBlocks++; 3042 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3043 if(Result == NFCSTATUS_SUCCESS) 3044 { 3045 Result = ((NdefMap->StdMifareContainer.AuthDone == 3046 PH_FRINFC_MIFARESTD_FLAG1)? 3047 phFriNfc_MifStd_H_RdABlock(NdefMap): 3048 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3049 } 3050 } 3051 } 3052 3053 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 3054 { 3055 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t) 3056 (((NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) || 3057 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0))? 3058 PH_FRINFC_MIFARESTD_FLAG1: 3059 PH_FRINFC_MIFARESTD_FLAG0); 3060 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 3061 } 3062 return Result; 3063 } 3064 #if 0 3065 static NFCSTATUS phFriNfc_MifStd_H_IntLenWithNdef(phFriNfc_NdefMap_t *NdefMap, 3066 uint8_t *TempintBytes) 3067 { 3068 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3069 uint16_t RemainingBytes = 0; 3070 uint8_t CRFlag = PH_FRINFC_MIFARESTD_FLAG0, 3071 RdFlag = PH_FRINFC_MIFARESTD_FLAG0, 3072 NDEFlength = 0; 3073 3074 RemainingBytes = (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); 3075 while(PH_FRINFC_MIFARESTD_FLAG1 == NdefMap->TLVStruct.NdefTLVFoundFlag) 3076 { 3077 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 3078 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - 3079 NdefMap->ApduBuffIndex); 3080 if(((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3081 NdefMap->StdMifareContainer.NdefBlocks) * 3082 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 3083 (NdefMap->StdMifareContainer.internalLength - 3084 *TempintBytes)) < 3085 RemainingBytes) 3086 { 3087 /* If the user Buffer is greater than the Card Size 3088 set LastBlockFlag = 1. This Flag is used to read bytes 3089 till the end of the card only */ 3090 RemainingBytes = ((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3091 NdefMap->StdMifareContainer.NdefBlocks) * 16) + 3092 (NdefMap->StdMifareContainer.internalLength - 3093 *TempintBytes)); 3094 3095 } 3096 3097 if((NdefMap->TLVStruct.TcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 3098 (NdefMap->TLVStruct.LcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 3099 (NdefMap->TLVStruct.NoLbytesinTLV != PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0)) 3100 { 3101 CRFlag = 1; 3102 break; 3103 } 3104 3105 /* if type (T) of TLV flag is not set then only the below check is valid 3106 because, for eg. assume, type (T) of TLV flag is set then this means 3107 that it is already checked from the previous internal bytes data (T is the 3108 last byte of internal bytes */ 3109 if(NdefMap->TLVStruct.TcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) 3110 { 3111 CRFlag =(uint8_t) ((NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]!= 3112 PH_FRINFC_MIFARESTD_NDEFTLV_T)? 3113 PH_FRINFC_MIFARESTD_FLAG1: 3114 PH_FRINFC_MIFARESTD_FLAG0); 3115 3116 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 3117 { 3118 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3119 PH_FRINFC_MIFARESTD_FLAG1; 3120 RdFlag = PH_FRINFC_MIFARESTD_FLAG1; 3121 break; 3122 } 3123 /* skip Type T of the TLV */ 3124 *TempintBytes += PH_FRINFC_MIFARESTD_INC_1; 3125 } 3126 else 3127 { 3128 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 3129 } 3130 3131 if(*TempintBytes == NdefMap->StdMifareContainer.internalLength) 3132 { 3133 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 3134 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 3135 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 3136 /* 16 bytes completed */ 3137 NdefMap->StdMifareContainer.currentBlock++; 3138 NdefMap->StdMifareContainer.NdefBlocks++; 3139 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3140 if(Result == NFCSTATUS_SUCCESS) 3141 { 3142 Result = 3143 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1)? 3144 phFriNfc_MifStd_H_RdABlock(NdefMap): 3145 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3146 } 3147 break; 3148 } 3149 3150 /* skip number of bytes taken by L in TLV, if L is already read */ 3151 if(NdefMap->TLVStruct.LcheckedinTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) 3152 { 3153 CRFlag = (uint8_t)((NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]== 3154 PH_FRINFC_MIFARESTD_NDEFTLV_L0)? 3155 PH_FRINFC_MIFARESTD_FLAG1: 3156 PH_FRINFC_MIFARESTD_FLAG0); 3157 3158 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 3159 { 3160 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3161 PH_FRINFC_MIFARESTD_FLAG1; 3162 RdFlag = PH_FRINFC_MIFARESTD_FLAG1; 3163 break; 3164 } 3165 NDEFlength = *TempintBytes; 3166 *TempintBytes += phFriNfc_MifStd_H_ChkNdefLen(NdefMap, 3167 NDEFlength, 3168 &CRFlag); 3169 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 3170 { 3171 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3172 PH_FRINFC_MIFARESTD_FLAG1; 3173 RdFlag = PH_FRINFC_MIFARESTD_FLAG1; 3174 break; 3175 } 3176 } 3177 else 3178 { 3179 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 3180 } 3181 3182 if(*TempintBytes == NdefMap->StdMifareContainer.internalLength) 3183 { 3184 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 3185 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 3186 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 3187 /* 16 bytes completed */ 3188 NdefMap->StdMifareContainer.currentBlock++; 3189 NdefMap->StdMifareContainer.NdefBlocks++; 3190 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3191 if(Result == NFCSTATUS_SUCCESS) 3192 { 3193 Result = ((NdefMap->StdMifareContainer.AuthDone == 3194 PH_FRINFC_MIFARESTD_FLAG1)? 3195 phFriNfc_MifStd_H_RdABlock(NdefMap): 3196 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3197 } 3198 break; 3199 } 3200 3201 if( (NdefMap->TLVStruct.BytesRemainLinTLV <= 3202 (NdefMap->StdMifareContainer.internalLength - *TempintBytes)) && 3203 (RemainingBytes <= NdefMap->TLVStruct.BytesRemainLinTLV)) 3204 { 3205 /* Copy the internal bytes to the user buffer */ 3206 (void)memcpy(&(NdefMap->ApduBuffer[ 3207 NdefMap->ApduBuffIndex]), 3208 &(NdefMap->StdMifareContainer.internalBuf[ 3209 (*TempintBytes)]), 3210 RemainingBytes); 3211 3212 NdefMap->ApduBuffIndex += RemainingBytes; 3213 *TempintBytes += ((uint8_t)RemainingBytes); 3214 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 3215 if(NdefMap->TLVStruct.BytesRemainLinTLV == 0) 3216 { 3217 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 3218 } 3219 /* Update the internal length */ 3220 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 3221 &(NdefMap->StdMifareContainer.internalBuf[ 3222 (*TempintBytes)]), 3223 RemainingBytes); 3224 NdefMap->StdMifareContainer.internalLength -= (*TempintBytes + 3225 RemainingBytes); 3226 3227 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3228 break; 3229 } 3230 else if((NdefMap->TLVStruct.BytesRemainLinTLV <= 3231 (NdefMap->StdMifareContainer.internalLength - *TempintBytes)) && 3232 (RemainingBytes > NdefMap->TLVStruct.BytesRemainLinTLV)) 3233 { 3234 /* Copy data to user buffer */ 3235 (void)memcpy(&(NdefMap->ApduBuffer[ 3236 NdefMap->ApduBuffIndex]), 3237 &(NdefMap->StdMifareContainer.internalBuf[ 3238 (*TempintBytes)]), 3239 NdefMap->TLVStruct.BytesRemainLinTLV); 3240 3241 /* increment the user buffer index */ 3242 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 3243 *TempintBytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 3244 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 3245 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 3246 3247 /* check for internal length bytes of data been used */ 3248 if(*TempintBytes == NdefMap->StdMifareContainer.internalLength) 3249 { 3250 /* 16 bytes completed */ 3251 NdefMap->StdMifareContainer.currentBlock++; 3252 NdefMap->StdMifareContainer.NdefBlocks++; 3253 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3254 if(Result == NFCSTATUS_SUCCESS) 3255 { 3256 Result = ((NdefMap->StdMifareContainer.AuthDone == 3257 PH_FRINFC_MIFARESTD_FLAG1)? 3258 phFriNfc_MifStd_H_RdABlock(NdefMap): 3259 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3260 } 3261 break; 3262 } 3263 } 3264 else if((NdefMap->TLVStruct.BytesRemainLinTLV > 3265 (NdefMap->StdMifareContainer.internalLength - *TempintBytes)) && 3266 (RemainingBytes <= (NdefMap->StdMifareContainer.internalLength - 3267 *TempintBytes))) 3268 { 3269 /* Copy data to user buffer */ 3270 (void)memcpy(&(NdefMap->ApduBuffer[ 3271 NdefMap->ApduBuffIndex]), 3272 &(NdefMap->StdMifareContainer.internalBuf[ 3273 (*TempintBytes)]), 3274 RemainingBytes); 3275 NdefMap->ApduBuffIndex += RemainingBytes; 3276 *TempintBytes += ((uint8_t)RemainingBytes); 3277 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 3278 3279 /* copy the bytes to internal buffer, that are read, 3280 but not used for the user buffer */ 3281 (void)memcpy(NdefMap->StdMifareContainer.internalBuf, 3282 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 3283 (NdefMap->StdMifareContainer.internalLength - *TempintBytes)); 3284 3285 /* Length of the internal buffer */ 3286 NdefMap->StdMifareContainer.internalLength -= *TempintBytes; 3287 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3288 break; 3289 } 3290 else 3291 { 3292 if((NdefMap->TLVStruct.BytesRemainLinTLV > 3293 (NdefMap->StdMifareContainer.internalLength - *TempintBytes)) && 3294 (RemainingBytes > (NdefMap->StdMifareContainer.internalLength - 3295 *TempintBytes))) 3296 { 3297 /* Copy data to user buffer */ 3298 (void)memcpy(&(NdefMap->ApduBuffer[ 3299 NdefMap->ApduBuffIndex]), 3300 &(NdefMap->StdMifareContainer.internalBuf[ 3301 (*TempintBytes)]), 3302 (NdefMap->StdMifareContainer.internalLength - 3303 *TempintBytes)); 3304 NdefMap->ApduBuffIndex += (NdefMap->StdMifareContainer.internalLength - 3305 *TempintBytes); 3306 NdefMap->TLVStruct.BytesRemainLinTLV -= 3307 (NdefMap->StdMifareContainer.internalLength - *TempintBytes); 3308 *TempintBytes += (uint8_t)(NdefMap->StdMifareContainer.internalLength - 3309 *TempintBytes); 3310 3311 NdefMap->StdMifareContainer.internalLength -= *TempintBytes; 3312 3313 /* 16 bytes completed */ 3314 NdefMap->StdMifareContainer.currentBlock++; 3315 NdefMap->StdMifareContainer.NdefBlocks++; 3316 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3317 if(Result == NFCSTATUS_SUCCESS) 3318 { 3319 Result = ((NdefMap->StdMifareContainer.AuthDone == 3320 PH_FRINFC_MIFARESTD_FLAG1)? 3321 phFriNfc_MifStd_H_RdABlock(NdefMap): 3322 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3323 } 3324 break; 3325 } 3326 } 3327 } 3328 3329 if(((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3330 NdefMap->StdMifareContainer.NdefBlocks) * 3331 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 3332 NdefMap->StdMifareContainer.internalLength) == 3333 PH_FRINFC_MIFARESTD_VAL0) 3334 { 3335 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3336 PH_FRINFC_MIFARESTD_FLAG1; 3337 } 3338 3339 if(CRFlag == PH_FRINFC_MIFARESTD_FLAG1) 3340 { 3341 Result = (((RdFlag == PH_FRINFC_MIFARESTD_FLAG1) && 3342 (NdefMap->ApduBuffIndex == PH_FRINFC_MIFARESTD_VAL0))? 3343 (PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 3344 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED)): 3345 Result); 3346 3347 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 3348 } 3349 3350 return Result; 3351 } 3352 #endif 3353 3354 static NFCSTATUS phFriNfc_MifStd_H_WriteNdefLen(phFriNfc_NdefMap_t *NdefMap) 3355 { 3356 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3357 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_NDEF_LEN; 3358 3359 /* If Current block = Ndef TLV block then the starting point 3360 is writing from type of TLV 3361 Else */ 3362 3363 if(NdefMap->StdMifareContainer.currentBlock == 3364 NdefMap->TLVStruct.NdefTLVBlock) 3365 { 3366 3367 if(NdefMap->TLVStruct.NULLTLVCount >= 3368 PH_FRINFC_MIFARESTD_VAL2) 3369 { 3370 phFriNfc_MifStd_H_fillTLV1(NdefMap); 3371 } 3372 else 3373 { 3374 phFriNfc_MifStd_H_fillTLV2(NdefMap); 3375 } 3376 } 3377 else 3378 { 3379 if(NdefMap->TLVStruct.NULLTLVCount >= 3380 PH_FRINFC_MIFARESTD_VAL2) 3381 { 3382 phFriNfc_MifStd_H_fillTLV1_1(NdefMap); 3383 } 3384 else 3385 { 3386 phFriNfc_MifStd_H_fillTLV2_1(NdefMap); 3387 } 3388 } 3389 3390 (void)memcpy( NdefMap->StdMifareContainer.Buffer, 3391 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1]), 3392 PH_FRINFC_MIFARESTD_BYTES_READ); 3393 3394 3395 /* Write from here */ 3396 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 3397 3398 #ifndef PH_HAL4_ENABLE 3399 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite16; 3400 #else 3401 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 3402 #endif 3403 3404 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 3405 /* Call the Overlapped HAL Transceive function */ 3406 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 3407 &NdefMap->MapCompletionInfo, 3408 NdefMap->psRemoteDevInfo, 3409 NdefMap->Cmd, 3410 &NdefMap->psDepAdditionalInfo, 3411 NdefMap->SendRecvBuf, 3412 NdefMap->SendLength, 3413 NdefMap->SendRecvBuf, 3414 NdefMap->SendRecvLength); 3415 3416 return Result; 3417 } 3418 #if 0 3419 static NFCSTATUS phFriNfc_MifStd_H_ChkNdefCmpltBlocks(phFriNfc_NdefMap_t *NdefMap) 3420 { 3421 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3422 NFCSTATUS_INVALID_PARAMETER); 3423 /* If NoOfNdefCompBlocks is found to be zero, 3424 should we warn the user */ 3425 if((NdefMap->StdMifareContainer.NoOfNdefCompBlocks != 3426 PH_FRINFC_MIFARESTD_VAL0) && 3427 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks <= 3428 PH_FRINFC_MIFARESTD4K_MAX_BLOCKS)) 3429 { 3430 /* Reading/writing to the card can start only 3431 from the block 4 */ 3432 NdefMap->StdMifareContainer.currentBlock = 4; 3433 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 3434 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3435 if((Result == NFCSTATUS_SUCCESS) && 3436 (NdefMap->StdMifareContainer.AuthDone == 3437 PH_FRINFC_MIFARESTD_FLAG1)) 3438 { 3439 NdefMap->StdMifareContainer.ReadAcsBitFlag = 0; 3440 Result = phFriNfc_MifStd_H_RdAcsBit(NdefMap); 3441 } 3442 else 3443 { 3444 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 3445 } 3446 } 3447 return Result; 3448 } 3449 #endif 3450 3451 static void phFriNfc_MifStd_H_RdWrReset(phFriNfc_NdefMap_t *NdefMap) 3452 { 3453 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_BLK4; 3454 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL1; 3455 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 3456 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 3457 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 3458 NdefMap->TLVStruct.NdefTLVAuthFlag = PH_FRINFC_MIFARESTD_FLAG0; 3459 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_MIFARESTD_MAD_BLK0; 3460 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 3461 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 3462 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 3463 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 3464 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 3465 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 3466 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG1; 3467 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 3468 NdefMap->StdMifareContainer.remainingSize = (uint16_t) 3469 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks * 3470 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 3471 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL1; 3472 3473 } 3474 3475 static NFCSTATUS phFriNfc_MifStd_H_RdtoWrNdefLen(phFriNfc_NdefMap_t *NdefMap) 3476 { 3477 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3478 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_TO_WR_NDEF_LEN; 3479 3480 if(NdefMap->TLVStruct.NdefTLVAuthFlag == PH_FRINFC_MIFARESTD_FLAG1) 3481 { 3482 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 3483 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 3484 } 3485 else 3486 { 3487 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 3488 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 3489 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 3490 3491 #ifndef PH_HAL4_ENABLE 3492 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareRead; 3493 #else 3494 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 3495 #endif 3496 /* Call the Overlapped HAL Transceive function */ 3497 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 3498 &NdefMap->MapCompletionInfo, 3499 NdefMap->psRemoteDevInfo, 3500 NdefMap->Cmd, 3501 &NdefMap->psDepAdditionalInfo, 3502 NdefMap->SendRecvBuf, 3503 NdefMap->SendLength, 3504 NdefMap->SendRecvBuf, 3505 NdefMap->SendRecvLength); 3506 } 3507 3508 return Result; 3509 } 3510 3511 static void phFriNfc_MifStd_H_SetNdefBlkAuth(phFriNfc_NdefMap_t *NdefMap) 3512 { 3513 NdefMap->TLVStruct.NdefTLVAuthFlag = 3514 ((phFriNfc_MifStd_H_GetSect(NdefMap->TLVStruct.NdefTLVBlock) 3515 == phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock))? 3516 PH_FRINFC_MIFARESTD_FLAG0: 3517 PH_FRINFC_MIFARESTD_FLAG1); 3518 } 3519 3520 static NFCSTATUS phFriNfc_MifStd_H_GetActCardLen(phFriNfc_NdefMap_t *NdefMap) 3521 { 3522 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3523 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_GET_ACT_CARDSIZE; 3524 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE; 3525 3526 Result = ((NdefMap->StdMifareContainer.AuthDone == 3527 PH_FRINFC_MIFARESTD_FLAG0)? 3528 phFriNfc_MifStd_H_AuthSector(NdefMap): 3529 phFriNfc_MifStd_H_Rd16Bytes(NdefMap, 3530 NdefMap->StdMifareContainer.currentBlock)); 3531 3532 return Result; 3533 } 3534 3535 static NFCSTATUS phFriNfc_MifStd_H_ChkTLVs(phFriNfc_NdefMap_t *NdefMap, 3536 uint8_t *CRFlag) 3537 { 3538 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3539 uint16_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 3540 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 3541 uint8_t TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 3542 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE; 3543 TempLength = NdefMap->TLVStruct.NdefTLVByte; 3544 for(;;) 3545 { 3546 #ifdef PH_HAL4_ENABLE 3547 if((NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_TERMTLV_T) && 3548 (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NULLTLV_T) && 3549 (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NDEFTLV_T) && 3550 (FALSE == NdefMap->TLVStruct.NdefTLVFoundFlag)) 3551 { 3552 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3553 NFCSTATUS_NO_NDEF_SUPPORT); 3554 NdefMap->TLVStruct.BytesRemainLinTLV = 0; 3555 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 3556 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3557 break; 3558 3559 } 3560 else 3561 #endif /* #ifdef PH_HAL4_ENABLE */ 3562 if((NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_TERMTLV_T) && 3563 (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NULLTLV_T)) 3564 { 3565 if(NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_NDEFTLV_T) 3566 { 3567 NdefMap->TLVStruct.NdefTLVBlock = 3568 NdefMap->StdMifareContainer.currentBlock; 3569 NdefMap->TLVStruct.NdefTLVByte = (uint8_t)TempLength; 3570 NdefMap->TLVStruct.NdefTLVFoundFlag = 3571 ((NdefMap->SendRecvBuf[TempLength] == 3572 PH_FRINFC_MIFARESTD_NDEFTLV_T)? 3573 PH_FRINFC_MIFARESTD_FLAG1: 3574 PH_FRINFC_MIFARESTD_FLAG0); 3575 3576 NdefMap->TLVStruct.NULLTLVCount = ((NdefMap->TLVStruct.NULLTLVCount 3577 == PH_FRINFC_MIFARESTD_VAL1)? 3578 PH_FRINFC_MIFARESTD_VAL0: 3579 NdefMap->TLVStruct.NULLTLVCount); 3580 } 3581 else 3582 { 3583 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 3584 } 3585 3586 TempLength++; 3587 if(TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) 3588 { 3589 NdefMap->TLVStruct.TcheckedinTLVFlag = 3590 PH_FRINFC_MIFARESTD_FLAG1; 3591 NdefMap->TLVStruct.NoLbytesinTLV = 3592 PH_FRINFC_MIFARESTD_VAL3; 3593 } 3594 Result = phFriNfc_MifStd_H_Chk16Bytes( NdefMap, 3595 TempLength); 3596 if(Result != NFCSTATUS_SUCCESS) 3597 { 3598 *CRFlag = (uint8_t)((Result == NFCSTATUS_PENDING)? 3599 PH_FRINFC_MIFARESTD_FLAG0: 3600 PH_FRINFC_MIFARESTD_FLAG1); 3601 break; 3602 } 3603 3604 if((((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3605 NdefMap->StdMifareContainer.NdefBlocks) * 3606 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 3607 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - 3608 TempLength)) < 3609 NdefMap->SendRecvBuf[TempLength]) && 3610 ((NdefMap->SendRecvBuf[TempLength] < 3611 PH_FRINFC_MIFARESTD_NDEFTLV_L) && 3612 (NdefMap->TLVStruct.NdefTLVFoundFlag != 3613 PH_FRINFC_MIFARESTD_VAL1))) 3614 { 3615 /* Result = Error */ 3616 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3617 NFCSTATUS_INVALID_PARAMETER); 3618 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3619 break; 3620 } 3621 3622 if((((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3623 NdefMap->StdMifareContainer.NdefBlocks) * 3624 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 3625 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - 3626 TempLength)) < 3627 NdefMap->SendRecvBuf[TempLength]) && 3628 ((NdefMap->SendRecvBuf[TempLength] == 3629 PH_FRINFC_MIFARESTD_VAL0) && 3630 (NdefMap->TLVStruct.NdefTLVFoundFlag == 3631 PH_FRINFC_MIFARESTD_VAL1))) 3632 { 3633 /* Result = Error */ 3634 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3635 NFCSTATUS_INVALID_PARAMETER); 3636 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3637 break; 3638 } 3639 3640 if((NdefMap->TLVStruct.NdefTLVFoundFlag == 3641 PH_FRINFC_MIFARESTD_FLAG1) && 3642 (NdefMap->SendRecvBuf[TempLength] < 3643 PH_FRINFC_MIFARESTD_NDEFTLV_L)) 3644 { 3645 Result = phFriNfc_MapTool_SetCardState(NdefMap, 3646 NdefMap->SendRecvBuf[TempLength]); 3647 NdefMap->TLVStruct.BytesRemainLinTLV = 3648 NdefMap->SendRecvBuf[TempLength]; 3649 NdefMap->StdMifareContainer.remainingSize -= 3650 PH_FRINFC_MIFARESTD_VAL2; 3651 /* This flag is set */ 3652 NdefMap->StdMifareContainer.remSizeUpdFlag = 3653 (uint8_t)((NdefMap->TLVStruct.NULLTLVCount >= 3654 PH_FRINFC_MIFARESTD_VAL2)? 3655 PH_FRINFC_MIFARESTD_FLAG0: 3656 PH_FRINFC_MIFARESTD_FLAG1); 3657 3658 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3659 break; 3660 } 3661 3662 NdefMap->StdMifareContainer.remainingSize -= 3663 (( NdefMap->SendRecvBuf[TempLength] < 3664 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 3665 (NdefMap->SendRecvBuf[TempLength] 3666 + PH_FRINFC_MIFARESTD_VAL2): 3667 PH_FRINFC_MIFARESTD_VAL0); 3668 3669 if(( NdefMap->SendRecvBuf[TempLength] == 3670 PH_FRINFC_MIFARESTD_VAL0)) 3671 { 3672 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3673 NFCSTATUS_INVALID_PARAMETER); 3674 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3675 break; 3676 } 3677 3678 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 3679 /* get the next TLV after the proprietary TLV */ 3680 Result = 3681 ((NdefMap->SendRecvBuf[TempLength] < 3682 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 3683 phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag): 3684 NFCSTATUS_PENDING); 3685 3686 if((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 3687 (Result == NFCSTATUS_SUCCESS)) 3688 { 3689 NdefMap->TLVStruct.TcheckedinTLVFlag = 3690 PH_FRINFC_MIFARESTD_FLAG0; 3691 NdefMap->TLVStruct.NoLbytesinTLV = 3692 PH_FRINFC_MIFARESTD_VAL0; 3693 3694 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 3695 *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)? 3696 PH_FRINFC_MIFARESTD_FLAG1: 3697 PH_FRINFC_MIFARESTD_FLAG0); 3698 break; 3699 } 3700 else 3701 { 3702 if(Result == NFCSTATUS_PENDING) 3703 { 3704 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG1; 3705 Result = ((NdefMap->SendRecvBuf[TempLength] == 3706 PH_FRINFC_MIFARESTD_NDEFTLV_L) ? 3707 NFCSTATUS_SUCCESS: 3708 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3709 NFCSTATUS_INVALID_PARAMETER))); 3710 3711 if(Result != NFCSTATUS_SUCCESS) 3712 { 3713 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3714 break; 3715 } 3716 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 3717 TempLength++; 3718 /* Check 0xFF */ 3719 if(TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) 3720 { 3721 NdefMap->TLVStruct.TcheckedinTLVFlag = 3722 PH_FRINFC_MIFARESTD_FLAG1; 3723 NdefMap->TLVStruct.NoLbytesinTLV = 3724 PH_FRINFC_MIFARESTD_VAL2; 3725 } 3726 Result = phFriNfc_MifStd_H_Chk16Bytes( NdefMap, 3727 TempLength); 3728 if(Result != NFCSTATUS_SUCCESS) 3729 { 3730 break; 3731 } 3732 3733 ShiftLength = NdefMap->SendRecvBuf[TempLength]; 3734 TempLength++; 3735 if(TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) 3736 { 3737 NdefMap->TLVStruct.TcheckedinTLVFlag = 3738 PH_FRINFC_MIFARESTD_FLAG1; 3739 NdefMap->TLVStruct.NoLbytesinTLV = 3740 PH_FRINFC_MIFARESTD_VAL1; 3741 NdefMap->TLVStruct.prevLenByteValue = 3742 NdefMap->SendRecvBuf[(TempLength - 3743 PH_FRINFC_MIFARESTD_VAL1)]; 3744 } 3745 Result = phFriNfc_MifStd_H_Chk16Bytes( NdefMap, 3746 TempLength); 3747 if(Result != NFCSTATUS_SUCCESS) 3748 { 3749 break; 3750 } 3751 3752 3753 if(((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3754 NdefMap->StdMifareContainer.NdefBlocks) * 3755 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 3756 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - 3757 TempLength)) < 3758 (( ShiftLength 3759 << 8) + NdefMap->SendRecvBuf[TempLength])) 3760 { 3761 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3762 NFCSTATUS_INVALID_REMOTE_DEVICE); 3763 3764 break; 3765 } 3766 3767 if(NdefMap->TLVStruct.NdefTLVFoundFlag == 3768 PH_FRINFC_MIFARESTD_FLAG1) 3769 { 3770 ShiftLength = (( ShiftLength<< 8) + 3771 NdefMap->SendRecvBuf[TempLength]); 3772 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 3773 Result = phFriNfc_MapTool_SetCardState(NdefMap, 3774 ShiftLength); 3775 NdefMap->StdMifareContainer.remainingSize -= 3776 PH_FRINFC_MIFARESTD_VAL4; 3777 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 3778 break; 3779 } 3780 3781 NdefMap->StdMifareContainer.remainingSize -= 3782 ((ShiftLength<< 8) + 3783 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]); 3784 TempLength++; 3785 3786 /* get the next TLV after the proprietary TLV */ 3787 Result = phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag); 3788 3789 if((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 3790 (Result == NFCSTATUS_SUCCESS)) 3791 { 3792 NdefMap->TLVStruct.TcheckedinTLVFlag = 3793 PH_FRINFC_MIFARESTD_FLAG0; 3794 NdefMap->TLVStruct.NoLbytesinTLV = 3795 PH_FRINFC_MIFARESTD_VAL0; 3796 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 3797 3798 break; 3799 } 3800 break; 3801 } 3802 } 3803 } 3804 else if((NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_TERMTLV_T) && 3805 (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG0)) 3806 { 3807 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3808 NFCSTATUS_INVALID_PARAMETER); 3809 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3810 PH_FRINFC_MIFARESTD_FLAG1; 3811 break; 3812 3813 } 3814 else if(NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_NULLTLV_T) 3815 { 3816 TempLength++; 3817 NdefMap->TLVStruct.NULLTLVCount += PH_FRINFC_MIFARESTD_VAL1; 3818 ShiftLength = NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)]; 3819 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL1; 3820 if(NdefMap->StdMifareContainer.remainingSize < 3821 (( ShiftLength << 8) + NdefMap->SendRecvBuf[TempLength])) 3822 { 3823 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3824 NFCSTATUS_INVALID_REMOTE_DEVICE); 3825 break; 3826 } 3827 Result = phFriNfc_MifStd_H_Chk16Bytes( NdefMap, 3828 TempLength); 3829 if(Result != NFCSTATUS_SUCCESS) 3830 { 3831 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 3832 break; 3833 } 3834 } 3835 else 3836 { 3837 if((NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_TERMTLV_T) && 3838 (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1)) 3839 { 3840 TempLength++; 3841 Result = NFCSTATUS_SUCCESS; 3842 NdefMap->StdMifareContainer.remainingSize -= 3843 PH_FRINFC_MIFARESTD_VAL1; 3844 } 3845 } 3846 } 3847 3848 if(NdefMap->TLVStruct.BytesRemainLinTLV > 3849 NdefMap->StdMifareContainer.remainingSize) 3850 { 3851 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3852 NFCSTATUS_INVALID_FORMAT); 3853 } 3854 else 3855 { 3856 if(NdefMap->StdMifareContainer.remainingSize == 3857 PH_FRINFC_MIFARESTD_VAL0) 3858 { 3859 Result = ((NdefMap->TLVStruct.NdefTLVFoundFlag == 3860 PH_FRINFC_MIFARESTD_FLAG1)? 3861 NFCSTATUS_SUCCESS: 3862 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 3863 NFCSTATUS_INVALID_PARAMETER))); 3864 } 3865 } 3866 return Result; 3867 } 3868 3869 static NFCSTATUS phFriNfc_MifStd_H_GetNxtTLV(phFriNfc_NdefMap_t *NdefMap, 3870 uint16_t *TempLength, 3871 uint8_t *TL4bytesFlag) 3872 { 3873 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3874 uint16_t LengthRemaining = PH_FRINFC_MIFARESTD_VAL0, 3875 TempLen = PH_FRINFC_MIFARESTD_VAL0, 3876 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 3877 3878 TempLen = (*TempLength); 3879 LengthRemaining = (PH_FRINFC_MIFARESTD_BYTES_READ - 3880 (TempLen + PH_FRINFC_MIFARESTD_VAL1)); 3881 3882 if(*TL4bytesFlag == PH_FRINFC_MIFARESTD_FLAG0) 3883 { 3884 (*TempLength) += (NdefMap->SendRecvBuf[TempLen] + 3885 PH_FRINFC_MIFARESTD_VAL1); 3886 3887 if(NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG0) 3888 { 3889 LengthRemaining = 3890 (((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ)? 3891 PH_FRINFC_MIFARESTD_VAL0: 3892 (NdefMap->SendRecvBuf[TempLen] - 3893 LengthRemaining)); 3894 } 3895 else 3896 { 3897 LengthRemaining = 3898 (((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ)? 3899 PH_FRINFC_MIFARESTD_VAL0: 3900 (NdefMap->SendRecvBuf[TempLen] - 3901 LengthRemaining)); 3902 } 3903 } 3904 else 3905 { 3906 *TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 3907 if(NdefMap->TLVStruct.NoLbytesinTLV == 3908 PH_FRINFC_MIFARESTD_VAL1) 3909 { 3910 ShiftLength = NdefMap->TLVStruct.prevLenByteValue; 3911 (*TempLength) += ((ShiftLength 3912 << 8) + NdefMap->SendRecvBuf[TempLen] + 3913 PH_FRINFC_MIFARESTD_VAL1); 3914 3915 LengthRemaining = 3916 (((ShiftLength 3917 << 8) + NdefMap->SendRecvBuf[TempLen]) - 3918 LengthRemaining); 3919 } 3920 else 3921 { 3922 ShiftLength = NdefMap->SendRecvBuf[(TempLen - PH_FRINFC_MIFARESTD_VAL1)]; 3923 (*TempLength) += ((ShiftLength 3924 << 8) + NdefMap->SendRecvBuf[TempLen] + 3925 PH_FRINFC_MIFARESTD_VAL1); 3926 3927 LengthRemaining = 3928 (((ShiftLength 3929 << 8) + NdefMap->SendRecvBuf[TempLen]) - 3930 LengthRemaining); 3931 } 3932 } 3933 3934 NdefMap->TLVStruct.NdefTLVByte = 3935 (uint8_t)(((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ)? 3936 (*TempLength): 3937 (LengthRemaining % PH_FRINFC_MIFARESTD_BYTES_READ)); 3938 3939 while(LengthRemaining != PH_FRINFC_MIFARESTD_VAL0) 3940 { 3941 NdefMap->StdMifareContainer.currentBlock++; 3942 NdefMap->StdMifareContainer.NdefBlocks++; 3943 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3944 LengthRemaining -= 3945 ((LengthRemaining <= PH_FRINFC_MIFARESTD_BYTES_READ)? 3946 LengthRemaining: 3947 PH_FRINFC_MIFARESTD_BYTES_READ); 3948 } 3949 3950 if(NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL0) 3951 { 3952 NdefMap->StdMifareContainer.currentBlock++; 3953 NdefMap->StdMifareContainer.NdefBlocks++; 3954 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3955 } 3956 3957 return Result; 3958 } 3959 3960 static NFCSTATUS phFriNfc_MifStd_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap, 3961 uint16_t TempLength) 3962 { 3963 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3964 if(TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) 3965 { 3966 NdefMap->StdMifareContainer.currentBlock++; 3967 NdefMap->StdMifareContainer.NdefBlocks++; 3968 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3969 3970 Result = 3971 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1)? 3972 phFriNfc_MifStd_H_GetActCardLen(NdefMap): 3973 phFriNfc_MifStd_H_AuthSector(NdefMap)); 3974 } 3975 return Result; 3976 } 3977 3978 static NFCSTATUS phFriNfc_MifStd_H_ChkRemainTLVs(phFriNfc_NdefMap_t *NdefMap, 3979 uint8_t *CRFlag, 3980 uint8_t *NDEFFlag) 3981 { 3982 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3983 uint16_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 3984 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 3985 uint8_t TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 3986 3987 switch(NdefMap->TLVStruct.NoLbytesinTLV) 3988 { 3989 case PH_FRINFC_MIFARESTD_VAL3: 3990 /* if TLV is found then set card state */ 3991 Result = ((NdefMap->TLVStruct.NdefTLVFoundFlag == 3992 PH_FRINFC_MIFARESTD_FLAG1)? 3993 phFriNfc_MapTool_SetCardState(NdefMap, 3994 NdefMap->SendRecvBuf[TempLength]): 3995 Result); 3996 3997 /* Check the length field is less than or 3998 equal to 0xFF if yes enter below statement 3999 else enter else if*/ 4000 if((NdefMap->SendRecvBuf[TempLength] < 4001 PH_FRINFC_MIFARESTD_NDEFTLV_L) && 4002 (Result == NFCSTATUS_SUCCESS)) 4003 { 4004 NdefMap->StdMifareContainer.remainingSize -= 4005 PH_FRINFC_MIFARESTD_VAL2; 4006 4007 Result = ((NdefMap->SendRecvBuf[TempLength] > 4008 NdefMap->StdMifareContainer.remainingSize)? 4009 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 4010 NFCSTATUS_INVALID_FORMAT)): 4011 Result); 4012 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 4013 if((NdefMap->TLVStruct.NdefTLVFoundFlag == 4014 PH_FRINFC_MIFARESTD_FLAG1) && 4015 (Result == NFCSTATUS_SUCCESS)) 4016 { 4017 NdefMap->TLVStruct.BytesRemainLinTLV = 4018 NdefMap->SendRecvBuf[TempLength]; 4019 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4020 4021 } 4022 else if(Result == NFCSTATUS_SUCCESS) 4023 { 4024 TempLength++; 4025 Result = phFriNfc_MifStd_H_GetNxtTLV(NdefMap, 4026 &TempLength, &TL4bytesFlag); 4027 4028 NdefMap->StdMifareContainer.remainingSize -= 4029 NdefMap->SendRecvBuf[TempLength]; 4030 if((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 4031 (*CRFlag == PH_FRINFC_MIFARESTD_FLAG0)) 4032 { 4033 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 4034 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 4035 } 4036 } 4037 4038 else 4039 { 4040 /* do nothing */ 4041 } 4042 } 4043 else if((NdefMap->SendRecvBuf[TempLength] == 4044 PH_FRINFC_MIFARESTD_NDEFTLV_L) && 4045 (Result == NFCSTATUS_SUCCESS)) 4046 { 4047 TempLength++; 4048 NdefMap->StdMifareContainer.remainingSize -= 4049 PH_FRINFC_MIFARESTD_VAL4; 4050 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 4051 Result = (((((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 4052 NdefMap->SendRecvBuf[(TempLength + 4053 PH_FRINFC_MIFARESTD_VAL1)]) > 4054 NdefMap->StdMifareContainer.remainingSize)? 4055 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 4056 NFCSTATUS_INVALID_FORMAT)): 4057 Result); 4058 if((NdefMap->TLVStruct.NdefTLVFoundFlag == 4059 PH_FRINFC_MIFARESTD_FLAG1) && 4060 (Result == NFCSTATUS_SUCCESS)) 4061 { 4062 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 4063 NdefMap->TLVStruct.BytesRemainLinTLV = 4064 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 4065 NdefMap->SendRecvBuf[(TempLength + 4066 PH_FRINFC_MIFARESTD_VAL1)]); 4067 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4068 } 4069 else if(Result == NFCSTATUS_SUCCESS) 4070 { 4071 TempLength++; 4072 4073 Result = phFriNfc_MifStd_H_GetNxtTLV(NdefMap, 4074 &TempLength, &TL4bytesFlag); 4075 NdefMap->StdMifareContainer.remainingSize -= 4076 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 4077 NdefMap->SendRecvBuf[(TempLength + 4078 PH_FRINFC_MIFARESTD_VAL1)]); 4079 4080 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 4081 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 4082 } 4083 else 4084 { 4085 /* do nothing */ 4086 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4087 } 4088 } 4089 else 4090 { 4091 /* Result = Error */ 4092 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 4093 NFCSTATUS_INVALID_FORMAT); 4094 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4095 } 4096 break; 4097 4098 case PH_FRINFC_MIFARESTD_VAL2: 4099 case PH_FRINFC_MIFARESTD_VAL1: 4100 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV == 4101 PH_FRINFC_MIFARESTD_VAL1)? 4102 ((NdefMap->TLVStruct.prevLenByteValue << 8) + 4103 NdefMap->SendRecvBuf[TempLength]): 4104 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 4105 NdefMap->SendRecvBuf[(TempLength + 4106 PH_FRINFC_MIFARESTD_VAL1)])); 4107 if(((( NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 4108 NdefMap->StdMifareContainer.NdefBlocks) * 4109 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 4110 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - 4111 TempLength)) < 4112 ShiftLength) 4113 { 4114 /* Result = Error */ 4115 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 4116 NFCSTATUS_INVALID_PARAMETER); 4117 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4118 } 4119 else 4120 { 4121 NdefMap->StdMifareContainer.remainingSize -= 4122 PH_FRINFC_MIFARESTD_VAL2; 4123 if(NdefMap->TLVStruct.NdefTLVFoundFlag == 4124 PH_FRINFC_MIFARESTD_FLAG1) 4125 { 4126 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 4127 if(NdefMap->TLVStruct.BytesRemainLinTLV > 4128 NdefMap->StdMifareContainer.remainingSize) 4129 { 4130 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 4131 NFCSTATUS_INVALID_FORMAT); 4132 } 4133 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 4134 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 4135 } 4136 else 4137 { 4138 NdefMap->StdMifareContainer.remainingSize -= 4139 ShiftLength; 4140 *CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 4141 TempLength += PH_FRINFC_MIFARESTD_VAL2; 4142 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG1; 4143 Result = ((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1)? 4144 NFCSTATUS_SUCCESS: 4145 phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag)); 4146 4147 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 4148 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 4149 } 4150 } 4151 break; 4152 4153 default: 4154 break; 4155 } 4156 return Result; 4157 } 4158 4159 static void phFriNfc_MifStd_H_Get1kStTrail(phFriNfc_NdefMap_t *NdefMap) 4160 { 4161 switch((NdefMap->StdMifareContainer.currentBlock % 4)) 4162 { 4163 case PH_FRINFC_MIFARESTD_VAL0: 4164 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4165 (NdefMap->StdMifareContainer.currentBlock + 4166 PH_FRINFC_MIFARESTD_MAD_BLK3); 4167 break; 4168 4169 case PH_FRINFC_MIFARESTD_VAL1: 4170 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4171 (NdefMap->StdMifareContainer.currentBlock + 4172 PH_FRINFC_MIFARESTD_MAD_BLK2); 4173 break; 4174 4175 case PH_FRINFC_MIFARESTD_VAL2: 4176 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4177 (NdefMap->StdMifareContainer.currentBlock + 4178 PH_FRINFC_MIFARESTD_MAD_BLK1); 4179 break; 4180 4181 default: 4182 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4183 NdefMap->StdMifareContainer.currentBlock; 4184 break; 4185 } 4186 } 4187 4188 static void phFriNfc_MifStd_H_Get4kStTrail(phFriNfc_NdefMap_t *NdefMap) 4189 { 4190 switch((NdefMap->StdMifareContainer.currentBlock % 16)) 4191 { 4192 case PH_FRINFC_MIFARESTD_MAD_BLK0: 4193 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4194 (NdefMap->StdMifareContainer.currentBlock + 4195 PH_FRINFC_MIFARESTD_BLK15); 4196 break; 4197 4198 case PH_FRINFC_MIFARESTD_MAD_BLK1: 4199 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4200 (NdefMap->StdMifareContainer.currentBlock + 4201 PH_FRINFC_MIFARESTD_BLK14); 4202 break; 4203 4204 case PH_FRINFC_MIFARESTD_MAD_BLK2: 4205 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4206 (NdefMap->StdMifareContainer.currentBlock + 4207 PH_FRINFC_MIFARESTD_BLK13); 4208 break; 4209 4210 case PH_FRINFC_MIFARESTD_MAD_BLK3: 4211 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4212 (NdefMap->StdMifareContainer.currentBlock + 4213 PH_FRINFC_MIFARESTD_BLK12); 4214 break; 4215 4216 case PH_FRINFC_MIFARESTD_BLK4: 4217 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4218 (NdefMap->StdMifareContainer.currentBlock + 4219 PH_FRINFC_MIFARESTD_BLK11); 4220 break; 4221 4222 case PH_FRINFC_MIFARESTD_BLK5: 4223 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4224 (NdefMap->StdMifareContainer.currentBlock + 4225 PH_FRINFC_MIFARESTD_BLK10); 4226 break; 4227 4228 case PH_FRINFC_MIFARESTD_BLK6: 4229 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4230 (NdefMap->StdMifareContainer.currentBlock + 4231 PH_FRINFC_MIFARESTD_BLK9); 4232 break; 4233 4234 case PH_FRINFC_MIFARESTD_BLK7: 4235 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4236 (NdefMap->StdMifareContainer.currentBlock + 4237 PH_FRINFC_MIFARESTD_BLK8); 4238 break; 4239 4240 case PH_FRINFC_MIFARESTD_BLK8: 4241 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4242 (NdefMap->StdMifareContainer.currentBlock + 4243 PH_FRINFC_MIFARESTD_BLK7); 4244 break; 4245 4246 case PH_FRINFC_MIFARESTD_BLK9: 4247 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4248 (NdefMap->StdMifareContainer.currentBlock + 4249 PH_FRINFC_MIFARESTD_BLK6); 4250 break; 4251 4252 case PH_FRINFC_MIFARESTD_BLK10: 4253 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4254 (NdefMap->StdMifareContainer.currentBlock + 4255 PH_FRINFC_MIFARESTD_BLK5); 4256 break; 4257 4258 case PH_FRINFC_MIFARESTD_BLK11: 4259 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4260 (NdefMap->StdMifareContainer.currentBlock + 4261 PH_FRINFC_MIFARESTD_BLK4); 4262 break; 4263 4264 case PH_FRINFC_MIFARESTD_BLK12: 4265 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4266 (NdefMap->StdMifareContainer.currentBlock + 4267 PH_FRINFC_MIFARESTD_MAD_BLK3); 4268 break; 4269 4270 case PH_FRINFC_MIFARESTD_BLK13: 4271 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4272 (NdefMap->StdMifareContainer.currentBlock + 4273 PH_FRINFC_MIFARESTD_MAD_BLK2); 4274 break; 4275 4276 case PH_FRINFC_MIFARESTD_BLK14: 4277 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4278 (NdefMap->StdMifareContainer.currentBlock + 4279 PH_FRINFC_MIFARESTD_MAD_BLK1); 4280 break; 4281 4282 default: 4283 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4284 NdefMap->StdMifareContainer.currentBlock; 4285 break; 4286 } 4287 } 4288 4289 static NFCSTATUS phFriNfc_MifStd_H_ProChkNdef(phFriNfc_NdefMap_t *NdefMap) 4290 { 4291 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4292 /* Copy remaining bytes into the AID array 4293 from Receive Buffer till array number 7 in aid */ 4294 if(NdefMap->StdMifareContainer.currentBlock == 4295 PH_FRINFC_MIFARESTD_VAL1) 4296 { 4297 /* Helper Function to Store AID Information */ 4298 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 4299 4300 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_VAL2; 4301 /* read remaining AIDs from block number 2 */ 4302 Result = ((NdefMap->StdMifareContainer.aidCompleteFlag == 4303 PH_FRINFC_MIFARESTD_FLAG1)? 4304 Result: 4305 phFriNfc_MifareStdMap_ChkNdef( NdefMap)); 4306 } 4307 else if(((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD) && 4308 (NdefMap->StdMifareContainer.currentBlock == 4309 PH_FRINFC_MIFARESTD_MAD_BLK2)) || ( 4310 (NdefMap->StdMifareContainer.currentBlock == 4311 PH_FRINFC_MIFARESTD_MAD_BLK66) && 4312 (NdefMap->CardType == 4313 PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD))) 4314 { 4315 /* Helper Function to Store AID Information */ 4316 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 4317 4318 NdefMap->StdMifareContainer.aidCompleteFlag = 4319 PH_FRINFC_MIFARESTD_FLAG1; 4320 }/* Mifare 1k and Mifare 4k end Check */ 4321 else if((NdefMap->StdMifareContainer.currentBlock > 4322 PH_FRINFC_MIFARESTD_VAL1) && 4323 (NdefMap->CardType == 4324 PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) 4325 { 4326 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 4327 /* read remaining AIDs from block number 2 */ 4328 /* Mifare 4k Helper Function */ 4329 Result = ((NdefMap->StdMifareContainer.aidCompleteFlag == 4330 PH_FRINFC_MIFARESTD_FLAG1)? 4331 Result: 4332 phFriNfc_MifStd4k_H_CheckNdef(NdefMap)); 4333 } /* Card Type 4k Check */ 4334 else 4335 { 4336 /* Since we have decided temporarily not to go 4337 for any new error codes we are using 4338 NFCSTATUS_INVALID_PARAMETER even though it is not 4339 the relevant error code here TBD */ 4340 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4341 NFCSTATUS_INVALID_PARAMETER); 4342 } 4343 4344 if(NdefMap->StdMifareContainer.aidCompleteFlag == 4345 PH_FRINFC_MIFARESTD_FLAG1) 4346 { 4347 NdefMap->StdMifareContainer.ChkNdefCompleteFlag = 4348 PH_FRINFC_MIFARESTD_FLAG1; 4349 /* The check for NDEF compliant information is now over for 4350 the Mifare 1K card. 4351 Update(decrement) the NoOfNdefCompBlocks as much required, 4352 depending on the NDEF compliant information found */ 4353 /* Check the Sectors are Ndef Compliant */ 4354 phFriNfc_MifStd_H_ChkNdefCmpltSects(NdefMap); 4355 if((NdefMap->StdMifareContainer.NoOfNdefCompBlocks == 0) || 4356 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks > 255)) 4357 { 4358 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4359 NFCSTATUS_NO_NDEF_SUPPORT); 4360 } 4361 else 4362 { 4363 NdefMap->StdMifareContainer.aidCompleteFlag = 4364 PH_FRINFC_MIFARESTD_FLAG0; 4365 NdefMap->StdMifareContainer.NFCforumSectFlag = 4366 PH_FRINFC_MIFARESTD_FLAG0; 4367 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_BLK4; 4368 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4369 Result = ((Result != NFCSTATUS_SUCCESS)? 4370 Result:phFriNfc_MifStd_H_AuthSector(NdefMap)); 4371 } 4372 4373 } 4374 return Result; 4375 } 4376 4377 static NFCSTATUS phFriNfc_MifStd_H_ProAuth(phFriNfc_NdefMap_t *NdefMap) 4378 { 4379 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4380 if(NdefMap->TLVStruct.NdefTLVAuthFlag == 4381 PH_FRINFC_MIFARESTD_FLAG1) 4382 { 4383 NdefMap->TLVStruct.NdefTLVAuthFlag = 4384 PH_FRINFC_MIFARESTD_FLAG0; 4385 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG1; 4386 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 4387 } 4388 else 4389 { 4390 NdefMap->StdMifareContainer.AuthDone = 1; 4391 NdefMap->StdMifareContainer.ReadAcsBitFlag = 1; 4392 Result = phFriNfc_MifStd_H_RdAcsBit(NdefMap); 4393 } 4394 return Result; 4395 } 4396 4397 static NFCSTATUS phFriNfc_MifStd_H_Rd16Bytes(phFriNfc_NdefMap_t *NdefMap, 4398 uint8_t BlockNo) 4399 { 4400 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4401 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = BlockNo; 4402 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 4403 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 4404 #ifndef PH_HAL4_ENABLE 4405 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareRead; 4406 #else 4407 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 4408 #endif 4409 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 4410 NdefMap->MapCompletionInfo.Context = NdefMap; 4411 /* Call the Overlapped HAL Transceive function */ 4412 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 4413 &NdefMap->MapCompletionInfo, 4414 NdefMap->psRemoteDevInfo, 4415 NdefMap->Cmd, 4416 &NdefMap->psDepAdditionalInfo, 4417 NdefMap->SendRecvBuf, 4418 NdefMap->SendLength, 4419 NdefMap->SendRecvBuf, 4420 NdefMap->SendRecvLength); 4421 return Result; 4422 } 4423 4424 static NFCSTATUS phFriNfc_MifStd_H_ProAcsBits(phFriNfc_NdefMap_t *NdefMap) 4425 { 4426 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4427 uint8_t CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 4428 if(*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) 4429 { 4430 if(NdefMap->StdMifareContainer.ReadAcsBitFlag == 4431 PH_FRINFC_MIFARESTD_FLAG1) 4432 { 4433 /* check for the correct access bits */ 4434 Result = phFriNfc_MifStd_H_ChkAcsBit(NdefMap); 4435 4436 if((NdefMap->StdMifareContainer.ChkNdefFlag == 4437 PH_FRINFC_MIFARESTD_FLAG1) && 4438 (Result == NFCSTATUS_SUCCESS)) 4439 { 4440 if(NdefMap->CardState == 4441 PH_NDEFMAP_CARD_STATE_INVALID) 4442 { 4443 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 4444 ((NdefMap->StdMifareContainer.currentBlock >= 4445 PH_FRINFC_MIFARESTD4K_BLK128)? 4446 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 4447 PH_FRINFC_MIFARESTD_BLK15): 4448 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 4449 PH_FRINFC_MIFARESTD_MAD_BLK3)); 4450 4451 NdefMap->StdMifareContainer.ProprforumSectFlag = 4452 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 4453 PH_FRINFC_MIFARESTD_FLAG1)? 4454 PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG: 4455 PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG); 4456 4457 Result = phFriNfc_MifStd_H_ProStatNotValid(NdefMap, Result); 4458 } 4459 else 4460 { 4461 NdefMap->StdMifareContainer.NFCforumSectFlag = 4462 (((NdefMap->StdMifareContainer.currentBlock == 64) && 4463 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD))? 4464 NdefMap->StdMifareContainer.NFCforumSectFlag: 4465 PH_FRINFC_MIFARESTD_FLAG1); 4466 } 4467 4468 if(NdefMap->StdMifareContainer.ProprforumSectFlag != 4469 PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG) 4470 { 4471 NdefMap->StdMifareContainer.ReadAcsBitFlag = PH_FRINFC_MIFARESTD_FLAG0; 4472 /* ((NdefMap->StdMifareContainer.ReadCompleteFlag == 4473 PH_FRINFC_MIFARESTD_FLAG1)? 4474 PH_FRINFC_MIFARESTD_FLAG0: 4475 PH_FRINFC_MIFARESTD_FLAG1);*/ 4476 4477 NdefMap->StdMifareContainer.ReadCompleteFlag = 4478 (uint8_t)((((((NdefMap->StdMifareContainer.currentBlock + 4479 PH_FRINFC_MIFARESTD_VAL4) >= 4480 PH_FRINFC_MIFARESTD1K_MAX_BLK) && 4481 (NdefMap->CardType == 4482 PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) && 4483 (NdefMap->StdMifareContainer.ReadCompleteFlag == 4484 PH_FRINFC_MIFARESTD_FLAG0)) || 4485 (NdefMap->StdMifareContainer.ReadCompleteFlag == 4486 PH_FRINFC_MIFARESTD_FLAG1))? 4487 PH_FRINFC_MIFARESTD_FLAG1: 4488 PH_FRINFC_MIFARESTD_FLAG0); 4489 4490 NdefMap->StdMifareContainer.ReadCompleteFlag = 4491 (uint8_t)((((((uint16_t)(NdefMap->StdMifareContainer.currentBlock + 4492 PH_FRINFC_MIFARESTD_VAL4) >= 4493 PH_FRINFC_MIFARESTD4K_MAX_BLK) && 4494 (NdefMap->CardType == 4495 PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) && 4496 (NdefMap->StdMifareContainer.ReadCompleteFlag == 4497 PH_FRINFC_MIFARESTD_FLAG0)) || 4498 (NdefMap->StdMifareContainer.ReadCompleteFlag == 4499 PH_FRINFC_MIFARESTD_FLAG1))? 4500 PH_FRINFC_MIFARESTD_FLAG1: 4501 PH_FRINFC_MIFARESTD_FLAG0); 4502 4503 NdefMap->StdMifareContainer.currentBlock = 4504 ((NdefMap->StdMifareContainer.ReadCompleteFlag == 4505 PH_FRINFC_MIFARESTD_FLAG1)? 4506 PH_FRINFC_MIFARESTD_BLK4: 4507 NdefMap->StdMifareContainer.currentBlock); 4508 4509 Result = 4510 ((NdefMap->StdMifareContainer.ReadCompleteFlag == 4511 PH_FRINFC_MIFARESTD_FLAG1)? 4512 phFriNfc_MifStd_H_BlkChk(NdefMap): 4513 Result); 4514 } 4515 } 4516 4517 Result = ((Result != NFCSTATUS_SUCCESS)? 4518 Result: 4519 phFriNfc_MifStd_H_ChkRdWr(NdefMap)); 4520 } 4521 else 4522 { 4523 NdefMap->StdMifareContainer.ChkNdefFlag = 4524 PH_FRINFC_MIFARESTD_FLAG0; 4525 /* Here its required to read the entire card to know the */ 4526 /* Get exact ndef size of the card */ 4527 Result = phFriNfc_MifStd_H_ChkTLVs(NdefMap, &CRFlag); 4528 } 4529 } 4530 else 4531 { 4532 /* Since we have decided temporarily not to go 4533 for any new error codes we are using 4534 NFCSTATUS_INVALID_PARAMETER even though it is not 4535 the relevant error code here TBD */ 4536 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4537 NFCSTATUS_INVALID_PARAMETER); 4538 } 4539 4540 return Result; 4541 } 4542 4543 static NFCSTATUS phFriNfc_MifStd_H_GPBChk(phFriNfc_NdefMap_t *NdefMap) 4544 { 4545 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4546 4547 /* Spec version needs to be checked every time */ 4548 Result = phFriNfc_MapTool_ChkSpcVer(NdefMap, PH_FRINFC_MIFARESTD_VAL9); 4549 4550 /* Check rhe read and write access field 4551 in GPB is 00b 4552 bit 0 and 1 for write access check 4553 bit 2 and 3 for read access check */ 4554 if(Result == NFCSTATUS_SUCCESS) 4555 { 4556 if(((NdefMap->SendRecvBuf[ 4557 PH_FRINFC_MIFARESTD_VAL9] & 4558 PH_FRINFC_MIFARESTD_MASK_GPB_WR) == 4559 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL) && 4560 ((NdefMap->SendRecvBuf[ 4561 PH_FRINFC_MIFARESTD_VAL9] & 4562 PH_FRINFC_MIFARESTD_MASK_GPB_RD) == 4563 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL)) 4564 { 4565 NdefMap->CardState = (((NdefMap->StdMifareContainer.ChkNdefFlag == 4566 PH_FRINFC_MIFARESTD_FLAG1) || 4567 (NdefMap->StdMifareContainer.ReadNdefFlag == 4568 PH_FRINFC_MIFARESTD_FLAG1) || 4569 (NdefMap->StdMifareContainer.WrNdefFlag == 4570 PH_FRINFC_MIFARESTD_FLAG1))? 4571 PH_NDEFMAP_CARD_STATE_INITIALIZED: 4572 PH_NDEFMAP_CARD_STATE_READ_WRITE); 4573 } 4574 else if(((NdefMap->SendRecvBuf[ 4575 PH_FRINFC_MIFARESTD_VAL9] & 4576 PH_FRINFC_MIFARESTD_MASK_GPB_WR) != 4577 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL) && 4578 ((NdefMap->SendRecvBuf[ 4579 PH_FRINFC_MIFARESTD_VAL9] & 4580 PH_FRINFC_MIFARESTD_MASK_GPB_RD) == 4581 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL)) 4582 { 4583 /* write access not given 4584 only read access check */ 4585 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY; 4586 } 4587 else 4588 { 4589 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 4590 } 4591 } 4592 return Result; 4593 } 4594 4595 static NFCSTATUS phFriNfc_MifStd_H_ProStatNotValid(phFriNfc_NdefMap_t *NdefMap, 4596 NFCSTATUS status) 4597 { 4598 NFCSTATUS Result = status; 4599 /* if NFC forum sector is not found before the proprietary one then 4600 authenticate the next sector 4601 Else it is a error*/ 4602 if(NdefMap->StdMifareContainer.NFCforumSectFlag == 4603 PH_FRINFC_MIFARESTD_FLAG0) 4604 { 4605 NdefMap->StdMifareContainer.ProprforumSectFlag = 4606 PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG; 4607 if(NdefMap->StdMifareContainer.currentBlock < 4608 PH_FRINFC_MIFARESTD4K_BLK128) 4609 { 4610 #ifdef PH_HAL4_ENABLE 4611 /* Fix for the disovery problem, 4612 if 1st sector is invalid then ignore the remaining sectors and 4613 send an error if the card is mifare 1k, 4614 if the card is mifare 4k, then update the block number to 67 and 4615 continue. 4616 Even if the authentication of that block fails then send error */ 4617 if(((NdefMap->StdMifareContainer.currentBlock < 4618 PH_FRINFC_MIFARESTD_BLK4) && 4619 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) || 4620 ((NdefMap->StdMifareContainer.currentBlock <= 4621 PH_FRINFC_MIFARESTD_MAD_BLK67) && 4622 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD))) 4623 { 4624 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4625 NFCSTATUS_NO_NDEF_SUPPORT); 4626 } 4627 else if((NdefMap->StdMifareContainer.currentBlock < 4628 PH_FRINFC_MIFARESTD_BLK4) && 4629 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) 4630 { 4631 Result = NFCSTATUS_SUCCESS; 4632 NdefMap->StdMifareContainer.currentBlock = 4633 PH_FRINFC_MIFARESTD_MAD_BLK67; 4634 } 4635 else 4636 #endif /* #ifdef PH_HAL4_ENABLE */ 4637 if(((NdefMap->StdMifareContainer.currentBlock + 4638 PH_FRINFC_MIFARESTD_BLK4) > 4639 PH_FRINFC_MIFARESTD1K_MAX_BLK) && 4640 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) 4641 { 4642 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4643 NFCSTATUS_NO_NDEF_SUPPORT); 4644 } 4645 else 4646 { 4647 NdefMap->StdMifareContainer.remainingSize -= 4648 (PH_FRINFC_MIFARESTD_MAD_BLK3 * PH_FRINFC_MIFARESTD_BLOCK_BYTES); 4649 NdefMap->StdMifareContainer.currentBlock += 4650 PH_FRINFC_MIFARESTD_BLK4; 4651 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4652 } 4653 } 4654 else if((NdefMap->StdMifareContainer.currentBlock + 4655 PH_FRINFC_MIFARESTD_BLK15) > 4656 PH_FRINFC_MIFARESTD4K_MAX_BLK) 4657 { 4658 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4659 NFCSTATUS_NO_NDEF_SUPPORT); 4660 } 4661 else 4662 { 4663 NdefMap->StdMifareContainer.remainingSize -= 4664 (PH_FRINFC_MIFARESTD_BLK15 * PH_FRINFC_MIFARESTD_BLOCK_BYTES); 4665 NdefMap->StdMifareContainer.currentBlock += 4666 PH_FRINFC_MIFARESTD_BLOCK_BYTES; 4667 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4668 } 4669 Result = ((Result != NFCSTATUS_SUCCESS)? 4670 (PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4671 NFCSTATUS_NO_NDEF_SUPPORT)): 4672 phFriNfc_MifStd_H_AuthSector(NdefMap)); 4673 } 4674 else if((NdefMap->StdMifareContainer.ProprforumSectFlag == 4675 PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG) && 4676 (NdefMap->StdMifareContainer.NFCforumSectFlag == 4677 PH_FRINFC_MIFARESTD_FLAG1)) 4678 { 4679 /* if the proprietary forum sector are found before 4680 NFC forum sector then again a proprietary 4681 forum sector are found after the NFC forum 4682 sector */ 4683 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4684 NFCSTATUS_NO_NDEF_SUPPORT); 4685 } 4686 else 4687 { 4688 NdefMap->StdMifareContainer.ProprforumSectFlag = 4689 PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG; 4690 switch(NdefMap->PrevOperation) 4691 { 4692 case PH_FRINFC_NDEFMAP_CHECK_OPE: 4693 case PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE: 4694 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4695 NFCSTATUS_NO_NDEF_SUPPORT); 4696 break; 4697 4698 case PH_FRINFC_NDEFMAP_READ_OPE: 4699 if((NdefMap->TLVStruct.NdefTLVFoundFlag == 4700 PH_FRINFC_MIFARESTD_FLAG1) && 4701 (NdefMap->TLVStruct.NoLbytesinTLV == 4702 PH_FRINFC_MIFARESTD_VAL0)) 4703 { 4704 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 4705 Result = NFCSTATUS_SUCCESS; 4706 } 4707 else 4708 { 4709 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4710 NFCSTATUS_NO_NDEF_SUPPORT); 4711 } 4712 break; 4713 4714 case PH_FRINFC_NDEFMAP_WRITE_OPE: 4715 default: 4716 /* This means the further write is not possible, 4717 EOF_NDEF_CONTAINER_REACHED */ 4718 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 4719 PH_FRINFC_MIFARESTD_FLAG1; 4720 /* Write the length to the L field in the TLV */ 4721 NdefMap->StdMifareContainer.TempBlockNo = 4722 NdefMap->StdMifareContainer.currentBlock; 4723 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 4724 NdefMap->StdMifareContainer.currentBlock = 4725 NdefMap->TLVStruct.NdefTLVBlock; 4726 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 4727 break; 4728 } 4729 } 4730 return Result; 4731 } 4732 4733 static NFCSTATUS phFriNfc_MifStd_H_RdBeforeWr(phFriNfc_NdefMap_t *NdefMap) 4734 { 4735 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4736 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_BEF_WR; 4737 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 4738 4739 Result = phFriNfc_MifStd_H_Rd16Bytes(NdefMap, 4740 NdefMap->StdMifareContainer.currentBlock); 4741 return Result; 4742 } 4743 4744 static NFCSTATUS phFriNfc_MifStd_H_ProBytesToWr(phFriNfc_NdefMap_t *NdefMap) 4745 { 4746 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4747 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0; 4748 4749 if(*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) 4750 { 4751 (void)memcpy(&NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1], 4752 NdefMap->SendRecvBuf, 4753 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 4754 4755 /* Write to Ndef TLV Block */ 4756 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4757 NdefMap->StdMifareContainer.currentBlock; 4758 4759 TempLength = ((NdefMap->StdMifareContainer.currentBlock == 4760 NdefMap->TLVStruct.NdefTLVBlock)? 4761 phFriNfc_MifStd_H_UpdateTLV(NdefMap): 4762 phFriNfc_MifStd_H_UpdRemTLV(NdefMap)); 4763 4764 NdefMap->StdMifareContainer.remainingSize -= 4765 ((NdefMap->StdMifareContainer.remSizeUpdFlag == 4766 PH_FRINFC_MIFARESTD_FLAG1)? 4767 PH_FRINFC_MIFARESTD_VAL2: 4768 PH_FRINFC_MIFARESTD_VAL0); 4769 4770 NdefMap->StdMifareContainer.remSizeUpdFlag = PH_FRINFC_MIFARESTD_FLAG0; 4771 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_TLV; 4772 Result = ((TempLength == PH_FRINFC_MIFARESTD_BLOCK_BYTES)? 4773 phFriNfc_MifStd_H_WrTLV(NdefMap): 4774 phFriNfc_MifStd_H_fillSendBuf(NdefMap, TempLength)); 4775 } 4776 else 4777 { 4778 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 4779 NFCSTATUS_READ_FAILED); 4780 } 4781 4782 return Result; 4783 } 4784 4785 static uint8_t phFriNfc_MifStd_H_UpdateTLV(phFriNfc_NdefMap_t *NdefMap) 4786 { 4787 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0; 4788 TempLength = (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL1); 4789 /* Creating TLV */ 4790 if(NdefMap->TLVStruct.NULLTLVCount >= 2) 4791 { 4792 if((PH_FRINFC_MIFARESTD_BYTES_READ - TempLength) == 4793 PH_FRINFC_MIFARESTD_VAL0) 4794 { 4795 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4796 } 4797 else 4798 { 4799 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4800 TempLength++; 4801 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 4802 } 4803 } 4804 else 4805 { 4806 switch((PH_FRINFC_MIFARESTD_BYTES_READ - 4807 TempLength)) 4808 { 4809 case PH_FRINFC_MIFARESTD_VAL0: 4810 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4811 break; 4812 4813 case PH_FRINFC_MIFARESTD_VAL1: 4814 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4815 TempLength++; 4816 NdefMap->TLVStruct.prevLenByteValue = 4817 (uint16_t)((NdefMap->SendRecvBuf[TempLength] >= 4818 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 4819 PH_FRINFC_MIFARESTD_VAL0: 4820 NdefMap->SendRecvBuf[TempLength]); 4821 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4822 break; 4823 4824 case PH_FRINFC_MIFARESTD_VAL2: 4825 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4826 TempLength++; 4827 NdefMap->TLVStruct.prevLenByteValue = 4828 (uint16_t)((NdefMap->SendRecvBuf[TempLength] >= 4829 PH_FRINFC_MIFARESTD_NDEFTLV_L)? 4830 NdefMap->SendRecvBuf[(TempLength + 4831 PH_FRINFC_MIFARESTD_VAL1)]: 4832 NdefMap->SendRecvBuf[TempLength]); 4833 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4834 TempLength++; 4835 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4836 break; 4837 4838 default: 4839 NdefMap->TLVStruct.prevLenByteValue = 4840 NdefMap->SendRecvBuf[TempLength]; 4841 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4842 TempLength++; 4843 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4844 TempLength++; 4845 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4846 TempLength++; 4847 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 4848 break; 4849 } 4850 } 4851 4852 return TempLength; 4853 } 4854 4855 static NFCSTATUS phFriNfc_MifStd_H_fillSendBuf(phFriNfc_NdefMap_t *NdefMap, 4856 uint8_t Length) 4857 { 4858 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4859 uint16_t RemainingBytes = PH_FRINFC_MIFARESTD_VAL0, 4860 BytesToWrite = PH_FRINFC_MIFARESTD_VAL0; 4861 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 4862 4863 Length = (Length + PH_FRINFC_MIFARESTD_VAL1); 4864 4865 RemainingBytes = (uint16_t)((NdefMap->StdMifareContainer.remainingSize 4866 < (uint16_t)(NdefMap->ApduBufferSize - 4867 NdefMap->ApduBuffIndex))? 4868 NdefMap->StdMifareContainer.remainingSize: 4869 (NdefMap->ApduBufferSize - 4870 NdefMap->ApduBuffIndex)); 4871 4872 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4873 NdefMap->StdMifareContainer.currentBlock; 4874 /* Get the number of bytes that can be written after copying 4875 the internal buffer */ 4876 BytesToWrite = ((RemainingBytes < 4877 ((PH_FRINFC_MIFARESTD_WR_A_BLK - Length) - 4878 NdefMap->StdMifareContainer.internalLength))? 4879 RemainingBytes: 4880 ((PH_FRINFC_MIFARESTD_WR_A_BLK - Length) - 4881 NdefMap->StdMifareContainer.internalLength)); 4882 4883 if(NdefMap->StdMifareContainer.internalLength > 4884 PH_FRINFC_MIFARESTD_VAL0) 4885 { 4886 /* copy the internal buffer to the send buffer */ 4887 (void)memcpy(&(NdefMap->SendRecvBuf[ 4888 Length]), 4889 NdefMap->StdMifareContainer.internalBuf, 4890 NdefMap->StdMifareContainer.internalLength); 4891 } 4892 4893 /* Copy Bytes to write in the send buffer */ 4894 (void)memcpy(&(NdefMap->SendRecvBuf[ 4895 (Length + 4896 NdefMap->StdMifareContainer.internalLength)]), 4897 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 4898 BytesToWrite); 4899 4900 /* update number of bytes written from the user buffer */ 4901 NdefMap->NumOfBytesWritten = BytesToWrite; 4902 4903 /* check the exact number of bytes written to a block including the 4904 internal length */ 4905 *NdefMap->DataCount = 4906 ((BytesToWrite + NdefMap->StdMifareContainer.internalLength 4907 + Length) - PH_FRINFC_MIFARESTD_VAL1); 4908 4909 /* if total bytes to write in the card is less than 4 bytes then 4910 pad zeroes till 4 bytes */ 4911 if((BytesToWrite + NdefMap->StdMifareContainer.internalLength + 4912 Length) < PH_FRINFC_MIFARESTD_WR_A_BLK) 4913 { 4914 for(index = (uint8_t)(BytesToWrite + 4915 NdefMap->StdMifareContainer.internalLength + 4916 Length); 4917 index < PH_FRINFC_MIFARESTD_WR_A_BLK; 4918 index++) 4919 { 4920 NdefMap->SendRecvBuf[index] = (uint8_t)((index == 4921 (BytesToWrite + Length + 4922 NdefMap->StdMifareContainer.internalLength))? 4923 PH_FRINFC_MIFARESTD_TERMTLV_T: 4924 PH_FRINFC_MIFARESTD_NULLTLV_T); 4925 4926 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 4927 } 4928 } 4929 #ifdef PH_HAL4_ENABLE 4930 4931 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 4932 4933 #endif /* #ifdef PH_HAL4_ENABLE */ 4934 4935 /* A temporary buffer to hold four bytes of data that is 4936 written to the card */ 4937 (void)memcpy(NdefMap->StdMifareContainer.Buffer, 4938 &(NdefMap->SendRecvBuf[ 4939 PH_FRINFC_MIFARESTD_VAL1]), 4940 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 4941 4942 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_TLV; 4943 Result = phFriNfc_MifStd_H_WrTLV(NdefMap); 4944 return Result; 4945 } 4946 4947 static NFCSTATUS phFriNfc_MifStd_H_WrTLV(phFriNfc_NdefMap_t *NdefMap) 4948 { 4949 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4950 4951 /* set the data for additional data exchange*/ 4952 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 4953 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 4954 NdefMap->psDepAdditionalInfo.NAD = 0; 4955 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 4956 NdefMap->MapCompletionInfo.Context = NdefMap; 4957 /* Write from here */ 4958 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 4959 4960 #ifndef PH_HAL4_ENABLE 4961 NdefMap->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite16; 4962 #else 4963 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 4964 #endif 4965 4966 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 4967 /* Call the Overlapped HAL Transceive function */ 4968 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, 4969 &NdefMap->MapCompletionInfo, 4970 NdefMap->psRemoteDevInfo, 4971 NdefMap->Cmd, 4972 &NdefMap->psDepAdditionalInfo, 4973 NdefMap->SendRecvBuf, 4974 NdefMap->SendLength, 4975 NdefMap->SendRecvBuf, 4976 NdefMap->SendRecvLength); 4977 4978 4979 return Result; 4980 } 4981 4982 static NFCSTATUS phFriNfc_MifStd_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap) 4983 { 4984 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4985 /* Check that if complete TLV has been written in the 4986 card if yes enter the below check or go to else*/ 4987 if(((((PH_FRINFC_MIFARESTD_BLOCK_BYTES - 4988 NdefMap->TLVStruct.NdefTLVByte) == 4989 PH_FRINFC_MIFARESTD_VAL1) && 4990 (NdefMap->TLVStruct.NULLTLVCount >= 4991 PH_FRINFC_MIFARESTD_VAL2)) || 4992 (((PH_FRINFC_MIFARESTD_BLOCK_BYTES - 4993 NdefMap->TLVStruct.NdefTLVByte) <= 4994 PH_FRINFC_MIFARESTD_VAL3) && 4995 (NdefMap->TLVStruct.NULLTLVCount == 4996 PH_FRINFC_MIFARESTD_VAL0))) && 4997 (NdefMap->StdMifareContainer.currentBlock == 4998 NdefMap->TLVStruct.NdefTLVBlock)) 4999 { 5000 /* increment the block and chekc the block is in the same sector 5001 using the block check function */ 5002 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 5003 NdefMap->StdMifareContainer.currentBlock++; 5004 NdefMap->StdMifareContainer.NdefBlocks++; 5005 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5006 if(Result == NFCSTATUS_SUCCESS) 5007 { 5008 Result = ((NdefMap->StdMifareContainer.AuthDone == 5009 PH_FRINFC_MIFARESTD_FLAG0)? 5010 phFriNfc_MifStd_H_AuthSector(NdefMap): 5011 phFriNfc_MifStd_H_RdBeforeWr(NdefMap)); 5012 } 5013 } 5014 else 5015 { 5016 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 5017 if(NdefMap->ApduBuffIndex < 5018 (uint16_t)NdefMap->ApduBufferSize) 5019 { 5020 if(*NdefMap->DataCount < PH_FRINFC_MIFARESTD_BLOCK_BYTES) 5021 { 5022 /* Write complete, so next byte shall be */ 5023 NdefMap->StdMifareContainer.internalLength = 5024 *NdefMap->DataCount; 5025 5026 /* Copy bytes less than 16 to internal buffer 5027 for the next write this can be used */ 5028 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 5029 NdefMap->StdMifareContainer.Buffer, 5030 NdefMap->StdMifareContainer.internalLength); 5031 } 5032 5033 /* Increment the Send Buffer index */ 5034 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 5035 5036 NdefMap->StdMifareContainer.remainingSize -= 5037 NdefMap->NumOfBytesWritten; 5038 5039 /* Check for the End of Card */ 5040 if((NdefMap->StdMifareContainer.remainingSize == 5041 PH_FRINFC_MIFARESTD_VAL0) || 5042 (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize)) 5043 { 5044 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 5045 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 0)? 5046 PH_FRINFC_MIFARESTD_FLAG1:PH_FRINFC_MIFARESTD_FLAG0); 5047 5048 if(NdefMap->StdMifareContainer.internalLength == 5049 PH_FRINFC_MIFARESTD_VAL0) 5050 { 5051 NdefMap->StdMifareContainer.currentBlock++; 5052 /* Mifare 4k Card, After 128th Block 5053 each sector = 16 blocks in Mifare 4k */ 5054 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5055 NdefMap->StdMifareContainer.NdefBlocks++; 5056 } 5057 5058 NdefMap->TLVStruct.SetTermTLVFlag = 5059 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 5060 PH_FRINFC_MIFARESTD_VAL0) || 5061 (NdefMap->TLVStruct.SetTermTLVFlag == 5062 PH_FRINFC_MIFARESTD_FLAG1))? 5063 PH_FRINFC_MIFARESTD_FLAG1: 5064 PH_FRINFC_MIFARESTD_FLAG0); 5065 5066 } 5067 else 5068 { 5069 NdefMap->StdMifareContainer.currentBlock++; 5070 /* Mifare 4k Card, After 128th Block 5071 each sector = 16 blocks in Mifare 4k */ 5072 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5073 if(Result == NFCSTATUS_SUCCESS) 5074 { 5075 NdefMap->StdMifareContainer.NdefBlocks++; 5076 Result = ((NdefMap->StdMifareContainer.AuthDone == 5077 PH_FRINFC_MIFARESTD_FLAG1)? 5078 phFriNfc_MifStd_H_WrABlock(NdefMap): 5079 phFriNfc_MifStd_H_AuthSector(NdefMap)); 5080 } 5081 } 5082 } 5083 } 5084 5085 if((Result == NFCSTATUS_SUCCESS) && 5086 (NdefMap->TLVStruct.SetTermTLVFlag != 5087 PH_FRINFC_MIFARESTD_FLAG1) && 5088 (NdefMap->StdMifareContainer.remainingSize > 5089 PH_FRINFC_MIFARESTD_VAL0)) 5090 { 5091 Result = phFriNfc_MifStd_H_WrTermTLV(NdefMap); 5092 } 5093 else 5094 { 5095 if((Result == NFCSTATUS_SUCCESS) && 5096 (NdefMap->TLVStruct.SetTermTLVFlag == 5097 PH_FRINFC_MIFARESTD_FLAG1)) 5098 { 5099 /* Write the length to the L field in the TLV */ 5100 NdefMap->StdMifareContainer.TempBlockNo = 5101 NdefMap->StdMifareContainer.currentBlock; 5102 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 5103 NdefMap->StdMifareContainer.currentBlock = 5104 NdefMap->TLVStruct.NdefTLVBlock; 5105 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 5106 } 5107 } 5108 return Result; 5109 } 5110 5111 static uint8_t phFriNfc_MifStd_H_UpdRemTLV(phFriNfc_NdefMap_t *NdefMap) 5112 { 5113 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL1; 5114 if(NdefMap->TLVStruct.NULLTLVCount >= 5115 PH_FRINFC_MIFARESTD_VAL2) 5116 { 5117 NdefMap->TLVStruct.prevLenByteValue = NdefMap->SendRecvBuf[TempLength]; 5118 NdefMap->SendRecvBuf[TempLength] = 5119 PH_FRINFC_MIFARESTD_NDEFTLV_L0; 5120 } 5121 else 5122 { 5123 switch((PH_FRINFC_MIFARESTD_BLOCK_BYTES - 5124 NdefMap->TLVStruct.NdefTLVByte)) 5125 { 5126 case PH_FRINFC_MIFARESTD_VAL1: 5127 NdefMap->TLVStruct.prevLenByteValue = 5128 (((NdefMap->SendRecvBuf[TempLength] == 5129 PH_FRINFC_MIFARESTD_NDEFTLV_L))? 5130 (((uint16_t)NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] 5131 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + 5132 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL2)]): 5133 NdefMap->SendRecvBuf[TempLength]); 5134 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5135 TempLength++; 5136 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5137 TempLength++; 5138 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 5139 break; 5140 5141 case PH_FRINFC_MIFARESTD_VAL2: 5142 NdefMap->TLVStruct.prevLenByteValue = 5143 (((NdefMap->SendRecvBuf[TempLength] == 5144 PH_FRINFC_MIFARESTD_NDEFTLV_L))? 5145 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 5146 PH_FRINFC_MIFARESTD_LEFTSHIFT8) + 5147 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]): 5148 NdefMap->SendRecvBuf[TempLength]); 5149 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5150 TempLength++; 5151 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 5152 break; 5153 5154 case PH_FRINFC_MIFARESTD_VAL3: 5155 default: 5156 NdefMap->TLVStruct.prevLenByteValue = 5157 ((NdefMap->TLVStruct.prevLenByteValue << 5158 PH_FRINFC_MIFARESTD_LEFTSHIFT8) 5159 + NdefMap->SendRecvBuf[TempLength]); 5160 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 5161 break; 5162 } 5163 } 5164 return TempLength; 5165 } 5166 5167 static void phFriNfc_MifStd_H_fillTLV1(phFriNfc_NdefMap_t *NdefMap) 5168 { 5169 uint8_t TempLength = (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + 5170 PH_FRINFC_MIFARESTD_VAL1); 5171 5172 NdefMap->TLVStruct.prevLenByteValue = 5173 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR)? 5174 (NdefMap->TLVStruct.prevLenByteValue + 5175 NdefMap->ApduBuffIndex): 5176 NdefMap->ApduBuffIndex); 5177 5178 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 5179 switch(NdefMap->TLVStruct.NdefTLVByte) 5180 { 5181 case PH_FRINFC_MIFARESTD_VAL0: 5182 if(NdefMap->TLVStruct.prevLenByteValue >= 5183 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5184 { 5185 NdefMap->SendRecvBuf[TempLength] = 5186 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5187 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5188 NdefMap->SendRecvBuf[(TempLength + 5189 PH_FRINFC_MIFARESTD_VAL1)] = 5190 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5191 } 5192 else 5193 { 5194 NdefMap->SendRecvBuf[TempLength] = 5195 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5196 NdefMap->SendRecvBuf[(TempLength + 5197 PH_FRINFC_MIFARESTD_VAL1)] = 5198 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5199 5200 NdefMap->StdMifareContainer.RdAfterWrFlag = 5201 PH_FRINFC_MIFARESTD_FLAG0; 5202 } 5203 break; 5204 5205 case PH_FRINFC_MIFARESTD_VAL1: 5206 if(NdefMap->TLVStruct.prevLenByteValue >= 5207 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5208 { 5209 NdefMap->SendRecvBuf[TempLength - PH_FRINFC_MIFARESTD_VAL1] = 5210 PH_FRINFC_MIFARESTD_NDEFTLV_L; 5211 NdefMap->SendRecvBuf[TempLength] = 5212 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5213 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5214 NdefMap->SendRecvBuf[(TempLength + 5215 PH_FRINFC_MIFARESTD_VAL1)] = 5216 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5217 } 5218 else 5219 { 5220 NdefMap->SendRecvBuf[TempLength] = 5221 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5222 NdefMap->SendRecvBuf[(TempLength + 5223 PH_FRINFC_MIFARESTD_VAL1)] = 5224 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5225 NdefMap->StdMifareContainer.RdAfterWrFlag = 5226 PH_FRINFC_MIFARESTD_FLAG0; 5227 } 5228 break; 5229 5230 case PH_FRINFC_MIFARESTD_VAL15: 5231 /* if "Type" of TLV present at byte 15 */ 5232 if(NdefMap->TLVStruct.prevLenByteValue >= 5233 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5234 { 5235 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 5236 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 5237 NdefMap->TLVStruct.NdefTLVBlock = 5238 NdefMap->StdMifareContainer.currentBlock; 5239 NdefMap->TLVStruct.NdefTLVByte = 5240 (TempLength - PH_FRINFC_MIFARESTD_VAL3); 5241 5242 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL2)] = 5243 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5244 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)] = 5245 PH_FRINFC_MIFARESTD_NDEFTLV_L; 5246 NdefMap->SendRecvBuf[TempLength] = 5247 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5248 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5249 } 5250 else 5251 { 5252 NdefMap->SendRecvBuf[TempLength] = 5253 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5254 } 5255 break; 5256 5257 default: 5258 /* Already the TLV is present so just append the length field */ 5259 if(NdefMap->TLVStruct.prevLenByteValue >= 5260 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5261 { 5262 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 5263 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 5264 NdefMap->TLVStruct.NdefTLVBlock = 5265 NdefMap->StdMifareContainer.currentBlock; 5266 NdefMap->TLVStruct.NdefTLVByte = 5267 (TempLength - PH_FRINFC_MIFARESTD_VAL3); 5268 5269 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL2)] = 5270 (uint8_t)PH_FRINFC_MIFARESTD_NDEFTLV_T; 5271 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)] = 5272 (uint8_t)PH_FRINFC_MIFARESTD_NDEFTLV_L; 5273 NdefMap->SendRecvBuf[TempLength] = 5274 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5275 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5276 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 5277 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5278 } 5279 else 5280 { 5281 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5282 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 5283 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5284 } 5285 NdefMap->StdMifareContainer.RdAfterWrFlag = 5286 PH_FRINFC_MIFARESTD_FLAG0; 5287 break; 5288 } 5289 } 5290 5291 static void phFriNfc_MifStd_H_fillTLV2(phFriNfc_NdefMap_t *NdefMap) 5292 { 5293 uint8_t TempLength = (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + 5294 PH_FRINFC_MIFARESTD_VAL1); 5295 5296 NdefMap->TLVStruct.prevLenByteValue = ((NdefMap->Offset == 5297 PH_FRINFC_NDEFMAP_SEEK_CUR)? 5298 (NdefMap->TLVStruct.prevLenByteValue + 5299 NdefMap->ApduBuffIndex): 5300 NdefMap->ApduBuffIndex); 5301 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 5302 switch(NdefMap->TLVStruct.NdefTLVByte) 5303 { 5304 case PH_FRINFC_MIFARESTD_VAL13: 5305 if(NdefMap->TLVStruct.prevLenByteValue >= 5306 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5307 { 5308 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5309 TempLength++; 5310 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 5311 TempLength++; 5312 NdefMap->SendRecvBuf[TempLength] = (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5313 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5314 } 5315 else 5316 { 5317 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5318 TempLength++; 5319 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5320 TempLength++; 5321 5322 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 5323 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 5324 NdefMap->TLVStruct.NdefTLVBlock = 5325 NdefMap->StdMifareContainer.currentBlock; 5326 NdefMap->TLVStruct.NdefTLVByte = 5327 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 5328 5329 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5330 } 5331 break; 5332 5333 case PH_FRINFC_MIFARESTD_VAL14: 5334 if(NdefMap->TLVStruct.prevLenByteValue >= 5335 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5336 { 5337 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5338 TempLength++; 5339 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 5340 } 5341 else 5342 { 5343 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5344 TempLength++; 5345 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5346 } 5347 break; 5348 5349 case PH_FRINFC_MIFARESTD_VAL15: 5350 if(NdefMap->TLVStruct.prevLenByteValue >= 5351 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5352 { 5353 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5354 } 5355 else 5356 { 5357 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5358 } 5359 break; 5360 5361 default: 5362 if(NdefMap->TLVStruct.prevLenByteValue >= 5363 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5364 { 5365 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5366 TempLength++; 5367 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 5368 TempLength++; 5369 NdefMap->SendRecvBuf[TempLength] = (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5370 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5371 TempLength++; 5372 NdefMap->SendRecvBuf[TempLength] = 5373 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5374 } 5375 else 5376 { 5377 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5378 TempLength++; 5379 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5380 TempLength++; 5381 5382 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 5383 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 5384 NdefMap->TLVStruct.NdefTLVBlock = 5385 NdefMap->StdMifareContainer.currentBlock; 5386 NdefMap->TLVStruct.NdefTLVByte = 5387 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 5388 5389 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5390 TempLength++; 5391 NdefMap->SendRecvBuf[TempLength] = 5392 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5393 } 5394 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 5395 break; 5396 } 5397 } 5398 5399 static NFCSTATUS phFriNfc_MifStd_H_CallWrNdefLen(phFriNfc_NdefMap_t *NdefMap) 5400 { 5401 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5402 if(NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) 5403 { 5404 if((NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL0) || 5405 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL1) ) 5406 { 5407 /* In this case, current block is decremented because the 5408 NULL TLVs are in the previous block */ 5409 NdefMap->StdMifareContainer.currentBlock--; 5410 Result = phFriNfc_MifStd_H_BlkChk_1(NdefMap); 5411 } 5412 else 5413 { 5414 /* case NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL15: 5415 Current block is incremented to update the remaining TLV 5416 structure */ 5417 NdefMap->StdMifareContainer.currentBlock++; 5418 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5419 } 5420 } 5421 else 5422 { 5423 if((NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL13) || 5424 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL14) || 5425 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL15)) 5426 { 5427 /* Current block is incremented to update the remaining TLV 5428 structure */ 5429 NdefMap->StdMifareContainer.currentBlock++; 5430 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5431 } 5432 } 5433 5434 Result = ((Result == NFCSTATUS_SUCCESS)? 5435 phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap): 5436 Result); 5437 return Result; 5438 } 5439 5440 static NFCSTATUS phFriNfc_MifStd_H_BlkChk_1(phFriNfc_NdefMap_t *NdefMap) 5441 { 5442 /* This function is to check the current block is in the authenticated sector and 5443 also check the block does not match with the sector trailer block. If there is a 5444 match then decrement the block and say the caller that the authentication 5445 is required */ 5446 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5447 uint8_t SectorID = PH_FRINFC_MIFARESTD_VAL0; 5448 5449 /* Get a Sector ID for the Current Block */ 5450 SectorID = phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 5451 5452 /* Check the sector id is valid or not and if valid then check the 5453 current block is greater than 128 */ 5454 if((NdefMap->StdMifareContainer.aid[SectorID] == 5455 PH_FRINFC_MIFARESTD_NDEF_COMP) && 5456 (((SectorID <= PH_FRINFC_MIFARESTD_VAL15) && 5457 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) || 5458 ((SectorID <= PH_FRINFC_MIFARESTD_SECTOR_NO39) && 5459 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)))) 5460 { 5461 if(NdefMap->StdMifareContainer.currentBlock > 128) 5462 { 5463 NdefMap->TLVStruct.NdefTLVAuthFlag = 5464 ((((NdefMap->StdMifareContainer.currentBlock + 5465 PH_FRINFC_MIFARESTD_VAL1) % 5466 PH_FRINFC_MIFARESTD_MAD_BLK16) == 5467 PH_FRINFC_MIFARESTD_VAL0)? 5468 PH_FRINFC_MIFARESTD_FLAG1: 5469 PH_FRINFC_MIFARESTD_FLAG0); 5470 5471 NdefMap->StdMifareContainer.currentBlock -= 5472 ((((NdefMap->StdMifareContainer.currentBlock + 5473 PH_FRINFC_MIFARESTD_VAL1) % 5474 PH_FRINFC_MIFARESTD_MAD_BLK16) == 5475 PH_FRINFC_MIFARESTD_VAL0)? 5476 PH_FRINFC_MIFARESTD_VAL1: 5477 PH_FRINFC_MIFARESTD_VAL0); 5478 5479 } 5480 else 5481 { 5482 NdefMap->TLVStruct.NdefTLVAuthFlag = 5483 ((((NdefMap->StdMifareContainer.currentBlock + 5484 PH_FRINFC_MIFARESTD_VAL1) % 5485 PH_FRINFC_MIFARESTD_BLK4) == 5486 PH_FRINFC_MIFARESTD_VAL0)? 5487 PH_FRINFC_MIFARESTD_FLAG1: 5488 PH_FRINFC_MIFARESTD_FLAG0); 5489 5490 NdefMap->StdMifareContainer.currentBlock -= 5491 ((((NdefMap->StdMifareContainer.currentBlock + 5492 PH_FRINFC_MIFARESTD_VAL1) % 5493 PH_FRINFC_MIFARESTD_BLK4) == 5494 PH_FRINFC_MIFARESTD_VAL1)? 5495 PH_FRINFC_MIFARESTD_VAL1: 5496 PH_FRINFC_MIFARESTD_VAL0); 5497 5498 } 5499 } 5500 else 5501 { 5502 /*Error: No Ndef Compliant Sectors present.*/ 5503 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 5504 NFCSTATUS_INVALID_PARAMETER); 5505 } 5506 5507 return Result; 5508 } 5509 5510 static void phFriNfc_MifStd_H_fillTLV1_1(phFriNfc_NdefMap_t *NdefMap) 5511 { 5512 switch(NdefMap->TLVStruct.NdefTLVByte) 5513 { 5514 case PH_FRINFC_MIFARESTD_VAL0: 5515 /* In the first write ndef length procedure, the 5516 length is updated, in this case T and L = 0xFF of TLV are 5517 updated */ 5518 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 5519 NdefMap->TLVStruct.NdefTLVBlock = 5520 NdefMap->StdMifareContainer.currentBlock; 5521 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL14; 5522 5523 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL15] = 5524 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5525 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL16] = 5526 PH_FRINFC_MIFARESTD_NDEFTLV_L; 5527 break; 5528 5529 case PH_FRINFC_MIFARESTD_VAL1: 5530 /* In the first write ndef length procedure, the 5531 length is updated, in this case T of TLV is 5532 updated */ 5533 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 5534 NdefMap->TLVStruct.NdefTLVBlock = 5535 NdefMap->StdMifareContainer.currentBlock; 5536 NdefMap->TLVStruct.NdefTLVByte = 5537 PH_FRINFC_MIFARESTD_VAL15; 5538 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL16] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5539 break; 5540 5541 case PH_FRINFC_MIFARESTD_VAL15: 5542 default: 5543 /* In the first ndef write length, part of the L field or only T 5544 (if update length is less than 255) is updated */ 5545 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1] = 5546 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5547 break; 5548 } 5549 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 5550 } 5551 5552 static void phFriNfc_MifStd_H_fillTLV2_1(phFriNfc_NdefMap_t *NdefMap) 5553 { 5554 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL1; 5555 switch(NdefMap->TLVStruct.NdefTLVByte) 5556 { 5557 case PH_FRINFC_MIFARESTD_VAL13: 5558 /* In last write ndef length, part of length (L) field of TLV 5559 is updated now */ 5560 NdefMap->SendRecvBuf[TempLength] = 5561 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5562 break; 5563 5564 case PH_FRINFC_MIFARESTD_VAL14: 5565 /* In last write ndef length, part of length (L) field of TLV 5566 is updated now */ 5567 if(NdefMap->TLVStruct.prevLenByteValue >= 5568 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5569 { 5570 NdefMap->SendRecvBuf[TempLength] = 5571 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5572 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5573 TempLength++; 5574 NdefMap->SendRecvBuf[TempLength] = 5575 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5576 } 5577 else 5578 { 5579 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 5580 NdefMap->TLVStruct.NdefTLVBlock = 5581 NdefMap->StdMifareContainer.currentBlock; 5582 NdefMap->TLVStruct.NdefTLVByte = 5583 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 5584 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 5585 TempLength++; 5586 NdefMap->SendRecvBuf[TempLength] = 5587 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5588 } 5589 break; 5590 5591 case PH_FRINFC_MIFARESTD_VAL15: 5592 default: 5593 if(NdefMap->TLVStruct.prevLenByteValue >= 5594 PH_FRINFC_MIFARESTD_NDEFTLV_L) 5595 { 5596 /* In last write ndef length, only T of TLV is updated and 5597 length (L) field of TLV is updated now */ 5598 NdefMap->SendRecvBuf[TempLength] = 5599 PH_FRINFC_MIFARESTD_NDEFTLV_L; 5600 TempLength++; 5601 NdefMap->SendRecvBuf[TempLength] = 5602 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 5603 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 5604 TempLength++; 5605 NdefMap->SendRecvBuf[TempLength] = 5606 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5607 } 5608 else 5609 { 5610 NdefMap->SendRecvBuf[TempLength] = 5611 PH_FRINFC_MIFARESTD_NULLTLV_T; 5612 TempLength++; 5613 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 5614 NdefMap->TLVStruct.NdefTLVBlock = 5615 NdefMap->StdMifareContainer.currentBlock; 5616 NdefMap->TLVStruct.NdefTLVByte = 5617 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 5618 NdefMap->SendRecvBuf[TempLength] = 5619 PH_FRINFC_MIFARESTD_NDEFTLV_T; 5620 TempLength++; 5621 NdefMap->SendRecvBuf[TempLength] = 5622 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 5623 } 5624 break; 5625 } 5626 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 5627 } 5628 5629 static NFCSTATUS phFriNfc_MifStd_H_RdTLV(phFriNfc_NdefMap_t *NdefMap) 5630 { 5631 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5632 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_TLV; 5633 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 5634 5635 Result = phFriNfc_MifStd_H_Rd16Bytes(NdefMap, 5636 NdefMap->StdMifareContainer.currentBlock); 5637 return Result; 5638 } 5639 5640 static NFCSTATUS phFriNfc_MifStd_H_ProRdTLV(phFriNfc_NdefMap_t *NdefMap) 5641 { 5642 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 5643 NFCSTATUS_INVALID_DEVICE_REQUEST); 5644 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 5645 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 5646 5647 /*TempLength = (uint8_t)(((NdefMap->TLVStruct.NULLTLVCount >= 5648 PH_FRINFC_MIFARESTD_VAL2) && 5649 (NdefMap->TLVStruct.BytesRemainLinTLV > 0xFE))? 5650 ((NdefMap->TLVStruct.NdefTLVByte + 5651 PH_FRINFC_MIFARESTD_VAL2)% 5652 PH_FRINFC_MIFARESTD_VAL16): 5653 ((NdefMap->TLVStruct.NdefTLVByte + 5654 PH_FRINFC_MIFARESTD_VAL4)% 5655 PH_FRINFC_MIFARESTD_VAL16));*/ 5656 5657 TempLength = (uint8_t)((NdefMap->TLVStruct.BytesRemainLinTLV <= 0xFE)? 5658 ((NdefMap->TLVStruct.NdefTLVByte + 5659 PH_FRINFC_MIFARESTD_VAL2)% 5660 PH_FRINFC_MIFARESTD_VAL16): 5661 ((NdefMap->TLVStruct.NdefTLVByte + 5662 PH_FRINFC_MIFARESTD_VAL4)% 5663 PH_FRINFC_MIFARESTD_VAL16)); 5664 5665 if((*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) && 5666 (NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)) 5667 { 5668 if(NdefMap->TLVStruct.BytesRemainLinTLV != 0) 5669 { 5670 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 5671 /* To read the remaining length (L) in TLV */ 5672 Result = phFriNfc_MifStd_H_RemainTLV(NdefMap, &NDEFFlag, &TempLength); 5673 } 5674 } 5675 return Result; 5676 } 5677 5678 static NFCSTATUS phFriNfc_MifStd_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap) 5679 { 5680 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5681 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 5682 5683 /* Change the state to check ndef compliancy */ 5684 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_TERM_TLV; 5685 5686 NdefMap->SendRecvBuf[index] = 5687 NdefMap->StdMifareContainer.currentBlock; 5688 index++; 5689 NdefMap->SendRecvBuf[index] = PH_FRINFC_MIFARESTD_TERMTLV_T; 5690 index++; 5691 5692 while(index < PH_FRINFC_MIFARESTD_WR_A_BLK) 5693 { 5694 NdefMap->SendRecvBuf[index] = PH_FRINFC_MIFARESTD_NULLTLV_T; 5695 index++; 5696 } 5697 5698 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 5699 5700 Result = phFriNfc_MifStd_H_WrTLV(NdefMap); 5701 5702 return Result; 5703 } 5704 5705 5706 static NFCSTATUS phFriNfc_MifStd_H_ProWrABlock(phFriNfc_NdefMap_t *NdefMap) 5707 { 5708 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5709 5710 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL0; 5711 if(NdefMap->ApduBuffIndex < 5712 (uint16_t)NdefMap->ApduBufferSize) 5713 { 5714 /* Remaining bytes to write < 16 */ 5715 if(NdefMap->StdMifareContainer.RemainingBufFlag == 5716 PH_FRINFC_MIFARESTD_FLAG1) 5717 { 5718 /* Write complete, so next byte shall be */ 5719 NdefMap->StdMifareContainer.internalLength = 5720 *NdefMap->DataCount; 5721 5722 /* Copy bytes less than 16 to internal buffer 5723 for the next write this can be used */ 5724 (void)memcpy( NdefMap->StdMifareContainer.internalBuf, 5725 NdefMap->StdMifareContainer.Buffer, 5726 NdefMap->StdMifareContainer.internalLength); 5727 5728 /* Increment the Send Buffer index */ 5729 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 5730 5731 NdefMap->StdMifareContainer.remainingSize -= 5732 NdefMap->NumOfBytesWritten; 5733 5734 NdefMap->StdMifareContainer.RemainingBufFlag = PH_FRINFC_MIFARESTD_VAL0; 5735 /* Check for the End of Card */ 5736 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 5737 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 5738 PH_FRINFC_MIFARESTD_VAL0)? 5739 PH_FRINFC_MIFARESTD_FLAG1: 5740 PH_FRINFC_MIFARESTD_FLAG0); 5741 5742 NdefMap->TLVStruct.SetTermTLVFlag = 5743 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 5744 PH_FRINFC_MIFARESTD_VAL0) || 5745 (NdefMap->TLVStruct.SetTermTLVFlag == 5746 PH_FRINFC_MIFARESTD_FLAG1))? 5747 PH_FRINFC_MIFARESTD_FLAG1: 5748 PH_FRINFC_MIFARESTD_FLAG0); 5749 5750 } /* internal Buffer > Send Buffer */ 5751 else if(NdefMap->StdMifareContainer.internalBufFlag == 5752 PH_FRINFC_MIFARESTD_FLAG1) 5753 { 5754 (void)memcpy(NdefMap->StdMifareContainer.internalBuf, 5755 NdefMap->StdMifareContainer.Buffer, 5756 *NdefMap->DataCount); 5757 5758 NdefMap->StdMifareContainer.internalLength = 5759 *NdefMap->DataCount; 5760 5761 /* Increment the Send Buffer index */ 5762 NdefMap->ApduBuffIndex += 5763 NdefMap->NumOfBytesWritten; 5764 5765 NdefMap->StdMifareContainer.remainingSize -= 5766 NdefMap->NumOfBytesWritten; 5767 5768 NdefMap->StdMifareContainer.internalBufFlag = 5769 PH_FRINFC_MIFARESTD_FLAG0; 5770 /* Check for the End of Card */ 5771 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 5772 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 5773 PH_FRINFC_MIFARESTD_VAL0) && 5774 (NdefMap->StdMifareContainer.internalLength == 5775 PH_FRINFC_MIFARESTD_VAL0))? 5776 PH_FRINFC_MIFARESTD_FLAG1: 5777 PH_FRINFC_MIFARESTD_FLAG0); 5778 5779 NdefMap->TLVStruct.SetTermTLVFlag = 5780 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 5781 PH_FRINFC_MIFARESTD_VAL0) || 5782 (NdefMap->TLVStruct.SetTermTLVFlag == 5783 PH_FRINFC_MIFARESTD_FLAG1))? 5784 PH_FRINFC_MIFARESTD_FLAG1: 5785 PH_FRINFC_MIFARESTD_FLAG0); 5786 } 5787 else 5788 { 5789 NdefMap->StdMifareContainer.internalLength = 0; 5790 /* Increment the Send Buffer index */ 5791 NdefMap->ApduBuffIndex += 5792 NdefMap->NumOfBytesWritten; 5793 NdefMap->StdMifareContainer.remainingSize -= 5794 NdefMap->NumOfBytesWritten; 5795 5796 /* Check for the End of Card */ 5797 if((NdefMap->StdMifareContainer.remainingSize == 5798 PH_FRINFC_MIFARESTD_VAL0) || 5799 (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize)) 5800 { 5801 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 5802 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 0)? 5803 PH_FRINFC_MIFARESTD_FLAG1:PH_FRINFC_MIFARESTD_FLAG0); 5804 5805 if(NdefMap->StdMifareContainer.internalLength == 5806 PH_FRINFC_MIFARESTD_VAL0) 5807 { 5808 NdefMap->StdMifareContainer.currentBlock++; 5809 /* Mifare 4k Card, After 128th Block 5810 each sector = 16 blocks in Mifare 4k */ 5811 Result = ((NdefMap->StdMifareContainer.remainingSize == 0)? 5812 Result: 5813 phFriNfc_MifStd_H_BlkChk(NdefMap)); 5814 NdefMap->StdMifareContainer.NdefBlocks++; 5815 } 5816 NdefMap->TLVStruct.SetTermTLVFlag = 5817 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 5818 PH_FRINFC_MIFARESTD_VAL0) || 5819 (NdefMap->TLVStruct.SetTermTLVFlag == 5820 PH_FRINFC_MIFARESTD_FLAG1))? 5821 PH_FRINFC_MIFARESTD_FLAG1: 5822 PH_FRINFC_MIFARESTD_FLAG0); 5823 } 5824 else 5825 { 5826 NdefMap->StdMifareContainer.currentBlock++; 5827 NdefMap->StdMifareContainer.WrLength = 5828 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); 5829 /* Mifare 4k Card, After 128th Block 5830 each sector = 16 blocks in Mifare 4k */ 5831 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 5832 if(Result == NFCSTATUS_SUCCESS) 5833 { 5834 NdefMap->StdMifareContainer.NdefBlocks++; 5835 Result = ((NdefMap->StdMifareContainer.AuthDone == 5836 PH_FRINFC_MIFARESTD_FLAG1)? 5837 phFriNfc_MifStd_H_WrABlock(NdefMap): 5838 phFriNfc_MifStd_H_AuthSector(NdefMap)); 5839 } 5840 } 5841 } 5842 } 5843 else 5844 { 5845 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP, 5846 NFCSTATUS_INVALID_DEVICE_REQUEST); 5847 } 5848 5849 if((Result == NFCSTATUS_SUCCESS) && 5850 (NdefMap->TLVStruct.SetTermTLVFlag != 5851 PH_FRINFC_MIFARESTD_FLAG1) && 5852 (NdefMap->StdMifareContainer.remainingSize > 5853 PH_FRINFC_MIFARESTD_VAL0)) 5854 { 5855 Result = phFriNfc_MifStd_H_WrTermTLV(NdefMap); 5856 } 5857 else 5858 { 5859 if((Result == NFCSTATUS_SUCCESS) && 5860 (NdefMap->TLVStruct.SetTermTLVFlag == 5861 PH_FRINFC_MIFARESTD_FLAG1)) 5862 { 5863 /* Write the length to the L field in the TLV */ 5864 NdefMap->StdMifareContainer.TempBlockNo = 5865 NdefMap->StdMifareContainer.currentBlock; 5866 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 5867 NdefMap->StdMifareContainer.currentBlock = 5868 NdefMap->TLVStruct.NdefTLVBlock; 5869 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 5870 } 5871 } 5872 return Result; 5873 } 5874 5875 static NFCSTATUS phFriNfc_MifStd_H_CallDisCon(phFriNfc_NdefMap_t *NdefMap) 5876 { 5877 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5878 /*Set Ndef State*/ 5879 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_DISCONNECT; 5880 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 5881 NdefMap->MapCompletionInfo.Context = NdefMap; 5882 5883 #ifndef PH_HAL4_ENABLE 5884 /*Call the Overlapped HAL POLL function */ 5885 Result = phFriNfc_OvrHal_Disconnect( NdefMap->LowerDevice, 5886 &NdefMap->MapCompletionInfo, 5887 NdefMap->psRemoteDevInfo); 5888 #else 5889 /*Call the Overlapped HAL Reconnect function */ 5890 Result = phFriNfc_OvrHal_Reconnect( NdefMap->LowerDevice, 5891 &NdefMap->MapCompletionInfo, 5892 NdefMap->psRemoteDevInfo); 5893 #endif 5894 5895 return Result; 5896 } 5897 5898 #ifndef PH_HAL4_ENABLE 5899 static NFCSTATUS phFriNfc_MifStd_H_CallPoll(phFriNfc_NdefMap_t *NdefMap) 5900 { 5901 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5902 /*Set Ndef State*/ 5903 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_POLL; 5904 /* Opmodes */ 5905 NdefMap->OpModeType[PH_FRINFC_MIFARESTD_VAL0] = phHal_eOpModesMifare; 5906 NdefMap->OpModeType[PH_FRINFC_MIFARESTD_VAL1] = phHal_eOpModesArrayTerminator; 5907 5908 /* Number of devices to poll */ 5909 NdefMap->NoOfDevices = PH_FRINFC_MIFARESTD_VAL1; 5910 5911 /*Call the Overlapped HAL POLL function */ 5912 Result = phFriNfc_OvrHal_Poll( NdefMap->LowerDevice, 5913 &NdefMap->MapCompletionInfo, 5914 NdefMap->OpModeType, 5915 NdefMap->psRemoteDevInfo, 5916 &NdefMap->NoOfDevices, 5917 NdefMap->StdMifareContainer.DevInputParam); 5918 return Result; 5919 } 5920 #endif 5921 5922 static NFCSTATUS phFriNfc_MifStd_H_CallConnect(phFriNfc_NdefMap_t *NdefMap) 5923 { 5924 NFCSTATUS Result = NFCSTATUS_SUCCESS; 5925 /*Set Ndef State*/ 5926 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_CONNECT; 5927 5928 /*Call the Overlapped HAL POLL function */ 5929 Result = phFriNfc_OvrHal_Connect( NdefMap->LowerDevice, 5930 &NdefMap->MapCompletionInfo, 5931 NdefMap->psRemoteDevInfo, 5932 NdefMap->StdMifareContainer.DevInputParam); 5933 return Result; 5934 } 5935 5936 static void phFriNfc_MifStd1k_H_BlkChk(phFriNfc_NdefMap_t *NdefMap, 5937 uint8_t SectorID, 5938 uint8_t *callbreak) 5939 { 5940 /* every last block of a sector needs to be skipped */ 5941 if(((NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_INC_1) % 5942 PH_FRINFC_MIFARESTD_BLK4) == 0) 5943 { 5944 NdefMap->StdMifareContainer.currentBlock++; 5945 } 5946 else 5947 { 5948 if(NdefMap->StdMifareContainer.aid[SectorID] == 5949 PH_FRINFC_MIFARESTD_NDEF_COMP) 5950 { 5951 /* Check whether the block is first block of a (next)new sector and 5952 also check if it is first block then internal length is zero 5953 or not. Because once Authentication is done for the sector again 5954 we should not authenticate it again */ 5955 if((NdefMap->StdMifareContainer.currentBlock == 5956 (SectorID * PH_FRINFC_MIFARESTD_BLK4)) && 5957 (NdefMap->StdMifareContainer.internalLength == 0)) 5958 { 5959 NdefMap->StdMifareContainer.AuthDone = 0; 5960 } 5961 *callbreak = 1; 5962 } 5963 else 5964 { 5965 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 5966 } 5967 } 5968 } 5969 5970 #ifdef UNIT_TEST 5971 #include <phUnitTestNfc_MifareStd_static.c> 5972 #endif 5973 5974 #endif /* PH_FRINFC_MAP_MIFARESTD_DISABLED */ 5975
