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