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 implementation file for the NFA P2P.
22 *
23 ******************************************************************************/
24 #include <android-base/stringprintf.h>
25 #include <base/logging.h>
26
27 #include "llcp_api.h"
28 #include "nfa_dm_int.h"
29 #include "nfa_p2p_api.h"
30 #include "nfa_p2p_int.h"
31
32 using android::base::StringPrintf;
33
34 extern bool nfc_debug_enabled;
35
36 /*****************************************************************************
37 ** Global Variables
38 *****************************************************************************/
39
40 /*****************************************************************************
41 ** Static Functions
42 *****************************************************************************/
43
44 /*****************************************************************************
45 ** Constants
46 *****************************************************************************/
47
48 /*******************************************************************************
49 **
50 ** Function nfa_p2p_allocate_conn_cb
51 **
52 ** Description Allocate data link connection control block
53 **
54 **
55 ** Returns uint8_t
56 **
57 *******************************************************************************/
nfa_p2p_allocate_conn_cb(uint8_t local_sap)58 static uint8_t nfa_p2p_allocate_conn_cb(uint8_t local_sap) {
59 uint8_t xx;
60
61 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
62 if (nfa_p2p_cb.conn_cb[xx].flags == 0) {
63 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_IN_USE;
64 nfa_p2p_cb.conn_cb[xx].local_sap = local_sap;
65
66 return (xx);
67 }
68 }
69
70 LOG(ERROR) << StringPrintf("No resource");
71
72 return LLCP_MAX_DATA_LINK;
73 }
74
75 /*******************************************************************************
76 **
77 ** Function nfa_p2p_deallocate_conn_cb
78 **
79 ** Description Deallocate data link connection control block
80 **
81 **
82 ** Returns void
83 **
84 *******************************************************************************/
nfa_p2p_deallocate_conn_cb(uint8_t xx)85 static void nfa_p2p_deallocate_conn_cb(uint8_t xx) {
86 if (xx < LLCP_MAX_DATA_LINK) {
87 nfa_p2p_cb.conn_cb[xx].flags = 0;
88 } else {
89 LOG(ERROR) << StringPrintf("Invalid index (%d)", xx);
90 }
91 }
92
93 /*******************************************************************************
94 **
95 ** Function nfa_p2p_find_conn_cb
96 **
97 ** Description Find data link connection control block by local/remote SAP
98 **
99 **
100 ** Returns uint8_t
101 **
102 *******************************************************************************/
nfa_p2p_find_conn_cb(uint8_t local_sap,uint8_t remote_sap)103 static uint8_t nfa_p2p_find_conn_cb(uint8_t local_sap, uint8_t remote_sap) {
104 uint8_t xx;
105
106 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
107 if ((nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE) &&
108 (nfa_p2p_cb.conn_cb[xx].local_sap == local_sap) &&
109 (nfa_p2p_cb.conn_cb[xx].remote_sap == remote_sap)) {
110 return (xx);
111 }
112 }
113
114 return (LLCP_MAX_DATA_LINK);
115 }
116
117 /*******************************************************************************
118 **
119 ** Function nfa_p2p_llcp_cback
120 **
121 ** Description Processing SAP callback events from LLCP
122 **
123 **
124 ** Returns None
125 **
126 *******************************************************************************/
nfa_p2p_llcp_cback(tLLCP_SAP_CBACK_DATA * p_data)127 static void nfa_p2p_llcp_cback(tLLCP_SAP_CBACK_DATA* p_data) {
128 DLOG_IF(INFO, nfc_debug_enabled)
129 << StringPrintf("event:0x%02X, local_sap:0x%02X", p_data->hdr.event,
130 p_data->hdr.local_sap);
131
132 switch (p_data->hdr.event) {
133 case LLCP_SAP_EVT_DATA_IND:
134 nfa_p2p_proc_llcp_data_ind(p_data);
135 break;
136
137 case LLCP_SAP_EVT_CONNECT_IND:
138 nfa_p2p_proc_llcp_connect_ind(p_data);
139 break;
140
141 case LLCP_SAP_EVT_CONNECT_RESP:
142 nfa_p2p_proc_llcp_connect_resp(p_data);
143 break;
144
145 case LLCP_SAP_EVT_DISCONNECT_IND:
146 nfa_p2p_proc_llcp_disconnect_ind(p_data);
147 break;
148
149 case LLCP_SAP_EVT_DISCONNECT_RESP:
150 nfa_p2p_proc_llcp_disconnect_resp(p_data);
151 break;
152
153 case LLCP_SAP_EVT_CONGEST:
154 nfa_p2p_proc_llcp_congestion(p_data);
155 break;
156
157 case LLCP_SAP_EVT_LINK_STATUS:
158 nfa_p2p_proc_llcp_link_status(p_data);
159 break;
160
161 default:
162 LOG(ERROR) << StringPrintf("Unknown event:0x%02X", p_data->hdr.event);
163 return;
164 }
165 }
166
167 /*******************************************************************************
168 **
169 ** Function nfa_p2p_sdp_cback
170 **
171 ** Description Process SDP callback event from LLCP
172 **
173 **
174 ** Returns None
175 **
176 *******************************************************************************/
nfa_p2p_sdp_cback(uint8_t tid,uint8_t remote_sap)177 void nfa_p2p_sdp_cback(uint8_t tid, uint8_t remote_sap) {
178 uint8_t local_sap;
179 uint8_t xx;
180 tNFA_P2P_EVT_DATA evt_data;
181
182 DLOG_IF(INFO, nfc_debug_enabled)
183 << StringPrintf("tid:0x%02X, remote_sap:0x%02X", tid, remote_sap);
184
185 /* search for callback function to process */
186 for (xx = 0; xx < LLCP_MAX_SDP_TRANSAC; xx++) {
187 if ((nfa_p2p_cb.sdp_cb[xx].local_sap != LLCP_INVALID_SAP) &&
188 (nfa_p2p_cb.sdp_cb[xx].tid == tid)) {
189 local_sap = nfa_p2p_cb.sdp_cb[xx].local_sap;
190
191 evt_data.sdp.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
192 evt_data.sdp.remote_sap = remote_sap;
193 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_SDP_EVT, &evt_data);
194
195 nfa_p2p_cb.sdp_cb[xx].local_sap = LLCP_INVALID_SAP;
196 break;
197 }
198 }
199 }
200
201 /*******************************************************************************
202 **
203 ** Function nfa_p2p_start_sdp
204 **
205 ** Description Initiate SDP
206 **
207 **
208 ** Returns TRUE if success
209 **
210 *******************************************************************************/
nfa_p2p_start_sdp(char * p_service_name,uint8_t local_sap)211 bool nfa_p2p_start_sdp(char* p_service_name, uint8_t local_sap) {
212 int xx;
213
214 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("SN:<%s>", p_service_name);
215
216 /* search for empty slot */
217 for (xx = 0; xx < LLCP_MAX_SDP_TRANSAC; xx++) {
218 if (nfa_p2p_cb.sdp_cb[xx].local_sap == LLCP_INVALID_SAP) {
219 if (LLCP_DiscoverService(p_service_name, nfa_p2p_sdp_cback,
220 &(nfa_p2p_cb.sdp_cb[xx].tid)) ==
221 LLCP_STATUS_SUCCESS) {
222 nfa_p2p_cb.sdp_cb[xx].local_sap = local_sap;
223 return true;
224 } else {
225 /* failure of SDP */
226 return false;
227 }
228 }
229 }
230 return false;
231 }
232
233 /*******************************************************************************
234 **
235 ** Function nfa_p2p_proc_llcp_data_ind
236 **
237 ** Description Processing incoming data event from LLCP
238 **
239 **
240 ** Returns None
241 **
242 *******************************************************************************/
nfa_p2p_proc_llcp_data_ind(tLLCP_SAP_CBACK_DATA * p_data)243 void nfa_p2p_proc_llcp_data_ind(tLLCP_SAP_CBACK_DATA* p_data) {
244 uint8_t local_sap, xx;
245 tNFA_P2P_EVT_DATA evt_data;
246
247 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
248
249 local_sap = p_data->data_ind.local_sap;
250
251 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
252 evt_data.data.handle = 0;
253 /* if connectionless */
254 if (p_data->data_ind.link_type == NFA_P2P_LLINK_TYPE) {
255 evt_data.data.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
256 } else {
257 xx = nfa_p2p_find_conn_cb(p_data->data_ind.local_sap,
258 p_data->data_ind.remote_sap);
259
260 if (xx != LLCP_MAX_DATA_LINK) {
261 evt_data.data.handle =
262 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
263 }
264 }
265
266 evt_data.data.remote_sap = p_data->data_ind.remote_sap;
267 evt_data.data.link_type = p_data->data_ind.link_type;
268
269 /* notify upper layer that there are data at LLCP */
270 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DATA_EVT, &evt_data);
271 }
272 }
273
274 /*******************************************************************************
275 **
276 ** Function nfa_p2p_proc_llcp_connect_ind
277 **
278 ** Description Processing connection request from peer
279 **
280 **
281 ** Returns None
282 **
283 *******************************************************************************/
nfa_p2p_proc_llcp_connect_ind(tLLCP_SAP_CBACK_DATA * p_data)284 void nfa_p2p_proc_llcp_connect_ind(tLLCP_SAP_CBACK_DATA* p_data) {
285 uint8_t server_sap;
286 tNFA_P2P_EVT_DATA evt_data;
287 uint8_t xx;
288
289 DLOG_IF(INFO, nfc_debug_enabled)
290 << StringPrintf("server_sap:0x%x", p_data->connect_ind.server_sap);
291
292 server_sap = p_data->connect_ind.server_sap;
293
294 if (nfa_p2p_cb.sap_cb[server_sap].p_cback) {
295 xx = nfa_p2p_allocate_conn_cb(server_sap);
296
297 if (xx != LLCP_MAX_DATA_LINK) {
298 nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_ind.remote_sap;
299 nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_ind.miu;
300
301 /* peer will not receive any data */
302 if (p_data->connect_ind.rw == 0)
303 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;
304
305 evt_data.conn_req.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
306 evt_data.conn_req.conn_handle =
307 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
308 evt_data.conn_req.remote_sap = p_data->connect_ind.remote_sap;
309 evt_data.conn_req.remote_miu = p_data->connect_ind.miu;
310 evt_data.conn_req.remote_rw = p_data->connect_ind.rw;
311
312 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_CONN_REQ_EVT, &evt_data);
313 }
314 } else {
315 LOG(ERROR) << StringPrintf("Not registered");
316 }
317 }
318
319 /*******************************************************************************
320 **
321 ** Function nfa_p2p_proc_llcp_connect_resp
322 **
323 ** Description Processing connection response from peer
324 **
325 **
326 ** Returns None
327 **
328 *******************************************************************************/
nfa_p2p_proc_llcp_connect_resp(tLLCP_SAP_CBACK_DATA * p_data)329 void nfa_p2p_proc_llcp_connect_resp(tLLCP_SAP_CBACK_DATA* p_data) {
330 uint8_t local_sap, xx;
331 tNFA_P2P_EVT_DATA evt_data;
332
333 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
334
335 local_sap = p_data->connect_resp.local_sap;
336
337 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
338 xx = nfa_p2p_allocate_conn_cb(local_sap);
339
340 if (xx != LLCP_MAX_DATA_LINK) {
341 nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_resp.remote_sap;
342 nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_resp.miu;
343
344 /* peer will not receive any data */
345 if (p_data->connect_resp.rw == 0)
346 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;
347
348 evt_data.connected.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
349 evt_data.connected.conn_handle =
350 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
351 evt_data.connected.remote_sap = p_data->connect_resp.remote_sap;
352 evt_data.connected.remote_miu = p_data->connect_resp.miu;
353 evt_data.connected.remote_rw = p_data->connect_resp.rw;
354
355 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONNECTED_EVT, &evt_data);
356 }
357 }
358 }
359
360 /*******************************************************************************
361 **
362 ** Function nfa_p2p_proc_llcp_disconnect_ind
363 **
364 ** Description Processing disconnection request from peer
365 **
366 **
367 ** Returns None
368 **
369 *******************************************************************************/
nfa_p2p_proc_llcp_disconnect_ind(tLLCP_SAP_CBACK_DATA * p_data)370 void nfa_p2p_proc_llcp_disconnect_ind(tLLCP_SAP_CBACK_DATA* p_data) {
371 uint8_t local_sap, xx;
372 tNFA_P2P_EVT_DATA evt_data;
373
374 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
375
376 local_sap = p_data->disconnect_ind.local_sap;
377
378 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
379 xx = nfa_p2p_find_conn_cb(p_data->disconnect_ind.local_sap,
380 p_data->disconnect_ind.remote_sap);
381
382 if (xx != LLCP_MAX_DATA_LINK) {
383 evt_data.disc.handle =
384 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
385 evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_INITIATE;
386
387 nfa_p2p_deallocate_conn_cb(xx);
388
389 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
390 } else {
391 /*
392 ** LLCP link has been deactivated before receiving CC or DM.
393 ** Return NFA_P2P_DISC_EVT to indicate failure of creating
394 ** connection
395 */
396
397 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
398 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
399
400 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
401
402 LOG(ERROR) << StringPrintf("Link deactivated");
403 }
404 }
405 }
406
407 /*******************************************************************************
408 **
409 ** Function nfa_p2p_proc_llcp_disconnect_resp
410 **
411 ** Description Processing rejected connection from peer
412 **
413 **
414 ** Returns None
415 **
416 *******************************************************************************/
nfa_p2p_proc_llcp_disconnect_resp(tLLCP_SAP_CBACK_DATA * p_data)417 void nfa_p2p_proc_llcp_disconnect_resp(tLLCP_SAP_CBACK_DATA* p_data) {
418 uint8_t local_sap, xx;
419 tNFA_P2P_EVT_DATA evt_data;
420
421 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
422
423 local_sap = p_data->disconnect_resp.local_sap;
424
425 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
426 if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_RESP_DISC) {
427 evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;
428 } else if ((p_data->disconnect_resp.reason ==
429 LLCP_SAP_DM_REASON_APP_REJECTED) ||
430 (p_data->disconnect_resp.reason ==
431 LLCP_SAP_DM_REASON_PERM_REJECT_THIS) ||
432 (p_data->disconnect_resp.reason ==
433 LLCP_SAP_DM_REASON_PERM_REJECT_ANY) ||
434 (p_data->disconnect_resp.reason ==
435 LLCP_SAP_DM_REASON_TEMP_REJECT_THIS) ||
436 (p_data->disconnect_resp.reason ==
437 LLCP_SAP_DM_REASON_TEMP_REJECT_ANY)) {
438 evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_REJECT;
439 } else if (p_data->disconnect_resp.reason ==
440 LLCP_SAP_DM_REASON_NO_SERVICE) {
441 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_SERVICE;
442 } else if (p_data->disconnect_resp.reason ==
443 LLCP_SAP_DM_REASON_NO_ACTIVE_CONNECTION) {
444 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
445 } else {
446 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;
447 }
448
449 if (evt_data.disc.reason == NFA_P2P_DISC_REASON_LOCAL_INITITATE) {
450 xx = nfa_p2p_find_conn_cb(p_data->disconnect_resp.local_sap,
451 p_data->disconnect_resp.remote_sap);
452
453 if (xx != LLCP_MAX_DATA_LINK) {
454 evt_data.disc.handle =
455 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
456
457 nfa_p2p_deallocate_conn_cb(xx);
458
459 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
460 } else {
461 LOG(ERROR) << StringPrintf("No connection found");
462 }
463 } else {
464 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
465 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
466 }
467 }
468 }
469
470 /*******************************************************************************
471 **
472 ** Function nfa_p2p_proc_llcp_congest
473 **
474 ** Description Processing LLCP congestion event
475 **
476 **
477 ** Returns None
478 **
479 *******************************************************************************/
nfa_p2p_proc_llcp_congestion(tLLCP_SAP_CBACK_DATA * p_data)480 void nfa_p2p_proc_llcp_congestion(tLLCP_SAP_CBACK_DATA* p_data) {
481 uint8_t local_sap, remote_sap, xx;
482 tNFA_P2P_EVT_DATA evt_data;
483
484 local_sap = p_data->congest.local_sap;
485 remote_sap = p_data->congest.remote_sap;
486
487 evt_data.congest.link_type = p_data->congest.link_type;
488 evt_data.congest.is_congested = p_data->congest.is_congested;
489
490 if (p_data->congest.is_congested) {
491 DLOG_IF(INFO, nfc_debug_enabled)
492 << StringPrintf("START SAP=(0x%x,0x%x)", local_sap, remote_sap);
493
494 } else {
495 DLOG_IF(INFO, nfc_debug_enabled)
496 << StringPrintf("END SAP=(0x%x,0x%x)", local_sap, remote_sap);
497 }
498
499 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
500 if (evt_data.congest.link_type == NFA_P2P_LLINK_TYPE) {
501 evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
502
503 if ((evt_data.congest.is_congested == false) &&
504 (nfa_p2p_cb.sap_cb[local_sap].flags &
505 NFA_P2P_SAP_FLAG_LLINK_CONGESTED)) {
506 nfa_p2p_cb.sap_cb[local_sap].flags &= ~NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
507 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
508 } else if ((evt_data.congest.is_congested == true) &&
509 (!(nfa_p2p_cb.sap_cb[local_sap].flags &
510 NFA_P2P_SAP_FLAG_LLINK_CONGESTED))) {
511 /* this is overall congestion due to high usage of buffer pool */
512 nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
513 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
514 }
515 } else {
516 xx = nfa_p2p_find_conn_cb(local_sap, remote_sap);
517
518 if (xx != LLCP_MAX_DATA_LINK) {
519 evt_data.congest.handle =
520 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
521
522 if ((evt_data.congest.is_congested == false) &&
523 (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED)) {
524 nfa_p2p_cb.conn_cb[xx].flags &= ~NFA_P2P_CONN_FLAG_CONGESTED;
525 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
526 } else if ((evt_data.congest.is_congested == true) &&
527 (!(nfa_p2p_cb.conn_cb[xx].flags &
528 NFA_P2P_CONN_FLAG_CONGESTED))) {
529 /* this is overall congestion due to high usage of buffer pool */
530 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
531 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
532 }
533 } else {
534 LOG(ERROR) << StringPrintf("No connection found");
535 }
536 }
537 }
538 }
539
540 /*******************************************************************************
541 **
542 ** Function nfa_p2p_proc_llcp_link_status
543 **
544 ** Description Processing LLCP link status
545 **
546 **
547 ** Returns next state after processing this event
548 **
549 *******************************************************************************/
nfa_p2p_proc_llcp_link_status(tLLCP_SAP_CBACK_DATA * p_data)550 void nfa_p2p_proc_llcp_link_status(tLLCP_SAP_CBACK_DATA* p_data) {
551 uint8_t local_sap, xx;
552 tNFA_P2P_EVT_DATA evt_data;
553
554 DLOG_IF(INFO, nfc_debug_enabled)
555 << StringPrintf("is_activated:%d", p_data->link_status.is_activated);
556
557 local_sap = p_data->link_status.local_sap;
558
559 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
560 if (p_data->link_status.is_activated) {
561 /* only for server */
562 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
563 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
564 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
565
566 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
567 } else /* if LLCP link is deactivated */
568 {
569 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
570 if ((nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE) &&
571 (nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)) {
572 evt_data.disc.handle =
573 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
574 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
575
576 nfa_p2p_deallocate_conn_cb(xx);
577 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
578 }
579 }
580
581 /* notify deactivation and clear flags */
582 if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_SERVER) {
583 evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
584 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DEACTIVATED_EVT,
585 &evt_data);
586
587 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_SERVER;
588 } else if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_CLIENT) {
589 evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
590 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DEACTIVATED_EVT,
591 &evt_data);
592
593 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_CLIENT;
594 } else /* if this is not registered service */
595 {
596 nfa_p2p_cb.sap_cb[local_sap].p_cback = nullptr;
597 }
598 }
599 }
600 }
601
602 /*******************************************************************************
603 **
604 ** Function nfa_p2p_reg_server
605 **
606 ** Description Allocate a service as server and register to LLCP
607 **
608 **
609 ** Returns FALSE if need to keep buffer
610 **
611 *******************************************************************************/
nfa_p2p_reg_server(tNFA_P2P_MSG * p_msg)612 bool nfa_p2p_reg_server(tNFA_P2P_MSG* p_msg) {
613 tNFA_P2P_EVT_DATA evt_data;
614 uint8_t server_sap;
615
616 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
617
618 server_sap = LLCP_RegisterServer(
619 p_msg->api_reg_server.server_sap, p_msg->api_reg_server.link_type,
620 p_msg->api_reg_server.service_name, nfa_p2p_llcp_cback);
621
622 if (server_sap == LLCP_INVALID_SAP) {
623 evt_data.reg_server.server_handle = NFA_HANDLE_INVALID;
624 evt_data.reg_server.server_sap = NFA_P2P_INVALID_SAP;
625 strlcpy(evt_data.reg_server.service_name,
626 p_msg->api_reg_server.service_name, LLCP_MAX_SN_LEN);
627 evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;
628
629 p_msg->api_reg_server.p_cback(NFA_P2P_REG_SERVER_EVT, &evt_data);
630
631 return true;
632 }
633
634 /* if need to update WKS in LLCP Gen bytes */
635 if (server_sap <= LLCP_UPPER_BOUND_WK_SAP) {
636 nfa_p2p_enable_listening(NFA_ID_P2P, true);
637 } else if (!nfa_p2p_cb.is_p2p_listening) {
638 nfa_p2p_enable_listening(NFA_ID_P2P, false);
639 }
640
641 nfa_p2p_cb.sap_cb[server_sap].p_cback = p_msg->api_reg_server.p_cback;
642 nfa_p2p_cb.sap_cb[server_sap].flags = NFA_P2P_SAP_FLAG_SERVER;
643
644 evt_data.reg_server.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
645 evt_data.reg_server.server_sap = server_sap;
646 strlcpy(evt_data.reg_server.service_name, p_msg->api_reg_server.service_name,
647 LLCP_MAX_SN_LEN);
648 evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;
649
650 /* notify NFA_P2P_REG_SERVER_EVT to server */
651 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_REG_SERVER_EVT, &evt_data);
652
653 /* if LLCP is already activated */
654 if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED) {
655 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | server_sap);
656 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
657 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
658
659 /* notify NFA_P2P_ACTIVATED_EVT to server */
660 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
661 }
662
663 return true;
664 }
665
666 /*******************************************************************************
667 **
668 ** Function nfa_p2p_reg_client
669 **
670 ** Description Allocate a service as client and register to LLCP
671 **
672 **
673 ** Returns TRUE to deallocate buffer
674 **
675 *******************************************************************************/
nfa_p2p_reg_client(tNFA_P2P_MSG * p_msg)676 bool nfa_p2p_reg_client(tNFA_P2P_MSG* p_msg) {
677 tNFA_P2P_EVT_DATA evt_data;
678 uint8_t local_sap;
679
680 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
681
682 local_sap =
683 LLCP_RegisterClient(p_msg->api_reg_client.link_type, nfa_p2p_llcp_cback);
684
685 if (local_sap == LLCP_INVALID_SAP) {
686 evt_data.reg_client.client_handle = NFA_HANDLE_INVALID;
687 p_msg->api_reg_client.p_cback(NFA_P2P_REG_CLIENT_EVT, &evt_data);
688 return true;
689 }
690
691 nfa_p2p_cb.sap_cb[local_sap].p_cback = p_msg->api_reg_client.p_cback;
692 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_CLIENT;
693
694 evt_data.reg_client.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
695 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_REG_CLIENT_EVT, &evt_data);
696
697 /* if LLCP is already activated */
698 if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED) {
699 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
700 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
701 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
702
703 /* notify NFA_P2P_ACTIVATED_EVT to client */
704 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
705 }
706
707 return true;
708 }
709
710 /*******************************************************************************
711 **
712 ** Function nfa_p2p_dereg
713 **
714 ** Description Deallocate a service as server or client and deregister to
715 ** LLCP. LLCP will deallocate data link connection created by
716 ** this server
717 **
718 ** Returns TRUE to deallocate buffer
719 **
720 *******************************************************************************/
nfa_p2p_dereg(tNFA_P2P_MSG * p_msg)721 bool nfa_p2p_dereg(tNFA_P2P_MSG* p_msg) {
722 uint8_t local_sap, xx;
723
724 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
725
726 local_sap = (uint8_t)(p_msg->api_dereg.handle & NFA_HANDLE_MASK);
727
728 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
729 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
730 if ((nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE) &&
731 (nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)) {
732 nfa_p2p_deallocate_conn_cb(xx);
733 }
734 }
735 }
736
737 LLCP_Deregister(local_sap);
738 nfa_p2p_cb.sap_cb[local_sap].p_cback = nullptr;
739
740 if (nfa_p2p_cb.is_p2p_listening) {
741 /* check if this is the last server on NFA P2P */
742 for (xx = 0; xx < NFA_P2P_NUM_SAP; xx++) {
743 if ((nfa_p2p_cb.sap_cb[xx].p_cback) &&
744 (nfa_p2p_cb.sap_cb[xx].flags & NFA_P2P_SAP_FLAG_SERVER)) {
745 break;
746 }
747 }
748
749 if (xx >= NFA_P2P_NUM_SAP) {
750 /* if need to update WKS in LLCP Gen bytes */
751 if (local_sap <= LLCP_UPPER_BOUND_WK_SAP)
752 nfa_p2p_disable_listening(NFA_ID_P2P, true);
753 else
754 nfa_p2p_disable_listening(NFA_ID_P2P, false);
755 }
756 /* if need to update WKS in LLCP Gen bytes */
757 else if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) {
758 nfa_p2p_enable_listening(NFA_ID_P2P, true);
759 }
760 }
761
762 return true;
763 }
764
765 /*******************************************************************************
766 **
767 ** Function nfa_p2p_accept_connection
768 **
769 ** Description Connection Confirm from local application
770 **
771 **
772 ** Returns TRUE to deallocate buffer
773 **
774 *******************************************************************************/
nfa_p2p_accept_connection(tNFA_P2P_MSG * p_msg)775 bool nfa_p2p_accept_connection(tNFA_P2P_MSG* p_msg) {
776 uint8_t xx;
777 tLLCP_CONNECTION_PARAMS params;
778
779 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
780
781 xx = (uint8_t)(p_msg->api_accept.conn_handle & NFA_HANDLE_MASK);
782 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
783
784 params.miu = p_msg->api_accept.miu;
785 params.rw = p_msg->api_accept.rw;
786 params.sn[0] = 0;
787
788 LLCP_ConnectCfm(nfa_p2p_cb.conn_cb[xx].local_sap,
789 nfa_p2p_cb.conn_cb[xx].remote_sap, ¶ms);
790
791 return true;
792 }
793
794 /*******************************************************************************
795 **
796 ** Function nfa_p2p_reject_connection
797 **
798 ** Description Reject connection by local application
799 **
800 **
801 ** Returns TRUE to deallocate buffer
802 **
803 *******************************************************************************/
nfa_p2p_reject_connection(tNFA_P2P_MSG * p_msg)804 bool nfa_p2p_reject_connection(tNFA_P2P_MSG* p_msg) {
805 uint8_t xx;
806
807 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
808
809 xx = (uint8_t)(p_msg->api_reject.conn_handle & NFA_HANDLE_MASK);
810 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
811
812 LLCP_ConnectReject(nfa_p2p_cb.conn_cb[xx].local_sap,
813 nfa_p2p_cb.conn_cb[xx].remote_sap,
814 LLCP_SAP_DM_REASON_APP_REJECTED);
815
816 /* no need to deregister service on LLCP */
817 nfa_p2p_deallocate_conn_cb(xx);
818
819 return true;
820 }
821
822 /*******************************************************************************
823 **
824 ** Function nfa_p2p_disconnect
825 **
826 ** Description Disconnect data link connection by local application
827 **
828 **
829 ** Returns TRUE to deallocate buffer
830 **
831 *******************************************************************************/
nfa_p2p_disconnect(tNFA_P2P_MSG * p_msg)832 bool nfa_p2p_disconnect(tNFA_P2P_MSG* p_msg) {
833 uint8_t local_sap, xx;
834 tLLCP_STATUS status;
835 tNFA_P2P_EVT_DATA evt_data;
836
837 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
838
839 xx = (uint8_t)(p_msg->api_disconnect.conn_handle & NFA_HANDLE_MASK);
840
841 /* if this is for data link connection */
842 if (xx & NFA_P2P_HANDLE_FLAG_CONN) {
843 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
844
845 status = LLCP_DisconnectReq(nfa_p2p_cb.conn_cb[xx].local_sap,
846 nfa_p2p_cb.conn_cb[xx].remote_sap,
847 p_msg->api_disconnect.flush);
848
849 if (status == LLCP_STATUS_SUCCESS) {
850 /* wait for disconnect response if successful */
851 return true;
852 } else {
853 /*
854 ** while we are waiting for connect confirm,
855 ** we cannot sent DISC because we don't know DSAP yet
856 */
857 local_sap = nfa_p2p_cb.conn_cb[xx].local_sap;
858
859 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
860 evt_data.disc.handle =
861 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
862 evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;
863
864 nfa_p2p_deallocate_conn_cb(xx);
865 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
866 }
867 }
868 } else {
869 LOG(ERROR) << StringPrintf("Handle is not for Data link connection");
870 }
871
872 return true;
873 }
874
875 /*******************************************************************************
876 **
877 ** Function nfa_p2p_create_data_link_connection
878 **
879 ** Description Create data link connection
880 **
881 **
882 ** Returns TRUE to deallocate buffer
883 **
884 *******************************************************************************/
nfa_p2p_create_data_link_connection(tNFA_P2P_MSG * p_msg)885 bool nfa_p2p_create_data_link_connection(tNFA_P2P_MSG* p_msg) {
886 uint8_t local_sap;
887 tNFA_P2P_EVT_DATA evt_data;
888 tLLCP_CONNECTION_PARAMS conn_params;
889 tLLCP_STATUS status;
890
891 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
892
893 local_sap = (uint8_t)(p_msg->api_connect.client_handle & NFA_HANDLE_MASK);
894
895 conn_params.miu = p_msg->api_connect.miu;
896 conn_params.rw = p_msg->api_connect.rw;
897
898 /* NFA_P2pConnectBySap () */
899 if (p_msg->api_connect.dsap != LLCP_INVALID_SAP) {
900 conn_params.sn[0] = 0;
901 status = LLCP_ConnectReq(local_sap, p_msg->api_connect.dsap, &conn_params);
902 }
903 /* NFA_P2pConnectByName () */
904 else {
905 strlcpy(conn_params.sn, p_msg->api_connect.service_name, LLCP_MAX_SN_LEN);
906 conn_params.sn[LLCP_MAX_SN_LEN] = 0;
907
908 status = LLCP_ConnectReq(local_sap, LLCP_SAP_SDP, &conn_params);
909 }
910
911 if (status != LLCP_STATUS_SUCCESS) {
912 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
913 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;
914
915 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
916 }
917
918 return true;
919 }
920
921 /*******************************************************************************
922 **
923 ** Function nfa_p2p_send_ui
924 **
925 ** Description Send UI PDU
926 **
927 **
928 ** Returns TRUE to deallocate buffer
929 **
930 *******************************************************************************/
nfa_p2p_send_ui(tNFA_P2P_MSG * p_msg)931 bool nfa_p2p_send_ui(tNFA_P2P_MSG* p_msg) {
932 uint8_t local_sap;
933 tLLCP_STATUS status;
934 tNFA_P2P_EVT_DATA evt_data;
935
936 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
937
938 local_sap = (uint8_t)(p_msg->api_send_ui.handle & NFA_HANDLE_MASK);
939
940 /* decrease number of tx UI PDU which is not processed by NFA for congestion
941 * control */
942 if (nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu)
943 nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu--;
944
945 if (nfa_p2p_cb.total_pending_ui_pdu) nfa_p2p_cb.total_pending_ui_pdu--;
946
947 status =
948 LLCP_SendUI(local_sap, p_msg->api_send_ui.dsap, p_msg->api_send_ui.p_msg);
949
950 if (status == LLCP_STATUS_CONGESTED) {
951 if (!(nfa_p2p_cb.sap_cb[local_sap].flags &
952 NFA_P2P_SAP_FLAG_LLINK_CONGESTED)) {
953 nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
954
955 /* notify that this logical link is congested */
956 evt_data.congest.link_type = NFA_P2P_LLINK_TYPE;
957 evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
958 evt_data.congest.is_congested = true;
959
960 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
961 }
962 }
963
964 return true;
965 }
966
967 /*******************************************************************************
968 **
969 ** Function nfa_p2p_send_data
970 **
971 ** Description Send I PDU
972 **
973 **
974 ** Returns TRUE to deallocate buffer
975 **
976 *******************************************************************************/
nfa_p2p_send_data(tNFA_P2P_MSG * p_msg)977 bool nfa_p2p_send_data(tNFA_P2P_MSG* p_msg) {
978 tNFA_P2P_EVT_DATA evt_data;
979 tLLCP_STATUS status;
980 uint8_t xx;
981
982 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
983
984 xx = (uint8_t)(p_msg->api_send_data.conn_handle & NFA_HANDLE_MASK);
985 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
986
987 /* decrease number of tx I PDU which is not processed by NFA for congestion
988 * control */
989 if (nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu)
990 nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu--;
991
992 if (nfa_p2p_cb.total_pending_i_pdu) nfa_p2p_cb.total_pending_i_pdu--;
993
994 status = LLCP_SendData(nfa_p2p_cb.conn_cb[xx].local_sap,
995 nfa_p2p_cb.conn_cb[xx].remote_sap,
996 p_msg->api_send_data.p_msg);
997
998 if (status == LLCP_STATUS_CONGESTED) {
999 if (!(nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED)) {
1000 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
1001
1002 /* notify that this data link is congested */
1003 evt_data.congest.link_type = NFA_P2P_DLINK_TYPE;
1004 evt_data.congest.handle =
1005 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
1006 evt_data.congest.is_congested = true;
1007
1008 nfa_p2p_cb.sap_cb[nfa_p2p_cb.conn_cb[xx].local_sap].p_cback(
1009 NFA_P2P_CONGEST_EVT, &evt_data);
1010 }
1011 }
1012
1013 return true;
1014 }
1015
1016 /*******************************************************************************
1017 **
1018 ** Function nfa_p2p_set_local_busy
1019 **
1020 ** Description Set or reset local busy
1021 **
1022 **
1023 ** Returns TRUE to deallocate buffer
1024 **
1025 *******************************************************************************/
nfa_p2p_set_local_busy(tNFA_P2P_MSG * p_msg)1026 bool nfa_p2p_set_local_busy(tNFA_P2P_MSG* p_msg) {
1027 uint8_t xx;
1028
1029 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1030
1031 xx = (uint8_t)(p_msg->api_local_busy.conn_handle & NFA_HANDLE_MASK);
1032 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
1033
1034 LLCP_SetLocalBusyStatus(nfa_p2p_cb.conn_cb[xx].local_sap,
1035 nfa_p2p_cb.conn_cb[xx].remote_sap,
1036 p_msg->api_local_busy.is_busy);
1037
1038 return true;
1039 }
1040
1041 /*******************************************************************************
1042 **
1043 ** Function nfa_p2p_get_link_info
1044 **
1045 ** Description Get WKS of remote and link MIU
1046 **
1047 **
1048 ** Returns TRUE to deallocate buffer
1049 **
1050 *******************************************************************************/
nfa_p2p_get_link_info(tNFA_P2P_MSG * p_msg)1051 bool nfa_p2p_get_link_info(tNFA_P2P_MSG* p_msg) {
1052 tNFA_P2P_EVT_DATA evt_data;
1053 uint8_t local_sap;
1054
1055 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1056
1057 evt_data.link_info.handle = p_msg->api_link_info.handle;
1058 evt_data.link_info.wks = LLCP_GetRemoteWKS();
1059 evt_data.link_info.local_link_miu = nfa_p2p_cb.local_link_miu;
1060 evt_data.link_info.remote_link_miu = nfa_p2p_cb.remote_link_miu;
1061
1062 local_sap = (uint8_t)(p_msg->api_link_info.handle & NFA_HANDLE_MASK);
1063 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_LINK_INFO_EVT, &evt_data);
1064
1065 return true;
1066 }
1067
1068 /*******************************************************************************
1069 **
1070 ** Function nfa_p2p_get_remote_sap
1071 **
1072 ** Description Get remote SAP
1073 **
1074 **
1075 ** Returns TRUE to deallocate buffer
1076 **
1077 *******************************************************************************/
nfa_p2p_get_remote_sap(tNFA_P2P_MSG * p_msg)1078 bool nfa_p2p_get_remote_sap(tNFA_P2P_MSG* p_msg) {
1079 tNFA_P2P_EVT_DATA evt_data;
1080 uint8_t local_sap;
1081
1082 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1083
1084 local_sap = (uint8_t)(p_msg->api_remote_sap.handle & NFA_HANDLE_MASK);
1085
1086 if (!nfa_p2p_start_sdp(p_msg->api_remote_sap.service_name, local_sap)) {
1087 evt_data.sdp.handle = p_msg->api_remote_sap.handle;
1088 evt_data.sdp.remote_sap = 0x00;
1089 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_SDP_EVT, &evt_data);
1090 }
1091
1092 return true;
1093 }
1094
1095 /*******************************************************************************
1096 **
1097 ** Function nfa_p2p_set_llcp_cfg
1098 **
1099 ** Description Set LLCP configuration
1100 **
1101 **
1102 ** Returns TRUE to deallocate buffer
1103 **
1104 *******************************************************************************/
nfa_p2p_set_llcp_cfg(tNFA_P2P_MSG * p_msg)1105 bool nfa_p2p_set_llcp_cfg(tNFA_P2P_MSG* p_msg) {
1106 LLCP_SetConfig(p_msg->api_set_llcp_cfg.link_miu, p_msg->api_set_llcp_cfg.opt,
1107 p_msg->api_set_llcp_cfg.wt,
1108 p_msg->api_set_llcp_cfg.link_timeout,
1109 p_msg->api_set_llcp_cfg.inact_timeout_init,
1110 p_msg->api_set_llcp_cfg.inact_timeout_target,
1111 p_msg->api_set_llcp_cfg.symm_delay,
1112 p_msg->api_set_llcp_cfg.data_link_timeout,
1113 p_msg->api_set_llcp_cfg.delay_first_pdu_timeout);
1114
1115 return true;
1116 }
1117
1118 /*******************************************************************************
1119 **
1120 ** Function nfa_p2p_restart_rf_discovery
1121 **
1122 ** Description Restart RF discovery by deactivating to IDLE
1123 **
1124 **
1125 ** Returns TRUE to deallocate buffer
1126 **
1127 *******************************************************************************/
nfa_p2p_restart_rf_discovery(tNFA_P2P_MSG * p_msg)1128 bool nfa_p2p_restart_rf_discovery(__attribute__((unused)) tNFA_P2P_MSG* p_msg) {
1129 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1130
1131 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
1132
1133 return true;
1134 }
1135