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