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 device management
22 *
23 ******************************************************************************/
24 #include <android-base/logging.h>
25 #include <android-base/stringprintf.h>
26 #include <log/log.h>
27 #include <string.h>
28
29 #include "ndef_utils.h"
30 #include "nfa_api.h"
31 #include "nfa_ce_int.h"
32 #include "nfa_nfcee_int.h"
33 #include "nfa_wlc_int.h"
34 #include "nfc_int.h"
35
36 using android::base::StringPrintf;
37
38 /*****************************************************************************
39 ** Constants
40 *****************************************************************************/
41
42 /*****************************************************************************
43 ** APIs
44 *****************************************************************************/
45 /*******************************************************************************
46 **
47 ** Function NFA_SetNfccMode
48 **
49 ** Description This function sets the different NFC controller modes.
50 **
51 ** mode ENABLE_MODE_DEFAULT or ENABLE_MODE_TRANSPARENT
52 ** or ENABLE_MODE_EE
53 **
54 ** Returns none
55 **
56 *******************************************************************************/
NFA_SetNfccMode(uint8_t mode)57 extern void NFA_SetNfccMode(uint8_t mode) {
58 LOG(DEBUG) << StringPrintf("%s: (%d) -> (%d)", __func__, nfc_cb.nfcc_mode,
59 mode);
60 nfc_cb.nfcc_mode = mode;
61 }
62
63 /*******************************************************************************
64 **
65 ** Function NFA_Partial_Init
66 **
67 ** Description This function initializes control blocks for NFA based on
68 ** mode
69 **
70 ** p_hal_entry_tbl points to a table of HAL entry points
71 ** mode ENABLE_MODE_DEFAULT or ENABLE_MODE_TRANSPARENT
72 ** or ENABLE_MODE_EE
73 **
74 ** NOTE: the buffer that p_hal_entry_tbl points must be
75 ** persistent until NFA is disabled.
76 **
77 ** Returns none
78 **
79 *******************************************************************************/
NFA_Partial_Init(tHAL_NFC_ENTRY * p_hal_entry_tbl,uint8_t mode)80 extern void NFA_Partial_Init(tHAL_NFC_ENTRY* p_hal_entry_tbl, uint8_t mode) {
81 LOG(DEBUG) << StringPrintf("%s: enter ", __func__);
82 if (mode == ENABLE_MODE_TRANSPARENT) {
83 nfa_sys_init();
84 nfa_dm_init();
85 } else if (mode == ENABLE_MODE_EE) {
86 nfa_sys_init();
87 nfa_dm_init();
88 nfa_ee_init();
89 } else {
90 LOG(ERROR) << StringPrintf("%s: Unknown Mode!", __func__);
91 return;
92 }
93 /* Initialize NFC module */
94 NFC_Init(p_hal_entry_tbl);
95 NFA_SetNfccMode(mode);
96 LOG(DEBUG) << StringPrintf("%s: exit ", __func__);
97 }
98
99 /*******************************************************************************
100 **
101 ** Function NFA_Init
102 **
103 ** Description This function initializes control blocks for NFA
104 **
105 ** p_hal_entry_tbl points to a table of HAL entry points
106 **
107 ** NOTE: the buffer that p_hal_entry_tbl points must be
108 ** persistent until NFA is disabled.
109 **
110 ** Returns none
111 **
112 *******************************************************************************/
NFA_Init(tHAL_NFC_ENTRY * p_hal_entry_tbl)113 void NFA_Init(tHAL_NFC_ENTRY* p_hal_entry_tbl) {
114 LOG(VERBOSE) << __func__;
115 nfa_sys_init();
116 nfa_dm_init();
117 nfa_rw_init();
118 nfa_ce_init();
119 nfa_ee_init();
120 if (nfa_ee_max_ee_cfg != 0) {
121 nfa_dm_cb.get_max_ee = p_hal_entry_tbl->get_max_ee;
122 nfa_t4tnfcee_init();
123 nfa_hci_init();
124 }
125 nfa_wlc_init();
126
127 /* Initialize NFC module */
128 NFC_Init(p_hal_entry_tbl);
129 }
130
131 /*******************************************************************************
132 **
133 ** Function NFA_Enable
134 **
135 ** Description This function enables NFC. Prior to calling NFA_Enable,
136 ** the NFCC must be powered up, and ready to receive commands.
137 ** This function enables the tasks needed by NFC, opens the NCI
138 ** transport, resets the NFC controller, downloads patches to
139 ** the NFCC (if necessary), and initializes the NFC subsystems.
140 **
141 ** This function should only be called once - typically when
142 ** NFC is enabled during boot-up, or when NFC is enabled from a
143 ** settings UI. Subsequent calls to NFA_Enable while NFA is
144 ** enabling or enabled will be ignored. When the NFC startup
145 ** procedure is completed, an NFA_DM_ENABLE_EVT is returned to
146 ** the application using the tNFA_DM_CBACK.
147 **
148 ** Returns NFA_STATUS_OK if successfully initiated
149 ** NFA_STATUS_FAILED otherwise
150 **
151 *******************************************************************************/
NFA_Enable(tNFA_DM_CBACK * p_dm_cback,tNFA_CONN_CBACK * p_conn_cback)152 tNFA_STATUS NFA_Enable(tNFA_DM_CBACK* p_dm_cback,
153 tNFA_CONN_CBACK* p_conn_cback) {
154 tNFA_DM_API_ENABLE* p_msg;
155
156 LOG(VERBOSE) << __func__;
157
158 /* Validate parameters */
159 if ((!p_dm_cback) || (!p_conn_cback)) {
160 LOG(ERROR) << StringPrintf("%s: error null callback", __func__);
161 return (NFA_STATUS_FAILED);
162 }
163
164 p_msg = (tNFA_DM_API_ENABLE*)GKI_getbuf(sizeof(tNFA_DM_API_ENABLE));
165 if (p_msg != nullptr) {
166 p_msg->hdr.event = NFA_DM_API_ENABLE_EVT;
167 p_msg->p_dm_cback = p_dm_cback;
168 p_msg->p_conn_cback = p_conn_cback;
169
170 nfa_sys_sendmsg(p_msg);
171
172 return (NFA_STATUS_OK);
173 }
174
175 return (NFA_STATUS_FAILED);
176 }
177
178 /*******************************************************************************
179 **
180 ** Function NFA_Disable
181 **
182 ** Description This function is called to shutdown NFC. The tasks for NFC
183 ** are terminated, and clean up routines are performed. This
184 ** function is typically called during platform shut-down, or
185 ** when NFC is disabled from a settings UI. When the NFC
186 ** shutdown procedure is completed, an NFA_DM_DISABLE_EVT is
187 ** returned to the application using the tNFA_DM_CBACK.
188 **
189 ** The platform should wait until the NFC_DISABLE_REVT is
190 ** received before powering down the NFC chip and NCI
191 ** transport. This is required to so that NFA can gracefully
192 ** shut down any open connections.
193 **
194 ** Returns NFA_STATUS_OK if successfully initiated
195 ** NFA_STATUS_FAILED otherwise
196 **
197 *******************************************************************************/
NFA_Disable(bool graceful)198 tNFA_STATUS NFA_Disable(bool graceful) {
199 tNFA_DM_API_DISABLE* p_msg;
200
201 LOG(VERBOSE) << StringPrintf("%s: (graceful=%i)", __func__, graceful);
202
203 p_msg = (tNFA_DM_API_DISABLE*)GKI_getbuf(sizeof(tNFA_DM_API_DISABLE));
204 if (p_msg != nullptr) {
205 p_msg->hdr.event = NFA_DM_API_DISABLE_EVT;
206 p_msg->graceful = graceful;
207
208 nfa_sys_sendmsg(p_msg);
209
210 return (NFA_STATUS_OK);
211 }
212
213 return (NFA_STATUS_FAILED);
214 }
215
216 /*******************************************************************************
217 **
218 ** Function NFA_GetNCIVersion
219 **
220 ** Description Returns the NCI version of the NFCC to upper layer
221 **
222 **
223 ** Returns NCI version NCI2.0 / NCI1.0
224 **
225 *******************************************************************************/
NFA_GetNCIVersion()226 uint8_t NFA_GetNCIVersion() { return NFC_GetNCIVersion(); }
227
228 /*******************************************************************************
229 **
230 ** Function NFA_SetPowerSubStateForScreenState
231 **
232 ** Description Update the power sub-state as per current screen state to
233 ** NFCC.
234 **
235 ** Returns NFA_STATUS_OK if successfully initiated
236 ** NFA_STATUS_FAILED otherwise
237 **
238 *******************************************************************************/
NFA_SetPowerSubStateForScreenState(uint8_t screenState)239 tNFA_STATUS NFA_SetPowerSubStateForScreenState(uint8_t screenState) {
240 LOG(VERBOSE) << StringPrintf("%s: state=0x%X", __func__, screenState);
241
242 uint8_t nci_scren_state = 0xFF;
243 uint16_t buf_size = sizeof(tNFA_DM_API_SET_POWER_SUB_STATE);
244 tNFA_DM_API_SET_POWER_SUB_STATE* p_msg =
245 (tNFA_DM_API_SET_POWER_SUB_STATE*)GKI_getbuf(buf_size);
246
247 if (p_msg != nullptr) {
248 p_msg->hdr.event = NFA_DM_API_SET_POWER_SUB_STATE_EVT;
249 switch (screenState) {
250 case NFA_SCREEN_STATE_ON_UNLOCKED:
251 nci_scren_state = SCREEN_STATE_ON_UNLOCKED;
252 break;
253 case NFA_SCREEN_STATE_OFF_UNLOCKED:
254 nci_scren_state = SCREEN_STATE_OFF_UNLOCKED;
255 break;
256 case NFA_SCREEN_STATE_ON_LOCKED:
257 nci_scren_state = SCREEN_STATE_ON_LOCKED;
258 break;
259 case NFA_SCREEN_STATE_OFF_LOCKED:
260 nci_scren_state = SCREEN_STATE_OFF_LOCKED;
261 break;
262
263 default:
264 LOG(VERBOSE) << StringPrintf("%s: unknown screen state", __func__);
265 break;
266 }
267
268 p_msg->screen_state = nci_scren_state;
269
270 nfa_sys_sendmsg(p_msg);
271 return (NFA_STATUS_OK);
272 }
273 return (NFA_STATUS_FAILED);
274 }
275 /*******************************************************************************
276 **
277 ** Function NFA_SetConfig
278 **
279 ** Description Set the configuration parameters to NFCC. The result is
280 ** reported with an NFA_DM_SET_CONFIG_EVT in the tNFA_DM_CBACK
281 ** callback.
282 **
283 ** Note: If RF discovery is started,
284 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
285 ** happen before calling this function. Most Configuration
286 ** parameters are related to RF discovery.
287 **
288 ** Returns NFA_STATUS_OK if successfully initiated
289 ** NFA_STATUS_BUSY if previous setting is on-going
290 ** NFA_STATUS_FAILED otherwise
291 **
292 *******************************************************************************/
NFA_SetConfig(tNFA_PMID param_id,uint8_t length,uint8_t * p_data)293 tNFA_STATUS NFA_SetConfig(tNFA_PMID param_id, uint8_t length, uint8_t* p_data) {
294 tNFA_DM_API_SET_CONFIG* p_msg;
295
296 LOG(VERBOSE) << StringPrintf("%s: param_id=0x%X", __func__, param_id);
297
298 p_msg = (tNFA_DM_API_SET_CONFIG*)GKI_getbuf(
299 (uint16_t)(sizeof(tNFA_DM_API_SET_CONFIG) + length));
300 if (p_msg != nullptr) {
301 p_msg->hdr.event = NFA_DM_API_SET_CONFIG_EVT;
302
303 p_msg->param_id = param_id;
304 p_msg->length = length;
305 p_msg->p_data = (uint8_t*)(p_msg + 1);
306
307 /* Copy parameter data */
308 memcpy(p_msg->p_data, p_data, length);
309
310 nfa_sys_sendmsg(p_msg);
311
312 return (NFA_STATUS_OK);
313 }
314
315 return (NFA_STATUS_FAILED);
316 }
317
318 /*******************************************************************************
319 **
320 ** Function NFA_GetConfig
321 **
322 ** Description Get the configuration parameters from NFCC. The result is
323 ** reported with an NFA_DM_GET_CONFIG_EVT in the tNFA_DM_CBACK
324 ** callback.
325 **
326 ** Returns NFA_STATUS_OK if successfully initiated
327 ** NFA_STATUS_FAILED otherwise
328 **
329 *******************************************************************************/
NFA_GetConfig(uint8_t num_ids,tNFA_PMID * p_param_ids)330 tNFA_STATUS NFA_GetConfig(uint8_t num_ids, tNFA_PMID* p_param_ids) {
331 tNFA_DM_API_GET_CONFIG* p_msg;
332
333 LOG(VERBOSE) << StringPrintf("%s: num_ids=%i", __func__, num_ids);
334
335 p_msg = (tNFA_DM_API_GET_CONFIG*)GKI_getbuf(
336 (uint16_t)(sizeof(tNFA_DM_API_GET_CONFIG) + num_ids));
337 if (p_msg != nullptr) {
338 p_msg->hdr.event = NFA_DM_API_GET_CONFIG_EVT;
339
340 p_msg->num_ids = num_ids;
341 p_msg->p_pmids = (tNFA_PMID*)(p_msg + 1);
342
343 /* Copy the param IDs */
344 memcpy(p_msg->p_pmids, p_param_ids, num_ids);
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_RequestExclusiveRfControl
357 **
358 ** Description Request exclusive control of NFC.
359 ** - Previous behavior (polling/tag reading, DH card emulation)
360 ** will be suspended .
361 ** - Polling and listening will be done based on the specified
362 ** params
363 **
364 ** The NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT event of
365 ** tNFA_CONN_CBACK indicates the status of the operation.
366 **
367 ** NFA_ACTIVATED_EVT and NFA_DEACTIVATED_EVT indicates link
368 ** activation/deactivation.
369 **
370 ** NFA_SendRawFrame is used to send data to the peer.
371 ** NFA_DATA_EVT indicates data from the peer.
372 **
373 ** If a tag is activated, then the NFA_RW APIs may be used to
374 ** send commands to the tag. Incoming NDEF messages are sent to
375 ** the NDEF callback.
376 **
377 ** Note: If RF discovery is started,
378 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
379 ** happen before calling this function
380 **
381 ** Returns NFA_STATUS_OK if successfully initiated
382 ** NFA_STATUS_FAILED otherwise
383 **
384 *******************************************************************************/
NFA_RequestExclusiveRfControl(tNFA_TECHNOLOGY_MASK poll_mask,tNFA_LISTEN_CFG * p_listen_cfg,tNFA_CONN_CBACK * p_conn_cback,tNFA_NDEF_CBACK * p_ndef_cback)385 tNFA_STATUS NFA_RequestExclusiveRfControl(tNFA_TECHNOLOGY_MASK poll_mask,
386 tNFA_LISTEN_CFG* p_listen_cfg,
387 tNFA_CONN_CBACK* p_conn_cback,
388 tNFA_NDEF_CBACK* p_ndef_cback) {
389 tNFA_DM_API_REQ_EXCL_RF_CTRL* p_msg;
390
391 LOG(VERBOSE) << StringPrintf("%s: poll_mask=0x%x", __func__, poll_mask);
392
393 if (!p_conn_cback) {
394 LOG(ERROR) << StringPrintf("%s: error null callback", __func__);
395 return (NFA_STATUS_FAILED);
396 }
397
398 p_msg = (tNFA_DM_API_REQ_EXCL_RF_CTRL*)GKI_getbuf(
399 sizeof(tNFA_DM_API_REQ_EXCL_RF_CTRL));
400 if (p_msg != nullptr) {
401 p_msg->hdr.event = NFA_DM_API_REQUEST_EXCL_RF_CTRL_EVT;
402 p_msg->poll_mask = poll_mask;
403 p_msg->p_conn_cback = p_conn_cback;
404 p_msg->p_ndef_cback = p_ndef_cback;
405
406 if (p_listen_cfg)
407 memcpy(&p_msg->listen_cfg, p_listen_cfg, sizeof(tNFA_LISTEN_CFG));
408 else
409 memset(&p_msg->listen_cfg, 0x00, sizeof(tNFA_LISTEN_CFG));
410
411 nfa_sys_sendmsg(p_msg);
412
413 return (NFA_STATUS_OK);
414 }
415
416 return (NFA_STATUS_FAILED);
417 }
418
419 /*******************************************************************************
420 **
421 ** Function NFA_ReleaseExclusiveRfControl
422 **
423 ** Description Release exclusive control of NFC. Once released, behavior
424 ** prior to obtaining exclusive RF control will resume.
425 **
426 ** Returns NFA_STATUS_OK if successfully initiated
427 ** NFA_STATUS_FAILED otherwise
428 **
429 *******************************************************************************/
NFA_ReleaseExclusiveRfControl(void)430 tNFA_STATUS NFA_ReleaseExclusiveRfControl(void) {
431 NFC_HDR* p_msg;
432
433 LOG(VERBOSE) << __func__;
434
435 if (!nfa_dm_cb.p_excl_conn_cback) {
436 LOG(ERROR) << StringPrintf(
437 "%s: Exclusive rf control is not in "
438 "progress",
439 __func__);
440 return (NFA_STATUS_FAILED);
441 }
442
443 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
444 if (p_msg != nullptr) {
445 p_msg->event = NFA_DM_API_RELEASE_EXCL_RF_CTRL_EVT;
446 nfa_sys_sendmsg(p_msg);
447 return (NFA_STATUS_OK);
448 }
449
450 return (NFA_STATUS_FAILED);
451 }
452
453 /*******************************************************************************
454 **
455 ** Function NFA_EnablePolling
456 **
457 ** Description Enable polling for technologies specified by poll_mask.
458 **
459 ** The following events (notified using the connection
460 ** callback registered with NFA_Enable) are generated during
461 ** polling:
462 **
463 ** - NFA_POLL_ENABLED_EVT indicates whether or not polling
464 ** successfully enabled.
465 ** - NFA_DISC_RESULT_EVT indicates there are more than one
466 ** devices, so application must select one of tags by calling
467 ** NFA_Select().
468 ** - NFA_SELECT_RESULT_EVT indicates whether previous selection
469 ** was successful or not. If it was failed then application
470 ** must select again or deactivate by calling
471 ** NFA_Deactivate().
472 ** - NFA_ACTIVATED_EVT is generated when an NFC link is
473 ** activated.
474 ** - NFA_NDEF_DETECT_EVT is generated if tag is activated
475 ** - NFA_DEACTIVATED_EVT will be returned after deactivating
476 ** NFC link.
477 **
478 ** Note: If RF discovery is started,
479 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
480 ** happen before calling this function
481 **
482 ** Returns NFA_STATUS_OK if successfully initiated
483 ** NFA_STATUS_FAILED otherwise
484 **
485 *******************************************************************************/
NFA_EnablePolling(tNFA_TECHNOLOGY_MASK poll_mask)486 tNFA_STATUS NFA_EnablePolling(tNFA_TECHNOLOGY_MASK poll_mask) {
487 tNFA_DM_API_ENABLE_POLL* p_msg;
488
489 LOG(VERBOSE) << StringPrintf("%s: poll_mask=0x%X", __func__, poll_mask);
490
491 p_msg = (tNFA_DM_API_ENABLE_POLL*)GKI_getbuf(sizeof(tNFA_DM_API_ENABLE_POLL));
492 if (p_msg != nullptr) {
493 p_msg->hdr.event = NFA_DM_API_ENABLE_POLLING_EVT;
494 p_msg->poll_mask = poll_mask;
495
496 nfa_sys_sendmsg(p_msg);
497
498 return (NFA_STATUS_OK);
499 }
500
501 return (NFA_STATUS_FAILED);
502 }
503
504 /*******************************************************************************
505 **
506 ** Function NFA_DisablePolling
507 **
508 ** Description Disable polling
509 ** NFA_POLL_DISABLED_EVT will be returned after stopping
510 ** polling.
511 **
512 ** Note: If RF discovery is started,
513 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
514 ** happen before calling this function
515 **
516 ** Returns NFA_STATUS_OK if successfully initiated
517 ** NFA_STATUS_FAILED otherwise
518 **
519 *******************************************************************************/
NFA_DisablePolling(void)520 tNFA_STATUS NFA_DisablePolling(void) {
521 NFC_HDR* p_msg;
522
523 LOG(VERBOSE) << __func__;
524
525 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
526 if (p_msg != nullptr) {
527 p_msg->event = NFA_DM_API_DISABLE_POLLING_EVT;
528
529 nfa_sys_sendmsg(p_msg);
530
531 return (NFA_STATUS_OK);
532 }
533
534 return (NFA_STATUS_FAILED);
535 }
536
537 /*******************************************************************************
538 **
539 ** Function NFA_EnableListening
540 **
541 ** Description Enable listening.
542 ** NFA_LISTEN_ENABLED_EVT will be returned after listening is
543 ** allowed.
544 **
545 ** The actual listening technologies are specified by other NFA
546 ** API functions. Such functions include (but not limited to)
547 ** NFA_CeConfigureUiccListenTech.
548 ** If NFA_DisableListening () is called to ignore the listening
549 ** technologies, NFA_EnableListening () is called to restore
550 ** the listening technologies set by these functions.
551 **
552 ** Note: If RF discovery is started,
553 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
554 ** happen before calling this function
555 **
556 ** Returns NFA_STATUS_OK if successfully initiated
557 ** NFA_STATUS_FAILED otherwise
558 **
559 *******************************************************************************/
NFA_EnableListening(void)560 tNFA_STATUS NFA_EnableListening(void) {
561 NFC_HDR* p_msg;
562
563 LOG(VERBOSE) << __func__;
564
565 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
566 if (p_msg != nullptr) {
567 p_msg->event = NFA_DM_API_ENABLE_LISTENING_EVT;
568
569 nfa_sys_sendmsg(p_msg);
570
571 return (NFA_STATUS_OK);
572 }
573
574 return (NFA_STATUS_FAILED);
575 }
576
577 /*******************************************************************************
578 **
579 ** Function NFA_DisableListening
580 **
581 ** Description Disable listening
582 ** NFA_LISTEN_DISABLED_EVT will be returned after stopping
583 ** listening. This function is called to exclude listen at RF
584 ** discovery.
585 **
586 ** Note: If RF discovery is started,
587 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
588 ** happen before calling this function
589 **
590 ** Returns NFA_STATUS_OK if successfully initiated
591 ** NFA_STATUS_FAILED otherwise
592 **
593 *******************************************************************************/
NFA_DisableListening(void)594 tNFA_STATUS NFA_DisableListening(void) {
595 NFC_HDR* p_msg;
596
597 LOG(VERBOSE) << __func__;
598
599 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
600 if (p_msg != nullptr) {
601 p_msg->event = NFA_DM_API_DISABLE_LISTENING_EVT;
602
603 nfa_sys_sendmsg(p_msg);
604
605 return (NFA_STATUS_OK);
606 }
607
608 return (NFA_STATUS_FAILED);
609 }
610
611 /*******************************************************************************
612 **
613 ** Function NFA_StartRfDiscovery
614 **
615 ** Description Start RF discovery
616 ** RF discovery parameters shall be set by other APIs.
617 **
618 ** An NFA_RF_DISCOVERY_STARTED_EVT indicates whether starting
619 ** was successful or not.
620 **
621 ** Returns NFA_STATUS_OK if successfully initiated
622 ** NFA_STATUS_FAILED otherwise
623 **
624 *******************************************************************************/
NFA_StartRfDiscovery(void)625 tNFA_STATUS NFA_StartRfDiscovery(void) {
626 NFC_HDR* p_msg;
627
628 LOG(VERBOSE) << __func__;
629
630 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
631 if (p_msg != nullptr) {
632 p_msg->event = NFA_DM_API_START_RF_DISCOVERY_EVT;
633
634 nfa_sys_sendmsg(p_msg);
635
636 return (NFA_STATUS_OK);
637 }
638
639 return (NFA_STATUS_FAILED);
640 }
641
642 /*******************************************************************************
643 **
644 ** Function NFA_StopRfDiscovery
645 **
646 ** Description Stop RF discovery
647 **
648 ** An NFA_RF_DISCOVERY_STOPPED_EVT indicates whether stopping
649 ** was successful or not.
650 **
651 ** Returns NFA_STATUS_OK if successfully initiated
652 ** NFA_STATUS_FAILED otherwise
653 **
654 *******************************************************************************/
NFA_StopRfDiscovery(void)655 tNFA_STATUS NFA_StopRfDiscovery(void) {
656 NFC_HDR* p_msg;
657
658 LOG(VERBOSE) << __func__;
659
660 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
661 if (p_msg != nullptr) {
662 p_msg->event = NFA_DM_API_STOP_RF_DISCOVERY_EVT;
663
664 nfa_sys_sendmsg(p_msg);
665
666 return (NFA_STATUS_OK);
667 }
668
669 return (NFA_STATUS_FAILED);
670 }
671
672 /*******************************************************************************
673 **
674 ** Function NFA_SetRfDiscoveryDuration
675 **
676 ** Description Set the duration of the single discovery period in [ms].
677 ** Allowable range: 0 ms to 0xFFFF ms.
678 **
679 ** If discovery is already started, the application should
680 ** call NFA_StopRfDiscovery prior to calling
681 ** NFA_SetRfDiscoveryDuration, and then call
682 ** NFA_StartRfDiscovery afterwards to restart discovery using
683 ** the new duration.
684 **
685 ** Note: If RF discovery is started,
686 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
687 ** happen before calling this function
688 **
689 ** Returns:
690 ** NFA_STATUS_OK, if command accepted
691 ** NFA_STATUS_FAILED: otherwise
692 **
693 *******************************************************************************/
NFA_SetRfDiscoveryDuration(uint16_t discovery_period_ms)694 tNFA_STATUS NFA_SetRfDiscoveryDuration(uint16_t discovery_period_ms) {
695 tNFA_DM_API_SET_RF_DISC_DUR* p_msg;
696
697 LOG(VERBOSE) << __func__;
698
699 /* Post the API message */
700 p_msg = (tNFA_DM_API_SET_RF_DISC_DUR*)GKI_getbuf(
701 sizeof(tNFA_DM_API_SET_RF_DISC_DUR));
702 if (p_msg != nullptr) {
703 p_msg->hdr.event = NFA_DM_API_SET_RF_DISC_DURATION_EVT;
704
705 /* Set discovery duration */
706 p_msg->rf_disc_dur_ms = discovery_period_ms;
707
708 nfa_sys_sendmsg(p_msg);
709
710 return (NFA_STATUS_OK);
711 }
712
713 return (NFA_STATUS_FAILED);
714 }
715
716 /*******************************************************************************
717 **
718 ** Function NFA_Select
719 **
720 ** Description Select one from detected devices during discovery
721 ** (from NFA_DISC_RESULT_EVTs). The application should wait for
722 ** the final NFA_DISC_RESULT_EVT before selecting.
723 **
724 ** An NFA_SELECT_RESULT_EVT indicates whether selection was
725 ** successful or not. If failed then application must select
726 ** again or deactivate by NFA_Deactivate().
727 **
728 ** Returns NFA_STATUS_OK if successfully initiated
729 ** NFA_STATUS_INVALID_PARAM if RF interface is not matched
730 ** protocol
731 ** NFA_STATUS_FAILED otherwise
732 **
733 *******************************************************************************/
NFA_Select(uint8_t rf_disc_id,tNFA_NFC_PROTOCOL protocol,tNFA_INTF_TYPE rf_interface)734 tNFA_STATUS NFA_Select(uint8_t rf_disc_id, tNFA_NFC_PROTOCOL protocol,
735 tNFA_INTF_TYPE rf_interface) {
736 tNFA_DM_API_SELECT* p_msg;
737
738 LOG(VERBOSE) << StringPrintf(
739 "%s: rf_disc_id=0x%X, protocol=0x%X, rf_interface=0x%X", __func__,
740 rf_disc_id, protocol, rf_interface);
741
742 if ((rf_interface == NFA_INTERFACE_ISO_DEP) &&
743 (protocol != NFA_PROTOCOL_ISO_DEP)) {
744 LOG(ERROR) << StringPrintf("%s: RF interface is not matched protocol",
745 __func__);
746 return (NFA_STATUS_INVALID_PARAM);
747 }
748
749 p_msg =
750 (tNFA_DM_API_SELECT*)GKI_getbuf((uint16_t)(sizeof(tNFA_DM_API_SELECT)));
751 if (p_msg != nullptr) {
752 p_msg->hdr.event = NFA_DM_API_SELECT_EVT;
753 p_msg->rf_disc_id = rf_disc_id;
754 p_msg->protocol = protocol;
755 p_msg->rf_interface = rf_interface;
756
757 nfa_sys_sendmsg(p_msg);
758
759 return (NFA_STATUS_OK);
760 }
761
762 return (NFA_STATUS_FAILED);
763 }
764
765 /*******************************************************************************
766 **
767 ** Function NFA_UpdateRFCommParams
768 **
769 ** Description This function is called to update RF Communication
770 ** parameters once the Frame RF Interface has been activated.
771 **
772 ** An NFA_UPDATE_RF_PARAM_RESULT_EVT indicates whether updating
773 ** was successful or not.
774 **
775 ** Returns NFA_STATUS_OK if successfully initiated
776 ** NFA_STATUS_FAILED otherwise
777 **
778 *******************************************************************************/
NFA_UpdateRFCommParams(tNFA_RF_COMM_PARAMS * p_params)779 tNFA_STATUS NFA_UpdateRFCommParams(tNFA_RF_COMM_PARAMS* p_params) {
780 tNFA_DM_API_UPDATE_RF_PARAMS* p_msg;
781
782 LOG(VERBOSE) << __func__;
783
784 p_msg = (tNFA_DM_API_UPDATE_RF_PARAMS*)GKI_getbuf(
785 (uint16_t)(sizeof(tNFA_DM_API_UPDATE_RF_PARAMS)));
786 if (p_msg != nullptr) {
787 p_msg->hdr.event = NFA_DM_API_UPDATE_RF_PARAMS_EVT;
788 memcpy(&p_msg->params, p_params, sizeof(tNFA_RF_COMM_PARAMS));
789
790 nfa_sys_sendmsg(p_msg);
791
792 return (NFA_STATUS_OK);
793 }
794
795 return (NFA_STATUS_FAILED);
796 }
797
798 /*******************************************************************************
799 **
800 ** Function NFA_StartRemovalDetection
801 **
802 ** Description Start the detection of RF endpoint removal when data
803 *exchange
804 ** ore charging with listener completed.
805 **
806 ** An NFA_DETECT_REMOVAL_RESULT_EVT indicates whether start
807 ** was successful or not.
808 **
809 ** Returns NFA_STATUS_OK if successfully initiated
810 ** NFA_STATUS_FAILED otherwise
811 **
812 *******************************************************************************/
NFA_StartRemovalDetection(uint8_t waiting_time_int)813 tNFA_STATUS NFA_StartRemovalDetection(uint8_t waiting_time_int) {
814 tNFA_DM_API_START_REMOVAL_DETECT* p_msg;
815
816 LOG(VERBOSE) << StringPrintf("%s: waiting_time_int=0x%X", __func__,
817 waiting_time_int);
818
819 p_msg = (tNFA_DM_API_START_REMOVAL_DETECT*)GKI_getbuf(
820 (uint8_t)(sizeof(tNFA_DM_API_START_REMOVAL_DETECT)));
821 if (p_msg != nullptr) {
822 p_msg->hdr.event = NFA_DM_API_START_REMOVAL_DETECT_EVT;
823 p_msg->waiting_time_int = waiting_time_int;
824 nfa_sys_sendmsg(p_msg);
825
826 return (NFA_STATUS_OK);
827 }
828
829 return (NFA_STATUS_FAILED);
830 }
831
832 /*******************************************************************************
833 **
834 ** Function NFA_Deactivate
835 **
836 ** Description
837 ** If sleep_mode=TRUE:
838 ** Deselect the activated device by deactivating into sleep
839 ** mode.
840 **
841 ** An NFA_DEACTIVATE_FAIL_EVT indicates that selection was
842 ** not successful. Application can select another
843 ** discovered device or deactivate by NFA_Deactivate()
844 ** after receiving NFA_DEACTIVATED_EVT.
845 **
846 ** Deactivating to sleep mode is not allowed when NFCC is
847 ** in wait-for-host-select mode, or in listen-sleep states;
848 ** NFA will deactivate to idle or discovery state for these
849 ** cases respectively.
850 **
851 **
852 ** If sleep_mode=FALSE:
853 ** Deactivate the connection (e.g. as a result of presence
854 ** check failure) NFA_DEACTIVATED_EVT will indicate that
855 ** link is deactivated. Polling/listening will resume
856 ** (unless the nfcc is in wait_for-all-discoveries state)
857 **
858 **
859 ** Returns NFA_STATUS_OK if successfully initiated
860 ** NFA_STATUS_FAILED otherwise
861 **
862 *******************************************************************************/
NFA_Deactivate(bool sleep_mode)863 extern tNFA_STATUS NFA_Deactivate(bool sleep_mode) {
864 tNFA_DM_API_DEACTIVATE* p_msg;
865
866 LOG(VERBOSE) << StringPrintf("%s: sleep_mode=%i", __func__, sleep_mode);
867
868 p_msg = (tNFA_DM_API_DEACTIVATE*)GKI_getbuf(
869 (uint16_t)(sizeof(tNFA_DM_API_DEACTIVATE)));
870 if (p_msg != nullptr) {
871 p_msg->hdr.event = NFA_DM_API_DEACTIVATE_EVT;
872 p_msg->sleep_mode = sleep_mode;
873
874 nfa_sys_sendmsg(p_msg);
875
876 return (NFA_STATUS_OK);
877 }
878
879 return (NFA_STATUS_FAILED);
880 }
881
882 /*******************************************************************************
883 **
884 ** Function NFA_SendRawFrame
885 **
886 ** Description Send a raw frame over the activated interface with the NFCC.
887 ** This function can only be called after NFC link is
888 ** activated.
889 **
890 ** If the activated interface is a tag and auto-presence check
891 ** is enabled then presence_check_start_delay can be used to
892 ** indicate the delay in msec after which the next auto
893 ** presence check command can be sent.
894 ** NFA_DM_DEFAULT_PRESENCE_CHECK_START_DELAY can be used as the
895 ** default value for the delay.
896 **
897 ** Returns NFA_STATUS_OK if successfully initiated
898 ** NFA_STATUS_FAILED otherwise
899 **
900 *******************************************************************************/
NFA_SendRawFrame(uint8_t * p_raw_data,uint16_t data_len,uint16_t presence_check_start_delay)901 tNFA_STATUS NFA_SendRawFrame(uint8_t* p_raw_data, uint16_t data_len,
902 uint16_t presence_check_start_delay) {
903 NFC_HDR* p_msg;
904 uint16_t size;
905 uint8_t* p;
906
907 LOG(VERBOSE) << StringPrintf("%s: data_len=%d", __func__, data_len);
908
909 size = NFC_HDR_SIZE + NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE + data_len;
910 /* Check for integer overflow */
911 if (size < data_len) {
912 android_errorWriteLog(0x534e4554, "120664978");
913 return NFA_STATUS_INVALID_PARAM;
914 }
915 p_msg = (NFC_HDR*)GKI_getbuf(size);
916 if (p_msg != nullptr) {
917 p_msg->event = NFA_DM_API_RAW_FRAME_EVT;
918 p_msg->layer_specific = presence_check_start_delay;
919 p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
920 p_msg->len = data_len;
921
922 p = (uint8_t*)(p_msg + 1) + p_msg->offset;
923 if ((data_len != 0) && (p_raw_data != nullptr)) {
924 memcpy(p, p_raw_data, data_len);
925 }
926
927 nfa_sys_sendmsg(p_msg);
928
929 return (NFA_STATUS_OK);
930 }
931
932 return (NFA_STATUS_FAILED);
933 }
934
935 /*******************************************************************************
936 ** NDEF Handler APIs
937 *******************************************************************************/
938
939 /*******************************************************************************
940 **
941 ** Function NFA_RegisterNDefTypeHandler
942 **
943 ** Description This function allows the applications to register for
944 ** specific types of NDEF records. When NDEF records are
945 ** received, NFA will parse the record-type field, and pass
946 ** the record to the registered tNFA_NDEF_CBACK.
947 **
948 ** For records types which were not registered, the record will
949 ** be sent to the default handler. A default type-handler may
950 ** be registered by calling this NFA_RegisterNDefTypeHandler
951 ** with tnf=NFA_TNF_DEFAULT. In this case, all un-registered
952 ** record types will be sent to the callback. Only one default
953 ** handler may be registered at a time.
954 **
955 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK
956 ** to indicate that registration was successful, and provide a
957 ** handle for this record type.
958 **
959 ** Returns NFA_STATUS_OK if successfully initiated
960 ** NFA_STATUS_FAILED otherwise
961 **
962 *******************************************************************************/
NFA_RegisterNDefTypeHandler(bool handle_whole_message,tNFA_TNF tnf,uint8_t * p_type_name,uint8_t type_name_len,tNFA_NDEF_CBACK * p_ndef_cback)963 tNFA_STATUS NFA_RegisterNDefTypeHandler(bool handle_whole_message, tNFA_TNF tnf,
964 uint8_t* p_type_name,
965 uint8_t type_name_len,
966 tNFA_NDEF_CBACK* p_ndef_cback) {
967 tNFA_DM_API_REG_NDEF_HDLR* p_msg;
968
969 LOG(VERBOSE) << StringPrintf(
970 "%s: handle whole ndef message=%i, "
971 "tnf=0x%02x",
972 __func__, handle_whole_message, tnf);
973
974 /* Check for NULL callback */
975 if (!p_ndef_cback) {
976 LOG(ERROR) << StringPrintf("%s: error - null callback", __func__);
977 return (NFA_STATUS_INVALID_PARAM);
978 }
979
980 p_msg = (tNFA_DM_API_REG_NDEF_HDLR*)GKI_getbuf(
981 (uint16_t)(sizeof(tNFA_DM_API_REG_NDEF_HDLR) + type_name_len));
982 if (p_msg != nullptr) {
983 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT;
984
985 p_msg->flags =
986 (handle_whole_message ? NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE : 0);
987 p_msg->tnf = tnf;
988 p_msg->name_len = type_name_len;
989 p_msg->p_ndef_cback = p_ndef_cback;
990 memcpy(p_msg->name, p_type_name, type_name_len);
991
992 nfa_sys_sendmsg(p_msg);
993
994 return (NFA_STATUS_OK);
995 }
996
997 return (NFA_STATUS_FAILED);
998 }
999
1000 /*******************************************************************************
1001 **
1002 ** Function NFA_RegisterNDefUriHandler
1003 **
1004 ** Description This API is a special-case of NFA_RegisterNDefTypeHandler
1005 ** with TNF=NFA_TNF_WKT, and type_name='U' (URI record); and
1006 ** allows registering for specific URI types (e.g. 'tel:' or
1007 ** 'mailto:').
1008 **
1009 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK
1010 ** to indicate that registration was successful, and provide a
1011 ** handle for this registration.
1012 **
1013 ** If uri_id=NFA_NDEF_URI_ID_ABSOLUTE, then p_abs_uri contains
1014 ** the unabridged URI. For all other uri_id values,
1015 ** the p_abs_uri parameter is ignored (i.e the URI prefix is
1016 ** implied by uri_id). See [NFC RTD URI] for more information.
1017 **
1018 ** Returns NFA_STATUS_OK if successfully initiated
1019 ** NFA_STATUS_FAILED otherwise
1020 **
1021 *******************************************************************************/
NFA_RegisterNDefUriHandler(bool handle_whole_message,tNFA_NDEF_URI_ID uri_id,uint8_t * p_abs_uri,uint8_t uri_id_len,tNFA_NDEF_CBACK * p_ndef_cback)1022 extern tNFA_STATUS NFA_RegisterNDefUriHandler(bool handle_whole_message,
1023 tNFA_NDEF_URI_ID uri_id,
1024 uint8_t* p_abs_uri,
1025 uint8_t uri_id_len,
1026 tNFA_NDEF_CBACK* p_ndef_cback) {
1027 tNFA_DM_API_REG_NDEF_HDLR* p_msg;
1028
1029 LOG(VERBOSE) << StringPrintf(
1030 "%s: handle whole ndef message=%i, "
1031 "uri_id=0x%02x",
1032 __func__, handle_whole_message, uri_id);
1033
1034 /* Check for NULL callback */
1035 if (!p_ndef_cback) {
1036 LOG(ERROR) << StringPrintf("%s: error - null callback", __func__);
1037 return (NFA_STATUS_INVALID_PARAM);
1038 }
1039
1040 p_msg = (tNFA_DM_API_REG_NDEF_HDLR*)GKI_getbuf(
1041 (uint16_t)(sizeof(tNFA_DM_API_REG_NDEF_HDLR) + uri_id_len));
1042 if (p_msg != nullptr) {
1043 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT;
1044
1045 p_msg->flags = NFA_NDEF_FLAGS_WKT_URI;
1046
1047 if (handle_whole_message) {
1048 p_msg->flags |= NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE;
1049 }
1050
1051 /* abs_uri is only valid fir uri_id=NFA_NDEF_URI_ID_ABSOLUTE */
1052 if (uri_id != NFA_NDEF_URI_ID_ABSOLUTE) {
1053 uri_id_len = 0;
1054 }
1055
1056 p_msg->tnf = NFA_TNF_WKT;
1057 p_msg->uri_id = uri_id;
1058 p_msg->name_len = uri_id_len;
1059 p_msg->p_ndef_cback = p_ndef_cback;
1060 memcpy(p_msg->name, p_abs_uri, uri_id_len);
1061
1062 nfa_sys_sendmsg(p_msg);
1063
1064 return (NFA_STATUS_OK);
1065 }
1066
1067 return (NFA_STATUS_FAILED);
1068 }
1069
1070 /*******************************************************************************
1071 **
1072 ** Function NFA_DeregisterNDefTypeHandler
1073 **
1074 ** Description Deregister NDEF record type handler.
1075 **
1076 ** Returns NFA_STATUS_OK if successfully initiated
1077 ** NFA_STATUS_FAILED otherwise
1078 **
1079 *******************************************************************************/
NFA_DeregisterNDefTypeHandler(tNFA_HANDLE ndef_type_handle)1080 extern tNFA_STATUS NFA_DeregisterNDefTypeHandler(tNFA_HANDLE ndef_type_handle) {
1081 tNFA_DM_API_DEREG_NDEF_HDLR* p_msg;
1082
1083 LOG(VERBOSE) << StringPrintf("%s: handle 0x%08x", __func__, ndef_type_handle);
1084
1085 p_msg = (tNFA_DM_API_DEREG_NDEF_HDLR*)GKI_getbuf(
1086 (uint16_t)(sizeof(tNFA_DM_API_DEREG_NDEF_HDLR)));
1087 if (p_msg != nullptr) {
1088 p_msg->hdr.event = NFA_DM_API_DEREG_NDEF_HDLR_EVT;
1089 p_msg->ndef_type_handle = ndef_type_handle;
1090
1091 nfa_sys_sendmsg(p_msg);
1092
1093 return (NFA_STATUS_OK);
1094 }
1095
1096 return (NFA_STATUS_FAILED);
1097 }
1098
1099 /*******************************************************************************
1100 **
1101 ** Function NFA_PowerOffSleepMode
1102 **
1103 ** Description This function is called to enter or leave NFCC Power Off
1104 ** Sleep mode NFA_DM_PWR_MODE_CHANGE_EVT will be sent to
1105 ** indicate status.
1106 **
1107 ** start_stop : TRUE if entering Power Off Sleep mode
1108 ** FALSE if leaving Power Off Sleep mode
1109 **
1110 ** Returns NFA_STATUS_OK if successfully initiated
1111 ** NFA_STATUS_FAILED otherwise
1112 **
1113 *******************************************************************************/
NFA_PowerOffSleepMode(bool start_stop)1114 tNFA_STATUS NFA_PowerOffSleepMode(bool start_stop) {
1115 NFC_HDR* p_msg;
1116
1117 LOG(VERBOSE) << StringPrintf("%s: start_stop=%d", __func__, start_stop);
1118
1119 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SETTING_PWR_MODE) {
1120 LOG(ERROR) << StringPrintf("%s: NFA DM is busy to update power mode",
1121 __func__);
1122 return (NFA_STATUS_FAILED);
1123 } else {
1124 nfa_dm_cb.flags |= NFA_DM_FLAGS_SETTING_PWR_MODE;
1125 }
1126
1127 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
1128 if (p_msg != nullptr) {
1129 p_msg->event = NFA_DM_API_POWER_OFF_SLEEP_EVT;
1130 p_msg->layer_specific = start_stop;
1131
1132 nfa_sys_sendmsg(p_msg);
1133
1134 return (NFA_STATUS_OK);
1135 }
1136
1137 return (NFA_STATUS_FAILED);
1138 }
1139
1140 /*******************************************************************************
1141 **
1142 ** Function NFA_RegVSCback
1143 **
1144 ** Description This function is called to register or de-register a
1145 ** callback function to receive Proprietary NCI response and
1146 ** notification events. The maximum number of callback
1147 ** functions allowed is NFC_NUM_VS_CBACKS
1148 **
1149 ** Returns tNFC_STATUS
1150 **
1151 *******************************************************************************/
NFA_RegVSCback(bool is_register,tNFA_VSC_CBACK * p_cback)1152 tNFC_STATUS NFA_RegVSCback(bool is_register, tNFA_VSC_CBACK* p_cback) {
1153 tNFA_DM_API_REG_VSC* p_msg;
1154
1155 LOG(VERBOSE) << StringPrintf("%s: is_register=%d", __func__, is_register);
1156
1157 if (p_cback == nullptr) {
1158 LOG(ERROR) << StringPrintf("%s: requires a valid callback function",
1159 __func__);
1160 return (NFA_STATUS_FAILED);
1161 }
1162
1163 p_msg = (tNFA_DM_API_REG_VSC*)GKI_getbuf(sizeof(tNFA_DM_API_REG_VSC));
1164 if (p_msg != nullptr) {
1165 p_msg->hdr.event = NFA_DM_API_REG_VSC_EVT;
1166 p_msg->is_register = is_register;
1167 p_msg->p_cback = p_cback;
1168
1169 nfa_sys_sendmsg(p_msg);
1170
1171 return (NFA_STATUS_OK);
1172 }
1173
1174 return (NFA_STATUS_FAILED);
1175 }
1176
1177 /*******************************************************************************
1178 **
1179 ** Function NFA_SendVsCommand
1180 **
1181 ** Description This function is called to send an NCI Vendor Specific
1182 ** command to NFCC.
1183 **
1184 ** oid - The opcode of the VS command.
1185 ** cmd_params_len - The command parameter len
1186 ** p_cmd_params - The command parameter
1187 ** p_cback - The callback function to receive the
1188 ** command status
1189 **
1190 ** Returns NFA_STATUS_OK if successfully initiated
1191 ** NFA_STATUS_FAILED otherwise
1192 **
1193 *******************************************************************************/
NFA_SendVsCommand(uint8_t oid,uint8_t cmd_params_len,uint8_t * p_cmd_params,tNFA_VSC_CBACK * p_cback)1194 tNFA_STATUS NFA_SendVsCommand(uint8_t oid, uint8_t cmd_params_len,
1195 uint8_t* p_cmd_params, tNFA_VSC_CBACK* p_cback) {
1196 tNFA_DM_API_SEND_VSC* p_msg;
1197 uint16_t size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len;
1198
1199 LOG(VERBOSE) << StringPrintf("%s: oid=0x%x", __func__, oid);
1200
1201 p_msg = (tNFA_DM_API_SEND_VSC*)GKI_getbuf(size);
1202 if (p_msg != nullptr) {
1203 p_msg->hdr.event = NFA_DM_API_SEND_VSC_EVT;
1204 p_msg->oid = oid;
1205 p_msg->p_cback = p_cback;
1206 if (cmd_params_len && p_cmd_params) {
1207 p_msg->cmd_params_len = cmd_params_len;
1208 p_msg->p_cmd_params = (uint8_t*)(p_msg + 1);
1209 memcpy(p_msg->p_cmd_params, p_cmd_params, cmd_params_len);
1210 } else {
1211 p_msg->cmd_params_len = 0;
1212 p_msg->p_cmd_params = nullptr;
1213 }
1214
1215 nfa_sys_sendmsg(p_msg);
1216
1217 return (NFA_STATUS_OK);
1218 }
1219
1220 return (NFA_STATUS_FAILED);
1221 }
1222
1223 /*******************************************************************************
1224 **
1225 ** Function NFA_SendRawVsCommand
1226 **
1227 ** Description This function is called to send raw Vendor Specific
1228 ** command to NFCC.
1229 **
1230 ** cmd_params_len - The command parameter len
1231 ** p_cmd_params - The command parameter
1232 ** p_cback - The callback function to receive the
1233 ** command
1234 **
1235 ** Returns NFA_STATUS_OK if successfully initiated
1236 ** NFA_STATUS_FAILED otherwise
1237 **
1238 *******************************************************************************/
NFA_SendRawVsCommand(uint8_t cmd_params_len,uint8_t * p_cmd_params,tNFA_VSC_CBACK * p_cback)1239 tNFA_STATUS NFA_SendRawVsCommand(uint8_t cmd_params_len, uint8_t* p_cmd_params,
1240 tNFA_VSC_CBACK* p_cback) {
1241 if (cmd_params_len == 0x00 || p_cmd_params == nullptr || p_cback == nullptr) {
1242 return NFA_STATUS_INVALID_PARAM;
1243 }
1244 uint16_t size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len;
1245 tNFA_DM_API_SEND_VSC* p_msg = (tNFA_DM_API_SEND_VSC*)GKI_getbuf(size);
1246
1247 if (p_msg != nullptr) {
1248 p_msg->hdr.event = NFA_DM_API_SEND_RAW_VS_EVT;
1249 p_msg->p_cback = p_cback;
1250 p_msg->cmd_params_len = cmd_params_len;
1251 p_msg->p_cmd_params = (uint8_t*)(p_msg + 1);
1252 memcpy(p_msg->p_cmd_params, p_cmd_params, cmd_params_len);
1253
1254 nfa_sys_sendmsg(p_msg);
1255
1256 return NFA_STATUS_OK;
1257 }
1258
1259 return NFA_STATUS_FAILED;
1260 }
1261
1262 /*******************************************************************************
1263 **
1264 ** Function: NFA_EnableDtamode
1265 **
1266 ** Description: Enable DTA Mode
1267 **
1268 ** Returns: none:
1269 **
1270 *******************************************************************************/
NFA_EnableDtamode(tNFA_eDtaModes eDtaMode)1271 void NFA_EnableDtamode(tNFA_eDtaModes eDtaMode) {
1272 LOG(VERBOSE) << StringPrintf("%s: eDtaMode=0x%x ", __func__, eDtaMode);
1273 appl_dta_mode_flag = 0x01;
1274 nfa_dm_cb.eDtaMode = eDtaMode;
1275 }
1276
1277 /*******************************************************************************
1278 **
1279 ** Function: NFA_DisableDtamode
1280 **
1281 ** Description: Disable DTA Mode
1282 **
1283 ** Returns: none:
1284 **
1285 *******************************************************************************/
NFA_DisableDtamode(void)1286 void NFA_DisableDtamode(void) {
1287 LOG(VERBOSE) << StringPrintf("%s: enter", __func__);
1288 appl_dta_mode_flag = 0x0;
1289 nfa_dm_cb.eDtaMode = NFA_DTA_APPL_MODE;
1290 }
1291
1292 /*******************************************************************************
1293 **
1294 ** Function: NFA_SetNfcSecure
1295 **
1296 ** Description: Prooagtes NFC secure settings to NFC TASK
1297 **
1298 ** Returns: none:
1299 **
1300 *******************************************************************************/
NFA_SetNfcSecure(bool status)1301 void NFA_SetNfcSecure(bool status) {
1302 LOG(DEBUG) << StringPrintf("%s: status=%d", __func__, status);
1303 nfa_dm_cb.is_nfc_secure = status;
1304 }
1305
1306 /*******************************************************************************
1307 **
1308 ** Function NFA_ChangeDiscoveryTech
1309 **
1310 ** Description Change RF discoverying technologies specified by
1311 ** pollTech and listenTech.
1312 **
1313 ** NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT will be returned.
1314 **
1315 ** If pollTech/listenTech are set to 0xFF, it revert to
1316 ** the polling/listening technologies
1317 ** before NFA_ChangeDiscoveryTech() was called.
1318 **
1319 ** is_revert_poll : TRUE if reverting RF polling tech
1320 ** before calling NFA_StopRfDiscovery
1321 ** FALSE if changing RF polling tech according
1322 ** to pollTech
1323 ** is_revert_listen : TRUE if reverting RF listening tech
1324 ** before calling NFA_StopRfDiscovery
1325 ** FALSE if changing RF listening tech according
1326 ** to listenTech
1327 ** change_default_tech : TRUE if the default technolofy mask
1328 ** has to be changed according to listenTech
1329 ** and pollTech settings
1330 **
1331 ** Note: If RF discovery is started,
1332 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT
1333 ** should happen before calling this function
1334 **
1335 ** Returns NFA_STATUS_OK if successfully initiated
1336 ** NFA_STATUS_FAILED otherwise
1337 **
1338 *******************************************************************************/
NFA_ChangeDiscoveryTech(tNFA_TECHNOLOGY_MASK pollTech,tNFA_TECHNOLOGY_MASK listenTech,bool is_revert_poll,bool is_revert_listen,bool change_default_tech)1339 tNFA_STATUS NFA_ChangeDiscoveryTech(tNFA_TECHNOLOGY_MASK pollTech,
1340 tNFA_TECHNOLOGY_MASK listenTech,
1341 bool is_revert_poll, bool is_revert_listen,
1342 bool change_default_tech) {
1343 tNFA_DM_API_CHANGE_DISCOVERY_TECH* p_msg;
1344 LOG(VERBOSE) << StringPrintf("%s: pollTech=0x%X listenTech=0x%X", __func__,
1345 pollTech, listenTech);
1346
1347 if ((p_msg = (tNFA_DM_API_CHANGE_DISCOVERY_TECH*)GKI_getbuf(
1348 sizeof(tNFA_DM_API_CHANGE_DISCOVERY_TECH))) != nullptr) {
1349 p_msg->hdr.event = NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT;
1350 p_msg->is_revert_poll = is_revert_poll;
1351 p_msg->is_revert_listen = is_revert_listen;
1352 p_msg->change_default_tech = change_default_tech;
1353 p_msg->change_poll_mask = pollTech;
1354 p_msg->change_listen_mask = listenTech;
1355
1356 nfa_sys_sendmsg(p_msg);
1357
1358 return (NFA_STATUS_OK);
1359 }
1360
1361 return (NFA_STATUS_FAILED);
1362 }
1363
1364 /*******************************************************************************
1365 **
1366 ** Function NFA_IsRfRemovalDetectionSupported
1367 **
1368 ** Description Indicates if RF Removal Detection mode is supported by NFCC
1369 ** and by activated RF Interface.
1370 **
1371 ** Returns true if supported else false.
1372 **
1373 *******************************************************************************/
NFA_IsRfRemovalDetectionSupported()1374 bool NFA_IsRfRemovalDetectionSupported() {
1375 return NFC_IsRfRemovalDetectionSupported();
1376 }
1377