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, local_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 local_sap = p_data->connect_ind.local_sap;
294
295 if (nfa_p2p_cb.sap_cb[server_sap].p_cback) {
296 xx = nfa_p2p_allocate_conn_cb(server_sap);
297
298 if (xx != LLCP_MAX_DATA_LINK) {
299 nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_ind.remote_sap;
300 nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_ind.miu;
301
302 /* peer will not receive any data */
303 if (p_data->connect_ind.rw == 0)
304 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;
305
306 evt_data.conn_req.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
307 evt_data.conn_req.conn_handle =
308 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
309 evt_data.conn_req.remote_sap = p_data->connect_ind.remote_sap;
310 evt_data.conn_req.remote_miu = p_data->connect_ind.miu;
311 evt_data.conn_req.remote_rw = p_data->connect_ind.rw;
312
313 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_CONN_REQ_EVT, &evt_data);
314 }
315 } else {
316 LOG(ERROR) << StringPrintf("Not registered");
317 }
318 }
319
320 /*******************************************************************************
321 **
322 ** Function nfa_p2p_proc_llcp_connect_resp
323 **
324 ** Description Processing connection response from peer
325 **
326 **
327 ** Returns None
328 **
329 *******************************************************************************/
nfa_p2p_proc_llcp_connect_resp(tLLCP_SAP_CBACK_DATA * p_data)330 void nfa_p2p_proc_llcp_connect_resp(tLLCP_SAP_CBACK_DATA* p_data) {
331 uint8_t local_sap, xx;
332 tNFA_P2P_EVT_DATA evt_data;
333
334 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
335
336 local_sap = p_data->connect_resp.local_sap;
337
338 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
339 xx = nfa_p2p_allocate_conn_cb(local_sap);
340
341 if (xx != LLCP_MAX_DATA_LINK) {
342 nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_resp.remote_sap;
343 nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_resp.miu;
344
345 /* peer will not receive any data */
346 if (p_data->connect_resp.rw == 0)
347 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;
348
349 evt_data.connected.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
350 evt_data.connected.conn_handle =
351 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
352 evt_data.connected.remote_sap = p_data->connect_resp.remote_sap;
353 evt_data.connected.remote_miu = p_data->connect_resp.miu;
354 evt_data.connected.remote_rw = p_data->connect_resp.rw;
355
356 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONNECTED_EVT, &evt_data);
357 }
358 }
359 }
360
361 /*******************************************************************************
362 **
363 ** Function nfa_p2p_proc_llcp_disconnect_ind
364 **
365 ** Description Processing disconnection request from peer
366 **
367 **
368 ** Returns None
369 **
370 *******************************************************************************/
nfa_p2p_proc_llcp_disconnect_ind(tLLCP_SAP_CBACK_DATA * p_data)371 void nfa_p2p_proc_llcp_disconnect_ind(tLLCP_SAP_CBACK_DATA* p_data) {
372 uint8_t local_sap, xx;
373 tNFA_P2P_EVT_DATA evt_data;
374
375 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
376
377 local_sap = p_data->disconnect_ind.local_sap;
378
379 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
380 xx = nfa_p2p_find_conn_cb(p_data->disconnect_ind.local_sap,
381 p_data->disconnect_ind.remote_sap);
382
383 if (xx != LLCP_MAX_DATA_LINK) {
384 evt_data.disc.handle =
385 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
386 evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_INITIATE;
387
388 nfa_p2p_deallocate_conn_cb(xx);
389
390 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
391 } else {
392 /*
393 ** LLCP link has been deactivated before receiving CC or DM.
394 ** Return NFA_P2P_DISC_EVT to indicate failure of creating
395 ** connection
396 */
397
398 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
399 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
400
401 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
402
403 LOG(ERROR) << StringPrintf("Link deactivated");
404 }
405 }
406 }
407
408 /*******************************************************************************
409 **
410 ** Function nfa_p2p_proc_llcp_disconnect_resp
411 **
412 ** Description Processing rejected connection from peer
413 **
414 **
415 ** Returns None
416 **
417 *******************************************************************************/
nfa_p2p_proc_llcp_disconnect_resp(tLLCP_SAP_CBACK_DATA * p_data)418 void nfa_p2p_proc_llcp_disconnect_resp(tLLCP_SAP_CBACK_DATA* p_data) {
419 uint8_t local_sap, xx;
420 tNFA_P2P_EVT_DATA evt_data;
421
422 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
423
424 local_sap = p_data->disconnect_resp.local_sap;
425
426 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
427 if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_RESP_DISC) {
428 evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;
429 } else if ((p_data->disconnect_resp.reason ==
430 LLCP_SAP_DM_REASON_APP_REJECTED) ||
431 (p_data->disconnect_resp.reason ==
432 LLCP_SAP_DM_REASON_PERM_REJECT_THIS) ||
433 (p_data->disconnect_resp.reason ==
434 LLCP_SAP_DM_REASON_PERM_REJECT_ANY) ||
435 (p_data->disconnect_resp.reason ==
436 LLCP_SAP_DM_REASON_TEMP_REJECT_THIS) ||
437 (p_data->disconnect_resp.reason ==
438 LLCP_SAP_DM_REASON_TEMP_REJECT_ANY)) {
439 evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_REJECT;
440 } else if (p_data->disconnect_resp.reason ==
441 LLCP_SAP_DM_REASON_NO_SERVICE) {
442 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_SERVICE;
443 } else if (p_data->disconnect_resp.reason ==
444 LLCP_SAP_DM_REASON_NO_ACTIVE_CONNECTION) {
445 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
446 } else {
447 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;
448 }
449
450 if (evt_data.disc.reason == NFA_P2P_DISC_REASON_LOCAL_INITITATE) {
451 xx = nfa_p2p_find_conn_cb(p_data->disconnect_resp.local_sap,
452 p_data->disconnect_resp.remote_sap);
453
454 if (xx != LLCP_MAX_DATA_LINK) {
455 evt_data.disc.handle =
456 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
457
458 nfa_p2p_deallocate_conn_cb(xx);
459
460 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
461 } else {
462 LOG(ERROR) << StringPrintf("No connection found");
463 }
464 } else {
465 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
466 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
467 }
468 }
469 }
470
471 /*******************************************************************************
472 **
473 ** Function nfa_p2p_proc_llcp_congest
474 **
475 ** Description Processing LLCP congestion event
476 **
477 **
478 ** Returns None
479 **
480 *******************************************************************************/
nfa_p2p_proc_llcp_congestion(tLLCP_SAP_CBACK_DATA * p_data)481 void nfa_p2p_proc_llcp_congestion(tLLCP_SAP_CBACK_DATA* p_data) {
482 uint8_t local_sap, remote_sap, xx;
483 tNFA_P2P_EVT_DATA evt_data;
484
485 local_sap = p_data->congest.local_sap;
486 remote_sap = p_data->congest.remote_sap;
487
488 evt_data.congest.link_type = p_data->congest.link_type;
489 evt_data.congest.is_congested = p_data->congest.is_congested;
490
491 if (p_data->congest.is_congested) {
492 DLOG_IF(INFO, nfc_debug_enabled)
493 << StringPrintf("START SAP=(0x%x,0x%x)", local_sap, remote_sap);
494
495 } else {
496 DLOG_IF(INFO, nfc_debug_enabled)
497 << StringPrintf("END SAP=(0x%x,0x%x)", local_sap, remote_sap);
498 }
499
500 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
501 if (evt_data.congest.link_type == NFA_P2P_LLINK_TYPE) {
502 evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
503
504 if ((evt_data.congest.is_congested == false) &&
505 (nfa_p2p_cb.sap_cb[local_sap].flags &
506 NFA_P2P_SAP_FLAG_LLINK_CONGESTED)) {
507 nfa_p2p_cb.sap_cb[local_sap].flags &= ~NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
508 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
509 } else if ((evt_data.congest.is_congested == true) &&
510 (!(nfa_p2p_cb.sap_cb[local_sap].flags &
511 NFA_P2P_SAP_FLAG_LLINK_CONGESTED))) {
512 /* this is overall congestion due to high usage of buffer pool */
513 nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
514 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
515 }
516 } else {
517 xx = nfa_p2p_find_conn_cb(local_sap, remote_sap);
518
519 if (xx != LLCP_MAX_DATA_LINK) {
520 evt_data.congest.handle =
521 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
522
523 if ((evt_data.congest.is_congested == false) &&
524 (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED)) {
525 nfa_p2p_cb.conn_cb[xx].flags &= ~NFA_P2P_CONN_FLAG_CONGESTED;
526 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
527 } else if ((evt_data.congest.is_congested == true) &&
528 (!(nfa_p2p_cb.conn_cb[xx].flags &
529 NFA_P2P_CONN_FLAG_CONGESTED))) {
530 /* this is overall congestion due to high usage of buffer pool */
531 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
532 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
533 }
534 } else {
535 LOG(ERROR) << StringPrintf("No connection found");
536 }
537 }
538 }
539 }
540
541 /*******************************************************************************
542 **
543 ** Function nfa_p2p_proc_llcp_link_status
544 **
545 ** Description Processing LLCP link status
546 **
547 **
548 ** Returns next state after processing this event
549 **
550 *******************************************************************************/
nfa_p2p_proc_llcp_link_status(tLLCP_SAP_CBACK_DATA * p_data)551 void nfa_p2p_proc_llcp_link_status(tLLCP_SAP_CBACK_DATA* p_data) {
552 uint8_t local_sap, xx;
553 tNFA_P2P_EVT_DATA evt_data;
554
555 DLOG_IF(INFO, nfc_debug_enabled)
556 << StringPrintf("is_activated:%d", p_data->link_status.is_activated);
557
558 local_sap = p_data->link_status.local_sap;
559
560 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
561 if (p_data->link_status.is_activated) {
562 /* only for server */
563 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
564 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
565 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
566
567 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
568 } else /* if LLCP link is deactivated */
569 {
570 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
571 if ((nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE) &&
572 (nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)) {
573 evt_data.disc.handle =
574 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
575 evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
576
577 nfa_p2p_deallocate_conn_cb(xx);
578 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
579 }
580 }
581
582 /* notify deactivation and clear flags */
583 if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_SERVER) {
584 evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
585 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DEACTIVATED_EVT,
586 &evt_data);
587
588 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_SERVER;
589 } else if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_CLIENT) {
590 evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
591 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DEACTIVATED_EVT,
592 &evt_data);
593
594 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_CLIENT;
595 } else /* if this is not registered service */
596 {
597 nfa_p2p_cb.sap_cb[local_sap].p_cback = nullptr;
598 }
599 }
600 }
601 }
602
603 /*******************************************************************************
604 **
605 ** Function nfa_p2p_reg_server
606 **
607 ** Description Allocate a service as server and register to LLCP
608 **
609 **
610 ** Returns FALSE if need to keep buffer
611 **
612 *******************************************************************************/
nfa_p2p_reg_server(tNFA_P2P_MSG * p_msg)613 bool nfa_p2p_reg_server(tNFA_P2P_MSG* p_msg) {
614 tNFA_P2P_EVT_DATA evt_data;
615 uint8_t server_sap;
616
617 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
618
619 server_sap = LLCP_RegisterServer(
620 p_msg->api_reg_server.server_sap, p_msg->api_reg_server.link_type,
621 p_msg->api_reg_server.service_name, nfa_p2p_llcp_cback);
622
623 if (server_sap == LLCP_INVALID_SAP) {
624 evt_data.reg_server.server_handle = NFA_HANDLE_INVALID;
625 evt_data.reg_server.server_sap = NFA_P2P_INVALID_SAP;
626 strlcpy(evt_data.reg_server.service_name,
627 p_msg->api_reg_server.service_name, LLCP_MAX_SN_LEN);
628 evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;
629
630 p_msg->api_reg_server.p_cback(NFA_P2P_REG_SERVER_EVT, &evt_data);
631
632 return true;
633 }
634
635 /* if need to update WKS in LLCP Gen bytes */
636 if (server_sap <= LLCP_UPPER_BOUND_WK_SAP) {
637 nfa_p2p_enable_listening(NFA_ID_P2P, true);
638 } else if (!nfa_p2p_cb.is_p2p_listening) {
639 nfa_p2p_enable_listening(NFA_ID_P2P, false);
640 }
641
642 nfa_p2p_cb.sap_cb[server_sap].p_cback = p_msg->api_reg_server.p_cback;
643 nfa_p2p_cb.sap_cb[server_sap].flags = NFA_P2P_SAP_FLAG_SERVER;
644
645 evt_data.reg_server.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
646 evt_data.reg_server.server_sap = server_sap;
647 strlcpy(evt_data.reg_server.service_name, p_msg->api_reg_server.service_name,
648 LLCP_MAX_SN_LEN);
649 evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;
650
651 /* notify NFA_P2P_REG_SERVER_EVT to server */
652 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_REG_SERVER_EVT, &evt_data);
653
654 /* if LLCP is already activated */
655 if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED) {
656 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | server_sap);
657 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
658 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
659
660 /* notify NFA_P2P_ACTIVATED_EVT to server */
661 nfa_p2p_cb.sap_cb[server_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
662 }
663
664 return true;
665 }
666
667 /*******************************************************************************
668 **
669 ** Function nfa_p2p_reg_client
670 **
671 ** Description Allocate a service as client and register to LLCP
672 **
673 **
674 ** Returns TRUE to deallocate buffer
675 **
676 *******************************************************************************/
nfa_p2p_reg_client(tNFA_P2P_MSG * p_msg)677 bool nfa_p2p_reg_client(tNFA_P2P_MSG* p_msg) {
678 tNFA_P2P_EVT_DATA evt_data;
679 uint8_t local_sap;
680
681 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
682
683 local_sap =
684 LLCP_RegisterClient(p_msg->api_reg_client.link_type, nfa_p2p_llcp_cback);
685
686 if (local_sap == LLCP_INVALID_SAP) {
687 evt_data.reg_client.client_handle = NFA_HANDLE_INVALID;
688 p_msg->api_reg_client.p_cback(NFA_P2P_REG_CLIENT_EVT, &evt_data);
689 return true;
690 }
691
692 nfa_p2p_cb.sap_cb[local_sap].p_cback = p_msg->api_reg_client.p_cback;
693 nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_CLIENT;
694
695 evt_data.reg_client.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
696 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_REG_CLIENT_EVT, &evt_data);
697
698 /* if LLCP is already activated */
699 if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED) {
700 evt_data.activated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
701 evt_data.activated.local_link_miu = nfa_p2p_cb.local_link_miu;
702 evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;
703
704 /* notify NFA_P2P_ACTIVATED_EVT to client */
705 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_ACTIVATED_EVT, &evt_data);
706 }
707
708 return true;
709 }
710
711 /*******************************************************************************
712 **
713 ** Function nfa_p2p_dereg
714 **
715 ** Description Deallocate a service as server or client and deregister to
716 ** LLCP. LLCP will deallocate data link connection created by
717 ** this server
718 **
719 ** Returns TRUE to deallocate buffer
720 **
721 *******************************************************************************/
nfa_p2p_dereg(tNFA_P2P_MSG * p_msg)722 bool nfa_p2p_dereg(tNFA_P2P_MSG* p_msg) {
723 uint8_t local_sap, xx;
724
725 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
726
727 local_sap = (uint8_t)(p_msg->api_dereg.handle & NFA_HANDLE_MASK);
728
729 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
730 for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++) {
731 if ((nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE) &&
732 (nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)) {
733 nfa_p2p_deallocate_conn_cb(xx);
734 }
735 }
736 }
737
738 LLCP_Deregister(local_sap);
739 nfa_p2p_cb.sap_cb[local_sap].p_cback = nullptr;
740
741 if (nfa_p2p_cb.is_p2p_listening) {
742 /* check if this is the last server on NFA P2P */
743 for (xx = 0; xx < NFA_P2P_NUM_SAP; xx++) {
744 if ((nfa_p2p_cb.sap_cb[xx].p_cback) &&
745 (nfa_p2p_cb.sap_cb[xx].flags & NFA_P2P_SAP_FLAG_SERVER)) {
746 break;
747 }
748 }
749
750 if (xx >= NFA_P2P_NUM_SAP) {
751 /* if need to update WKS in LLCP Gen bytes */
752 if (local_sap <= LLCP_UPPER_BOUND_WK_SAP)
753 nfa_p2p_disable_listening(NFA_ID_P2P, true);
754 else
755 nfa_p2p_disable_listening(NFA_ID_P2P, false);
756 }
757 /* if need to update WKS in LLCP Gen bytes */
758 else if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) {
759 nfa_p2p_enable_listening(NFA_ID_P2P, true);
760 }
761 }
762
763 return true;
764 }
765
766 /*******************************************************************************
767 **
768 ** Function nfa_p2p_accept_connection
769 **
770 ** Description Connection Confirm from local application
771 **
772 **
773 ** Returns TRUE to deallocate buffer
774 **
775 *******************************************************************************/
nfa_p2p_accept_connection(tNFA_P2P_MSG * p_msg)776 bool nfa_p2p_accept_connection(tNFA_P2P_MSG* p_msg) {
777 uint8_t xx;
778 tLLCP_CONNECTION_PARAMS params;
779
780 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
781
782 xx = (uint8_t)(p_msg->api_accept.conn_handle & NFA_HANDLE_MASK);
783 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
784
785 params.miu = p_msg->api_accept.miu;
786 params.rw = p_msg->api_accept.rw;
787 params.sn[0] = 0;
788
789 LLCP_ConnectCfm(nfa_p2p_cb.conn_cb[xx].local_sap,
790 nfa_p2p_cb.conn_cb[xx].remote_sap, ¶ms);
791
792 return true;
793 }
794
795 /*******************************************************************************
796 **
797 ** Function nfa_p2p_reject_connection
798 **
799 ** Description Reject connection by local application
800 **
801 **
802 ** Returns TRUE to deallocate buffer
803 **
804 *******************************************************************************/
nfa_p2p_reject_connection(tNFA_P2P_MSG * p_msg)805 bool nfa_p2p_reject_connection(tNFA_P2P_MSG* p_msg) {
806 uint8_t xx;
807
808 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
809
810 xx = (uint8_t)(p_msg->api_reject.conn_handle & NFA_HANDLE_MASK);
811 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
812
813 LLCP_ConnectReject(nfa_p2p_cb.conn_cb[xx].local_sap,
814 nfa_p2p_cb.conn_cb[xx].remote_sap,
815 LLCP_SAP_DM_REASON_APP_REJECTED);
816
817 /* no need to deregister service on LLCP */
818 nfa_p2p_deallocate_conn_cb(xx);
819
820 return true;
821 }
822
823 /*******************************************************************************
824 **
825 ** Function nfa_p2p_disconnect
826 **
827 ** Description Disconnect data link connection by local application
828 **
829 **
830 ** Returns TRUE to deallocate buffer
831 **
832 *******************************************************************************/
nfa_p2p_disconnect(tNFA_P2P_MSG * p_msg)833 bool nfa_p2p_disconnect(tNFA_P2P_MSG* p_msg) {
834 uint8_t local_sap, xx;
835 tLLCP_STATUS status;
836 tNFA_P2P_EVT_DATA evt_data;
837
838 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
839
840 xx = (uint8_t)(p_msg->api_disconnect.conn_handle & NFA_HANDLE_MASK);
841
842 /* if this is for data link connection */
843 if (xx & NFA_P2P_HANDLE_FLAG_CONN) {
844 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
845
846 status = LLCP_DisconnectReq(nfa_p2p_cb.conn_cb[xx].local_sap,
847 nfa_p2p_cb.conn_cb[xx].remote_sap,
848 p_msg->api_disconnect.flush);
849
850 if (status == LLCP_STATUS_SUCCESS) {
851 /* wait for disconnect response if successful */
852 return true;
853 } else {
854 /*
855 ** while we are waiting for connect confirm,
856 ** we cannot sent DISC because we don't know DSAP yet
857 */
858 local_sap = nfa_p2p_cb.conn_cb[xx].local_sap;
859
860 if (nfa_p2p_cb.sap_cb[local_sap].p_cback) {
861 evt_data.disc.handle =
862 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
863 evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;
864
865 nfa_p2p_deallocate_conn_cb(xx);
866 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
867 }
868 }
869 } else {
870 LOG(ERROR) << StringPrintf("Handle is not for Data link connection");
871 }
872
873 return true;
874 }
875
876 /*******************************************************************************
877 **
878 ** Function nfa_p2p_create_data_link_connection
879 **
880 ** Description Create data link connection
881 **
882 **
883 ** Returns TRUE to deallocate buffer
884 **
885 *******************************************************************************/
nfa_p2p_create_data_link_connection(tNFA_P2P_MSG * p_msg)886 bool nfa_p2p_create_data_link_connection(tNFA_P2P_MSG* p_msg) {
887 uint8_t local_sap;
888 tNFA_P2P_EVT_DATA evt_data;
889 tLLCP_CONNECTION_PARAMS conn_params;
890 tLLCP_STATUS status;
891
892 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
893
894 local_sap = (uint8_t)(p_msg->api_connect.client_handle & NFA_HANDLE_MASK);
895
896 conn_params.miu = p_msg->api_connect.miu;
897 conn_params.rw = p_msg->api_connect.rw;
898
899 /* NFA_P2pConnectBySap () */
900 if (p_msg->api_connect.dsap != LLCP_INVALID_SAP) {
901 conn_params.sn[0] = 0;
902 status = LLCP_ConnectReq(local_sap, p_msg->api_connect.dsap, &conn_params);
903 }
904 /* NFA_P2pConnectByName () */
905 else {
906 strlcpy(conn_params.sn, p_msg->api_connect.service_name, LLCP_MAX_SN_LEN);
907 conn_params.sn[LLCP_MAX_SN_LEN] = 0;
908
909 status = LLCP_ConnectReq(local_sap, LLCP_SAP_SDP, &conn_params);
910 }
911
912 if (status != LLCP_STATUS_SUCCESS) {
913 evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
914 evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;
915
916 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_DISC_EVT, &evt_data);
917 }
918
919 return true;
920 }
921
922 /*******************************************************************************
923 **
924 ** Function nfa_p2p_send_ui
925 **
926 ** Description Send UI PDU
927 **
928 **
929 ** Returns TRUE to deallocate buffer
930 **
931 *******************************************************************************/
nfa_p2p_send_ui(tNFA_P2P_MSG * p_msg)932 bool nfa_p2p_send_ui(tNFA_P2P_MSG* p_msg) {
933 uint8_t local_sap;
934 tLLCP_STATUS status;
935 tNFA_P2P_EVT_DATA evt_data;
936
937 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
938
939 local_sap = (uint8_t)(p_msg->api_send_ui.handle & NFA_HANDLE_MASK);
940
941 /* decrease number of tx UI PDU which is not processed by NFA for congestion
942 * control */
943 if (nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu)
944 nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu--;
945
946 if (nfa_p2p_cb.total_pending_ui_pdu) nfa_p2p_cb.total_pending_ui_pdu--;
947
948 status =
949 LLCP_SendUI(local_sap, p_msg->api_send_ui.dsap, p_msg->api_send_ui.p_msg);
950
951 if (status == LLCP_STATUS_CONGESTED) {
952 if (!(nfa_p2p_cb.sap_cb[local_sap].flags &
953 NFA_P2P_SAP_FLAG_LLINK_CONGESTED)) {
954 nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
955
956 /* notify that this logical link is congested */
957 evt_data.congest.link_type = NFA_P2P_LLINK_TYPE;
958 evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
959 evt_data.congest.is_congested = true;
960
961 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_CONGEST_EVT, &evt_data);
962 }
963 }
964
965 return true;
966 }
967
968 /*******************************************************************************
969 **
970 ** Function nfa_p2p_send_data
971 **
972 ** Description Send I PDU
973 **
974 **
975 ** Returns TRUE to deallocate buffer
976 **
977 *******************************************************************************/
nfa_p2p_send_data(tNFA_P2P_MSG * p_msg)978 bool nfa_p2p_send_data(tNFA_P2P_MSG* p_msg) {
979 tNFA_P2P_EVT_DATA evt_data;
980 tLLCP_STATUS status;
981 uint8_t xx;
982
983 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
984
985 xx = (uint8_t)(p_msg->api_send_data.conn_handle & NFA_HANDLE_MASK);
986 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
987
988 /* decrease number of tx I PDU which is not processed by NFA for congestion
989 * control */
990 if (nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu)
991 nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu--;
992
993 if (nfa_p2p_cb.total_pending_i_pdu) nfa_p2p_cb.total_pending_i_pdu--;
994
995 status = LLCP_SendData(nfa_p2p_cb.conn_cb[xx].local_sap,
996 nfa_p2p_cb.conn_cb[xx].remote_sap,
997 p_msg->api_send_data.p_msg);
998
999 if (status == LLCP_STATUS_CONGESTED) {
1000 if (!(nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED)) {
1001 nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
1002
1003 /* notify that this data link is congested */
1004 evt_data.congest.link_type = NFA_P2P_DLINK_TYPE;
1005 evt_data.congest.handle =
1006 (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
1007 evt_data.congest.is_congested = true;
1008
1009 nfa_p2p_cb.sap_cb[nfa_p2p_cb.conn_cb[xx].local_sap].p_cback(
1010 NFA_P2P_CONGEST_EVT, &evt_data);
1011 }
1012 }
1013
1014 return true;
1015 }
1016
1017 /*******************************************************************************
1018 **
1019 ** Function nfa_p2p_set_local_busy
1020 **
1021 ** Description Set or reset local busy
1022 **
1023 **
1024 ** Returns TRUE to deallocate buffer
1025 **
1026 *******************************************************************************/
nfa_p2p_set_local_busy(tNFA_P2P_MSG * p_msg)1027 bool nfa_p2p_set_local_busy(tNFA_P2P_MSG* p_msg) {
1028 uint8_t xx;
1029
1030 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1031
1032 xx = (uint8_t)(p_msg->api_local_busy.conn_handle & NFA_HANDLE_MASK);
1033 xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
1034
1035 LLCP_SetLocalBusyStatus(nfa_p2p_cb.conn_cb[xx].local_sap,
1036 nfa_p2p_cb.conn_cb[xx].remote_sap,
1037 p_msg->api_local_busy.is_busy);
1038
1039 return true;
1040 }
1041
1042 /*******************************************************************************
1043 **
1044 ** Function nfa_p2p_get_link_info
1045 **
1046 ** Description Get WKS of remote and link MIU
1047 **
1048 **
1049 ** Returns TRUE to deallocate buffer
1050 **
1051 *******************************************************************************/
nfa_p2p_get_link_info(tNFA_P2P_MSG * p_msg)1052 bool nfa_p2p_get_link_info(tNFA_P2P_MSG* p_msg) {
1053 tNFA_P2P_EVT_DATA evt_data;
1054 uint8_t local_sap;
1055
1056 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1057
1058 evt_data.link_info.handle = p_msg->api_link_info.handle;
1059 evt_data.link_info.wks = LLCP_GetRemoteWKS();
1060 evt_data.link_info.local_link_miu = nfa_p2p_cb.local_link_miu;
1061 evt_data.link_info.remote_link_miu = nfa_p2p_cb.remote_link_miu;
1062
1063 local_sap = (uint8_t)(p_msg->api_link_info.handle & NFA_HANDLE_MASK);
1064 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_LINK_INFO_EVT, &evt_data);
1065
1066 return true;
1067 }
1068
1069 /*******************************************************************************
1070 **
1071 ** Function nfa_p2p_get_remote_sap
1072 **
1073 ** Description Get remote SAP
1074 **
1075 **
1076 ** Returns TRUE to deallocate buffer
1077 **
1078 *******************************************************************************/
nfa_p2p_get_remote_sap(tNFA_P2P_MSG * p_msg)1079 bool nfa_p2p_get_remote_sap(tNFA_P2P_MSG* p_msg) {
1080 tNFA_P2P_EVT_DATA evt_data;
1081 uint8_t local_sap;
1082
1083 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1084
1085 local_sap = (uint8_t)(p_msg->api_remote_sap.handle & NFA_HANDLE_MASK);
1086
1087 if (!nfa_p2p_start_sdp(p_msg->api_remote_sap.service_name, local_sap)) {
1088 evt_data.sdp.handle = p_msg->api_remote_sap.handle;
1089 evt_data.sdp.remote_sap = 0x00;
1090 nfa_p2p_cb.sap_cb[local_sap].p_cback(NFA_P2P_SDP_EVT, &evt_data);
1091 }
1092
1093 return true;
1094 }
1095
1096 /*******************************************************************************
1097 **
1098 ** Function nfa_p2p_set_llcp_cfg
1099 **
1100 ** Description Set LLCP configuration
1101 **
1102 **
1103 ** Returns TRUE to deallocate buffer
1104 **
1105 *******************************************************************************/
nfa_p2p_set_llcp_cfg(tNFA_P2P_MSG * p_msg)1106 bool nfa_p2p_set_llcp_cfg(tNFA_P2P_MSG* p_msg) {
1107 LLCP_SetConfig(p_msg->api_set_llcp_cfg.link_miu, p_msg->api_set_llcp_cfg.opt,
1108 p_msg->api_set_llcp_cfg.wt,
1109 p_msg->api_set_llcp_cfg.link_timeout,
1110 p_msg->api_set_llcp_cfg.inact_timeout_init,
1111 p_msg->api_set_llcp_cfg.inact_timeout_target,
1112 p_msg->api_set_llcp_cfg.symm_delay,
1113 p_msg->api_set_llcp_cfg.data_link_timeout,
1114 p_msg->api_set_llcp_cfg.delay_first_pdu_timeout);
1115
1116 return true;
1117 }
1118
1119 /*******************************************************************************
1120 **
1121 ** Function nfa_p2p_restart_rf_discovery
1122 **
1123 ** Description Restart RF discovery by deactivating to IDLE
1124 **
1125 **
1126 ** Returns TRUE to deallocate buffer
1127 **
1128 *******************************************************************************/
nfa_p2p_restart_rf_discovery(tNFA_P2P_MSG * p_msg)1129 bool nfa_p2p_restart_rf_discovery(__attribute__((unused)) tNFA_P2P_MSG* p_msg) {
1130 DLOG_IF(INFO, nfc_debug_enabled) << __func__;
1131
1132 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
1133
1134 return true;
1135 }
1136