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