1 /* 2 /* 3 * Copyright (C) 2010 NXP Semiconductors 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /*! 19 * \file phFriNfc_ISO15693Map.c 20 * \brief This component encapsulates read/write/check ndef/process functionalities, 21 * for the ISO-15693 Card. 22 * 23 * Project: NFC-FRI 24 * 25 * $Date: $ 26 * $Author: ing02260 $ 27 * $Revision: $ 28 * $Aliases: $ 29 * 30 */ 31 32 #ifndef PH_FRINFC_MAP_ISO15693_DISABLED 33 34 #include <phNfcTypes.h> 35 #include <phNfcConfig.h> 36 #include <phNfcInterface.h> 37 #include <phNfcHalTypes.h> 38 #include <phFriNfc.h> 39 #include <phFriNfc_NdefMap.h> 40 #include <phFriNfc_OvrHal.h> 41 #include <phFriNfc_MapTools.h> 42 #include <phFriNfc_ISO15693Map.h> 43 44 /************************** START DATA STRUCTURE *********************/ 45 46 typedef enum phFriNfc_eChkNdefSeq 47 { 48 ISO15693_NDEF_TLV_T, 49 ISO15693_NDEF_TLV_L, 50 ISO15693_NDEF_TLV_V, 51 ISO15693_PROP_TLV_L, 52 ISO15693_PROP_TLV_V 53 54 }phFriNfc_eChkNdefSeq_t; 55 56 typedef enum phFriNfc_eWrNdefSeq 57 { 58 ISO15693_RD_BEFORE_WR_NDEF_L_0, 59 ISO15693_WRITE_DATA, 60 ISO15693_RD_BEFORE_WR_NDEF_L, 61 ISO15693_WRITE_NDEF_TLV_L 62 63 }phFriNfc_eWrNdefSeq_t; 64 65 #ifdef FRINFC_READONLY_NDEF 66 67 typedef enum phFriNfc_eRONdefSeq 68 { 69 ISO15693_RD_BEFORE_WR_CC, 70 ISO15693_WRITE_CC, 71 ISO15693_LOCK_BLOCK 72 73 }phFriNfc_eRONdefSeq_t; 74 75 #endif /* #ifdef FRINFC_READONLY_NDEF */ 76 77 /************************** END DATA STRUCTURE *********************/ 78 79 /************************** START MACROS definition *********************/ 80 81 82 83 84 /* UID bytes to differentiate ICODE cards */ 85 #define ISO15693_UID_BYTE_4 0x04U 86 #define ISO15693_UID_BYTE_5 0x05U 87 #define ISO15693_UID_BYTE_6 0x06U 88 #define ISO15693_UID_BYTE_7 0x07U 89 90 /* UID 7th byte value shall be 0xE0 */ 91 #define ISO15693_UIDBYTE_7_VALUE 0xE0U 92 /* UID 6th byte value shall be 0x04 - NXP manufacturer */ 93 #define ISO15693_UIDBYTE_6_VALUE 0x04U 94 95 96 /* UID value for 97 SL2 ICS20 98 SL2S2002 99 */ 100 #define ISO15693_UIDBYTE_5_VALUE_SLI_X 0x01U 101 /* Card size SL2 ICS20 / SL2S2002 */ 102 #define ISO15693_SL2_S2002_ICS20 112U 103 104 /* UID value for 105 SL2 ICS53, 106 SL2 ICS54 107 SL2S5302 108 */ 109 #define ISO15693_UIDBYTE_5_VALUE_SLI_X_S 0x02U 110 #define ISO15693_UIDBYTE_4_VALUE_SLI_X_S 0x00U 111 #define ISO15693_UIDBYTE_4_VALUE_SLI_X_SHC 0x80U 112 #define ISO15693_UIDBYTE_4_VALUE_SLI_X_SY 0x40U 113 /* SL2 ICS53, SL2 ICS54 and SL2S5302 */ 114 #define ISO15693_SL2_S5302_ICS53_ICS54 160U 115 116 /* UID value for 117 SL2 ICS50 118 SL2 ICS51 119 SL2S5002 120 */ 121 #define ISO15693_UIDBYTE_5_VALUE_SLI_X_L 0x03U 122 #define ISO15693_UIDBYTE_4_VALUE_SLI_X_L 0x00U 123 #define ISO15693_UIDBYTE_4_VALUE_SLI_X_LHC 0x80U 124 /* SL2 ICS50, SL2 ICS51 and SL2S5002 */ 125 #define ISO15693_SL2_S5002_ICS50_ICS51 32U 126 127 128 /* State Machine declaration 129 CHECK NDEF state */ 130 #define ISO15693_CHECK_NDEF 0x01U 131 /* READ NDEF state */ 132 #define ISO15693_READ_NDEF 0x02U 133 /* WRITE NDEF state */ 134 #define ISO15693_WRITE_NDEF 0x03U 135 #ifdef FRINFC_READONLY_NDEF 136 137 /* READ ONLY NDEF state */ 138 #define ISO15693_READ_ONLY_NDEF 0x04U 139 140 /* READ ONLY MASK byte for CC */ 141 #define ISO15693_CC_READ_ONLY_MASK 0x03U 142 143 /* CC READ WRITE index */ 144 #define ISO15693_RW_BTYE_INDEX 0x01U 145 146 /* LOCK BLOCK command */ 147 #define ISO15693_LOCK_BLOCK_CMD 0x22U 148 149 #endif /* #ifdef FRINFC_READONLY_NDEF */ 150 151 /* CC Bytes 152 Magic number */ 153 #define ISO15693_CC_MAGIC_BYTE 0xE1U 154 /* Expected mapping version */ 155 #define ISO15693_MAPPING_VERSION 0x01U 156 /* Major version is in upper 2 bits */ 157 #define ISO15693_MAJOR_VERSION_MASK 0xC0U 158 159 /* CC indicating tag is capable of multi-block read */ 160 #define ISO15693_CC_USE_MBR 0x01U 161 /* CC indicating tag is capable of inventory page read */ 162 #define ISO15693_CC_USE_IPR 0x02U 163 /* EXTRA byte in the response */ 164 #define ISO15693_EXTRA_RESP_BYTE 0x01U 165 166 /* Maximum card size multiplication factor */ 167 #define ISO15693_MULT_FACTOR 0x08U 168 /* NIBBLE mask for READ WRITE access */ 169 #define ISO15693_LSB_NIBBLE_MASK 0x0FU 170 #define ISO15693_RD_WR_PERMISSION 0x00U 171 #define ISO15693_RD_ONLY_PERMISSION 0x03U 172 173 /* READ command identifier */ 174 #define ISO15693_READ_COMMAND 0x20U 175 176 /* READ multiple command identifier */ 177 #define ISO15693_READ_MULTIPLE_COMMAND 0x23U 178 179 /* INVENTORY pageread command identifier */ 180 #define ICODE_INVENTORY_PAGEREAD_COMMAND 0xB0U 181 #define INVENTORY_PAGEREAD_FLAGS 0x24U 182 #define NXP_MANUFACTURING_CODE 0x04U 183 184 /* WRITE command identifier */ 185 #define ISO15693_WRITE_COMMAND 0x21U 186 /* FLAG option */ 187 #define ISO15693_FLAGS 0x20U 188 189 /* RESPONSE length expected for single block READ */ 190 #define ISO15693_SINGLE_BLK_RD_RESP_LEN 0x04U 191 /* NULL TLV identifier */ 192 #define ISO15693_NULL_TLV_ID 0x00U 193 /* NDEF TLV, TYPE identifier */ 194 #define ISO15693_NDEF_TLV_TYPE_ID 0x03U 195 196 /* 8 BIT shift */ 197 #define ISO15693_BTYE_SHIFT 0x08U 198 199 /* Proprietary TLV TYPE identifier */ 200 #define ISO15693_PROP_TLV_ID 0xFDU 201 202 /* CC SIZE in BYTES */ 203 #define ISO15693_CC_SIZE 0x04U 204 205 /* To get the remaining size in the card. 206 Inputs are 207 1. maximum data size 208 2. block number 209 3. index of the block number */ 210 #define ISO15693_GET_REMAINING_SIZE(max_data_size, blk, index) \ 211 (max_data_size - ((blk * ISO15693_BYTES_PER_BLOCK) + index)) 212 213 #define ISO15693_GET_LEN_FIELD_BLOCK_NO(blk, byte_addr, ndef_size) \ 214 (((byte_addr + ((ndef_size >= ISO15693_THREE_BYTE_LENGTH_ID) ? 3 : 1)) > \ 215 (ISO15693_BYTES_PER_BLOCK - 1)) ? (blk + 1) : blk) 216 217 #define ISO15693_GET_LEN_FIELD_BYTE_NO(blk, byte_addr, ndef_size) \ 218 (((byte_addr + ((ndef_size >= ISO15693_THREE_BYTE_LENGTH_ID) ? 3 : 1)) % \ 219 ISO15693_BYTES_PER_BLOCK)) 220 221 222 223 /************************** END MACROS definition *********************/ 224 225 /************************** START static functions declaration *********************/ 226 static 227 NFCSTATUS 228 phFriNfc_ISO15693_H_ProcessReadOnly ( 229 phFriNfc_NdefMap_t *psNdefMap); 230 231 static 232 NFCSTATUS 233 phFriNfc_ISO15693_H_ProcessWriteNdef ( 234 phFriNfc_NdefMap_t *psNdefMap); 235 236 static 237 NFCSTATUS 238 phFriNfc_ISO15693_H_ProcessReadNdef ( 239 phFriNfc_NdefMap_t *psNdefMap); 240 241 static 242 NFCSTATUS 243 phFriNfc_ISO15693_H_ProcessCheckNdef ( 244 phFriNfc_NdefMap_t *psNdefMap); 245 246 static 247 void 248 phFriNfc_ISO15693_H_Complete ( 249 phFriNfc_NdefMap_t *psNdefMap, 250 NFCSTATUS Status); 251 252 static 253 NFCSTATUS 254 phFriNfc_ISO15693_H_ReadWrite ( 255 phFriNfc_NdefMap_t *psNdefMap, 256 uint8_t command, 257 uint8_t *p_data, 258 uint8_t data_length); 259 260 static 261 NFCSTATUS 262 phFriNfc_ReadRemainingInMultiple ( 263 phFriNfc_NdefMap_t *psNdefMap, 264 uint32_t startBlock); 265 266 /************************** END static functions declaration *********************/ 267 268 /************************** START static functions definition *********************/ 269 270 static 271 NFCSTATUS 272 phFriNfc_ISO15693_H_ProcessWriteNdef ( 273 phFriNfc_NdefMap_t *psNdefMap) 274 { 275 NFCSTATUS result = NFCSTATUS_SUCCESS; 276 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 277 &(psNdefMap->ISO15693Container); 278 phFriNfc_eWrNdefSeq_t e_wr_ndef_seq = (phFriNfc_eWrNdefSeq_t) 279 psNdefMap->ISO15693Container.ndef_seq; 280 uint8_t *p_recv_buf = NULL; 281 uint8_t recv_length = 0; 282 uint8_t write_flag = FALSE; 283 uint8_t a_write_buf[ISO15693_BYTES_PER_BLOCK] = {0}; 284 uint8_t remaining_size = 0; 285 286 switch (e_wr_ndef_seq) 287 { 288 case ISO15693_RD_BEFORE_WR_NDEF_L_0: 289 { 290 /* L byte is read */ 291 p_recv_buf = (psNdefMap->SendRecvBuf + ISO15693_EXTRA_RESP_BYTE); 292 recv_length = (uint8_t) 293 (*psNdefMap->SendRecvLength - ISO15693_EXTRA_RESP_BYTE); 294 295 if (ISO15693_SINGLE_BLK_RD_RESP_LEN == recv_length) 296 { 297 /* Response length is correct */ 298 uint8_t byte_index = 0; 299 300 /* Copy the recevied buffer */ 301 (void)memcpy ((void *)a_write_buf, (void *)p_recv_buf, 302 recv_length); 303 304 byte_index = ISO15693_GET_LEN_FIELD_BYTE_NO( 305 ps_iso_15693_con->ndef_tlv_type_blk, 306 ps_iso_15693_con->ndef_tlv_type_byte, 307 psNdefMap->ApduBufferSize); 308 309 /* Writing length field to 0, Update length field to 0 */ 310 *(a_write_buf + byte_index) = 0x00; 311 312 if ((ISO15693_BYTES_PER_BLOCK - 1) != byte_index) 313 { 314 /* User data is updated in the buffer */ 315 byte_index = (uint8_t)(byte_index + 1); 316 /* Block number shall be udate */ 317 remaining_size = (ISO15693_BYTES_PER_BLOCK - byte_index); 318 319 if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) 320 < remaining_size) 321 { 322 remaining_size = (uint8_t)(psNdefMap->ApduBufferSize - 323 psNdefMap->ApduBuffIndex); 324 } 325 326 /* Go to next byte to fill the write buffer */ 327 (void)memcpy ((void *)(a_write_buf + byte_index), 328 (void *)(psNdefMap->ApduBuffer + 329 psNdefMap->ApduBuffIndex), remaining_size); 330 331 /* Write index updated */ 332 psNdefMap->ApduBuffIndex = (uint8_t)(psNdefMap->ApduBuffIndex + 333 remaining_size); 334 } 335 336 /* After this write, user data can be written. 337 Update the sequence accordingly */ 338 e_wr_ndef_seq = ISO15693_WRITE_DATA; 339 write_flag = TRUE; 340 } /* if (ISO15693_SINGLE_BLK_RD_RESP_LEN == recv_length) */ 341 else 342 { 343 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 344 NFCSTATUS_INVALID_RECEIVE_LENGTH); 345 } 346 break; 347 } /* case ISO15693_RD_BEFORE_WR_NDEF_L_0: */ 348 349 case ISO15693_RD_BEFORE_WR_NDEF_L: 350 { 351 p_recv_buf = (psNdefMap->SendRecvBuf + ISO15693_EXTRA_RESP_BYTE); 352 recv_length = (uint8_t)(*psNdefMap->SendRecvLength - 353 ISO15693_EXTRA_RESP_BYTE); 354 355 if (ISO15693_SINGLE_BLK_RD_RESP_LEN == recv_length) 356 { 357 uint8_t byte_index = 0; 358 359 (void)memcpy ((void *)a_write_buf, (void *)p_recv_buf, 360 recv_length); 361 362 byte_index = ISO15693_GET_LEN_FIELD_BYTE_NO( 363 ps_iso_15693_con->ndef_tlv_type_blk, 364 ps_iso_15693_con->ndef_tlv_type_byte, 365 psNdefMap->ApduBuffIndex); 366 367 *(a_write_buf + byte_index) = (uint8_t)psNdefMap->ApduBuffIndex; 368 e_wr_ndef_seq = ISO15693_WRITE_NDEF_TLV_L; 369 write_flag = TRUE; 370 } 371 else 372 { 373 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 374 NFCSTATUS_INVALID_RECEIVE_LENGTH); 375 } 376 break; 377 } 378 379 case ISO15693_WRITE_DATA: 380 { 381 if ((psNdefMap->ApduBufferSize == psNdefMap->ApduBuffIndex) 382 || (ps_iso_15693_con->current_block == 383 (ps_iso_15693_con->max_data_size / ISO15693_BYTES_PER_BLOCK))) 384 { 385 ps_iso_15693_con->current_block = 386 ISO15693_GET_LEN_FIELD_BLOCK_NO( 387 ps_iso_15693_con->ndef_tlv_type_blk, 388 ps_iso_15693_con->ndef_tlv_type_byte, 389 psNdefMap->ApduBuffIndex); 390 e_wr_ndef_seq = ISO15693_RD_BEFORE_WR_NDEF_L; 391 } 392 else 393 { 394 remaining_size = ISO15693_BYTES_PER_BLOCK; 395 396 ps_iso_15693_con->current_block = (uint16_t) 397 (ps_iso_15693_con->current_block + 1); 398 399 if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) 400 < remaining_size) 401 { 402 remaining_size = (uint8_t)(psNdefMap->ApduBufferSize - 403 psNdefMap->ApduBuffIndex); 404 } 405 406 (void)memcpy ((void *)a_write_buf, (void *) 407 (psNdefMap->ApduBuffer + 408 psNdefMap->ApduBuffIndex), remaining_size); 409 410 psNdefMap->ApduBuffIndex = (uint8_t)(psNdefMap->ApduBuffIndex + 411 remaining_size); 412 write_flag = TRUE; 413 } 414 break; 415 } /* case ISO15693_WRITE_DATA: */ 416 417 case ISO15693_WRITE_NDEF_TLV_L: 418 { 419 *psNdefMap->WrNdefPacketLength = psNdefMap->ApduBuffIndex; 420 ps_iso_15693_con->actual_ndef_size = psNdefMap->ApduBuffIndex; 421 break; 422 } 423 424 default: 425 { 426 break; 427 } 428 } /* switch (e_wr_ndef_seq) */ 429 430 if (((0 == psNdefMap->ApduBuffIndex) 431 || (*psNdefMap->WrNdefPacketLength != psNdefMap->ApduBuffIndex)) 432 && (!result)) 433 { 434 if (FALSE == write_flag) 435 { 436 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 437 ISO15693_READ_COMMAND, NULL, 0); 438 } 439 else 440 { 441 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 442 ISO15693_WRITE_COMMAND, 443 a_write_buf, sizeof (a_write_buf)); 444 } 445 } 446 447 psNdefMap->ISO15693Container.ndef_seq = (uint8_t)e_wr_ndef_seq; 448 return result; 449 } 450 451 static 452 NFCSTATUS 453 phFriNfc_ISO15693_H_ReadWrite ( 454 phFriNfc_NdefMap_t *psNdefMap, 455 uint8_t command, 456 uint8_t *p_data, 457 uint8_t data_length) 458 { 459 NFCSTATUS result = NFCSTATUS_SUCCESS; 460 uint8_t send_index = 0; 461 462 /* set the data for additional data exchange*/ 463 psNdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 464 psNdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 465 psNdefMap->psDepAdditionalInfo.NAD = 0; 466 467 psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_ISO15693_Process; 468 psNdefMap->MapCompletionInfo.Context = psNdefMap; 469 470 *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength; 471 472 psNdefMap->Cmd.Iso15693Cmd = phHal_eIso15693_Cmd; 473 474 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t)ISO15693_FLAGS; 475 send_index = (uint8_t)(send_index + 1); 476 477 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t)command; 478 send_index = (uint8_t)(send_index + 1); 479 480 (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 481 (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.Uid, 482 psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength); 483 send_index = (uint8_t)(send_index + 484 psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength); 485 486 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t) 487 psNdefMap->ISO15693Container.current_block; 488 send_index = (uint8_t)(send_index + 1); 489 490 if ((ISO15693_WRITE_COMMAND == command) || 491 (ISO15693_READ_MULTIPLE_COMMAND == command)) 492 { 493 (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 494 (void *)p_data, data_length); 495 send_index = (uint8_t)(send_index + data_length); 496 } 497 498 psNdefMap->SendLength = send_index; 499 result = phFriNfc_OvrHal_Transceive(psNdefMap->LowerDevice, 500 &psNdefMap->MapCompletionInfo, 501 psNdefMap->psRemoteDevInfo, 502 psNdefMap->Cmd, 503 &psNdefMap->psDepAdditionalInfo, 504 psNdefMap->SendRecvBuf, 505 psNdefMap->SendLength, 506 psNdefMap->SendRecvBuf, 507 psNdefMap->SendRecvLength); 508 509 return result; 510 } 511 512 static 513 NFCSTATUS 514 phFriNfc_ISO15693_H_Inventory_Page_Read ( 515 phFriNfc_NdefMap_t *psNdefMap, 516 uint8_t command, 517 uint8_t page, 518 uint8_t numPages) 519 { 520 NFCSTATUS result = NFCSTATUS_SUCCESS; 521 uint8_t send_index = 0; 522 523 /* set the data for additional data exchange*/ 524 psNdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; 525 psNdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; 526 psNdefMap->psDepAdditionalInfo.NAD = 0; 527 528 psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_ISO15693_Process; 529 psNdefMap->MapCompletionInfo.Context = psNdefMap; 530 531 *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength; 532 533 psNdefMap->Cmd.Iso15693Cmd = phHal_eIso15693_Cmd; 534 535 *(psNdefMap->SendRecvBuf + send_index) = INVENTORY_PAGEREAD_FLAGS; 536 send_index = (uint8_t)(send_index + 1); 537 538 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t)command; 539 send_index = (uint8_t)(send_index + 1); 540 541 *(psNdefMap->SendRecvBuf + send_index) = NXP_MANUFACTURING_CODE; 542 send_index = (uint8_t)(send_index + 1); 543 544 *(psNdefMap->SendRecvBuf + send_index) = 0x40; 545 send_index = (uint8_t)(send_index + 1); 546 547 (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index), 548 (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.Uid, 549 psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength); 550 send_index = (uint8_t)(send_index + 551 psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength); 552 553 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t) 554 page; 555 send_index = (uint8_t)(send_index + 1); 556 557 *(psNdefMap->SendRecvBuf + send_index) = (uint8_t) 558 numPages; 559 send_index = (uint8_t)(send_index + 1); 560 561 psNdefMap->SendLength = send_index; 562 563 result = phFriNfc_OvrHal_Transceive(psNdefMap->LowerDevice, 564 &psNdefMap->MapCompletionInfo, 565 psNdefMap->psRemoteDevInfo, 566 psNdefMap->Cmd, 567 &psNdefMap->psDepAdditionalInfo, 568 psNdefMap->SendRecvBuf, 569 psNdefMap->SendLength, 570 psNdefMap->SendRecvBuf, 571 psNdefMap->SendRecvLength); 572 573 return result; 574 } 575 576 static 577 NFCSTATUS 578 phFriNfc_ISO15693_Reformat_Pageread_Buffer ( 579 uint8_t *p_recv_buf, 580 uint8_t recv_length, 581 uint8_t *p_dst_buf, 582 uint8_t dst_length) 583 { 584 // Inventory page reads return an extra security byte per page 585 // So we need to reformat the returned buffer in memory 586 uint32_t i = 0; 587 uint32_t reformatted_index = 0; 588 while (i < recv_length) { 589 // Going for another page of 16 bytes, check for space in dst buffer 590 if (reformatted_index + 16 > dst_length) { 591 break; 592 } 593 if (p_recv_buf[i] == 0x0F) { 594 // Security, insert 16 0 bytes 595 memset(&(p_dst_buf[reformatted_index]), 0, 16); 596 reformatted_index += 16; 597 i++; 598 } else { 599 // Skip security byte 600 i++; 601 if (i + 16 <= recv_length) { 602 memcpy(&(p_dst_buf[reformatted_index]), &(p_recv_buf[i]), 16); 603 reformatted_index += 16; 604 } else { 605 break; 606 } 607 i+=16; 608 } 609 } 610 return reformatted_index; 611 } 612 613 static 614 NFCSTATUS 615 phFriNfc_ISO15693_H_ProcessReadNdef ( 616 phFriNfc_NdefMap_t *psNdefMap) 617 { 618 NFCSTATUS result = NFCSTATUS_SUCCESS; 619 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 620 &(psNdefMap->ISO15693Container); 621 uint16_t remaining_data_size = 0; 622 uint8_t *p_recv_buf = 623 (psNdefMap->SendRecvBuf + ISO15693_EXTRA_RESP_BYTE); 624 uint8_t recv_length = (uint8_t) 625 (*psNdefMap->SendRecvLength - ISO15693_EXTRA_RESP_BYTE); 626 627 uint8_t *reformatted_buf = (uint8_t*) phOsalNfc_GetMemory(ps_iso_15693_con->max_data_size); 628 629 if (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR) 630 { 631 uint8_t reformatted_size = phFriNfc_ISO15693_Reformat_Pageread_Buffer(p_recv_buf, recv_length, 632 reformatted_buf, ps_iso_15693_con->max_data_size); 633 p_recv_buf = reformatted_buf + (ps_iso_15693_con->current_block * ISO15693_BYTES_PER_BLOCK); 634 recv_length = reformatted_size - (ps_iso_15693_con->current_block * ISO15693_BYTES_PER_BLOCK); 635 } 636 if (ps_iso_15693_con->store_length) 637 { 638 /* Continue Offset option selected 639 So stored data already existing, 640 copy the information to the user buffer 641 */ 642 if (ps_iso_15693_con->store_length 643 <= (psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex)) 644 { 645 /* Stored data length is less than or equal 646 to the user expected size */ 647 (void)memcpy ((void *)(psNdefMap->ApduBuffer + 648 psNdefMap->ApduBuffIndex), 649 (void *)ps_iso_15693_con->store_read_data, 650 ps_iso_15693_con->store_length); 651 652 psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 653 ps_iso_15693_con->store_length); 654 655 remaining_data_size = ps_iso_15693_con->store_length; 656 657 ps_iso_15693_con->store_length = 0; 658 } 659 else 660 { 661 /* stored length is more than the user expected size */ 662 remaining_data_size = (uint16_t)(ps_iso_15693_con->store_length - 663 (psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex)); 664 665 (void)memcpy ((void *)(psNdefMap->ApduBuffer + 666 psNdefMap->ApduBuffIndex), 667 (void *)ps_iso_15693_con->store_read_data, 668 remaining_data_size); 669 670 /* As stored data is more than the user expected data. So store 671 the remaining bytes again into the data structure */ 672 (void)memcpy ((void *)ps_iso_15693_con->store_read_data, 673 (void *)(ps_iso_15693_con->store_read_data + 674 remaining_data_size), 675 (ps_iso_15693_con->store_length - remaining_data_size)); 676 677 psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 678 remaining_data_size); 679 680 ps_iso_15693_con->store_length = (uint8_t) 681 (ps_iso_15693_con->store_length - remaining_data_size); 682 } 683 } /* if (ps_iso_15693_con->store_length) */ 684 else 685 { 686 /* Data is read from the card. */ 687 uint8_t byte_index = 0; 688 689 remaining_data_size = ps_iso_15693_con->remaining_size_to_read; 690 691 /* Check if the block number is to read the first VALUE field */ 692 if (ISO15693_GET_VALUE_FIELD_BLOCK_NO(ps_iso_15693_con->ndef_tlv_type_blk, 693 ps_iso_15693_con->ndef_tlv_type_byte, 694 ps_iso_15693_con->actual_ndef_size) 695 == ps_iso_15693_con->current_block) 696 { 697 /* Read from the beginning option selected, 698 BYTE number may start from the middle */ 699 byte_index = (uint8_t)ISO15693_GET_VALUE_FIELD_BYTE_NO( 700 ps_iso_15693_con->ndef_tlv_type_blk, 701 ps_iso_15693_con->ndef_tlv_type_byte, 702 ps_iso_15693_con->actual_ndef_size); 703 } 704 705 if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) 706 < remaining_data_size) 707 { 708 remaining_data_size = (uint8_t) 709 (recv_length - byte_index); 710 /* user input is less than the remaining card size */ 711 if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) 712 < (uint16_t)remaining_data_size) 713 { 714 /* user data required is less than the data read */ 715 remaining_data_size = (uint8_t)(psNdefMap->ApduBufferSize - 716 psNdefMap->ApduBuffIndex); 717 718 if (0 != (recv_length - (byte_index + 719 remaining_data_size))) 720 { 721 /* Store the data for the continue read option */ 722 (void)memcpy ((void *)ps_iso_15693_con->store_read_data, 723 (void *)(p_recv_buf + (byte_index + 724 remaining_data_size)), 725 (recv_length - (byte_index + 726 remaining_data_size))); 727 728 ps_iso_15693_con->store_length = (uint8_t) 729 (recv_length - (byte_index + 730 remaining_data_size)); 731 } 732 } 733 } 734 else 735 { 736 /* user data required is equal or greater than the data read */ 737 if (remaining_data_size > (recv_length - byte_index)) 738 { 739 remaining_data_size = (uint8_t) 740 (recv_length - byte_index); 741 } 742 } 743 744 /* Copy data in the user buffer */ 745 (void)memcpy ((void *)(psNdefMap->ApduBuffer + 746 psNdefMap->ApduBuffIndex), 747 (void *)(p_recv_buf + byte_index), 748 remaining_data_size); 749 750 /* Update the read index */ 751 psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex + 752 remaining_data_size); 753 754 } /* else part of if (ps_iso_15693_con->store_length) */ 755 756 /* Remaining size is decremented */ 757 ps_iso_15693_con->remaining_size_to_read = (uint8_t) 758 (ps_iso_15693_con->remaining_size_to_read - 759 remaining_data_size); 760 761 if ((psNdefMap->ApduBuffIndex != psNdefMap->ApduBufferSize) 762 && (0 != ps_iso_15693_con->remaining_size_to_read)) 763 { 764 ps_iso_15693_con->current_block = (uint16_t) 765 (ps_iso_15693_con->current_block + 1); 766 /* READ again */ 767 if ((ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_MBR) || 768 (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR)) { 769 result = phFriNfc_ReadRemainingInMultiple(psNdefMap, ps_iso_15693_con->current_block); 770 } 771 else { 772 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, ISO15693_READ_COMMAND, 773 NULL, 0); 774 } 775 } 776 else 777 { 778 /* Read completed, EITHER index has reached to the user size 779 OR end of the card is reached 780 update the user data structure with read data size */ 781 *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex; 782 } 783 if (reformatted_buf != NULL) { 784 phOsalNfc_FreeMemory(reformatted_buf); 785 } 786 return result; 787 } 788 789 static 790 NFCSTATUS 791 phFriNfc_ISO15693_H_CheckCCBytes ( 792 phFriNfc_NdefMap_t *psNdefMap) 793 { 794 NFCSTATUS result = NFCSTATUS_SUCCESS; 795 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 796 &(psNdefMap->ISO15693Container); 797 uint8_t recv_index = 0; 798 uint8_t *p_recv_buf = (psNdefMap->SendRecvBuf + 1); 799 800 /* expected CC byte : E1 40 "MAX SIZE depends on tag" */ 801 if (ISO15693_CC_MAGIC_BYTE == *p_recv_buf) 802 { 803 /* 0xE1 magic byte found*/ 804 recv_index = (uint8_t)(recv_index + 1); 805 uint8_t tag_major_version = (*(p_recv_buf + recv_index) & ISO15693_MAJOR_VERSION_MASK) >> 6; 806 if (ISO15693_MAPPING_VERSION >= tag_major_version) 807 { 808 /* Correct mapping version found */ 809 switch (*(p_recv_buf + recv_index) & ISO15693_LSB_NIBBLE_MASK) 810 { 811 case ISO15693_RD_WR_PERMISSION: 812 { 813 /* READ/WRITE possible */ 814 psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE; 815 break; 816 } 817 818 case ISO15693_RD_ONLY_PERMISSION: 819 { 820 /* ONLY READ possible, WRITE NOT possible */ 821 psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY; 822 break; 823 } 824 825 default: 826 { 827 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 828 NFCSTATUS_NO_NDEF_SUPPORT); 829 break; 830 } 831 } 832 recv_index = (uint8_t)(recv_index + 1); 833 834 if (!result) 835 { 836 /* Update MAX SIZE */ 837 ps_iso_15693_con->max_data_size = (uint16_t) 838 (*(p_recv_buf + recv_index) * 839 ISO15693_MULT_FACTOR); 840 recv_index = (uint8_t)(recv_index + 1); 841 ps_iso_15693_con->read_capabilities = (*(p_recv_buf + recv_index)); 842 843 844 } 845 } 846 else 847 { 848 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 849 NFCSTATUS_NO_NDEF_SUPPORT); 850 } 851 } 852 else 853 { 854 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 855 NFCSTATUS_NO_NDEF_SUPPORT); 856 } 857 return result; 858 } 859 860 static 861 NFCSTATUS 862 phFriNfc_ISO15693_H_ProcessCheckNdef ( 863 phFriNfc_NdefMap_t *psNdefMap) 864 { 865 NFCSTATUS result = NFCSTATUS_SUCCESS; 866 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 867 &(psNdefMap->ISO15693Container); 868 phFriNfc_eChkNdefSeq_t e_chk_ndef_seq = (phFriNfc_eChkNdefSeq_t) 869 psNdefMap->ISO15693Container.ndef_seq; 870 871 uint8_t *p_recv_buf = 872 (psNdefMap->SendRecvBuf + ISO15693_EXTRA_RESP_BYTE); 873 uint8_t recv_length = (uint8_t) 874 (*psNdefMap->SendRecvLength - ISO15693_EXTRA_RESP_BYTE); 875 uint8_t parse_index = 0; 876 static uint16_t prop_ndef_index = 0; 877 uint8_t *reformatted_buf = (uint8_t*) phOsalNfc_GetMemory(ps_iso_15693_con->max_data_size); 878 879 if (0 == ps_iso_15693_con->current_block) 880 { 881 /* Check CC byte */ 882 result = phFriNfc_ISO15693_H_CheckCCBytes (psNdefMap); 883 parse_index = (uint8_t)(parse_index + recv_length); 884 } 885 else if (1 == ps_iso_15693_con->current_block && 886 (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR)) 887 { 888 889 uint8_t reformatted_size = phFriNfc_ISO15693_Reformat_Pageread_Buffer(p_recv_buf, recv_length, 890 reformatted_buf, ps_iso_15693_con->max_data_size); 891 // Skip initial CC bytes 892 p_recv_buf = reformatted_buf + (ps_iso_15693_con->current_block * ISO15693_BYTES_PER_BLOCK); 893 recv_length = reformatted_size - (ps_iso_15693_con->current_block * ISO15693_BYTES_PER_BLOCK); 894 } 895 else 896 { 897 /* Propreitary TLVs VALUE can end in between a block, 898 so when that block is read, update the parse_index 899 with byte address value */ 900 if (ISO15693_PROP_TLV_V == e_chk_ndef_seq) 901 { 902 parse_index = ps_iso_15693_con->ndef_tlv_type_byte; 903 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 904 } 905 } 906 907 while ((parse_index < recv_length) 908 && (NFCSTATUS_SUCCESS == result) 909 && (ISO15693_NDEF_TLV_V != e_chk_ndef_seq)) 910 { 911 /* Parse 912 1. till the received length of the block 913 2. till there is no error during parse 914 3. till LENGTH field of NDEF TLV is found 915 */ 916 switch (e_chk_ndef_seq) 917 { 918 case ISO15693_NDEF_TLV_T: 919 { 920 /* Expected value is 0x03 TYPE identifier 921 of the NDEF TLV */ 922 prop_ndef_index = 0; 923 switch (*(p_recv_buf + parse_index)) 924 { 925 case ISO15693_NDEF_TLV_TYPE_ID: 926 { 927 /* Update the data structure with the byte address and 928 the block number */ 929 ps_iso_15693_con->ndef_tlv_type_byte = parse_index; 930 ps_iso_15693_con->ndef_tlv_type_blk = 931 ps_iso_15693_con->current_block; 932 e_chk_ndef_seq = ISO15693_NDEF_TLV_L; 933 934 break; 935 } 936 937 case ISO15693_NULL_TLV_ID: 938 { 939 /* Dont do any thing, go to next byte */ 940 break; 941 } 942 943 case ISO15693_PROP_TLV_ID: 944 { 945 /* Move the sequence to find the length 946 of the proprietary TLV */ 947 e_chk_ndef_seq = ISO15693_PROP_TLV_L; 948 break; 949 } 950 951 default: 952 { 953 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 954 NFCSTATUS_NO_NDEF_SUPPORT); 955 break; 956 } 957 } /* switch (*(p_recv_buf + parse_index)) */ 958 break; 959 } 960 961 case ISO15693_PROP_TLV_L: 962 { 963 /* Length field of the proprietary TLV */ 964 switch (prop_ndef_index) 965 { 966 /* Length field can have 1 or 3 bytes depending 967 on the data size, so check for each index byte */ 968 case 0: 969 { 970 /* 1st index of the length field of the TLV */ 971 if (0 == *(p_recv_buf + parse_index)) 972 { 973 /* LENGTH is 0, not possible, so error */ 974 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 975 NFCSTATUS_NO_NDEF_SUPPORT); 976 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 977 } 978 else 979 { 980 if (ISO15693_THREE_BYTE_LENGTH_ID == 981 *(p_recv_buf + parse_index)) 982 { 983 /* 3 byte LENGTH field identified, so increment the 984 index, so next time 2nd byte is parsed */ 985 prop_ndef_index = (uint8_t)(prop_ndef_index + 1); 986 } 987 else 988 { 989 /* 1 byte LENGTH field identified, so "static" 990 index is set to 0 and actual ndef size is 991 copied to the data structure 992 */ 993 ps_iso_15693_con->actual_ndef_size = 994 *(p_recv_buf + parse_index); 995 e_chk_ndef_seq = ISO15693_PROP_TLV_V; 996 prop_ndef_index = 0; 997 } 998 } 999 break; 1000 } 1001 1002 case 1: 1003 { 1004 /* 2nd index of the LENGTH field that is MSB of the length, 1005 so the length is left shifted by 8 */ 1006 ps_iso_15693_con->actual_ndef_size = (uint16_t) 1007 (*(p_recv_buf + parse_index) << 1008 ISO15693_BTYE_SHIFT); 1009 prop_ndef_index = (uint8_t)(prop_ndef_index + 1); 1010 break; 1011 } 1012 1013 case 2: 1014 { 1015 /* 3rd index of the LENGTH field that is LSB of the length, 1016 so the length ORed with the previously stored size */ 1017 ps_iso_15693_con->actual_ndef_size = (uint16_t) 1018 (ps_iso_15693_con->actual_ndef_size | 1019 *(p_recv_buf + parse_index)); 1020 1021 e_chk_ndef_seq = ISO15693_PROP_TLV_V; 1022 prop_ndef_index = 0; 1023 break; 1024 } 1025 1026 default: 1027 { 1028 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1029 NFCSTATUS_INVALID_DEVICE_REQUEST); 1030 break; 1031 } 1032 } /* switch (prop_ndef_index) */ 1033 1034 if ((ISO15693_PROP_TLV_V == e_chk_ndef_seq) 1035 && (ISO15693_GET_REMAINING_SIZE(ps_iso_15693_con->max_data_size, 1036 ps_iso_15693_con->current_block, parse_index) 1037 <= ps_iso_15693_con->actual_ndef_size)) 1038 { 1039 /* Check for the length field value has not exceeded the card size, 1040 if size is exceeded or then return error */ 1041 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1042 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1043 NFCSTATUS_NO_NDEF_SUPPORT); 1044 } 1045 else 1046 { 1047 uint16_t prop_byte_addr = 0; 1048 1049 /* skip the proprietary TLVs value field */ 1050 prop_byte_addr = (uint16_t) 1051 ((ps_iso_15693_con->current_block * ISO15693_BYTES_PER_BLOCK) + 1052 parse_index + ps_iso_15693_con->actual_ndef_size); 1053 1054 ps_iso_15693_con->ndef_tlv_type_byte = (uint8_t)(prop_byte_addr % 1055 ISO15693_BYTES_PER_BLOCK); 1056 ps_iso_15693_con->ndef_tlv_type_blk = (uint16_t)(prop_byte_addr / 1057 ISO15693_BYTES_PER_BLOCK); 1058 if (parse_index + ps_iso_15693_con->actual_ndef_size >= 1059 recv_length) 1060 { 1061 parse_index = (uint8_t)recv_length; 1062 } 1063 else 1064 { 1065 parse_index = (uint8_t)(parse_index + 1066 ps_iso_15693_con->actual_ndef_size); 1067 } 1068 1069 } 1070 break; 1071 } /* case ISO15693_PROP_TLV_L: */ 1072 1073 case ISO15693_PROP_TLV_V: 1074 { 1075 uint8_t remaining_length = (uint8_t)(recv_length - 1076 parse_index); 1077 1078 if ((ps_iso_15693_con->actual_ndef_size - prop_ndef_index) 1079 > remaining_length) 1080 { 1081 parse_index = (uint8_t)(parse_index + remaining_length); 1082 prop_ndef_index = (uint8_t)(prop_ndef_index + remaining_length); 1083 } 1084 else if ((ps_iso_15693_con->actual_ndef_size - prop_ndef_index) 1085 == remaining_length) 1086 { 1087 parse_index = (uint8_t)(parse_index + remaining_length); 1088 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1089 prop_ndef_index = 0; 1090 } 1091 else 1092 { 1093 parse_index = (uint8_t)(parse_index + 1094 (ps_iso_15693_con->actual_ndef_size - 1095 prop_ndef_index)); 1096 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1097 prop_ndef_index = 0; 1098 } 1099 break; 1100 } /* case ISO15693_PROP_TLV_V: */ 1101 1102 case ISO15693_NDEF_TLV_L: 1103 { 1104 /* Length field of the NDEF TLV */ 1105 switch (prop_ndef_index) 1106 { 1107 /* Length field can have 1 or 3 bytes depending 1108 on the data size, so check for each index byte */ 1109 case 0: 1110 { 1111 /* 1st index of the length field of the TLV */ 1112 if (0 == *(p_recv_buf + parse_index)) 1113 { 1114 /* LENGTH is 0, card is in INITILIASED STATE */ 1115 e_chk_ndef_seq = ISO15693_NDEF_TLV_V; 1116 ps_iso_15693_con->actual_ndef_size = 0; 1117 } 1118 else 1119 { 1120 prop_ndef_index = (uint8_t)(prop_ndef_index + 1); 1121 1122 if (ISO15693_THREE_BYTE_LENGTH_ID == 1123 *(p_recv_buf + parse_index)) 1124 { 1125 /* At present no CARD supports more than 255 bytes, 1126 so error is returned */ 1127 prop_ndef_index = (uint8_t)(prop_ndef_index + 1); 1128 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1129 NFCSTATUS_NO_NDEF_SUPPORT); 1130 prop_ndef_index = 0; 1131 } 1132 else 1133 { 1134 /* 1 byte LENGTH field identified, so "static" 1135 index is set to 0 and actual ndef size is 1136 copied to the data structure 1137 */ 1138 ps_iso_15693_con->actual_ndef_size = 1139 *(p_recv_buf + parse_index); 1140 /* next values are the DATA field of the NDEF TLV */ 1141 e_chk_ndef_seq = ISO15693_NDEF_TLV_V; 1142 prop_ndef_index = 0; 1143 } 1144 } 1145 break; 1146 } 1147 1148 case 1: 1149 { 1150 /* 2nd index of the LENGTH field that is MSB of the length, 1151 so the length is left shifted by 8 */ 1152 ps_iso_15693_con->actual_ndef_size = (uint16_t) 1153 (*(p_recv_buf + parse_index) << 1154 ISO15693_BTYE_SHIFT); 1155 prop_ndef_index = (uint8_t)(prop_ndef_index + 1); 1156 break; 1157 } 1158 1159 case 2: 1160 { 1161 /* 3rd index of the LENGTH field that is LSB of the length, 1162 so the length ORed with the previously stored size */ 1163 ps_iso_15693_con->actual_ndef_size = (uint16_t) 1164 (ps_iso_15693_con->actual_ndef_size | 1165 *(p_recv_buf + parse_index)); 1166 1167 e_chk_ndef_seq = ISO15693_NDEF_TLV_V; 1168 prop_ndef_index = 0; 1169 break; 1170 } 1171 1172 default: 1173 { 1174 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1175 NFCSTATUS_INVALID_DEVICE_REQUEST); 1176 break; 1177 } 1178 } /* switch (prop_ndef_index) */ 1179 1180 if ((ISO15693_NDEF_TLV_V == e_chk_ndef_seq) 1181 && (ISO15693_GET_REMAINING_SIZE(ps_iso_15693_con->max_data_size, 1182 /* parse_index + 1 is done because the data starts from the next index. 1183 "MOD" operation is used to know that parse_index > 1184 ISO15693_BYTES_PER_BLOCK, then block shall be incremented 1185 */ 1186 (((parse_index + 1) % ISO15693_BYTES_PER_BLOCK) ? 1187 ps_iso_15693_con->current_block : 1188 ps_iso_15693_con->current_block + 1), ((parse_index + 1) % 1189 ISO15693_BYTES_PER_BLOCK)) 1190 < ps_iso_15693_con->actual_ndef_size)) 1191 { 1192 /* Check for the length field value has not exceeded the card size */ 1193 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1194 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1195 NFCSTATUS_NO_NDEF_SUPPORT); 1196 } 1197 else 1198 { 1199 psNdefMap->CardState = (uint8_t) 1200 ((PH_NDEFMAP_CARD_STATE_READ_ONLY 1201 == psNdefMap->CardState) ? 1202 PH_NDEFMAP_CARD_STATE_READ_ONLY : 1203 ((ps_iso_15693_con->actual_ndef_size) ? 1204 PH_NDEFMAP_CARD_STATE_READ_WRITE : 1205 PH_NDEFMAP_CARD_STATE_INITIALIZED)); 1206 } 1207 break; 1208 } /* case ISO15693_NDEF_TLV_L: */ 1209 1210 case ISO15693_NDEF_TLV_V: 1211 { 1212 break; 1213 } 1214 1215 default: 1216 { 1217 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1218 NFCSTATUS_INVALID_DEVICE_REQUEST); 1219 break; 1220 } 1221 } /* switch (e_chk_ndef_seq) */ 1222 parse_index = (uint8_t)(parse_index + 1); 1223 } /* while ((parse_index < recv_length) 1224 && (NFCSTATUS_SUCCESS == result) 1225 && (ISO15693_NDEF_TLV_V != e_chk_ndef_seq)) */ 1226 1227 if (result) 1228 { 1229 /* Error returned while parsing, so STOP read */ 1230 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1231 prop_ndef_index = 0; 1232 } 1233 else if (ISO15693_NDEF_TLV_V != e_chk_ndef_seq) 1234 { 1235 /* READ again */ 1236 if (ISO15693_PROP_TLV_V != e_chk_ndef_seq) 1237 { 1238 ps_iso_15693_con->current_block = (uint16_t) 1239 (ps_iso_15693_con->current_block + 1); 1240 } 1241 else 1242 { 1243 /* Proprietary TLV detected, so skip the proprietary blocks */ 1244 ps_iso_15693_con->current_block = ps_iso_15693_con->ndef_tlv_type_blk; 1245 } 1246 1247 uint32_t remaining_size = ISO15693_GET_REMAINING_SIZE(ps_iso_15693_con->max_data_size, 1248 ps_iso_15693_con->current_block, 0); 1249 if (remaining_size > 0) 1250 { 1251 if ((ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_MBR) || 1252 (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR)) { 1253 result = phFriNfc_ReadRemainingInMultiple(psNdefMap, ps_iso_15693_con->current_block); 1254 } else { 1255 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, ISO15693_READ_COMMAND, 1256 NULL, 0); 1257 } 1258 } 1259 else 1260 { 1261 /* End of card reached, error no NDEF information found */ 1262 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1263 prop_ndef_index = 0; 1264 /* Error, no size to parse */ 1265 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1266 NFCSTATUS_NO_NDEF_SUPPORT); 1267 } 1268 1269 } 1270 else 1271 { 1272 /* Successful read with proper NDEF information updated */ 1273 prop_ndef_index = 0; 1274 e_chk_ndef_seq = ISO15693_NDEF_TLV_T; 1275 psNdefMap->CardType = (uint8_t)PH_FRINFC_NDEFMAP_ISO15693_CARD; 1276 } 1277 1278 psNdefMap->ISO15693Container.ndef_seq = (uint8_t)e_chk_ndef_seq; 1279 1280 if (reformatted_buf != NULL) { 1281 phOsalNfc_FreeMemory(reformatted_buf); 1282 } 1283 return result; 1284 } 1285 1286 static 1287 void 1288 phFriNfc_ISO15693_H_Complete ( 1289 phFriNfc_NdefMap_t *psNdefMap, 1290 NFCSTATUS Status) 1291 { 1292 /* set the state back to the RESET_INIT state*/ 1293 psNdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT; 1294 1295 /* set the completion routine*/ 1296 psNdefMap->CompletionRoutine[psNdefMap->ISO15693Container.cr_index]. 1297 CompletionRoutine (psNdefMap->CompletionRoutine->Context, Status); 1298 } 1299 1300 #ifdef FRINFC_READONLY_NDEF 1301 1302 static 1303 NFCSTATUS 1304 phFriNfc_ISO15693_H_ProcessReadOnly ( 1305 phFriNfc_NdefMap_t *psNdefMap) 1306 { 1307 NFCSTATUS result = NFCSTATUS_SUCCESS; 1308 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 1309 &(psNdefMap->ISO15693Container); 1310 phFriNfc_eRONdefSeq_t e_ro_ndef_seq = (phFriNfc_eRONdefSeq_t) 1311 ps_iso_15693_con->ndef_seq; 1312 uint8_t *p_recv_buf = (psNdefMap->SendRecvBuf + 1313 ISO15693_EXTRA_RESP_BYTE); 1314 uint8_t recv_length = (uint8_t)(*psNdefMap->SendRecvLength - 1315 ISO15693_EXTRA_RESP_BYTE); 1316 uint8_t a_write_buf[ISO15693_BYTES_PER_BLOCK] = {0}; 1317 1318 switch (e_ro_ndef_seq) 1319 { 1320 case ISO15693_RD_BEFORE_WR_CC: 1321 { 1322 if (ISO15693_SINGLE_BLK_RD_RESP_LEN == recv_length) 1323 { 1324 result = phFriNfc_ISO15693_H_CheckCCBytes (psNdefMap); 1325 /* Check CC bytes and also the card state for READ ONLY, 1326 if the card is already read only, then dont continue with 1327 next operation */ 1328 if ((PH_NDEFMAP_CARD_STATE_READ_ONLY != psNdefMap->CardState) 1329 && (!result)) 1330 { 1331 /* CC byte read successful */ 1332 (void)memcpy ((void *)a_write_buf, (void *)p_recv_buf, 1333 sizeof (a_write_buf)); 1334 1335 /* Change the read write access to read only */ 1336 *(a_write_buf + ISO15693_RW_BTYE_INDEX) = (uint8_t) 1337 (*(a_write_buf + ISO15693_RW_BTYE_INDEX) | 1338 ISO15693_CC_READ_ONLY_MASK); 1339 1340 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1341 ISO15693_WRITE_COMMAND, a_write_buf, 1342 sizeof (a_write_buf)); 1343 1344 e_ro_ndef_seq = ISO15693_WRITE_CC; 1345 } 1346 } 1347 break; 1348 } 1349 1350 case ISO15693_WRITE_CC: 1351 { 1352 /* Write to CC is successful. */ 1353 e_ro_ndef_seq = ISO15693_LOCK_BLOCK; 1354 /* Start the lock block command to lock the blocks */ 1355 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1356 ISO15693_LOCK_BLOCK_CMD, NULL, 0); 1357 break; 1358 } 1359 1360 case ISO15693_LOCK_BLOCK: 1361 { 1362 if (ps_iso_15693_con->current_block == 1363 ((ps_iso_15693_con->max_data_size / ISO15693_BYTES_PER_BLOCK) - 1364 1)) 1365 { 1366 /* End of card reached, READ ONLY successful */ 1367 } 1368 else 1369 { 1370 /* current block is incremented */ 1371 ps_iso_15693_con->current_block = (uint16_t) 1372 (ps_iso_15693_con->current_block + 1); 1373 /* Lock the current block */ 1374 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1375 ISO15693_LOCK_BLOCK_CMD, NULL, 0); 1376 } 1377 break; 1378 } 1379 1380 default: 1381 { 1382 break; 1383 } 1384 } 1385 1386 ps_iso_15693_con->ndef_seq = (uint8_t)e_ro_ndef_seq; 1387 return result; 1388 } 1389 1390 #endif /* #ifdef FRINFC_READONLY_NDEF */ 1391 /************************** END static functions definition *********************/ 1392 1393 /************************** START external functions *********************/ 1394 1395 NFCSTATUS 1396 phFriNfc_ISO15693_ChkNdef ( 1397 phFriNfc_NdefMap_t *psNdefMap) 1398 { 1399 NFCSTATUS result = NFCSTATUS_SUCCESS; 1400 phHal_sIso15693Info_t *ps_iso_15693_info = 1401 &(psNdefMap->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info); 1402 1403 /* Update the previous operation with current operation. 1404 This becomes the previous operation after this execution */ 1405 psNdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE; 1406 /* Update the CR index to know from which operation completion 1407 routine has to be called */ 1408 psNdefMap->ISO15693Container.cr_index = PH_FRINFC_NDEFMAP_CR_CHK_NDEF; 1409 /* State update */ 1410 psNdefMap->State = ISO15693_CHECK_NDEF; 1411 /* Reset the NDEF sequence */ 1412 psNdefMap->ISO15693Container.ndef_seq = 0; 1413 psNdefMap->ISO15693Container.current_block = 0; 1414 psNdefMap->ISO15693Container.actual_ndef_size = 0; 1415 psNdefMap->ISO15693Container.ndef_tlv_type_blk = 0; 1416 psNdefMap->ISO15693Container.ndef_tlv_type_byte = 0; 1417 psNdefMap->ISO15693Container.store_length = 0; 1418 psNdefMap->ISO15693Container.remaining_size_to_read = 0; 1419 psNdefMap->ISO15693Container.read_capabilities = 0; 1420 1421 if ((ISO15693_UIDBYTE_6_VALUE == 1422 ps_iso_15693_info->Uid[ISO15693_UID_BYTE_6]) 1423 && (ISO15693_UIDBYTE_7_VALUE == 1424 ps_iso_15693_info->Uid[ISO15693_UID_BYTE_7])) 1425 { 1426 /* Check if the card is manufactured by NXP (6th byte 1427 index of UID value = 0x04 and the 1428 last byte i.e., 7th byte of UID is 0xE0, only then the card detected 1429 is NDEF compliant */ 1430 switch (ps_iso_15693_info->Uid[ISO15693_UID_BYTE_5]) 1431 { 1432 /* Check for supported tags, by checking the 5th byte index of UID */ 1433 case ISO15693_UIDBYTE_5_VALUE_SLI_X: 1434 { 1435 /* ISO 15693 card type is ICODE SLI 1436 so maximum size is 112 */ 1437 psNdefMap->ISO15693Container.max_data_size = 1438 ISO15693_SL2_S2002_ICS20; 1439 break; 1440 } 1441 1442 case ISO15693_UIDBYTE_5_VALUE_SLI_X_S: 1443 { 1444 /* ISO 15693 card type is ICODE SLI/X S 1445 so maximum size depends on the 4th UID byte index */ 1446 switch (ps_iso_15693_info->Uid[ISO15693_UID_BYTE_4]) 1447 { 1448 case ISO15693_UIDBYTE_4_VALUE_SLI_X_S: 1449 case ISO15693_UIDBYTE_4_VALUE_SLI_X_SHC: 1450 case ISO15693_UIDBYTE_4_VALUE_SLI_X_SY: 1451 { 1452 /* Supported tags are with value (4th byte UID index) 1453 of 0x00, 0x80 and 0x40 1454 For these cards max size is 160 bytes */ 1455 psNdefMap->ISO15693Container.max_data_size = 1456 ISO15693_SL2_S5302_ICS53_ICS54; 1457 break; 1458 } 1459 1460 default: 1461 { 1462 /* Tag not supported */ 1463 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1464 NFCSTATUS_INVALID_DEVICE_REQUEST); 1465 break; 1466 } 1467 } 1468 break; 1469 } 1470 1471 case ISO15693_UIDBYTE_5_VALUE_SLI_X_L: 1472 { 1473 /* ISO 15693 card type is ICODE SLI/X L 1474 so maximum size depends on the 4th UID byte index */ 1475 switch (ps_iso_15693_info->Uid[ISO15693_UID_BYTE_4]) 1476 { 1477 case ISO15693_UIDBYTE_4_VALUE_SLI_X_L: 1478 case ISO15693_UIDBYTE_4_VALUE_SLI_X_LHC: 1479 { 1480 /* Supported tags are with value (4th byte UID index) 1481 of 0x00 and 0x80 1482 For these cards max size is 32 bytes */ 1483 psNdefMap->ISO15693Container.max_data_size = 1484 ISO15693_SL2_S5002_ICS50_ICS51; 1485 break; 1486 } 1487 1488 default: 1489 { 1490 /* Tag not supported */ 1491 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1492 NFCSTATUS_INVALID_DEVICE_REQUEST); 1493 break; 1494 } 1495 } 1496 break; 1497 } 1498 1499 default: 1500 { 1501 /* Tag not supported */ 1502 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1503 NFCSTATUS_INVALID_DEVICE_REQUEST); 1504 break; 1505 } 1506 } 1507 } 1508 else 1509 { 1510 /* Tag not supported */ 1511 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1512 NFCSTATUS_INVALID_DEVICE_REQUEST); 1513 } 1514 1515 if (!result) 1516 { 1517 /* Start reading the data */ 1518 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, ISO15693_READ_COMMAND, 1519 NULL, 0); 1520 } 1521 1522 1523 return result; 1524 } 1525 1526 NFCSTATUS 1527 phFriNfc_ISO15693_RdNdef ( 1528 phFriNfc_NdefMap_t *psNdefMap, 1529 uint8_t *pPacketData, 1530 uint32_t *pPacketDataLength, 1531 uint8_t Offset) 1532 { 1533 NFCSTATUS result = NFCSTATUS_SUCCESS; 1534 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 1535 &(psNdefMap->ISO15693Container); 1536 1537 /* Update the previous operation with current operation. 1538 This becomes the previous operation after this execution */ 1539 psNdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 1540 /* Update the CR index to know from which operation completion 1541 routine has to be called */ 1542 psNdefMap->ISO15693Container.cr_index = PH_FRINFC_NDEFMAP_CR_RD_NDEF; 1543 /* State update */ 1544 psNdefMap->State = ISO15693_READ_NDEF; 1545 /* Copy user buffer to the context */ 1546 psNdefMap->ApduBuffer = pPacketData; 1547 /* Copy user length to the context */ 1548 psNdefMap->ApduBufferSize = *pPacketDataLength; 1549 /* Update the user memory size to a context variable */ 1550 psNdefMap->NumOfBytesRead = pPacketDataLength; 1551 /* Number of bytes read from the card is zero. 1552 This variable returns the number of bytes read 1553 from the card. */ 1554 *psNdefMap->NumOfBytesRead = 0; 1555 /* Index to know the length read */ 1556 psNdefMap->ApduBuffIndex = 0; 1557 /* Store the offset in the context */ 1558 psNdefMap->Offset = Offset; 1559 1560 if ((!ps_iso_15693_con->remaining_size_to_read) 1561 && (!psNdefMap->Offset)) 1562 { 1563 /* Entire data is already read from the card. 1564 There is no data to give */ 1565 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1566 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 1567 } 1568 else if (0 == ps_iso_15693_con->actual_ndef_size) 1569 { 1570 /* Card is NDEF, but no data in the card. */ 1571 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1572 NFCSTATUS_READ_FAILED); 1573 } 1574 else if (PH_NDEFMAP_CARD_STATE_INITIALIZED == psNdefMap->CardState) 1575 { 1576 /* Card is NDEF, but no data in the card. */ 1577 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 1578 NFCSTATUS_READ_FAILED); 1579 } 1580 else if (psNdefMap->Offset) 1581 { 1582 /* BEGIN offset, so reset the remaining read size and 1583 also the curretn block */ 1584 ps_iso_15693_con->remaining_size_to_read = 1585 ps_iso_15693_con->actual_ndef_size; 1586 ps_iso_15693_con->current_block = 1587 ISO15693_GET_VALUE_FIELD_BLOCK_NO( 1588 ps_iso_15693_con->ndef_tlv_type_blk, 1589 ps_iso_15693_con->ndef_tlv_type_byte, 1590 ps_iso_15693_con->actual_ndef_size); 1591 1592 // Check capabilities 1593 if ((ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_MBR) || 1594 (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR)) { 1595 result = phFriNfc_ReadRemainingInMultiple(psNdefMap, ps_iso_15693_con->current_block); 1596 } else { 1597 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, ISO15693_READ_COMMAND, 1598 NULL, 0); 1599 } 1600 } 1601 else 1602 { 1603 /* CONTINUE offset */ 1604 if (ps_iso_15693_con->store_length > 0) 1605 { 1606 /* Previous read had extra bytes, so data is stored, so give that take 1607 that data from store. If more data is required, then read remaining bytes */ 1608 result = phFriNfc_ISO15693_H_ProcessReadNdef (psNdefMap); 1609 } 1610 else 1611 { 1612 ps_iso_15693_con->current_block = (uint16_t) 1613 (ps_iso_15693_con->current_block + 1); 1614 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1615 ISO15693_READ_COMMAND, NULL, 0); 1616 } 1617 } 1618 1619 return result; 1620 } 1621 1622 static 1623 NFCSTATUS 1624 phFriNfc_ReadRemainingInMultiple ( 1625 phFriNfc_NdefMap_t *psNdefMap, 1626 uint32_t startBlock) 1627 { 1628 NFCSTATUS result = NFCSTATUS_FAILED; 1629 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = &(psNdefMap->ISO15693Container); 1630 1631 uint32_t remaining_size = ISO15693_GET_REMAINING_SIZE(ps_iso_15693_con->max_data_size, 1632 startBlock, 0); 1633 // Check capabilities 1634 if (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_MBR) { 1635 // Multi-page read command 1636 uint8_t mbread[1]; 1637 mbread[0] = (remaining_size / ISO15693_BYTES_PER_BLOCK) - 1; 1638 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, ISO15693_READ_MULTIPLE_COMMAND, 1639 mbread, 1); 1640 } else if (ps_iso_15693_con->read_capabilities & ISO15693_CC_USE_IPR) { 1641 uint32_t page = 0; 1642 uint32_t pagesToRead = (remaining_size / ISO15693_BYTES_PER_BLOCK / 4) - 1; 1643 if ((remaining_size % (ISO15693_BYTES_PER_BLOCK * ISO15693_BLOCKS_PER_PAGE)) != 0) { 1644 pagesToRead++; 1645 } 1646 result = phFriNfc_ISO15693_H_Inventory_Page_Read (psNdefMap, ICODE_INVENTORY_PAGEREAD_COMMAND, 1647 page, pagesToRead); 1648 // Inventory 1649 } else { 1650 result = NFCSTATUS_FAILED; 1651 } 1652 return result; 1653 } 1654 1655 NFCSTATUS 1656 phFriNfc_ISO15693_WrNdef ( 1657 phFriNfc_NdefMap_t *psNdefMap, 1658 uint8_t *pPacketData, 1659 uint32_t *pPacketDataLength, 1660 uint8_t Offset) 1661 { 1662 NFCSTATUS result = NFCSTATUS_SUCCESS; 1663 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 1664 &(psNdefMap->ISO15693Container); 1665 uint8_t a_write_buf[ISO15693_BYTES_PER_BLOCK] = {0}; 1666 1667 /* Update the previous operation with current operation. 1668 This becomes the previous operation after this execution */ 1669 psNdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 1670 /* Update the CR index to know from which operation completion 1671 routine has to be called */ 1672 psNdefMap->ISO15693Container.cr_index = PH_FRINFC_NDEFMAP_CR_WR_NDEF; 1673 /* State update */ 1674 psNdefMap->State = ISO15693_WRITE_NDEF; 1675 /* Copy user buffer to the context */ 1676 psNdefMap->ApduBuffer = pPacketData; 1677 /* Copy user length to the context */ 1678 psNdefMap->ApduBufferSize = *pPacketDataLength; 1679 /* Update the user memory size to a context variable */ 1680 psNdefMap->NumOfBytesRead = pPacketDataLength; 1681 /* Number of bytes written to the card is zero. 1682 This variable returns the number of bytes written 1683 to the card. */ 1684 *psNdefMap->WrNdefPacketLength = 0; 1685 /* Index to know the length read */ 1686 psNdefMap->ApduBuffIndex = 0; 1687 /* Store the offset in the context */ 1688 psNdefMap->Offset = Offset; 1689 1690 /* Set the current block correctly to write the length field to 0 */ 1691 ps_iso_15693_con->current_block = 1692 ISO15693_GET_LEN_FIELD_BLOCK_NO( 1693 ps_iso_15693_con->ndef_tlv_type_blk, 1694 ps_iso_15693_con->ndef_tlv_type_byte, 1695 *pPacketDataLength); 1696 1697 if (ISO15693_GET_LEN_FIELD_BYTE_NO( 1698 ps_iso_15693_con->ndef_tlv_type_blk, 1699 ps_iso_15693_con->ndef_tlv_type_byte, 1700 *pPacketDataLength)) 1701 { 1702 /* Check the byte address to write. If length byte address is in between or 1703 is the last byte of the block, then READ before write 1704 reason, write should not corrupt other data 1705 */ 1706 ps_iso_15693_con->ndef_seq = (uint8_t)ISO15693_RD_BEFORE_WR_NDEF_L_0; 1707 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1708 ISO15693_READ_COMMAND, NULL, 0); 1709 } 1710 else 1711 { 1712 /* If length byte address is at the beginning of the block then WRITE 1713 length field to 0 and as also write user DATA */ 1714 ps_iso_15693_con->ndef_seq = (uint8_t)ISO15693_WRITE_DATA; 1715 1716 /* Length is made 0x00 */ 1717 *a_write_buf = 0x00; 1718 1719 /* Write remaining data */ 1720 (void)memcpy ((void *)(a_write_buf + 1), 1721 (void *)psNdefMap->ApduBuffer, 1722 (ISO15693_BYTES_PER_BLOCK - 1)); 1723 1724 /* Write data */ 1725 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1726 ISO15693_WRITE_COMMAND, 1727 a_write_buf, ISO15693_BYTES_PER_BLOCK); 1728 1729 /* Increment the index to keep track of bytes sent for write */ 1730 psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex 1731 + (ISO15693_BYTES_PER_BLOCK - 1)); 1732 } 1733 1734 return result; 1735 } 1736 1737 #ifdef FRINFC_READONLY_NDEF 1738 1739 NFCSTATUS 1740 phFriNfc_ISO15693_ConvertToReadOnly ( 1741 phFriNfc_NdefMap_t *psNdefMap) 1742 { 1743 NFCSTATUS result = NFCSTATUS_SUCCESS; 1744 phFriNfc_ISO15693Cont_t *ps_iso_15693_con = 1745 &(psNdefMap->ISO15693Container); 1746 1747 psNdefMap->State = ISO15693_READ_ONLY_NDEF; 1748 /* READ CC bytes */ 1749 ps_iso_15693_con->ndef_seq = (uint8_t)ISO15693_RD_BEFORE_WR_CC; 1750 ps_iso_15693_con->current_block = 0; 1751 1752 result = phFriNfc_ISO15693_H_ReadWrite (psNdefMap, 1753 ISO15693_READ_COMMAND, NULL, 0); 1754 1755 return result; 1756 } 1757 1758 #endif /* #ifdef FRINFC_READONLY_NDEF */ 1759 1760 1761 void 1762 phFriNfc_ISO15693_Process ( 1763 void *pContext, 1764 NFCSTATUS Status) 1765 { 1766 phFriNfc_NdefMap_t *psNdefMap = 1767 (phFriNfc_NdefMap_t *)pContext; 1768 1769 if ((NFCSTATUS_SUCCESS & PHNFCSTBLOWER) == (Status & PHNFCSTBLOWER)) 1770 { 1771 switch (psNdefMap->State) 1772 { 1773 case ISO15693_CHECK_NDEF: 1774 { 1775 /* State = CHECK NDEF in progress */ 1776 Status = phFriNfc_ISO15693_H_ProcessCheckNdef (psNdefMap); 1777 break; 1778 } 1779 1780 case ISO15693_READ_NDEF: 1781 { 1782 /* State = READ NDEF in progress */ 1783 Status = phFriNfc_ISO15693_H_ProcessReadNdef (psNdefMap); 1784 break; 1785 } 1786 1787 case ISO15693_WRITE_NDEF: 1788 { 1789 /* State = WRITE NDEF in progress */ 1790 Status = phFriNfc_ISO15693_H_ProcessWriteNdef (psNdefMap); 1791 break; 1792 } 1793 1794 #ifdef FRINFC_READONLY_NDEF 1795 case ISO15693_READ_ONLY_NDEF: 1796 { 1797 /* State = RAD ONLY NDEF in progress */ 1798 Status = phFriNfc_ISO15693_H_ProcessReadOnly (psNdefMap); 1799 break; 1800 } 1801 #endif /* #ifdef FRINFC_READONLY_NDEF */ 1802 1803 default: 1804 { 1805 break; 1806 } 1807 } 1808 } 1809 1810 /* Call for the Completion Routine*/ 1811 if (NFCSTATUS_PENDING != Status) 1812 { 1813 phFriNfc_ISO15693_H_Complete(psNdefMap, Status); 1814 } 1815 } 1816 1817 /************************** END external functions *********************/ 1818 1819 #endif /* #ifndef PH_FRINFC_MAP_ISO15693_DISABLED */ 1820
