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