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 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 *******************************************************************************/
NFA_RwLocateTlv(UINT8 tlv_type)327 tNFA_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 *******************************************************************************/
NFA_RwT1tRid(void)376 tNFA_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 *******************************************************************************/
NFA_RwT1tReadAll(void)408 tNFA_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 *******************************************************************************/
NFA_RwT1tRead(UINT8 block_number,UINT8 index)440 tNFA_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 *******************************************************************************/
NFA_RwT1tWrite(UINT8 block_number,UINT8 index,UINT8 data,BOOLEAN b_erase)474 tNFA_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 *******************************************************************************/
NFA_RwT1tReadSeg(UINT8 segment_number)510 tNFA_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 *******************************************************************************/
NFA_RwT1tRead8(UINT8 block_number)543 tNFA_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 *******************************************************************************/
NFA_RwT1tWrite8(UINT8 block_number,UINT8 * p_data,BOOLEAN b_erase)576 tNFA_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 *******************************************************************************/
NFA_RwT2tRead(UINT8 block_number)612 tNFA_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 *******************************************************************************/
NFA_RwT2tWrite(UINT8 block_number,UINT8 * p_data)646 tNFA_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 *******************************************************************************/
NFA_RwT2tSectorSelect(UINT8 sector_number)683 tNFA_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 *******************************************************************************/
NFA_RwT3tRead(UINT8 num_blocks,tNFA_T3T_BLOCK_DESC * t3t_blocks)719 tNFA_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 *******************************************************************************/
NFA_RwT3tWrite(UINT8 num_blocks,tNFA_T3T_BLOCK_DESC * t3t_blocks,UINT8 * p_data)768 tNFA_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 *******************************************************************************/
NFA_RwI93Inventory(BOOLEAN afi_present,UINT8 afi,UINT8 * p_uid)824 tNFA_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 *******************************************************************************/
NFA_RwI93StayQuiet(void)878 tNFA_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 *******************************************************************************/
NFA_RwI93ReadSingleBlock(UINT8 block_number)920 tNFA_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 *******************************************************************************/
NFA_RwI93WriteSingleBlock(UINT8 block_number,UINT8 * p_data)963 tNFA_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 *******************************************************************************/
NFA_RwI93LockBlock(UINT8 block_number)1017 tNFA_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 *******************************************************************************/
NFA_RwI93ReadMultipleBlocks(UINT8 first_block_number,UINT16 number_blocks)1061 tNFA_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 *******************************************************************************/
NFA_RwI93WriteMultipleBlocks(UINT8 first_block_number,UINT16 number_blocks,UINT8 * p_data)1106 tNFA_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 *******************************************************************************/
NFA_RwI93Select(UINT8 * p_uid)1169 tNFA_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 *******************************************************************************/
NFA_RwI93ResetToReady(void)1213 tNFA_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 *******************************************************************************/
NFA_RwI93WriteAFI(UINT8 afi)1254 tNFA_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 *******************************************************************************/
NFA_RwI93LockAFI(void)1297 tNFA_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 *******************************************************************************/
NFA_RwI93WriteDSFID(UINT8 dsfid)1338 tNFA_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 *******************************************************************************/
NFA_RwI93LockDSFID(void)1381 tNFA_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 *******************************************************************************/
NFA_RwI93GetSysInfo(UINT8 * p_uid)1423 tNFA_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 *******************************************************************************/
NFA_RwI93GetMultiBlockSecurityStatus(UINT8 first_block_number,UINT16 number_blocks)1475 tNFA_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