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