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 * This is the main implementation file for the NFA P2P.
22 *
23 ******************************************************************************/
24 #include <string>
25
26 #include <android-base/stringprintf.h>
27 #include <base/logging.h>
28
29 #include "llcp_api.h"
30 #include "nfa_dm_int.h"
31 #include "nfa_p2p_int.h"
32
33 using android::base::StringPrintf;
34
35 extern bool nfc_debug_enabled;
36
37 /*****************************************************************************
38 ** Global Variables
39 *****************************************************************************/
40
41 /* system manager control block definition */
42 tNFA_P2P_CB nfa_p2p_cb;
43
44 /*****************************************************************************
45 ** Static Functions
46 *****************************************************************************/
47
48 /* event handler function type */
49 static bool nfa_p2p_evt_hdlr(NFC_HDR* p_msg);
50
51 /* disable function type */
52 static void nfa_p2p_sys_disable(void);
53 static void nfa_p2p_update_active_listen(void);
54
55 /* debug functions type */
56 static std::string nfa_p2p_llcp_state_code(tNFA_P2P_LLCP_STATE state_code);
57 static std::string nfa_p2p_evt_code(uint16_t evt_code);
58
59 /*****************************************************************************
60 ** Constants
61 *****************************************************************************/
62 /* timeout to restore active listen mode if no RF activation on passive mode */
63 #define NFA_P2P_RESTORE_ACTIVE_LISTEN_TIMEOUT 5000
64
65 static const tNFA_SYS_REG nfa_p2p_sys_reg = {nullptr, nfa_p2p_evt_hdlr,
66 nfa_p2p_sys_disable, nullptr};
67
68 #define NFA_P2P_NUM_ACTIONS (NFA_P2P_LAST_EVT & 0x00ff)
69
70 /* type for action functions */
71 typedef bool (*tNFA_P2P_ACTION)(tNFA_P2P_MSG* p_data);
72
73 /* action function list */
74 const tNFA_P2P_ACTION nfa_p2p_action[] = {
75 nfa_p2p_reg_server, /* NFA_P2P_API_REG_SERVER_EVT */
76 nfa_p2p_reg_client, /* NFA_P2P_API_REG_CLIENT_EVT */
77 nfa_p2p_dereg, /* NFA_P2P_API_DEREG_EVT */
78 nfa_p2p_accept_connection, /* NFA_P2P_API_ACCEPT_CONN_EVT */
79 nfa_p2p_reject_connection, /* NFA_P2P_API_REJECT_CONN_EVT */
80 nfa_p2p_disconnect, /* NFA_P2P_API_DISCONNECT_EVT */
81 nfa_p2p_create_data_link_connection, /* NFA_P2P_API_CONNECT_EVT */
82 nfa_p2p_send_ui, /* NFA_P2P_API_SEND_UI_EVT */
83 nfa_p2p_send_data, /* NFA_P2P_API_SEND_DATA_EVT */
84 nfa_p2p_set_local_busy, /* NFA_P2P_API_SET_LOCAL_BUSY_EVT */
85 nfa_p2p_get_link_info, /* NFA_P2P_API_GET_LINK_INFO_EVT */
86 nfa_p2p_get_remote_sap, /* NFA_P2P_API_GET_REMOTE_SAP_EVT */
87 nfa_p2p_set_llcp_cfg, /* NFA_P2P_API_SET_LLCP_CFG_EVT */
88 nfa_p2p_restart_rf_discovery /* NFA_P2P_INT_RESTART_RF_DISC_EVT */
89 };
90
91 /*******************************************************************************
92 **
93 ** Function nfa_p2p_discovery_cback
94 **
95 ** Description Processing event from discovery callback for listening
96 **
97 **
98 ** Returns None
99 **
100 *******************************************************************************/
nfa_p2p_discovery_cback(tNFA_DM_RF_DISC_EVT event,tNFC_DISCOVER * p_data)101 void nfa_p2p_discovery_cback(tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER* p_data) {
102 tNFA_CONN_EVT_DATA evt_data;
103
104 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event:0x%02X", event);
105
106 switch (event) {
107 case NFA_DM_RF_DISC_START_EVT:
108 if (p_data->status == NFC_STATUS_OK) {
109 nfa_p2p_cb.llcp_state = NFA_P2P_LLCP_STATE_LISTENING;
110 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_DISCOVERY;
111 }
112 break;
113
114 case NFA_DM_RF_DISC_ACTIVATED_EVT:
115
116 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_LISTEN_ACTIVE;
117
118 /* notify NFC link activation */
119 memcpy(&(evt_data.activated.activate_ntf), &(p_data->activate),
120 sizeof(tNFC_ACTIVATE_DEVT));
121 nfa_dm_conn_cback_event_notify(NFA_ACTIVATED_EVT, &evt_data);
122
123 if ((p_data->activate.protocol == NFC_PROTOCOL_NFC_DEP) &&
124 (p_data->activate.intf_param.type == NFC_INTERFACE_NFC_DEP)) {
125 nfa_p2p_activate_llcp(p_data);
126
127 /* stop timer not to deactivate LLCP link on passive mode */
128 nfa_sys_stop_timer(&nfa_p2p_cb.active_listen_restore_timer);
129 }
130 break;
131
132 case NFA_DM_RF_DISC_DEACTIVATED_EVT:
133
134 if ((nfa_p2p_cb.rf_disc_state != NFA_DM_RFST_LISTEN_ACTIVE) &&
135 (nfa_p2p_cb.rf_disc_state != NFA_DM_RFST_LISTEN_SLEEP)) {
136 /* this is not for P2P listen
137 ** DM broadcasts deactivaiton event in listen sleep state.
138 */
139 break;
140 }
141
142 /* notify deactivation */
143 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
144 (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
145 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_LISTEN_SLEEP;
146 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
147 } else {
148 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_DISCOVERY;
149 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
150 }
151 nfa_dm_conn_cback_event_notify(NFA_DEACTIVATED_EVT, &evt_data);
152 break;
153
154 default:
155 LOG(ERROR) << StringPrintf("Unexpected event");
156 break;
157 }
158 }
159
160 /*******************************************************************************
161 **
162 ** Function nfa_p2p_update_active_listen_timeout_cback
163 **
164 ** Description Timeout while waiting for passive mode activation
165 **
166 ** Returns void
167 **
168 *******************************************************************************/
nfa_p2p_update_active_listen_timeout_cback(TIMER_LIST_ENT * p_tle)169 static void nfa_p2p_update_active_listen_timeout_cback(__attribute__((unused))
170 TIMER_LIST_ENT* p_tle) {
171 LOG(ERROR) << __func__;
172
173 /* restore active listen mode */
174 nfa_p2p_update_active_listen();
175 }
176
177 /*******************************************************************************
178 **
179 ** Function nfa_p2p_update_active_listen
180 **
181 ** Description Remove active listen mode temporarily or restore it
182 **
183 **
184 ** Returns None
185 **
186 *******************************************************************************/
nfa_p2p_update_active_listen(void)187 static void nfa_p2p_update_active_listen(void) {
188 tNFA_DM_DISC_TECH_PROTO_MASK p2p_listen_mask = 0;
189 NFC_HDR* p_msg;
190
191 DLOG_IF(INFO, nfc_debug_enabled)
192 << StringPrintf("listen_tech_mask_to_restore:0x%x",
193 nfa_p2p_cb.listen_tech_mask_to_restore);
194
195 /* if active listen mode was removed temporarily */
196 if (nfa_p2p_cb.listen_tech_mask_to_restore) {
197 /* restore listen technologies */
198 nfa_p2p_cb.listen_tech_mask = nfa_p2p_cb.listen_tech_mask_to_restore;
199 nfa_p2p_cb.listen_tech_mask_to_restore = 0;
200 nfa_sys_stop_timer(&nfa_p2p_cb.active_listen_restore_timer);
201 } else {
202 /* start timer in case of no passive activation */
203 nfa_p2p_cb.active_listen_restore_timer.p_cback =
204 (TIMER_CBACK*)nfa_p2p_update_active_listen_timeout_cback;
205 nfa_sys_start_timer(&nfa_p2p_cb.active_listen_restore_timer, 0,
206 NFA_P2P_RESTORE_ACTIVE_LISTEN_TIMEOUT);
207
208 /* save listen techonologies */
209 nfa_p2p_cb.listen_tech_mask_to_restore = nfa_p2p_cb.listen_tech_mask;
210
211 /* remove active listen mode */
212 if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
213 nfa_p2p_cb.listen_tech_mask &= ~(NFA_TECHNOLOGY_MASK_ACTIVE);
214 } else {
215 nfa_p2p_cb.listen_tech_mask &=
216 ~(NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE);
217 }
218 }
219
220 if (nfa_p2p_cb.dm_disc_handle != NFA_HANDLE_INVALID) {
221 nfa_dm_delete_rf_discover(nfa_p2p_cb.dm_disc_handle);
222 nfa_p2p_cb.dm_disc_handle = NFA_HANDLE_INVALID;
223 }
224
225 /* collect listen technologies with NFC-DEP protocol */
226 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A)
227 p2p_listen_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP;
228
229 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F)
230 p2p_listen_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
231 if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
232 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE)
233 p2p_listen_mask |= NFA_DM_DISC_MASK_LACM_NFC_DEP;
234 } else {
235 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
236 p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
237 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
238 p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
239 }
240
241 /* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP layer. For
242 * LLCP DTA mode activate LLCP Bypassing LLCP is handled in
243 * nfa_dm_poll_disc_cback */
244
245 if (appl_dta_mode_flag == 1 &&
246 ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
247 // Configure listen technologies and protocols and register callback to DTA
248
249 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
250 "%s: DTA mode:Registering nfa_dm_poll_disc_cback to avoid LLCP in P2P",
251 __func__);
252 nfa_p2p_cb.dm_disc_handle =
253 nfa_dm_add_rf_discover(p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH,
254 nfa_dm_poll_disc_cback_dta_wrapper);
255 } else {
256 /* Configure listen technologies and protocols and register callback to NFA
257 * DM discovery */
258 nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
259 p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
260 }
261
262 /* restart RF discovery to update RF technologies */
263 p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
264 if (p_msg != nullptr) {
265 p_msg->event = NFA_P2P_INT_RESTART_RF_DISC_EVT;
266 nfa_sys_sendmsg(p_msg);
267 }
268 }
269
270 /*******************************************************************************
271 **
272 ** Function nfa_p2p_llcp_link_cback
273 **
274 ** Description Processing event from LLCP link management callback
275 **
276 **
277 ** Returns None
278 **
279 *******************************************************************************/
nfa_p2p_llcp_link_cback(uint8_t event,uint8_t reason)280 void nfa_p2p_llcp_link_cback(uint8_t event, uint8_t reason) {
281 tNFA_LLCP_ACTIVATED llcp_activated;
282 tNFA_LLCP_DEACTIVATED llcp_deactivated;
283
284 DLOG_IF(INFO, nfc_debug_enabled)
285 << StringPrintf("event:0x%x, reason:0x%x", event, reason);
286
287 if (event == LLCP_LINK_ACTIVATION_COMPLETE_EVT) {
288 LLCP_GetLinkMIU(&nfa_p2p_cb.local_link_miu, &nfa_p2p_cb.remote_link_miu);
289 nfa_p2p_cb.llcp_state = NFA_P2P_LLCP_STATE_ACTIVATED;
290
291 if (nfa_p2p_cb.is_initiator) {
292 /* notify NFA DM to send Activate Event to applicaiton with status */
293 nfa_dm_notify_activation_status(NFA_STATUS_OK, nullptr);
294 }
295
296 llcp_activated.is_initiator = nfa_p2p_cb.is_initiator;
297 llcp_activated.local_link_miu = nfa_p2p_cb.local_link_miu;
298 llcp_activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
299 llcp_activated.remote_lsc = LLCP_GetRemoteLSC();
300 llcp_activated.remote_wks = LLCP_GetRemoteWKS();
301 llcp_activated.remote_version = LLCP_GetRemoteVersion();
302
303 tNFA_CONN_EVT_DATA nfa_conn_evt_data;
304 nfa_conn_evt_data.llcp_activated = llcp_activated;
305 nfa_dm_act_conn_cback_notify(NFA_LLCP_ACTIVATED_EVT, &nfa_conn_evt_data);
306
307 } else if (event == LLCP_LINK_ACTIVATION_FAILED_EVT) {
308 nfa_p2p_cb.llcp_state = NFA_P2P_LLCP_STATE_IDLE;
309
310 if (nfa_p2p_cb.is_initiator) {
311 /* notify NFA DM to send Activate Event to applicaiton with status */
312 nfa_dm_notify_activation_status(NFA_STATUS_FAILED, nullptr);
313 }
314
315 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
316 } else if (event == LLCP_LINK_FIRST_PACKET_RECEIVED_EVT) {
317 nfa_dm_act_conn_cback_notify(NFA_LLCP_FIRST_PACKET_RECEIVED_EVT, nullptr);
318 } else /* LLCP_LINK_DEACTIVATED_EVT */
319 {
320 nfa_p2p_cb.llcp_state = NFA_P2P_LLCP_STATE_IDLE;
321
322 /* if got RF link loss without any rx LLC PDU */
323 if (reason == LLCP_LINK_RF_LINK_LOSS_NO_RX_LLC) {
324 /* if it was active listen mode */
325 if ((nfa_p2p_cb.is_active_mode) && (!nfa_p2p_cb.is_initiator)) {
326 /* if it didn't retry without active listen mode and passive mode is
327 * available */
328 if ((nfa_p2p_cb.listen_tech_mask_to_restore == 0x00) &&
329 (nfa_p2p_cb.listen_tech_mask &
330 (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F))) {
331 DLOG_IF(INFO, nfc_debug_enabled)
332 << StringPrintf("Retry without active listen mode");
333
334 /* retry without active listen mode */
335 nfa_p2p_update_active_listen();
336 }
337 } else if (nfa_p2p_cb.listen_tech_mask_to_restore) {
338 nfa_sys_start_timer(&nfa_p2p_cb.active_listen_restore_timer, 0,
339 NFA_P2P_RESTORE_ACTIVE_LISTEN_TIMEOUT);
340 }
341
342 reason = LLCP_LINK_RF_LINK_LOSS_ERR;
343 } else {
344 if (nfa_p2p_cb.listen_tech_mask_to_restore) {
345 /* restore active listen mode */
346 nfa_p2p_update_active_listen();
347 }
348 }
349
350 llcp_deactivated.reason = reason;
351 tNFA_CONN_EVT_DATA nfa_conn_evt_data;
352 nfa_conn_evt_data.llcp_deactivated = llcp_deactivated;
353 nfa_dm_act_conn_cback_notify(NFA_LLCP_DEACTIVATED_EVT, &nfa_conn_evt_data);
354
355 if (reason != LLCP_LINK_RF_LINK_LOSS_ERR) /* if NFC link is still up */
356 {
357 if (nfa_p2p_cb.is_initiator) {
358 /*For LLCP DTA test, Deactivate to Sleep is needed to send DSL_REQ*/
359 if (appl_dta_mode_flag == 1 &&
360 ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_LLCP_MODE)) {
361 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_SLEEP);
362 } else {
363 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
364 }
365 } else if ((nfa_p2p_cb.is_active_mode) && (reason == LLCP_LINK_TIMEOUT)) {
366 /*
367 ** target needs to trun off RF in case of receiving invalid
368 ** frame from initiator
369 */
370 DLOG_IF(INFO, nfc_debug_enabled)
371 << StringPrintf("Got LLCP_LINK_TIMEOUT in active mode on target");
372 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
373 }
374 }
375 }
376 }
377
378 /*******************************************************************************
379 **
380 ** Function nfa_p2p_activate_llcp
381 **
382 ** Description Activate LLCP link
383 **
384 **
385 ** Returns None
386 **
387 *******************************************************************************/
nfa_p2p_activate_llcp(tNFC_DISCOVER * p_data)388 void nfa_p2p_activate_llcp(tNFC_DISCOVER* p_data) {
389 tLLCP_ACTIVATE_CONFIG config;
390
391 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
392
393 if ((p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) ||
394 (p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_F)) {
395 config.is_initiator = true;
396 } else {
397 config.is_initiator = false;
398 }
399 if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
400 if (p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_ACTIVE) {
401 config.is_initiator = true;
402 }
403 } else {
404 if ((p_data->activate.rf_tech_param.mode ==
405 NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
406 (p_data->activate.rf_tech_param.mode ==
407 NFC_DISCOVERY_TYPE_POLL_F_ACTIVE)) {
408 config.is_initiator = true;
409 }
410 }
411 if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
412 if ((p_data->activate.rf_tech_param.mode ==
413 NFC_DISCOVERY_TYPE_POLL_ACTIVE) ||
414 (p_data->activate.rf_tech_param.mode ==
415 NFC_DISCOVERY_TYPE_LISTEN_ACTIVE)) {
416 nfa_p2p_cb.is_active_mode = true;
417 } else {
418 nfa_p2p_cb.is_active_mode = false;
419 }
420 } else {
421 if ((p_data->activate.rf_tech_param.mode ==
422 NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
423 (p_data->activate.rf_tech_param.mode ==
424 NFC_DISCOVERY_TYPE_POLL_F_ACTIVE) ||
425 (p_data->activate.rf_tech_param.mode ==
426 NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ||
427 (p_data->activate.rf_tech_param.mode ==
428 NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE)) {
429 nfa_p2p_cb.is_active_mode = true;
430 } else {
431 nfa_p2p_cb.is_active_mode = false;
432 }
433 }
434
435 nfa_p2p_cb.is_initiator = config.is_initiator;
436
437 config.max_payload_size =
438 p_data->activate.intf_param.intf_param.pa_nfc.max_payload_size;
439 config.waiting_time =
440 p_data->activate.intf_param.intf_param.pa_nfc.waiting_time;
441 config.p_gen_bytes = p_data->activate.intf_param.intf_param.pa_nfc.gen_bytes;
442 config.gen_bytes_len =
443 p_data->activate.intf_param.intf_param.pa_nfc.gen_bytes_len;
444
445 LLCP_ActivateLink(config, nfa_p2p_llcp_link_cback);
446 }
447
448 /*******************************************************************************
449 **
450 ** Function nfa_p2p_deactivate_llcp
451 **
452 ** Description Deactivate LLCP link
453 **
454 **
455 ** Returns None
456 **
457 *******************************************************************************/
nfa_p2p_deactivate_llcp(void)458 void nfa_p2p_deactivate_llcp(void) {
459 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
460
461 LLCP_DeactivateLink();
462 }
463
464 /*******************************************************************************
465 **
466 ** Function nfa_p2p_init
467 **
468 ** Description Initialize NFA P2P
469 **
470 **
471 ** Returns None
472 **
473 *******************************************************************************/
nfa_p2p_init(void)474 void nfa_p2p_init(void) {
475 uint8_t xx;
476
477 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
478 /* Set initial P2P flag to paused. So that if platform doesn't support P2P,
479 * p2p_prio_logic should be disabled in reader mode */
480 nfa_dm_cb.flags |= NFA_DM_FLAGS_P2P_PAUSED;
481
482 /* initialize control block */
483 memset(&nfa_p2p_cb, 0, sizeof(tNFA_P2P_CB));
484 nfa_p2p_cb.dm_disc_handle = NFA_HANDLE_INVALID;
485
486 for (xx = 0; xx < LLCP_MAX_SDP_TRANSAC; xx++) {
487 nfa_p2p_cb.sdp_cb[xx].local_sap = LLCP_INVALID_SAP;
488 }
489
490 /* register message handler on NFA SYS */
491 nfa_sys_register(NFA_ID_P2P, &nfa_p2p_sys_reg);
492 }
493
494 /*******************************************************************************
495 **
496 ** Function nfa_p2p_sys_disable
497 **
498 ** Description Deregister NFA P2P from NFA SYS/DM
499 **
500 **
501 ** Returns None
502 **
503 *******************************************************************************/
nfa_p2p_sys_disable(void)504 static void nfa_p2p_sys_disable(void) {
505 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
506
507 nfa_sys_stop_timer(&nfa_p2p_cb.active_listen_restore_timer);
508
509 /* deregister message handler on NFA SYS */
510 nfa_sys_deregister(NFA_ID_P2P);
511 }
512
513 /*******************************************************************************
514 **
515 ** Function nfa_p2p_set_config
516 **
517 ** Description Set General bytes and WT parameters for LLCP
518 **
519 **
520 ** Returns void
521 **
522 *******************************************************************************/
nfa_p2p_set_config(tNFA_DM_DISC_TECH_PROTO_MASK disc_mask)523 void nfa_p2p_set_config(tNFA_DM_DISC_TECH_PROTO_MASK disc_mask) {
524 uint8_t wt, gen_bytes_len = LLCP_MAX_GEN_BYTES;
525 uint8_t params[LLCP_MAX_GEN_BYTES + 5], *p, length;
526
527 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
528
529 LLCP_GetDiscoveryConfig(&wt, params + 2, &gen_bytes_len);
530 if (nfa_dm_is_p2p_paused()) {
531 gen_bytes_len = 0;
532 }
533
534 if ((disc_mask &
535 (NFA_DM_DISC_MASK_PA_NFC_DEP | NFA_DM_DISC_MASK_PF_NFC_DEP)) ||
536 ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
537 (disc_mask & NFA_DM_DISC_MASK_PACM_NFC_DEP)) ||
538 ((NFC_GetNCIVersion() != NCI_VERSION_2_0) &&
539 (disc_mask &
540 (NFA_DM_DISC_MASK_PAA_NFC_DEP | NFA_DM_DISC_MASK_PFA_NFC_DEP)))) {
541 p = params;
542
543 UINT8_TO_BE_STREAM(p, NFC_PMID_ATR_REQ_GEN_BYTES);
544 UINT8_TO_BE_STREAM(p, gen_bytes_len);
545
546 p += gen_bytes_len;
547 length = gen_bytes_len + 2;
548
549 nfa_dm_check_set_config(length, params, false);
550 }
551
552 if ((disc_mask &
553 (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LF_NFC_DEP)) ||
554 ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
555 (disc_mask & NFA_DM_DISC_MASK_LACM_NFC_DEP)) ||
556 ((NFC_GetNCIVersion() != NCI_VERSION_2_0) &&
557 (disc_mask &
558 (NFA_DM_DISC_MASK_LFA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)))) {
559 p = params;
560
561 UINT8_TO_BE_STREAM(p, NFC_PMID_ATR_RES_GEN_BYTES);
562 UINT8_TO_BE_STREAM(p, gen_bytes_len);
563
564 p += gen_bytes_len;
565 length = gen_bytes_len + 2;
566
567 UINT8_TO_BE_STREAM(p, NFC_PMID_WT);
568 UINT8_TO_BE_STREAM(p, NCI_PARAM_LEN_WT);
569 UINT8_TO_BE_STREAM(p, wt);
570
571 length += 3;
572
573 nfa_dm_check_set_config(length, params, false);
574 }
575 }
576
577 /*******************************************************************************
578 **
579 ** Function nfa_p2p_enable_listening
580 **
581 ** Description Configure listen technologies and protocols for LLCP
582 ** If LLCP WKS is changed then LLCP Gen bytes will be updated.
583 **
584 ** Returns void
585 **
586 *******************************************************************************/
nfa_p2p_enable_listening(tNFA_SYS_ID sys_id,bool update_wks)587 void nfa_p2p_enable_listening(tNFA_SYS_ID sys_id, bool update_wks) {
588 tNFA_DM_DISC_TECH_PROTO_MASK p2p_listen_mask = 0;
589
590 DLOG_IF(INFO, nfc_debug_enabled)
591 << StringPrintf("sys_id = %d, update_wks = %d", sys_id, update_wks);
592
593 if (sys_id == NFA_ID_P2P)
594 nfa_p2p_cb.is_p2p_listening = true;
595 else if (sys_id == NFA_ID_SNEP)
596 nfa_p2p_cb.is_snep_listening = true;
597
598 if (nfa_p2p_cb.dm_disc_handle != NFA_HANDLE_INVALID) {
599 /* if need to update WKS in LLCP Gen bytes */
600 if (update_wks) {
601 /* update LLCP Gen Bytes */
602 nfa_p2p_set_config(NFA_DM_DISC_MASK_PA_NFC_DEP |
603 NFA_DM_DISC_MASK_LA_NFC_DEP);
604 }
605 return;
606 }
607
608 /* collect listen technologies with NFC-DEP protocol */
609 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A)
610 p2p_listen_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP;
611
612 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F)
613 p2p_listen_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
614
615 if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
616 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE)
617 p2p_listen_mask |= NFA_DM_DISC_MASK_LACM_NFC_DEP;
618 } else {
619 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
620 p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
621
622 if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
623 p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
624 }
625
626 if (p2p_listen_mask) {
627 /* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP layer.
628 * For LLCP DTA mode activate LLCP Bypassing LLCP is handled in
629 * nfa_dm_poll_disc_cback */
630 if (appl_dta_mode_flag == 1 &&
631 ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
632 /* Configure listen technologies and protocols and register callback to
633 * NFA DM discovery */
634 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
635 "%s: DTA mode:Registering nfa_dm_poll_disc_cback to avoid LLCP in "
636 "P2P",
637 __func__);
638 nfa_p2p_cb.dm_disc_handle =
639 nfa_dm_add_rf_discover(p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH,
640 nfa_dm_poll_disc_cback_dta_wrapper);
641 } else {
642 /* Configure listen technologies and protocols and register callback to
643 * NFA DM discovery */
644 nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
645 p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
646 }
647 }
648 }
649
650 /*******************************************************************************
651 **
652 ** Function nfa_p2p_disable_listening
653 **
654 ** Description Remove listen technologies and protocols for LLCP and
655 ** deregister callback from NFA DM discovery if all of
656 ** P2P/CHO/SNEP doesn't listen LLCP any more.
657 ** If LLCP WKS is changed then ATR_RES will be updated.
658 **
659 ** Returns void
660 **
661 *******************************************************************************/
nfa_p2p_disable_listening(tNFA_SYS_ID sys_id,bool update_wks)662 void nfa_p2p_disable_listening(tNFA_SYS_ID sys_id, bool update_wks) {
663 DLOG_IF(INFO, nfc_debug_enabled)
664 << StringPrintf("sys_id = %d, update_wks = %d", sys_id, update_wks);
665
666 if (sys_id == NFA_ID_P2P)
667 nfa_p2p_cb.is_p2p_listening = false;
668 else if (sys_id == NFA_ID_SNEP)
669 nfa_p2p_cb.is_snep_listening = false;
670
671 if (nfa_p2p_cb.dm_disc_handle != NFA_HANDLE_INVALID) {
672 if ((nfa_p2p_cb.is_p2p_listening == false) &&
673 (nfa_p2p_cb.is_snep_listening == false)) {
674 nfa_p2p_cb.llcp_state = NFA_P2P_LLCP_STATE_IDLE;
675 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_IDLE;
676
677 nfa_dm_delete_rf_discover(nfa_p2p_cb.dm_disc_handle);
678 nfa_p2p_cb.dm_disc_handle = NFA_HANDLE_INVALID;
679 } else if (update_wks) {
680 /* update LLCP Gen Bytes */
681 nfa_p2p_set_config(NFA_DM_DISC_MASK_PA_NFC_DEP |
682 NFA_DM_DISC_MASK_LA_NFC_DEP);
683 }
684 }
685 }
686
687 /*******************************************************************************
688 **
689 ** Function nfa_p2p_update_listen_tech
690 **
691 ** Description Update P2P listen technologies. If there is change then
692 ** restart or stop P2P listen.
693 **
694 ** Returns void
695 **
696 *******************************************************************************/
nfa_p2p_update_listen_tech(tNFA_TECHNOLOGY_MASK tech_mask)697 void nfa_p2p_update_listen_tech(tNFA_TECHNOLOGY_MASK tech_mask) {
698 DLOG_IF(INFO, nfc_debug_enabled)
699 << StringPrintf("tech_mask = 0x%x", tech_mask);
700
701 if (nfa_p2p_cb.listen_tech_mask_to_restore) {
702 nfa_p2p_cb.listen_tech_mask_to_restore = 0;
703 nfa_sys_stop_timer(&nfa_p2p_cb.active_listen_restore_timer);
704 }
705
706 if (nfa_p2p_cb.listen_tech_mask != tech_mask) {
707 nfa_p2p_cb.listen_tech_mask = tech_mask;
708
709 if (nfa_p2p_cb.dm_disc_handle != NFA_HANDLE_INVALID) {
710 nfa_p2p_cb.rf_disc_state = NFA_DM_RFST_IDLE;
711
712 nfa_dm_delete_rf_discover(nfa_p2p_cb.dm_disc_handle);
713 nfa_p2p_cb.dm_disc_handle = NFA_HANDLE_INVALID;
714 }
715
716 /* restart discovery without updating sub-module status */
717 if (nfa_p2p_cb.is_p2p_listening || appl_dta_mode_flag)
718 nfa_p2p_enable_listening(NFA_ID_P2P, false);
719 else if (nfa_p2p_cb.is_snep_listening)
720 nfa_p2p_enable_listening(NFA_ID_SNEP, false);
721 }
722 }
723
724 /*******************************************************************************
725 **
726 ** Function nfa_p2p_evt_hdlr
727 **
728 ** Description Processing event for NFA P2P
729 **
730 **
731 ** Returns TRUE if p_msg needs to be deallocated
732 **
733 *******************************************************************************/
nfa_p2p_evt_hdlr(NFC_HDR * p_hdr)734 static bool nfa_p2p_evt_hdlr(NFC_HDR* p_hdr) {
735 bool delete_msg = true;
736 uint16_t event;
737
738 DLOG_IF(INFO, nfc_debug_enabled)
739 << StringPrintf("LLCP State [%s], Event [%s]",
740 nfa_p2p_llcp_state_code(nfa_p2p_cb.llcp_state).c_str(),
741 nfa_p2p_evt_code(p_hdr->event).c_str());
742
743 event = p_hdr->event & 0x00ff;
744
745 /* execute action functions */
746 if (event < NFA_P2P_NUM_ACTIONS) {
747 tNFA_P2P_MSG* p_msg = (tNFA_P2P_MSG*)p_hdr;
748 delete_msg = (*nfa_p2p_action[event])(p_msg);
749 } else {
750 LOG(ERROR) << StringPrintf("Unhandled event");
751 }
752
753 return delete_msg;
754 }
755
756 /*******************************************************************************
757 **
758 ** Function nfa_p2p_llcp_state_code
759 **
760 ** Description
761 **
762 ** Returns string of state
763 **
764 *******************************************************************************/
nfa_p2p_llcp_state_code(tNFA_P2P_LLCP_STATE state_code)765 static std::string nfa_p2p_llcp_state_code(tNFA_P2P_LLCP_STATE state_code) {
766 switch (state_code) {
767 case NFA_P2P_LLCP_STATE_IDLE:
768 return "Link IDLE";
769 case NFA_P2P_LLCP_STATE_LISTENING:
770 return "Link LISTENING";
771 case NFA_P2P_LLCP_STATE_ACTIVATED:
772 return "Link ACTIVATED";
773 default:
774 return "Unknown state";
775 }
776 }
777
778 /*******************************************************************************
779 **
780 ** Function nfa_p2p_evt_code
781 **
782 ** Description
783 **
784 ** Returns string of event
785 **
786 *******************************************************************************/
nfa_p2p_evt_code(uint16_t evt_code)787 static std::string nfa_p2p_evt_code(uint16_t evt_code) {
788 switch (evt_code) {
789 case NFA_P2P_API_REG_SERVER_EVT:
790 return "API_REG_SERVER";
791 case NFA_P2P_API_REG_CLIENT_EVT:
792 return "API_REG_CLIENT";
793 case NFA_P2P_API_DEREG_EVT:
794 return "API_DEREG";
795 case NFA_P2P_API_ACCEPT_CONN_EVT:
796 return "API_ACCEPT_CONN";
797 case NFA_P2P_API_REJECT_CONN_EVT:
798 return "API_REJECT_CONN";
799 case NFA_P2P_API_DISCONNECT_EVT:
800 return "API_DISCONNECT";
801 case NFA_P2P_API_CONNECT_EVT:
802 return "API_CONNECT";
803 case NFA_P2P_API_SEND_UI_EVT:
804 return "API_SEND_UI";
805 case NFA_P2P_API_SEND_DATA_EVT:
806 return "API_SEND_DATA";
807 case NFA_P2P_API_SET_LOCAL_BUSY_EVT:
808 return "API_SET_LOCAL_BUSY";
809 case NFA_P2P_API_GET_LINK_INFO_EVT:
810 return "API_GET_LINK_INFO";
811 case NFA_P2P_API_GET_REMOTE_SAP_EVT:
812 return "API_GET_REMOTE_SAP";
813 case NFA_P2P_API_SET_LLCP_CFG_EVT:
814 return "API_SET_LLCP_CFG_EVT";
815 case NFA_P2P_INT_RESTART_RF_DISC_EVT:
816 return "RESTART_RF_DISC_EVT";
817 default:
818 return "Unknown event";
819 }
820 }
821