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