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("Unknown Mode!");
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("error null callback");
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("NFA_Disable (graceful=%i)", 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("param_id:0x%X", 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("num_ids: %i", 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("poll_mask=0x%x", poll_mask);
392
393 if (!p_conn_cback) {
394 LOG(ERROR) << StringPrintf("error null callback");
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 "Exclusive rf control is not in "
438 "progress");
439 return (NFA_STATUS_FAILED);
440 }
441
442 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
443 if (p_msg != nullptr) {
444 p_msg->event = NFA_DM_API_RELEASE_EXCL_RF_CTRL_EVT;
445 nfa_sys_sendmsg(p_msg);
446 return (NFA_STATUS_OK);
447 }
448
449 return (NFA_STATUS_FAILED);
450 }
451
452 /*******************************************************************************
453 **
454 ** Function NFA_EnablePolling
455 **
456 ** Description Enable polling for technologies specified by poll_mask.
457 **
458 ** The following events (notified using the connection
459 ** callback registered with NFA_Enable) are generated during
460 ** polling:
461 **
462 ** - NFA_POLL_ENABLED_EVT indicates whether or not polling
463 ** successfully enabled.
464 ** - NFA_DISC_RESULT_EVT indicates there are more than one
465 ** devices, so application must select one of tags by calling
466 ** NFA_Select().
467 ** - NFA_SELECT_RESULT_EVT indicates whether previous selection
468 ** was successful or not. If it was failed then application
469 ** must select again or deactivate by calling
470 ** NFA_Deactivate().
471 ** - NFA_ACTIVATED_EVT is generated when an NFC link is
472 ** activated.
473 ** - NFA_NDEF_DETECT_EVT is generated if tag is activated
474 ** - NFA_DEACTIVATED_EVT will be returned after deactivating
475 ** NFC link.
476 **
477 ** Note: If RF discovery is started,
478 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
479 ** happen before calling this function
480 **
481 ** Returns NFA_STATUS_OK if successfully initiated
482 ** NFA_STATUS_FAILED otherwise
483 **
484 *******************************************************************************/
NFA_EnablePolling(tNFA_TECHNOLOGY_MASK poll_mask)485 tNFA_STATUS NFA_EnablePolling(tNFA_TECHNOLOGY_MASK poll_mask) {
486 tNFA_DM_API_ENABLE_POLL* p_msg;
487
488 LOG(VERBOSE) << StringPrintf("0x%X", poll_mask);
489
490 p_msg = (tNFA_DM_API_ENABLE_POLL*)GKI_getbuf(sizeof(tNFA_DM_API_ENABLE_POLL));
491 if (p_msg != nullptr) {
492 p_msg->hdr.event = NFA_DM_API_ENABLE_POLLING_EVT;
493 p_msg->poll_mask = poll_mask;
494
495 nfa_sys_sendmsg(p_msg);
496
497 return (NFA_STATUS_OK);
498 }
499
500 return (NFA_STATUS_FAILED);
501 }
502
503 /*******************************************************************************
504 **
505 ** Function NFA_DisablePolling
506 **
507 ** Description Disable polling
508 ** NFA_POLL_DISABLED_EVT will be returned after stopping
509 ** polling.
510 **
511 ** Note: If RF discovery is started,
512 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
513 ** happen before calling this function
514 **
515 ** Returns NFA_STATUS_OK if successfully initiated
516 ** NFA_STATUS_FAILED otherwise
517 **
518 *******************************************************************************/
NFA_DisablePolling(void)519 tNFA_STATUS NFA_DisablePolling(void) {
520 NFC_HDR* p_msg;
521
522 LOG(VERBOSE) << __func__;
523
524 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
525 if (p_msg != nullptr) {
526 p_msg->event = NFA_DM_API_DISABLE_POLLING_EVT;
527
528 nfa_sys_sendmsg(p_msg);
529
530 return (NFA_STATUS_OK);
531 }
532
533 return (NFA_STATUS_FAILED);
534 }
535
536 /*******************************************************************************
537 **
538 ** Function NFA_EnableListening
539 **
540 ** Description Enable listening.
541 ** NFA_LISTEN_ENABLED_EVT will be returned after listening is
542 ** allowed.
543 **
544 ** The actual listening technologies are specified by other NFA
545 ** API functions. Such functions include (but not limited to)
546 ** NFA_CeConfigureUiccListenTech.
547 ** If NFA_DisableListening () is called to ignore the listening
548 ** technologies, NFA_EnableListening () is called to restore
549 ** the listening technologies set by these functions.
550 **
551 ** Note: If RF discovery is started,
552 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
553 ** happen before calling this function
554 **
555 ** Returns NFA_STATUS_OK if successfully initiated
556 ** NFA_STATUS_FAILED otherwise
557 **
558 *******************************************************************************/
NFA_EnableListening(void)559 tNFA_STATUS NFA_EnableListening(void) {
560 NFC_HDR* p_msg;
561
562 LOG(VERBOSE) << __func__;
563
564 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
565 if (p_msg != nullptr) {
566 p_msg->event = NFA_DM_API_ENABLE_LISTENING_EVT;
567
568 nfa_sys_sendmsg(p_msg);
569
570 return (NFA_STATUS_OK);
571 }
572
573 return (NFA_STATUS_FAILED);
574 }
575
576 /*******************************************************************************
577 **
578 ** Function NFA_DisableListening
579 **
580 ** Description Disable listening
581 ** NFA_LISTEN_DISABLED_EVT will be returned after stopping
582 ** listening. This function is called to exclude listen at RF
583 ** discovery.
584 **
585 ** Note: If RF discovery is started,
586 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
587 ** happen before calling this function
588 **
589 ** Returns NFA_STATUS_OK if successfully initiated
590 ** NFA_STATUS_FAILED otherwise
591 **
592 *******************************************************************************/
NFA_DisableListening(void)593 tNFA_STATUS NFA_DisableListening(void) {
594 NFC_HDR* p_msg;
595
596 LOG(VERBOSE) << __func__;
597
598 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
599 if (p_msg != nullptr) {
600 p_msg->event = NFA_DM_API_DISABLE_LISTENING_EVT;
601
602 nfa_sys_sendmsg(p_msg);
603
604 return (NFA_STATUS_OK);
605 }
606
607 return (NFA_STATUS_FAILED);
608 }
609
610 /*******************************************************************************
611 **
612 ** Function NFA_StartRfDiscovery
613 **
614 ** Description Start RF discovery
615 ** RF discovery parameters shall be set by other APIs.
616 **
617 ** An NFA_RF_DISCOVERY_STARTED_EVT indicates whether starting
618 ** was successful or not.
619 **
620 ** Returns NFA_STATUS_OK if successfully initiated
621 ** NFA_STATUS_FAILED otherwise
622 **
623 *******************************************************************************/
NFA_StartRfDiscovery(void)624 tNFA_STATUS NFA_StartRfDiscovery(void) {
625 NFC_HDR* p_msg;
626
627 LOG(VERBOSE) << __func__;
628
629 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
630 if (p_msg != nullptr) {
631 p_msg->event = NFA_DM_API_START_RF_DISCOVERY_EVT;
632
633 nfa_sys_sendmsg(p_msg);
634
635 return (NFA_STATUS_OK);
636 }
637
638 return (NFA_STATUS_FAILED);
639 }
640
641 /*******************************************************************************
642 **
643 ** Function NFA_StopRfDiscovery
644 **
645 ** Description Stop RF discovery
646 **
647 ** An NFA_RF_DISCOVERY_STOPPED_EVT indicates whether stopping
648 ** was successful or not.
649 **
650 ** Returns NFA_STATUS_OK if successfully initiated
651 ** NFA_STATUS_FAILED otherwise
652 **
653 *******************************************************************************/
NFA_StopRfDiscovery(void)654 tNFA_STATUS NFA_StopRfDiscovery(void) {
655 NFC_HDR* p_msg;
656
657 LOG(VERBOSE) << __func__;
658
659 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
660 if (p_msg != nullptr) {
661 p_msg->event = NFA_DM_API_STOP_RF_DISCOVERY_EVT;
662
663 nfa_sys_sendmsg(p_msg);
664
665 return (NFA_STATUS_OK);
666 }
667
668 return (NFA_STATUS_FAILED);
669 }
670
671 /*******************************************************************************
672 **
673 ** Function NFA_SetRfDiscoveryDuration
674 **
675 ** Description Set the duration of the single discovery period in [ms].
676 ** Allowable range: 0 ms to 0xFFFF ms.
677 **
678 ** If discovery is already started, the application should
679 ** call NFA_StopRfDiscovery prior to calling
680 ** NFA_SetRfDiscoveryDuration, and then call
681 ** NFA_StartRfDiscovery afterwards to restart discovery using
682 ** the new duration.
683 **
684 ** Note: If RF discovery is started,
685 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
686 ** happen before calling this function
687 **
688 ** Returns:
689 ** NFA_STATUS_OK, if command accepted
690 ** NFA_STATUS_FAILED: otherwise
691 **
692 *******************************************************************************/
NFA_SetRfDiscoveryDuration(uint16_t discovery_period_ms)693 tNFA_STATUS NFA_SetRfDiscoveryDuration(uint16_t discovery_period_ms) {
694 tNFA_DM_API_SET_RF_DISC_DUR* p_msg;
695
696 LOG(VERBOSE) << __func__;
697
698 /* Post the API message */
699 p_msg = (tNFA_DM_API_SET_RF_DISC_DUR*)GKI_getbuf(
700 sizeof(tNFA_DM_API_SET_RF_DISC_DUR));
701 if (p_msg != nullptr) {
702 p_msg->hdr.event = NFA_DM_API_SET_RF_DISC_DURATION_EVT;
703
704 /* Set discovery duration */
705 p_msg->rf_disc_dur_ms = discovery_period_ms;
706
707 nfa_sys_sendmsg(p_msg);
708
709 return (NFA_STATUS_OK);
710 }
711
712 return (NFA_STATUS_FAILED);
713 }
714
715 /*******************************************************************************
716 **
717 ** Function NFA_Select
718 **
719 ** Description Select one from detected devices during discovery
720 ** (from NFA_DISC_RESULT_EVTs). The application should wait for
721 ** the final NFA_DISC_RESULT_EVT before selecting.
722 **
723 ** An NFA_SELECT_RESULT_EVT indicates whether selection was
724 ** successful or not. If failed then application must select
725 ** again or deactivate by NFA_Deactivate().
726 **
727 ** Returns NFA_STATUS_OK if successfully initiated
728 ** NFA_STATUS_INVALID_PARAM if RF interface is not matched
729 ** protocol
730 ** NFA_STATUS_FAILED otherwise
731 **
732 *******************************************************************************/
NFA_Select(uint8_t rf_disc_id,tNFA_NFC_PROTOCOL protocol,tNFA_INTF_TYPE rf_interface)733 tNFA_STATUS NFA_Select(uint8_t rf_disc_id, tNFA_NFC_PROTOCOL protocol,
734 tNFA_INTF_TYPE rf_interface) {
735 tNFA_DM_API_SELECT* p_msg;
736
737 LOG(VERBOSE) << StringPrintf(
738 "rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X", rf_disc_id, protocol,
739 rf_interface);
740
741 if ((rf_interface == NFA_INTERFACE_ISO_DEP) &&
742 (protocol != NFA_PROTOCOL_ISO_DEP)) {
743 LOG(ERROR) << StringPrintf("%s; RF interface is not matched protocol",
744 __func__);
745 return (NFA_STATUS_INVALID_PARAM);
746 }
747
748 p_msg =
749 (tNFA_DM_API_SELECT*)GKI_getbuf((uint16_t)(sizeof(tNFA_DM_API_SELECT)));
750 if (p_msg != nullptr) {
751 p_msg->hdr.event = NFA_DM_API_SELECT_EVT;
752 p_msg->rf_disc_id = rf_disc_id;
753 p_msg->protocol = protocol;
754 p_msg->rf_interface = rf_interface;
755
756 nfa_sys_sendmsg(p_msg);
757
758 return (NFA_STATUS_OK);
759 }
760
761 return (NFA_STATUS_FAILED);
762 }
763
764 /*******************************************************************************
765 **
766 ** Function NFA_UpdateRFCommParams
767 **
768 ** Description This function is called to update RF Communication
769 ** parameters once the Frame RF Interface has been activated.
770 **
771 ** An NFA_UPDATE_RF_PARAM_RESULT_EVT indicates whether updating
772 ** was successful or not.
773 **
774 ** Returns NFA_STATUS_OK if successfully initiated
775 ** NFA_STATUS_FAILED otherwise
776 **
777 *******************************************************************************/
NFA_UpdateRFCommParams(tNFA_RF_COMM_PARAMS * p_params)778 tNFA_STATUS NFA_UpdateRFCommParams(tNFA_RF_COMM_PARAMS* p_params) {
779 tNFA_DM_API_UPDATE_RF_PARAMS* p_msg;
780
781 LOG(VERBOSE) << __func__;
782
783 p_msg = (tNFA_DM_API_UPDATE_RF_PARAMS*)GKI_getbuf(
784 (uint16_t)(sizeof(tNFA_DM_API_UPDATE_RF_PARAMS)));
785 if (p_msg != nullptr) {
786 p_msg->hdr.event = NFA_DM_API_UPDATE_RF_PARAMS_EVT;
787 memcpy(&p_msg->params, p_params, sizeof(tNFA_RF_COMM_PARAMS));
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_Deactivate
800 **
801 ** Description
802 ** If sleep_mode=TRUE:
803 ** Deselect the activated device by deactivating into sleep
804 ** mode.
805 **
806 ** An NFA_DEACTIVATE_FAIL_EVT indicates that selection was
807 ** not successful. Application can select another
808 ** discovered device or deactivate by NFA_Deactivate()
809 ** after receiving NFA_DEACTIVATED_EVT.
810 **
811 ** Deactivating to sleep mode is not allowed when NFCC is
812 ** in wait-for-host-select mode, or in listen-sleep states;
813 ** NFA will deactivate to idle or discovery state for these
814 ** cases respectively.
815 **
816 **
817 ** If sleep_mode=FALSE:
818 ** Deactivate the connection (e.g. as a result of presence
819 ** check failure) NFA_DEACTIVATED_EVT will indicate that
820 ** link is deactivated. Polling/listening will resume
821 ** (unless the nfcc is in wait_for-all-discoveries state)
822 **
823 **
824 ** Returns NFA_STATUS_OK if successfully initiated
825 ** NFA_STATUS_FAILED otherwise
826 **
827 *******************************************************************************/
NFA_Deactivate(bool sleep_mode)828 extern tNFA_STATUS NFA_Deactivate(bool sleep_mode) {
829 tNFA_DM_API_DEACTIVATE* p_msg;
830
831 LOG(VERBOSE) << StringPrintf("sleep_mode:%i", sleep_mode);
832
833 p_msg = (tNFA_DM_API_DEACTIVATE*)GKI_getbuf(
834 (uint16_t)(sizeof(tNFA_DM_API_DEACTIVATE)));
835 if (p_msg != nullptr) {
836 p_msg->hdr.event = NFA_DM_API_DEACTIVATE_EVT;
837 p_msg->sleep_mode = sleep_mode;
838
839 nfa_sys_sendmsg(p_msg);
840
841 return (NFA_STATUS_OK);
842 }
843
844 return (NFA_STATUS_FAILED);
845 }
846
847 /*******************************************************************************
848 **
849 ** Function NFA_SendRawFrame
850 **
851 ** Description Send a raw frame over the activated interface with the NFCC.
852 ** This function can only be called after NFC link is
853 ** activated.
854 **
855 ** If the activated interface is a tag and auto-presence check
856 ** is enabled then presence_check_start_delay can be used to
857 ** indicate the delay in msec after which the next auto
858 ** presence check command can be sent.
859 ** NFA_DM_DEFAULT_PRESENCE_CHECK_START_DELAY can be used as the
860 ** default value for the delay.
861 **
862 ** Returns NFA_STATUS_OK if successfully initiated
863 ** NFA_STATUS_FAILED otherwise
864 **
865 *******************************************************************************/
NFA_SendRawFrame(uint8_t * p_raw_data,uint16_t data_len,uint16_t presence_check_start_delay)866 tNFA_STATUS NFA_SendRawFrame(uint8_t* p_raw_data, uint16_t data_len,
867 uint16_t presence_check_start_delay) {
868 NFC_HDR* p_msg;
869 uint16_t size;
870 uint8_t* p;
871
872 LOG(VERBOSE) << StringPrintf("data_len:%d", data_len);
873
874 size = NFC_HDR_SIZE + NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE + data_len;
875 /* Check for integer overflow */
876 if (size < data_len) {
877 android_errorWriteLog(0x534e4554, "120664978");
878 return NFA_STATUS_INVALID_PARAM;
879 }
880 p_msg = (NFC_HDR*)GKI_getbuf(size);
881 if (p_msg != nullptr) {
882 p_msg->event = NFA_DM_API_RAW_FRAME_EVT;
883 p_msg->layer_specific = presence_check_start_delay;
884 p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
885 p_msg->len = data_len;
886
887 p = (uint8_t*)(p_msg + 1) + p_msg->offset;
888 if ((data_len != 0) && (p_raw_data != nullptr)) {
889 memcpy(p, p_raw_data, data_len);
890 }
891
892 nfa_sys_sendmsg(p_msg);
893
894 return (NFA_STATUS_OK);
895 }
896
897 return (NFA_STATUS_FAILED);
898 }
899
900 /*******************************************************************************
901 ** NDEF Handler APIs
902 *******************************************************************************/
903
904 /*******************************************************************************
905 **
906 ** Function NFA_RegisterNDefTypeHandler
907 **
908 ** Description This function allows the applications to register for
909 ** specific types of NDEF records. When NDEF records are
910 ** received, NFA will parse the record-type field, and pass
911 ** the record to the registered tNFA_NDEF_CBACK.
912 **
913 ** For records types which were not registered, the record will
914 ** be sent to the default handler. A default type-handler may
915 ** be registered by calling this NFA_RegisterNDefTypeHandler
916 ** with tnf=NFA_TNF_DEFAULT. In this case, all un-registered
917 ** record types will be sent to the callback. Only one default
918 ** handler may be registered at a time.
919 **
920 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK
921 ** to indicate that registration was successful, and provide a
922 ** handle for this record type.
923 **
924 ** Returns NFA_STATUS_OK if successfully initiated
925 ** NFA_STATUS_FAILED otherwise
926 **
927 *******************************************************************************/
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)928 tNFA_STATUS NFA_RegisterNDefTypeHandler(bool handle_whole_message, tNFA_TNF tnf,
929 uint8_t* p_type_name,
930 uint8_t type_name_len,
931 tNFA_NDEF_CBACK* p_ndef_cback) {
932 tNFA_DM_API_REG_NDEF_HDLR* p_msg;
933
934 LOG(VERBOSE) << StringPrintf(
935 "handle whole ndef message: %i, "
936 "tnf=0x%02x",
937 handle_whole_message, tnf);
938
939 /* Check for NULL callback */
940 if (!p_ndef_cback) {
941 LOG(ERROR) << StringPrintf("error - null callback");
942 return (NFA_STATUS_INVALID_PARAM);
943 }
944
945 p_msg = (tNFA_DM_API_REG_NDEF_HDLR*)GKI_getbuf(
946 (uint16_t)(sizeof(tNFA_DM_API_REG_NDEF_HDLR) + type_name_len));
947 if (p_msg != nullptr) {
948 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT;
949
950 p_msg->flags =
951 (handle_whole_message ? NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE : 0);
952 p_msg->tnf = tnf;
953 p_msg->name_len = type_name_len;
954 p_msg->p_ndef_cback = p_ndef_cback;
955 memcpy(p_msg->name, p_type_name, type_name_len);
956
957 nfa_sys_sendmsg(p_msg);
958
959 return (NFA_STATUS_OK);
960 }
961
962 return (NFA_STATUS_FAILED);
963 }
964
965 /*******************************************************************************
966 **
967 ** Function NFA_RegisterNDefUriHandler
968 **
969 ** Description This API is a special-case of NFA_RegisterNDefTypeHandler
970 ** with TNF=NFA_TNF_WKT, and type_name='U' (URI record); and
971 ** allows registering for specific URI types (e.g. 'tel:' or
972 ** 'mailto:').
973 **
974 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK
975 ** to indicate that registration was successful, and provide a
976 ** handle for this registration.
977 **
978 ** If uri_id=NFA_NDEF_URI_ID_ABSOLUTE, then p_abs_uri contains
979 ** the unabridged URI. For all other uri_id values,
980 ** the p_abs_uri parameter is ignored (i.e the URI prefix is
981 ** implied by uri_id). See [NFC RTD URI] for more information.
982 **
983 ** Returns NFA_STATUS_OK if successfully initiated
984 ** NFA_STATUS_FAILED otherwise
985 **
986 *******************************************************************************/
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)987 extern tNFA_STATUS NFA_RegisterNDefUriHandler(bool handle_whole_message,
988 tNFA_NDEF_URI_ID uri_id,
989 uint8_t* p_abs_uri,
990 uint8_t uri_id_len,
991 tNFA_NDEF_CBACK* p_ndef_cback) {
992 tNFA_DM_API_REG_NDEF_HDLR* p_msg;
993
994 LOG(VERBOSE) << StringPrintf(
995 "handle whole ndef message: %i, "
996 "uri_id=0x%02x",
997 handle_whole_message, uri_id);
998
999 /* Check for NULL callback */
1000 if (!p_ndef_cback) {
1001 LOG(ERROR) << StringPrintf("error - null callback");
1002 return (NFA_STATUS_INVALID_PARAM);
1003 }
1004
1005 p_msg = (tNFA_DM_API_REG_NDEF_HDLR*)GKI_getbuf(
1006 (uint16_t)(sizeof(tNFA_DM_API_REG_NDEF_HDLR) + uri_id_len));
1007 if (p_msg != nullptr) {
1008 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT;
1009
1010 p_msg->flags = NFA_NDEF_FLAGS_WKT_URI;
1011
1012 if (handle_whole_message) {
1013 p_msg->flags |= NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE;
1014 }
1015
1016 /* abs_uri is only valid fir uri_id=NFA_NDEF_URI_ID_ABSOLUTE */
1017 if (uri_id != NFA_NDEF_URI_ID_ABSOLUTE) {
1018 uri_id_len = 0;
1019 }
1020
1021 p_msg->tnf = NFA_TNF_WKT;
1022 p_msg->uri_id = uri_id;
1023 p_msg->name_len = uri_id_len;
1024 p_msg->p_ndef_cback = p_ndef_cback;
1025 memcpy(p_msg->name, p_abs_uri, uri_id_len);
1026
1027 nfa_sys_sendmsg(p_msg);
1028
1029 return (NFA_STATUS_OK);
1030 }
1031
1032 return (NFA_STATUS_FAILED);
1033 }
1034
1035 /*******************************************************************************
1036 **
1037 ** Function NFA_DeregisterNDefTypeHandler
1038 **
1039 ** Description Deregister NDEF record type handler.
1040 **
1041 ** Returns NFA_STATUS_OK if successfully initiated
1042 ** NFA_STATUS_FAILED otherwise
1043 **
1044 *******************************************************************************/
NFA_DeregisterNDefTypeHandler(tNFA_HANDLE ndef_type_handle)1045 extern tNFA_STATUS NFA_DeregisterNDefTypeHandler(tNFA_HANDLE ndef_type_handle) {
1046 tNFA_DM_API_DEREG_NDEF_HDLR* p_msg;
1047
1048 LOG(VERBOSE) << StringPrintf("handle 0x%08x", ndef_type_handle);
1049
1050 p_msg = (tNFA_DM_API_DEREG_NDEF_HDLR*)GKI_getbuf(
1051 (uint16_t)(sizeof(tNFA_DM_API_DEREG_NDEF_HDLR)));
1052 if (p_msg != nullptr) {
1053 p_msg->hdr.event = NFA_DM_API_DEREG_NDEF_HDLR_EVT;
1054 p_msg->ndef_type_handle = ndef_type_handle;
1055
1056 nfa_sys_sendmsg(p_msg);
1057
1058 return (NFA_STATUS_OK);
1059 }
1060
1061 return (NFA_STATUS_FAILED);
1062 }
1063
1064 /*******************************************************************************
1065 **
1066 ** Function NFA_PowerOffSleepMode
1067 **
1068 ** Description This function is called to enter or leave NFCC Power Off
1069 ** Sleep mode NFA_DM_PWR_MODE_CHANGE_EVT will be sent to
1070 ** indicate status.
1071 **
1072 ** start_stop : TRUE if entering Power Off Sleep mode
1073 ** FALSE if leaving Power Off Sleep mode
1074 **
1075 ** Returns NFA_STATUS_OK if successfully initiated
1076 ** NFA_STATUS_FAILED otherwise
1077 **
1078 *******************************************************************************/
NFA_PowerOffSleepMode(bool start_stop)1079 tNFA_STATUS NFA_PowerOffSleepMode(bool start_stop) {
1080 NFC_HDR* p_msg;
1081
1082 LOG(VERBOSE) << StringPrintf("start_stop=%d", start_stop);
1083
1084 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SETTING_PWR_MODE) {
1085 LOG(ERROR) << StringPrintf("NFA DM is busy to update power mode");
1086 return (NFA_STATUS_FAILED);
1087 } else {
1088 nfa_dm_cb.flags |= NFA_DM_FLAGS_SETTING_PWR_MODE;
1089 }
1090
1091 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
1092 if (p_msg != nullptr) {
1093 p_msg->event = NFA_DM_API_POWER_OFF_SLEEP_EVT;
1094 p_msg->layer_specific = start_stop;
1095
1096 nfa_sys_sendmsg(p_msg);
1097
1098 return (NFA_STATUS_OK);
1099 }
1100
1101 return (NFA_STATUS_FAILED);
1102 }
1103
1104 /*******************************************************************************
1105 **
1106 ** Function NFA_RegVSCback
1107 **
1108 ** Description This function is called to register or de-register a
1109 ** callback function to receive Proprietary NCI response and
1110 ** notification events. The maximum number of callback
1111 ** functions allowed is NFC_NUM_VS_CBACKS
1112 **
1113 ** Returns tNFC_STATUS
1114 **
1115 *******************************************************************************/
NFA_RegVSCback(bool is_register,tNFA_VSC_CBACK * p_cback)1116 tNFC_STATUS NFA_RegVSCback(bool is_register, tNFA_VSC_CBACK* p_cback) {
1117 tNFA_DM_API_REG_VSC* p_msg;
1118
1119 LOG(VERBOSE) << StringPrintf("is_register=%d", is_register);
1120
1121 if (p_cback == nullptr) {
1122 LOG(ERROR) << StringPrintf("requires a valid callback function");
1123 return (NFA_STATUS_FAILED);
1124 }
1125
1126 p_msg = (tNFA_DM_API_REG_VSC*)GKI_getbuf(sizeof(tNFA_DM_API_REG_VSC));
1127 if (p_msg != nullptr) {
1128 p_msg->hdr.event = NFA_DM_API_REG_VSC_EVT;
1129 p_msg->is_register = is_register;
1130 p_msg->p_cback = p_cback;
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_SendVsCommand
1143 **
1144 ** Description This function is called to send an NCI Vendor Specific
1145 ** command to NFCC.
1146 **
1147 ** oid - The opcode of the VS command.
1148 ** cmd_params_len - The command parameter len
1149 ** p_cmd_params - The command parameter
1150 ** p_cback - The callback function to receive the
1151 ** command status
1152 **
1153 ** Returns NFA_STATUS_OK if successfully initiated
1154 ** NFA_STATUS_FAILED otherwise
1155 **
1156 *******************************************************************************/
NFA_SendVsCommand(uint8_t oid,uint8_t cmd_params_len,uint8_t * p_cmd_params,tNFA_VSC_CBACK * p_cback)1157 tNFA_STATUS NFA_SendVsCommand(uint8_t oid, uint8_t cmd_params_len,
1158 uint8_t* p_cmd_params, tNFA_VSC_CBACK* p_cback) {
1159 tNFA_DM_API_SEND_VSC* p_msg;
1160 uint16_t size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len;
1161
1162 LOG(VERBOSE) << StringPrintf("oid=0x%x", oid);
1163
1164 p_msg = (tNFA_DM_API_SEND_VSC*)GKI_getbuf(size);
1165 if (p_msg != nullptr) {
1166 p_msg->hdr.event = NFA_DM_API_SEND_VSC_EVT;
1167 p_msg->oid = oid;
1168 p_msg->p_cback = p_cback;
1169 if (cmd_params_len && p_cmd_params) {
1170 p_msg->cmd_params_len = cmd_params_len;
1171 p_msg->p_cmd_params = (uint8_t*)(p_msg + 1);
1172 memcpy(p_msg->p_cmd_params, p_cmd_params, cmd_params_len);
1173 } else {
1174 p_msg->cmd_params_len = 0;
1175 p_msg->p_cmd_params = nullptr;
1176 }
1177
1178 nfa_sys_sendmsg(p_msg);
1179
1180 return (NFA_STATUS_OK);
1181 }
1182
1183 return (NFA_STATUS_FAILED);
1184 }
1185
1186 /*******************************************************************************
1187 **
1188 ** Function NFA_SendRawVsCommand
1189 **
1190 ** Description This function is called to send raw Vendor Specific
1191 ** command to NFCC.
1192 **
1193 ** cmd_params_len - The command parameter len
1194 ** p_cmd_params - The command parameter
1195 ** p_cback - The callback function to receive the
1196 ** command
1197 **
1198 ** Returns NFA_STATUS_OK if successfully initiated
1199 ** NFA_STATUS_FAILED otherwise
1200 **
1201 *******************************************************************************/
NFA_SendRawVsCommand(uint8_t cmd_params_len,uint8_t * p_cmd_params,tNFA_VSC_CBACK * p_cback)1202 tNFA_STATUS NFA_SendRawVsCommand(uint8_t cmd_params_len, uint8_t* p_cmd_params,
1203 tNFA_VSC_CBACK* p_cback) {
1204 if (cmd_params_len == 0x00 || p_cmd_params == nullptr || p_cback == nullptr) {
1205 return NFA_STATUS_INVALID_PARAM;
1206 }
1207 uint16_t size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len;
1208 tNFA_DM_API_SEND_VSC* p_msg = (tNFA_DM_API_SEND_VSC*)GKI_getbuf(size);
1209
1210 if (p_msg != nullptr) {
1211 p_msg->hdr.event = NFA_DM_API_SEND_RAW_VS_EVT;
1212 p_msg->p_cback = p_cback;
1213 p_msg->cmd_params_len = cmd_params_len;
1214 p_msg->p_cmd_params = (uint8_t*)(p_msg + 1);
1215 memcpy(p_msg->p_cmd_params, p_cmd_params, cmd_params_len);
1216
1217 nfa_sys_sendmsg(p_msg);
1218
1219 return NFA_STATUS_OK;
1220 }
1221
1222 return NFA_STATUS_FAILED;
1223 }
1224
1225 /*******************************************************************************
1226 **
1227 ** Function: NFA_EnableDtamode
1228 **
1229 ** Description: Enable DTA Mode
1230 **
1231 ** Returns: none:
1232 **
1233 *******************************************************************************/
NFA_EnableDtamode(tNFA_eDtaModes eDtaMode)1234 void NFA_EnableDtamode(tNFA_eDtaModes eDtaMode) {
1235 LOG(VERBOSE) << StringPrintf("%s: 0x%x ", __func__, eDtaMode);
1236 appl_dta_mode_flag = 0x01;
1237 nfa_dm_cb.eDtaMode = eDtaMode;
1238 }
1239
1240 /*******************************************************************************
1241 **
1242 ** Function: NFA_DisableDtamode
1243 **
1244 ** Description: Disable DTA Mode
1245 **
1246 ** Returns: none:
1247 **
1248 *******************************************************************************/
NFA_DisableDtamode(void)1249 void NFA_DisableDtamode(void) {
1250 LOG(VERBOSE) << StringPrintf("%s: enter", __func__);
1251 appl_dta_mode_flag = 0x0;
1252 nfa_dm_cb.eDtaMode = NFA_DTA_APPL_MODE;
1253 }
1254
1255 /*******************************************************************************
1256 **
1257 ** Function: NFA_SetNfcSecure
1258 **
1259 ** Description: Prooagtes NFC secure settings to NFC TASK
1260 **
1261 ** Returns: none:
1262 **
1263 *******************************************************************************/
NFA_SetNfcSecure(bool status)1264 void NFA_SetNfcSecure(bool status) {
1265 LOG(DEBUG) << StringPrintf("%s; status: %d", __func__, status);
1266 nfa_dm_cb.is_nfc_secure = status;
1267 }
1268
1269 /*******************************************************************************
1270 **
1271 ** Function NFA_ChangeDiscoveryTech
1272 **
1273 ** Description Change RF discoverying technologies specified by
1274 ** pollTech and listenTech.
1275 **
1276 ** NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT will be returned.
1277 **
1278 ** If pollTech/listenTech are set to 0xFF, it revert to
1279 ** the polling/listening technologies
1280 ** before NFA_ChangeDiscoveryTech() was called.
1281 **
1282 ** is_revert_poll : TRUE if reverting RF polling tech
1283 ** before calling NFA_StopRfDiscovery
1284 ** FALSE if changing RF polling tech according
1285 ** to pollTech
1286 ** is_revert_listen : TRUE if reverting RF listening tech
1287 ** before calling NFA_StopRfDiscovery
1288 ** FALSE if changing RF listening tech according
1289 ** to listenTech
1290 ** change_default_tech : TRUE if the default technolofy mask
1291 ** has to be changed according to listenTech
1292 ** and pollTech settings
1293 **
1294 ** Note: If RF discovery is started,
1295 ** NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT
1296 ** should happen before calling this function
1297 **
1298 ** Returns NFA_STATUS_OK if successfully initiated
1299 ** NFA_STATUS_FAILED otherwise
1300 **
1301 *******************************************************************************/
NFA_ChangeDiscoveryTech(tNFA_TECHNOLOGY_MASK pollTech,tNFA_TECHNOLOGY_MASK listenTech,bool is_revert_poll,bool is_revert_listen,bool change_default_tech)1302 tNFA_STATUS NFA_ChangeDiscoveryTech(tNFA_TECHNOLOGY_MASK pollTech,
1303 tNFA_TECHNOLOGY_MASK listenTech,
1304 bool is_revert_poll, bool is_revert_listen,
1305 bool change_default_tech) {
1306 tNFA_DM_API_CHANGE_DISCOVERY_TECH* p_msg;
1307 LOG(VERBOSE) << StringPrintf("%s: 0x%X 0x%X", __func__, pollTech, listenTech);
1308
1309 if ((p_msg = (tNFA_DM_API_CHANGE_DISCOVERY_TECH*)GKI_getbuf(
1310 sizeof(tNFA_DM_API_CHANGE_DISCOVERY_TECH))) != nullptr) {
1311 p_msg->hdr.event = NFA_DM_API_CHANGE_DISCOVERY_TECH_EVT;
1312 p_msg->is_revert_poll = is_revert_poll;
1313 p_msg->is_revert_listen = is_revert_listen;
1314 p_msg->change_default_tech = change_default_tech;
1315 p_msg->change_poll_mask = pollTech;
1316 p_msg->change_listen_mask = listenTech;
1317
1318 nfa_sys_sendmsg(p_msg);
1319
1320 return (NFA_STATUS_OK);
1321 }
1322
1323 return (NFA_STATUS_FAILED);
1324 }
1325