1 /****************************************************************************** 2 * 3 * Copyright (C) 2010-2013 Broadcom Corporation 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 20 /****************************************************************************** 21 * 22 * NFA interface for tag Reader/Writer 23 * 24 ******************************************************************************/ 25 #include <string.h> 26 #include "nfa_api.h" 27 #include "nfa_sys.h" 28 #include "nfa_rw_int.h" 29 #include "nfa_sys_int.h" 30 31 /***************************************************************************** 32 ** Constants 33 *****************************************************************************/ 34 35 36 /***************************************************************************** 37 ** APIs 38 *****************************************************************************/ 39 40 /******************************************************************************* 41 ** 42 ** Function NFA_RwDetectNDef 43 ** 44 ** Description Perform the NDEF detection procedure using the appropriate 45 ** method for the currently activated tag. 46 ** 47 ** Upon successful completion of NDEF detection, a 48 ** NFA_NDEF_DETECT_EVT will be sent, to notify the application 49 ** of the NDEF attributes (NDEF total memory size, current 50 ** size, etc.). 51 ** 52 ** It is not mandatory to call this function - NFA_RwReadNDef 53 ** and NFA_RwWriteNDef will perform NDEF detection internally if 54 ** not performed already. This API may be called to get a 55 ** tag's NDEF size before issuing a write-request. 56 ** 57 ** Returns: 58 ** NFA_STATUS_OK if successfully initiated 59 ** NFC_STATUS_REFUSED if tag does not support NDEF 60 ** NFA_STATUS_FAILED otherwise 61 ** 62 *******************************************************************************/ 63 tNFA_STATUS NFA_RwDetectNDef (void) 64 { 65 tNFA_RW_OPERATION *p_msg; 66 67 NFA_TRACE_API0 ("NFA_RwDetectNDef"); 68 69 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 70 { 71 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 72 p_msg->op = NFA_RW_OP_DETECT_NDEF; 73 74 nfa_sys_sendmsg (p_msg); 75 76 return (NFA_STATUS_OK); 77 } 78 79 return (NFA_STATUS_FAILED); 80 } 81 82 /******************************************************************************* 83 ** 84 ** Function NFA_RwReadNDef 85 ** 86 ** Description Read NDEF message from tag. This function will internally 87 ** perform the NDEF detection procedure (if not performed 88 ** previously), and read the NDEF tag data using the 89 ** appropriate method for the currently activated tag. 90 ** 91 ** Upon successful completion of NDEF detection (if performed), 92 ** a NFA_NDEF_DETECT_EVT will be sent, to notify the application 93 ** of the NDEF attributes (NDEF total memory size, current size, 94 ** etc.). 95 ** 96 ** Upon receiving the NDEF message, the message will be sent to 97 ** the handler registered with NFA_RegisterNDefTypeHandler or 98 ** NFA_RequestExclusiveRfControl (if exclusive RF mode is active) 99 ** 100 ** Returns: 101 ** NFA_STATUS_OK if successfully initiated 102 ** NFC_STATUS_REFUSED if tag does not support NDEF 103 ** NFC_STATUS_NOT_INITIALIZED if NULL NDEF was detected on the tag 104 ** NFA_STATUS_FAILED otherwise 105 ** 106 *******************************************************************************/ 107 tNFA_STATUS NFA_RwReadNDef (void) 108 { 109 tNFA_RW_OPERATION *p_msg; 110 111 NFA_TRACE_API0 ("NFA_RwReadNDef"); 112 113 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 114 { 115 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 116 p_msg->op = NFA_RW_OP_READ_NDEF; 117 118 nfa_sys_sendmsg (p_msg); 119 120 return (NFA_STATUS_OK); 121 } 122 123 return (NFA_STATUS_FAILED); 124 } 125 126 127 128 /******************************************************************************* 129 ** 130 ** Function NFA_RwWriteNDef 131 ** 132 ** Description Write NDEF data to the activated tag. This function will 133 ** internally perform NDEF detection if necessary, and write 134 ** the NDEF tag data using the appropriate method for the 135 ** currently activated tag. 136 ** 137 ** When the entire message has been written, or if an error 138 ** occurs, the app will be notified with NFA_WRITE_CPLT_EVT. 139 ** 140 ** p_data needs to be persistent until NFA_WRITE_CPLT_EVT 141 ** 142 ** 143 ** Returns: 144 ** NFA_STATUS_OK if successfully initiated 145 ** NFC_STATUS_REFUSED if tag does not support NDEF/locked 146 ** NFA_STATUS_FAILED otherwise 147 ** 148 *******************************************************************************/ 149 tNFA_STATUS NFA_RwWriteNDef (UINT8 *p_data, UINT32 len) 150 { 151 tNFA_RW_OPERATION *p_msg; 152 153 NFA_TRACE_API2 ("NFA_RwWriteNDef (): ndef p_data=%08x, len: %i", p_data, len); 154 155 /* Validate parameters */ 156 if (p_data == NULL) 157 return (NFA_STATUS_INVALID_PARAM); 158 159 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 160 { 161 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 162 p_msg->op = NFA_RW_OP_WRITE_NDEF; 163 p_msg->params.write_ndef.len = len; 164 p_msg->params.write_ndef.p_data = p_data; 165 nfa_sys_sendmsg (p_msg); 166 167 return (NFA_STATUS_OK); 168 } 169 170 return (NFA_STATUS_FAILED); 171 } 172 173 /***************************************************************************** 174 ** 175 ** Function NFA_RwPresenceCheck 176 ** 177 ** Description Check if the tag is still in the field. 178 ** 179 ** The NFA_RW_PRESENCE_CHECK_EVT w/ status is used to 180 ** indicate presence or non-presence. 181 ** 182 ** Returns 183 ** NFA_STATUS_OK if successfully initiated 184 ** NFA_STATUS_FAILED otherwise 185 ** 186 *****************************************************************************/ 187 tNFA_STATUS NFA_RwPresenceCheck (void) 188 { 189 tNFA_RW_OPERATION *p_msg; 190 191 NFA_TRACE_API0 ("NFA_RwPresenceCheck"); 192 193 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 194 { 195 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 196 p_msg->op = NFA_RW_OP_PRESENCE_CHECK; 197 198 nfa_sys_sendmsg (p_msg); 199 200 return (NFA_STATUS_OK); 201 } 202 203 return (NFA_STATUS_FAILED); 204 } 205 206 /***************************************************************************** 207 ** 208 ** Function NFA_RwFormatTag 209 ** 210 ** Description Check if the tag is NDEF Formatable. If yes Format the tag 211 ** 212 ** The NFA_RW_FORMAT_CPLT_EVT w/ status is used to 213 ** indicate if tag is successfully formated or not 214 ** 215 ** Returns 216 ** NFA_STATUS_OK if successfully initiated 217 ** NFA_STATUS_FAILED otherwise 218 ** 219 *****************************************************************************/ 220 tNFA_STATUS NFA_RwFormatTag (void) 221 { 222 tNFA_RW_OPERATION *p_msg; 223 224 NFA_TRACE_API0 ("NFA_RwFormatTag"); 225 226 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16)(sizeof (tNFA_RW_OPERATION)))) != NULL) 227 { 228 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 229 p_msg->op = NFA_RW_OP_FORMAT_TAG; 230 231 nfa_sys_sendmsg (p_msg); 232 233 return (NFA_STATUS_OK); 234 } 235 236 return (NFA_STATUS_FAILED); 237 } 238 239 /******************************************************************************* 240 ** 241 ** Function NFA_RwSetTagReadOnly 242 ** 243 ** Description: 244 ** Sets tag as read only. 245 ** 246 ** When tag is set as read only, or if an error occurs, the app will be 247 ** notified with NFA_SET_TAG_RO_EVT. 248 ** 249 ** Returns: 250 ** NFA_STATUS_OK if successfully initiated 251 ** NFA_STATUS_REJECTED if protocol is not T1/T2/ISO15693 252 ** (or) if hard lock is not requested for protocol ISO15693 253 ** NFA_STATUS_FAILED otherwise 254 ** 255 *******************************************************************************/ 256 tNFA_STATUS NFA_RwSetTagReadOnly (BOOLEAN b_hard_lock) 257 { 258 tNFA_RW_OPERATION *p_msg; 259 tNFC_PROTOCOL protocol = nfa_rw_cb.protocol; 260 261 if ((protocol != NFC_PROTOCOL_T1T) && (protocol != NFC_PROTOCOL_T2T) && (protocol != NFC_PROTOCOL_15693) && (protocol != NFC_PROTOCOL_ISO_DEP) && (protocol != NFC_PROTOCOL_T3T)) 262 { 263 NFA_TRACE_API1 ("NFA_RwSetTagReadOnly (): Cannot Configure as read only for Protocol: %d", protocol); 264 return (NFA_STATUS_REJECTED); 265 } 266 267 if ( (!b_hard_lock && (protocol == NFC_PROTOCOL_15693)) 268 ||(b_hard_lock && (protocol == NFC_PROTOCOL_ISO_DEP)) ) 269 { 270 NFA_TRACE_API2 ("NFA_RwSetTagReadOnly (): Cannot %s for Protocol: %d", b_hard_lock ? "Hard lock" : "Soft lock", protocol); 271 return (NFA_STATUS_REJECTED); 272 } 273 274 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 275 { 276 /* Fill in tNFA_RW_OPERATION struct */ 277 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 278 p_msg->op = NFA_RW_OP_SET_TAG_RO; 279 p_msg->params.set_readonly.b_hard_lock = b_hard_lock; 280 281 nfa_sys_sendmsg (p_msg); 282 return (NFA_STATUS_OK); 283 } 284 return (NFA_STATUS_FAILED); 285 } 286 287 /******************************************************************************* 288 ** Tag specific APIs 289 ** (note: for Type-4 tags, use NFA_SendRawFrame to exchange APDUs) 290 *******************************************************************************/ 291 292 /******************************************************************************* 293 ** 294 ** Function NFA_RwLocateTlv 295 ** 296 ** Description: 297 ** Search for the Lock/Memory contril TLV on the activated Type1/Type2 tag 298 ** 299 ** Data is returned to the application using the NFA_TLV_DETECT_EVT. When 300 ** search operation has completed, or if an error occurs, the app will be 301 ** notified with NFA_TLV_DETECT_EVT. 302 ** 303 ** Description Perform the TLV detection procedure using the appropriate 304 ** method for the currently activated tag. 305 ** 306 ** Upon successful completion of TLV detection in T1/T2 tag, a 307 ** NFA_TLV_DETECT_EVT will be sent, to notify the application 308 ** of the TLV attributes (total lock/reserved bytes etc.). 309 ** However if the TLV type specified is NDEF then it is same as 310 ** calling NFA_RwDetectNDef and should expect to receive 311 ** NFA_NDEF_DETECT_EVT instead of NFA_TLV_DETECT_EVT 312 ** 313 ** It is not mandatory to call this function - NFA_RwDetectNDef, 314 ** NFA_RwReadNDef and NFA_RwWriteNDef will perform TLV detection 315 ** internally if not performed already. An application may call 316 ** this API to check the a tag/card-emulator's total Reserved/ 317 ** Lock bytes before issuing a write-request. 318 ** 319 ** Returns: 320 ** NFA_STATUS_OK if successfully initiated 321 ** NFC_STATUS_REFUSED if tlv_type is NDEF & tag won't support NDEF 322 ** NFA_STATUS_FAILED otherwise 323 ** 324 *******************************************************************************/ 325 tNFA_STATUS NFA_RwLocateTlv (UINT8 tlv_type) 326 { 327 tNFA_RW_OPERATION *p_msg; 328 329 NFA_TRACE_API0 ("NFA_RwLocateTlv"); 330 331 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 332 { 333 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 334 335 if (tlv_type == TAG_LOCK_CTRL_TLV) 336 { 337 p_msg->op = NFA_RW_OP_DETECT_LOCK_TLV; 338 } 339 else if (tlv_type == TAG_MEM_CTRL_TLV) 340 { 341 p_msg->op = NFA_RW_OP_DETECT_MEM_TLV; 342 } 343 else if (tlv_type == TAG_NDEF_TLV) 344 { 345 p_msg->op = NFA_RW_OP_DETECT_NDEF; 346 } 347 else 348 return (NFA_STATUS_FAILED); 349 350 nfa_sys_sendmsg (p_msg); 351 352 return (NFA_STATUS_OK); 353 } 354 355 return (NFA_STATUS_FAILED); 356 } 357 358 /******************************************************************************* 359 ** 360 ** Function NFA_RwT1tRid 361 ** 362 ** Description: 363 ** Send a RID command to the activated Type 1 tag. 364 ** 365 ** Data is returned to the application using the NFA_DATA_EVT. When the read 366 ** operation has completed, or if an error occurs, the app will be notified with 367 ** NFA_READ_CPLT_EVT. 368 ** 369 ** Returns: 370 ** NFA_STATUS_OK if successfully initiated 371 ** NFA_STATUS_FAILED otherwise 372 ** 373 *******************************************************************************/ 374 tNFA_STATUS NFA_RwT1tRid (void) 375 { 376 tNFA_RW_OPERATION *p_msg; 377 378 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 379 { 380 /* Fill in tNFA_RW_OPERATION struct */ 381 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 382 p_msg->op = NFA_RW_OP_T1T_RID; 383 384 nfa_sys_sendmsg (p_msg); 385 return (NFA_STATUS_OK); 386 } 387 return (NFA_STATUS_FAILED); 388 } 389 390 /******************************************************************************* 391 ** 392 ** Function NFA_RwT1tReadAll 393 ** 394 ** Description: 395 ** Send a RALL command to the activated Type 1 tag. 396 ** 397 ** Data is returned to the application using the NFA_DATA_EVT. When the read 398 ** operation has completed, or if an error occurs, the app will be notified with 399 ** NFA_READ_CPLT_EVT. 400 ** 401 ** Returns: 402 ** NFA_STATUS_OK if successfully initiated 403 ** NFA_STATUS_FAILED otherwise 404 ** 405 *******************************************************************************/ 406 tNFA_STATUS NFA_RwT1tReadAll (void) 407 { 408 tNFA_RW_OPERATION *p_msg; 409 410 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 411 { 412 /* Fill in tNFA_RW_OPERATION struct */ 413 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 414 p_msg->op = NFA_RW_OP_T1T_RALL; 415 416 nfa_sys_sendmsg (p_msg); 417 return (NFA_STATUS_OK); 418 } 419 return (NFA_STATUS_FAILED); 420 } 421 422 /******************************************************************************* 423 ** 424 ** Function NFA_RwT1tRead 425 ** 426 ** Description: 427 ** Send a READ command to the activated Type 1 tag. 428 ** 429 ** Data is returned to the application using the NFA_DATA_EVT. When the read 430 ** operation has completed, or if an error occurs, the app will be notified with 431 ** NFA_READ_CPLT_EVT. 432 ** 433 ** Returns: 434 ** NFA_STATUS_OK if successfully initiated 435 ** NFA_STATUS_FAILED otherwise 436 ** 437 *******************************************************************************/ 438 tNFA_STATUS NFA_RwT1tRead (UINT8 block_number, UINT8 index) 439 { 440 tNFA_RW_OPERATION *p_msg; 441 442 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 443 { 444 /* Fill in tNFA_RW_OPERATION struct */ 445 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 446 p_msg->op = NFA_RW_OP_T1T_READ; 447 p_msg->params.t1t_read.block_number = block_number; 448 p_msg->params.t1t_read.index = index; 449 450 nfa_sys_sendmsg (p_msg); 451 return (NFA_STATUS_OK); 452 } 453 return (NFA_STATUS_FAILED); 454 } 455 456 /******************************************************************************* 457 ** 458 ** Function NFA_RwT1tWrite 459 ** 460 ** Description: 461 ** Send a WRITE command to the activated Type 1 tag. 462 ** 463 ** Data is returned to the application using the NFA_DATA_EVT. When the write 464 ** operation has completed, or if an error occurs, the app will be notified with 465 ** NFA_WRITE_CPLT_EVT. 466 ** 467 ** Returns: 468 ** NFA_STATUS_OK if successfully initiated 469 ** NFA_STATUS_FAILED otherwise 470 ** 471 *******************************************************************************/ 472 tNFA_STATUS NFA_RwT1tWrite (UINT8 block_number, UINT8 index, UINT8 data, BOOLEAN b_erase) 473 { 474 tNFA_RW_OPERATION *p_msg; 475 476 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 477 { 478 /* Fill in tNFA_RW_OPERATION struct */ 479 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 480 p_msg->params.t1t_write.b_erase = b_erase; 481 p_msg->op = NFA_RW_OP_T1T_WRITE; 482 p_msg->params.t1t_write.block_number = block_number; 483 p_msg->params.t1t_write.index = index; 484 p_msg->params.t1t_write.p_block_data[0] = data; 485 486 nfa_sys_sendmsg (p_msg); 487 return (NFA_STATUS_OK); 488 } 489 return (NFA_STATUS_FAILED); 490 } 491 492 /******************************************************************************* 493 ** 494 ** Function NFA_RwT1tReadSeg 495 ** 496 ** Description: 497 ** Send a RSEG command to the activated Type 1 tag. 498 ** 499 ** Data is returned to the application using the NFA_DATA_EVT. When the read 500 ** operation has completed, or if an error occurs, the app will be notified with 501 ** NFA_READ_CPLT_EVT. 502 ** 503 ** Returns: 504 ** NFA_STATUS_OK if successfully initiated 505 ** NFA_STATUS_FAILED otherwise 506 ** 507 *******************************************************************************/ 508 tNFA_STATUS NFA_RwT1tReadSeg (UINT8 segment_number) 509 { 510 tNFA_RW_OPERATION *p_msg; 511 512 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 513 { 514 /* Fill in tNFA_RW_OPERATION struct */ 515 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 516 p_msg->op = NFA_RW_OP_T1T_RSEG; 517 p_msg->params.t1t_read.segment_number = segment_number; 518 519 nfa_sys_sendmsg (p_msg); 520 return (NFA_STATUS_OK); 521 } 522 return (NFA_STATUS_FAILED); 523 } 524 525 /******************************************************************************* 526 ** 527 ** Function NFA_RwT1tRead8 528 ** 529 ** Description: 530 ** Send a READ8 command to the activated Type 1 tag. 531 ** 532 ** Data is returned to the application using the NFA_DATA_EVT. When the read 533 ** operation has completed, or if an error occurs, the app will be notified with 534 ** NFA_READ_CPLT_EVT. 535 ** 536 ** Returns: 537 ** NFA_STATUS_OK if successfully initiated 538 ** NFA_STATUS_FAILED otherwise 539 ** 540 *******************************************************************************/ 541 tNFA_STATUS NFA_RwT1tRead8 (UINT8 block_number) 542 { 543 tNFA_RW_OPERATION *p_msg; 544 545 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 546 { 547 /* Fill in tNFA_RW_OPERATION struct */ 548 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 549 p_msg->op = NFA_RW_OP_T1T_READ8; 550 p_msg->params.t1t_write.block_number = block_number; 551 552 nfa_sys_sendmsg (p_msg); 553 return (NFA_STATUS_OK); 554 } 555 return (NFA_STATUS_FAILED); 556 } 557 558 /******************************************************************************* 559 ** 560 ** Function NFA_RwT1tWrite8 561 ** 562 ** Description: 563 ** Send a WRITE8_E / WRITE8_NE command to the activated Type 1 tag. 564 ** 565 ** Data is returned to the application using the NFA_DATA_EVT. When the read 566 ** operation has completed, or if an error occurs, the app will be notified with 567 ** NFA_READ_CPLT_EVT. 568 ** 569 ** Returns: 570 ** NFA_STATUS_OK if successfully initiated 571 ** NFA_STATUS_FAILED otherwise 572 ** 573 *******************************************************************************/ 574 tNFA_STATUS NFA_RwT1tWrite8 (UINT8 block_number, UINT8 *p_data, BOOLEAN b_erase) 575 { 576 tNFA_RW_OPERATION *p_msg; 577 578 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 579 { 580 /* Fill in tNFA_RW_OPERATION struct */ 581 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 582 p_msg->params.t1t_write.b_erase = b_erase; 583 p_msg->op = NFA_RW_OP_T1T_WRITE8; 584 p_msg->params.t1t_write.block_number = block_number; 585 586 memcpy (p_msg->params.t1t_write.p_block_data,p_data,8); 587 588 nfa_sys_sendmsg (p_msg); 589 return (NFA_STATUS_OK); 590 } 591 return (NFA_STATUS_FAILED); 592 } 593 594 /******************************************************************************* 595 ** 596 ** Function NFA_RwT2tRead 597 ** 598 ** Description: 599 ** Send a READ command to the activated Type 2 tag. 600 ** 601 ** Data is returned to the application using the NFA_DATA_EVT. When the read 602 ** operation has completed, or if an error occurs, the app will be notified with 603 ** NFA_READ_CPLT_EVT. 604 ** 605 ** Returns: 606 ** NFA_STATUS_OK if successfully initiated 607 ** NFA_STATUS_FAILED otherwise 608 ** 609 *******************************************************************************/ 610 tNFA_STATUS NFA_RwT2tRead (UINT8 block_number) 611 { 612 tNFA_RW_OPERATION *p_msg; 613 614 NFA_TRACE_API1 ("NFA_RwT2tRead (): Block to read: %d", block_number); 615 616 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 617 { 618 /* Fill in tNFA_RW_OPERATION struct */ 619 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 620 p_msg->op = NFA_RW_OP_T2T_READ; 621 p_msg->params.t2t_read.block_number = block_number; 622 623 nfa_sys_sendmsg (p_msg); 624 return (NFA_STATUS_OK); 625 } 626 return (NFA_STATUS_FAILED); 627 } 628 629 /******************************************************************************* 630 ** 631 ** Function NFA_RwT2tWrite 632 ** 633 ** Description: 634 ** Send an WRITE command to the activated Type 2 tag. 635 ** 636 ** When the write operation has completed (or if an error occurs), the 637 ** app will be notified with NFA_WRITE_CPLT_EVT. 638 ** 639 ** Returns: 640 ** NFA_STATUS_OK if successfully initiated 641 ** NFA_STATUS_FAILED otherwise 642 ** 643 *******************************************************************************/ 644 tNFA_STATUS NFA_RwT2tWrite (UINT8 block_number, UINT8 *p_data) 645 { 646 tNFA_RW_OPERATION *p_msg; 647 648 NFA_TRACE_API1 ("NFA_RwT2tWrite (): Block to write: %d", block_number); 649 650 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 651 { 652 /* Fill in tNFA_RW_OPERATION struct */ 653 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 654 p_msg->op = NFA_RW_OP_T2T_WRITE; 655 656 p_msg->params.t2t_write.block_number = block_number; 657 658 memcpy (p_msg->params.t2t_write.p_block_data,p_data,4); 659 660 nfa_sys_sendmsg (p_msg); 661 return (NFA_STATUS_OK); 662 } 663 return (NFA_STATUS_FAILED); 664 } 665 666 /******************************************************************************* 667 ** 668 ** Function NFA_RwT2tSectorSelect 669 ** 670 ** Description: 671 ** Send SECTOR SELECT command to the activated Type 2 tag. 672 ** 673 ** When the sector select operation has completed (or if an error occurs), the 674 ** app will be notified with NFA_SECTOR_SELECT_CPLT_EVT. 675 ** 676 ** Returns: 677 ** NFA_STATUS_OK if successfully initiated 678 ** NFA_STATUS_FAILED otherwise 679 ** 680 *******************************************************************************/ 681 tNFA_STATUS NFA_RwT2tSectorSelect (UINT8 sector_number) 682 { 683 tNFA_RW_OPERATION *p_msg; 684 685 NFA_TRACE_API1 ("NFA_RwT2tRead (): sector to select: %d", sector_number); 686 687 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 688 { 689 /* Fill in tNFA_RW_OPERATION struct */ 690 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 691 p_msg->op = NFA_RW_OP_T2T_SECTOR_SELECT; 692 693 p_msg->params.t2t_sector_select.sector_number = sector_number; 694 695 nfa_sys_sendmsg (p_msg); 696 return (NFA_STATUS_OK); 697 } 698 return (NFA_STATUS_FAILED); 699 } 700 701 /******************************************************************************* 702 ** 703 ** Function NFA_RwT3tRead 704 ** 705 ** Description: 706 ** Send a CHECK (read) command to the activated Type 3 tag. 707 ** 708 ** Data is returned to the application using the NFA_DATA_EVT. When the read 709 ** operation has completed, or if an error occurs, the app will be notified with 710 ** NFA_READ_CPLT_EVT. 711 ** 712 ** Returns: 713 ** NFA_STATUS_OK if successfully initiated 714 ** NFA_STATUS_FAILED otherwise 715 ** 716 *******************************************************************************/ 717 tNFA_STATUS NFA_RwT3tRead (UINT8 num_blocks, tNFA_T3T_BLOCK_DESC *t3t_blocks) 718 { 719 tNFA_RW_OPERATION *p_msg; 720 UINT8 *p_block_desc; 721 722 NFA_TRACE_API1 ("NFA_RwT3tRead (): num_blocks to read: %i", num_blocks); 723 724 /* Validate parameters */ 725 if ((num_blocks == 0) || (t3t_blocks == NULL)) 726 return (NFA_STATUS_INVALID_PARAM); 727 728 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC))))) != NULL) 729 { 730 /* point to area after tNFA_RW_OPERATION */ 731 p_block_desc = (UINT8 *) (p_msg+1); 732 733 /* Fill in tNFA_RW_OPERATION struct */ 734 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 735 p_msg->op = NFA_RW_OP_T3T_READ; 736 737 p_msg->params.t3t_read.num_blocks = num_blocks; 738 p_msg->params.t3t_read.p_block_desc = (tNFA_T3T_BLOCK_DESC *) p_block_desc; 739 740 /* Copy block descriptor list */ 741 memcpy (p_block_desc, t3t_blocks, (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC))); 742 743 nfa_sys_sendmsg (p_msg); 744 745 return (NFA_STATUS_OK); 746 } 747 748 return (NFA_STATUS_FAILED); 749 } 750 751 /******************************************************************************* 752 ** 753 ** Function NFA_RwT3tWrite 754 ** 755 ** Description: 756 ** Send an UPDATE (write) command to the activated Type 3 tag. 757 ** 758 ** When the write operation has completed (or if an error occurs), the 759 ** app will be notified with NFA_WRITE_CPLT_EVT. 760 ** 761 ** Returns: 762 ** NFA_STATUS_OK if successfully initiated 763 ** NFA_STATUS_FAILED otherwise 764 ** 765 *******************************************************************************/ 766 tNFA_STATUS NFA_RwT3tWrite (UINT8 num_blocks, tNFA_T3T_BLOCK_DESC *t3t_blocks, UINT8 *p_data) 767 { 768 tNFA_RW_OPERATION *p_msg; 769 UINT8 *p_block_desc, *p_data_area; 770 771 NFA_TRACE_API1 ("NFA_RwT3tWrite (): num_blocks to write: %i", num_blocks); 772 773 /* Validate parameters */ 774 if ((num_blocks == 0) || (t3t_blocks == NULL) | (p_data == NULL)) 775 return (NFA_STATUS_INVALID_PARAM); 776 777 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + (num_blocks * (sizeof (tNFA_T3T_BLOCK_DESC) + 16))))) != NULL) 778 { 779 /* point to block descriptor and data areas after tNFA_RW_OPERATION */ 780 p_block_desc = (UINT8 *) (p_msg+1); 781 p_data_area = p_block_desc + (num_blocks * (sizeof (tNFA_T3T_BLOCK_DESC))); 782 783 /* Fill in tNFA_RW_OPERATION struct */ 784 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 785 p_msg->op = NFA_RW_OP_T3T_WRITE; 786 787 p_msg->params.t3t_write.num_blocks = num_blocks; 788 p_msg->params.t3t_write.p_block_desc = (tNFA_T3T_BLOCK_DESC *) p_block_desc; 789 p_msg->params.t3t_write.p_block_data = p_data_area; 790 791 /* Copy block descriptor list */ 792 memcpy (p_block_desc, t3t_blocks, (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC))); 793 794 /* Copy data */ 795 memcpy (p_data_area, p_data, (num_blocks * 16)); 796 797 nfa_sys_sendmsg (p_msg); 798 799 return (NFA_STATUS_OK); 800 } 801 802 return (NFA_STATUS_FAILED); 803 } 804 805 /******************************************************************************* 806 ** 807 ** Function NFA_RwI93Inventory 808 ** 809 ** Description: 810 ** Send Inventory command to the activated ISO 15693 tag with/without AFI 811 ** If UID is provided then set UID[0]:MSB, ... UID[7]:LSB 812 ** 813 ** When the operation has completed (or if an error occurs), the 814 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 815 ** 816 ** Returns: 817 ** NFA_STATUS_OK if successfully initiated 818 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 819 ** NFA_STATUS_FAILED otherwise 820 ** 821 *******************************************************************************/ 822 tNFA_STATUS NFA_RwI93Inventory (BOOLEAN afi_present, UINT8 afi, UINT8 *p_uid) 823 { 824 tNFA_RW_OPERATION *p_msg; 825 826 NFA_TRACE_API2 ("NFA_RwI93Inventory (): afi_present:%d, AFI: 0x%02X", afi_present, afi); 827 828 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 829 { 830 return (NFA_STATUS_WRONG_PROTOCOL); 831 } 832 833 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 834 { 835 /* Fill in tNFA_RW_OPERATION struct */ 836 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 837 p_msg->op = NFA_RW_OP_I93_INVENTORY; 838 839 p_msg->params.i93_cmd.afi_present = afi_present; 840 p_msg->params.i93_cmd.afi = afi; 841 842 if (p_uid) 843 { 844 p_msg->params.i93_cmd.uid_present = TRUE; 845 memcpy (p_msg->params.i93_cmd.uid, p_uid, I93_UID_BYTE_LEN); 846 } 847 else 848 { 849 p_msg->params.i93_cmd.uid_present = FALSE; 850 } 851 852 nfa_sys_sendmsg (p_msg); 853 854 return (NFA_STATUS_OK); 855 } 856 857 return (NFA_STATUS_FAILED); 858 } 859 860 /******************************************************************************* 861 ** 862 ** Function NFA_RwI93StayQuiet 863 ** 864 ** Description: 865 ** Send Stay Quiet command to the activated ISO 15693 tag. 866 ** 867 ** When the operation has completed (or if an error occurs), the 868 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 869 ** 870 ** Returns: 871 ** NFA_STATUS_OK if successfully initiated 872 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 873 ** NFA_STATUS_FAILED otherwise 874 ** 875 *******************************************************************************/ 876 tNFA_STATUS NFA_RwI93StayQuiet (void) 877 { 878 tNFA_RW_OPERATION *p_msg; 879 880 NFA_TRACE_API0 ("NFA_RwI93StayQuiet ()"); 881 882 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 883 { 884 return (NFA_STATUS_WRONG_PROTOCOL); 885 } 886 887 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 888 { 889 /* Fill in tNFA_RW_OPERATION struct */ 890 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 891 p_msg->op = NFA_RW_OP_I93_STAY_QUIET; 892 893 nfa_sys_sendmsg (p_msg); 894 895 return (NFA_STATUS_OK); 896 } 897 898 return (NFA_STATUS_FAILED); 899 } 900 901 /******************************************************************************* 902 ** 903 ** Function NFA_RwI93ReadSingleBlock 904 ** 905 ** Description: 906 ** Send Read Single Block command to the activated ISO 15693 tag. 907 ** 908 ** Data is returned to the application using the NFA_DATA_EVT. When the read 909 ** operation has completed, or if an error occurs, the app will be notified with 910 ** NFA_I93_CMD_CPLT_EVT. 911 ** 912 ** Returns: 913 ** NFA_STATUS_OK if successfully initiated 914 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 915 ** NFA_STATUS_FAILED otherwise 916 ** 917 *******************************************************************************/ 918 tNFA_STATUS NFA_RwI93ReadSingleBlock (UINT8 block_number) 919 { 920 tNFA_RW_OPERATION *p_msg; 921 922 NFA_TRACE_API1 ("NFA_RwI93ReadSingleBlock (): block_number: 0x%02X", block_number); 923 924 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 925 { 926 return (NFA_STATUS_WRONG_PROTOCOL); 927 } 928 929 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 930 { 931 /* Fill in tNFA_RW_OPERATION struct */ 932 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 933 p_msg->op = NFA_RW_OP_I93_READ_SINGLE_BLOCK; 934 935 p_msg->params.i93_cmd.first_block_number = block_number; 936 937 nfa_sys_sendmsg (p_msg); 938 939 return (NFA_STATUS_OK); 940 } 941 942 return (NFA_STATUS_FAILED); 943 } 944 945 /******************************************************************************* 946 ** 947 ** Function NFA_RwI93WriteSingleBlock 948 ** 949 ** Description: 950 ** Send Write Single Block command to the activated ISO 15693 tag. 951 ** 952 ** When the write operation has completed (or if an error occurs), the 953 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 954 ** 955 ** Returns: 956 ** NFA_STATUS_OK if successfully initiated 957 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 958 ** NFA_STATUS_FAILED otherwise 959 ** 960 *******************************************************************************/ 961 tNFA_STATUS NFA_RwI93WriteSingleBlock (UINT8 block_number, 962 UINT8 *p_data) 963 { 964 tNFA_RW_OPERATION *p_msg; 965 966 NFA_TRACE_API1 ("NFA_RwI93WriteSingleBlock (): block_number: 0x%02X", block_number); 967 968 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 969 { 970 return (NFA_STATUS_WRONG_PROTOCOL); 971 } 972 973 /* we don't know block size of tag */ 974 if ( (nfa_rw_cb.i93_block_size == 0) 975 ||(nfa_rw_cb.i93_num_block == 0) ) 976 { 977 return (NFA_STATUS_FAILED); 978 } 979 980 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + nfa_rw_cb.i93_block_size))) != NULL) 981 { 982 /* Fill in tNFA_RW_OPERATION struct */ 983 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 984 p_msg->op = NFA_RW_OP_I93_WRITE_SINGLE_BLOCK; 985 986 p_msg->params.i93_cmd.first_block_number = block_number; 987 p_msg->params.i93_cmd.p_data = (UINT8*) (p_msg + 1); 988 989 memcpy (p_msg->params.i93_cmd.p_data, p_data, nfa_rw_cb.i93_block_size); 990 991 nfa_sys_sendmsg (p_msg); 992 993 return (NFA_STATUS_OK); 994 } 995 996 return (NFA_STATUS_FAILED); 997 } 998 999 /******************************************************************************* 1000 ** 1001 ** Function NFA_RwI93LockBlock 1002 ** 1003 ** Description: 1004 ** Send Lock block command to the activated ISO 15693 tag. 1005 ** 1006 ** When the operation has completed (or if an error occurs), the 1007 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1008 ** 1009 ** Returns: 1010 ** NFA_STATUS_OK if successfully initiated 1011 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1012 ** NFA_STATUS_FAILED otherwise 1013 ** 1014 *******************************************************************************/ 1015 tNFA_STATUS NFA_RwI93LockBlock (UINT8 block_number) 1016 { 1017 tNFA_RW_OPERATION *p_msg; 1018 1019 NFA_TRACE_API1 ("NFA_RwI93LockBlock (): block_number: 0x%02X", block_number); 1020 1021 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1022 { 1023 return (NFA_STATUS_WRONG_PROTOCOL); 1024 } 1025 1026 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1027 { 1028 /* Fill in tNFA_RW_OPERATION struct */ 1029 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1030 p_msg->op = NFA_RW_OP_I93_LOCK_BLOCK; 1031 1032 p_msg->params.i93_cmd.first_block_number = block_number; 1033 1034 nfa_sys_sendmsg (p_msg); 1035 1036 return (NFA_STATUS_OK); 1037 } 1038 1039 return (NFA_STATUS_FAILED); 1040 } 1041 1042 /******************************************************************************* 1043 ** 1044 ** Function NFA_RwI93ReadMultipleBlocks 1045 ** 1046 ** Description: 1047 ** Send Read Multiple Block command to the activated ISO 15693 tag. 1048 ** 1049 ** Data is returned to the application using the NFA_DATA_EVT. When the read 1050 ** operation has completed, or if an error occurs, the app will be notified with 1051 ** NFA_I93_CMD_CPLT_EVT. 1052 ** 1053 ** Returns: 1054 ** NFA_STATUS_OK if successfully initiated 1055 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1056 ** NFA_STATUS_FAILED otherwise 1057 ** 1058 *******************************************************************************/ 1059 tNFA_STATUS NFA_RwI93ReadMultipleBlocks (UINT8 first_block_number, 1060 UINT16 number_blocks) 1061 { 1062 tNFA_RW_OPERATION *p_msg; 1063 1064 NFA_TRACE_API2 ("NFA_RwI93ReadMultipleBlocks(): %d, %d", first_block_number, number_blocks); 1065 1066 if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1067 { 1068 return (NFA_STATUS_WRONG_PROTOCOL); 1069 } 1070 1071 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1072 { 1073 /* Fill in tNFA_RW_OPERATION struct */ 1074 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1075 p_msg->op = NFA_RW_OP_I93_READ_MULTI_BLOCK; 1076 1077 p_msg->params.i93_cmd.first_block_number = first_block_number; 1078 p_msg->params.i93_cmd.number_blocks = number_blocks; 1079 1080 nfa_sys_sendmsg (p_msg); 1081 1082 return (NFA_STATUS_OK); 1083 } 1084 1085 return (NFA_STATUS_FAILED); 1086 } 1087 1088 /******************************************************************************* 1089 ** 1090 ** Function NFA_RwI93WriteMultipleBlocks 1091 ** 1092 ** Description: 1093 ** Send Write Multiple Block command to the activated ISO 15693 tag. 1094 ** 1095 ** When the write operation has completed (or if an error occurs), the 1096 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1097 ** 1098 ** Returns: 1099 ** NFA_STATUS_OK if successfully initiated 1100 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1101 ** NFA_STATUS_FAILED otherwise 1102 ** 1103 *******************************************************************************/ 1104 tNFA_STATUS NFA_RwI93WriteMultipleBlocks (UINT8 first_block_number, 1105 UINT16 number_blocks, 1106 UINT8 *p_data) 1107 { 1108 tNFA_RW_OPERATION *p_msg; 1109 UINT16 data_length; 1110 1111 NFA_TRACE_API2 ("NFA_RwI93WriteMultipleBlocks (): %d, %d", first_block_number, number_blocks); 1112 1113 if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1114 { 1115 return (NFA_STATUS_WRONG_PROTOCOL); 1116 } 1117 1118 /* we don't know block size of tag */ 1119 if ((nfa_rw_cb.i93_block_size == 0) || (nfa_rw_cb.i93_num_block == 0)) 1120 { 1121 return (NFA_STATUS_FAILED); 1122 } 1123 1124 data_length = nfa_rw_cb.i93_block_size * number_blocks; 1125 1126 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + data_length))) != NULL) 1127 { 1128 /* Fill in tNFA_RW_OPERATION struct */ 1129 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1130 p_msg->op = NFA_RW_OP_I93_WRITE_MULTI_BLOCK; 1131 1132 p_msg->params.i93_cmd.first_block_number = first_block_number; 1133 p_msg->params.i93_cmd.number_blocks = number_blocks; 1134 p_msg->params.i93_cmd.p_data = (UINT8*) (p_msg + 1); 1135 1136 memcpy (p_msg->params.i93_cmd.p_data, p_data, data_length); 1137 1138 nfa_sys_sendmsg (p_msg); 1139 1140 return (NFA_STATUS_OK); 1141 } 1142 1143 return (NFA_STATUS_FAILED); 1144 } 1145 1146 /******************************************************************************* 1147 ** 1148 ** Function NFA_RwI93Select 1149 ** 1150 ** Description: 1151 ** Send Select command to the activated ISO 15693 tag. 1152 ** 1153 ** UID[0]: 0xE0, MSB 1154 ** UID[1]: IC Mfg Code 1155 ** ... 1156 ** UID[7]: LSB 1157 ** 1158 ** When the operation has completed (or if an error occurs), the 1159 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1160 ** 1161 ** Returns: 1162 ** NFA_STATUS_OK if successfully initiated 1163 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1164 ** NFA_STATUS_FAILED otherwise 1165 ** 1166 *******************************************************************************/ 1167 tNFA_STATUS NFA_RwI93Select (UINT8 *p_uid) 1168 { 1169 tNFA_RW_OPERATION *p_msg; 1170 1171 NFA_TRACE_API3 ("NFA_RwI93Select (): UID: [%02X%02X%02X...]", *(p_uid), *(p_uid+1), *(p_uid+2)); 1172 1173 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1174 { 1175 return (NFA_STATUS_WRONG_PROTOCOL); 1176 } 1177 1178 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + I93_UID_BYTE_LEN))) != NULL) 1179 { 1180 /* Fill in tNFA_RW_OPERATION struct */ 1181 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1182 p_msg->op = NFA_RW_OP_I93_SELECT; 1183 1184 p_msg->params.i93_cmd.p_data = (UINT8 *) (p_msg + 1); 1185 memcpy (p_msg->params.i93_cmd.p_data, p_uid, I93_UID_BYTE_LEN); 1186 1187 nfa_sys_sendmsg (p_msg); 1188 1189 return (NFA_STATUS_OK); 1190 } 1191 1192 return (NFA_STATUS_FAILED); 1193 } 1194 1195 /******************************************************************************* 1196 ** 1197 ** Function NFA_RwI93ResetToReady 1198 ** 1199 ** Description: 1200 ** Send Reset to ready command to the activated ISO 15693 tag. 1201 ** 1202 ** When the operation has completed (or if an error occurs), the 1203 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1204 ** 1205 ** Returns: 1206 ** NFA_STATUS_OK if successfully initiated 1207 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1208 ** NFA_STATUS_FAILED otherwise 1209 ** 1210 *******************************************************************************/ 1211 tNFA_STATUS NFA_RwI93ResetToReady (void) 1212 { 1213 tNFA_RW_OPERATION *p_msg; 1214 1215 NFA_TRACE_API0 ("NFA_RwI93ResetToReady ()"); 1216 1217 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1218 { 1219 return (NFA_STATUS_WRONG_PROTOCOL); 1220 } 1221 1222 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1223 { 1224 /* Fill in tNFA_RW_OPERATION struct */ 1225 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1226 p_msg->op = NFA_RW_OP_I93_RESET_TO_READY; 1227 1228 nfa_sys_sendmsg (p_msg); 1229 1230 return (NFA_STATUS_OK); 1231 } 1232 1233 return (NFA_STATUS_FAILED); 1234 } 1235 1236 /******************************************************************************* 1237 ** 1238 ** Function NFA_RwI93WriteAFI 1239 ** 1240 ** Description: 1241 ** Send Write AFI command to the activated ISO 15693 tag. 1242 ** 1243 ** When the operation has completed (or if an error occurs), the 1244 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1245 ** 1246 ** Returns: 1247 ** NFA_STATUS_OK if successfully initiated 1248 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1249 ** NFA_STATUS_FAILED otherwise 1250 ** 1251 *******************************************************************************/ 1252 tNFA_STATUS NFA_RwI93WriteAFI (UINT8 afi) 1253 { 1254 tNFA_RW_OPERATION *p_msg; 1255 1256 NFA_TRACE_API1 ("NFA_RwI93WriteAFI (): AFI: 0x%02X", afi); 1257 1258 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1259 { 1260 return (NFA_STATUS_WRONG_PROTOCOL); 1261 } 1262 1263 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1264 { 1265 /* Fill in tNFA_RW_OPERATION struct */ 1266 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1267 p_msg->op = NFA_RW_OP_I93_WRITE_AFI; 1268 1269 p_msg->params.i93_cmd.afi = afi; 1270 1271 nfa_sys_sendmsg (p_msg); 1272 1273 return (NFA_STATUS_OK); 1274 } 1275 1276 return (NFA_STATUS_FAILED); 1277 } 1278 1279 /******************************************************************************* 1280 ** 1281 ** Function NFA_RwI93LockAFI 1282 ** 1283 ** Description: 1284 ** Send Lock AFI command to the activated ISO 15693 tag. 1285 ** 1286 ** When the operation has completed (or if an error occurs), the 1287 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1288 ** 1289 ** Returns: 1290 ** NFA_STATUS_OK if successfully initiated 1291 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1292 ** NFA_STATUS_FAILED otherwise 1293 ** 1294 *******************************************************************************/ 1295 tNFA_STATUS NFA_RwI93LockAFI (void) 1296 { 1297 tNFA_RW_OPERATION *p_msg; 1298 1299 NFA_TRACE_API0 ("NFA_RwI93LockAFI ()"); 1300 1301 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1302 { 1303 return (NFA_STATUS_WRONG_PROTOCOL); 1304 } 1305 1306 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1307 { 1308 /* Fill in tNFA_RW_OPERATION struct */ 1309 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1310 p_msg->op = NFA_RW_OP_I93_LOCK_AFI; 1311 1312 nfa_sys_sendmsg (p_msg); 1313 1314 return (NFA_STATUS_OK); 1315 } 1316 1317 return (NFA_STATUS_FAILED); 1318 } 1319 1320 /******************************************************************************* 1321 ** 1322 ** Function NFA_RwI93WriteDSFID 1323 ** 1324 ** Description: 1325 ** Send Write DSFID command to the activated ISO 15693 tag. 1326 ** 1327 ** When the operation has completed (or if an error occurs), the 1328 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1329 ** 1330 ** Returns: 1331 ** NFA_STATUS_OK if successfully initiated 1332 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1333 ** NFA_STATUS_FAILED otherwise 1334 ** 1335 *******************************************************************************/ 1336 tNFA_STATUS NFA_RwI93WriteDSFID (UINT8 dsfid) 1337 { 1338 tNFA_RW_OPERATION *p_msg; 1339 1340 NFA_TRACE_API1 ("NFA_RwI93WriteDSFID (): DSFID: 0x%02X", dsfid); 1341 1342 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1343 { 1344 return (NFA_STATUS_WRONG_PROTOCOL); 1345 } 1346 1347 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1348 { 1349 /* Fill in tNFA_RW_OPERATION struct */ 1350 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1351 p_msg->op = NFA_RW_OP_I93_WRITE_DSFID; 1352 1353 p_msg->params.i93_cmd.dsfid = dsfid; 1354 1355 nfa_sys_sendmsg (p_msg); 1356 1357 return (NFA_STATUS_OK); 1358 } 1359 1360 return (NFA_STATUS_FAILED); 1361 } 1362 1363 /******************************************************************************* 1364 ** 1365 ** Function NFA_RwI93LockDSFID 1366 ** 1367 ** Description: 1368 ** Send Lock DSFID command to the activated ISO 15693 tag. 1369 ** 1370 ** When the operation has completed (or if an error occurs), the 1371 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1372 ** 1373 ** Returns: 1374 ** NFA_STATUS_OK if successfully initiated 1375 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1376 ** NFA_STATUS_FAILED otherwise 1377 ** 1378 *******************************************************************************/ 1379 tNFA_STATUS NFA_RwI93LockDSFID (void) 1380 { 1381 tNFA_RW_OPERATION *p_msg; 1382 1383 NFA_TRACE_API0 ("NFA_RwI93LockDSFID ()"); 1384 1385 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1386 { 1387 return (NFA_STATUS_WRONG_PROTOCOL); 1388 } 1389 1390 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1391 { 1392 /* Fill in tNFA_RW_OPERATION struct */ 1393 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1394 p_msg->op = NFA_RW_OP_I93_LOCK_DSFID; 1395 1396 nfa_sys_sendmsg (p_msg); 1397 1398 return (NFA_STATUS_OK); 1399 } 1400 1401 return (NFA_STATUS_FAILED); 1402 } 1403 1404 /******************************************************************************* 1405 ** 1406 ** Function NFA_RwI93GetSysInfo 1407 ** 1408 ** Description: 1409 ** Send Get system information command to the activated ISO 15693 tag. 1410 ** If UID is provided then set UID[0]:MSB, ... UID[7]:LSB 1411 ** 1412 ** When the operation has completed (or if an error occurs), the 1413 ** app will be notified with NFA_I93_CMD_CPLT_EVT. 1414 ** 1415 ** Returns: 1416 ** NFA_STATUS_OK if successfully initiated 1417 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1418 ** NFA_STATUS_FAILED otherwise 1419 ** 1420 *******************************************************************************/ 1421 tNFA_STATUS NFA_RwI93GetSysInfo (UINT8 *p_uid) 1422 { 1423 tNFA_RW_OPERATION *p_msg; 1424 1425 NFA_TRACE_API0 ("NFA_RwI93GetSysInfo ()"); 1426 1427 if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1428 { 1429 return (NFA_STATUS_WRONG_PROTOCOL); 1430 } 1431 1432 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1433 { 1434 /* Fill in tNFA_RW_OPERATION struct */ 1435 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1436 p_msg->op = NFA_RW_OP_I93_GET_SYS_INFO; 1437 1438 if (p_uid) 1439 { 1440 p_msg->params.i93_cmd.uid_present = TRUE; 1441 memcpy (p_msg->params.i93_cmd.uid, p_uid, I93_UID_BYTE_LEN); 1442 } 1443 else 1444 { 1445 p_msg->params.i93_cmd.uid_present = FALSE; 1446 } 1447 1448 nfa_sys_sendmsg (p_msg); 1449 1450 return (NFA_STATUS_OK); 1451 } 1452 1453 return (NFA_STATUS_FAILED); 1454 } 1455 1456 /******************************************************************************* 1457 ** 1458 ** Function NFA_RwI93GetMultiBlockSecurityStatus 1459 ** 1460 ** Description: 1461 ** Send Get Multiple block security status command to the activated ISO 15693 tag. 1462 ** 1463 ** Data is returned to the application using the NFA_DATA_EVT. When the read 1464 ** operation has completed, or if an error occurs, the app will be notified with 1465 ** NFA_I93_CMD_CPLT_EVT. 1466 ** 1467 ** Returns: 1468 ** NFA_STATUS_OK if successfully initiated 1469 ** NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated 1470 ** NFA_STATUS_FAILED otherwise 1471 ** 1472 *******************************************************************************/ 1473 tNFA_STATUS NFA_RwI93GetMultiBlockSecurityStatus (UINT8 first_block_number, 1474 UINT16 number_blocks) 1475 { 1476 tNFA_RW_OPERATION *p_msg; 1477 1478 NFA_TRACE_API2 ("NFA_RwI93GetMultiBlockSecurityStatus(): %d, %d", first_block_number, number_blocks); 1479 1480 if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693) 1481 { 1482 return (NFA_STATUS_WRONG_PROTOCOL); 1483 } 1484 1485 if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL) 1486 { 1487 /* Fill in tNFA_RW_OPERATION struct */ 1488 p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT; 1489 p_msg->op = NFA_RW_OP_I93_GET_MULTI_BLOCK_STATUS; 1490 1491 p_msg->params.i93_cmd.first_block_number = first_block_number; 1492 p_msg->params.i93_cmd.number_blocks = number_blocks; 1493 1494 nfa_sys_sendmsg (p_msg); 1495 1496 return (NFA_STATUS_OK); 1497 } 1498 1499 return (NFA_STATUS_FAILED); 1500 } 1501
