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