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