• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright (C) 2010-2014 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  NFA interface to LLCP
22  *
23  ******************************************************************************/
24 #include <android-base/stringprintf.h>
25 #include <base/logging.h>
26 
27 #include "nfa_p2p_api.h"
28 #include "nfa_p2p_int.h"
29 
30 using android::base::StringPrintf;
31 
32 extern bool nfc_debug_enabled;
33 
34 /*****************************************************************************
35 **  Constants
36 *****************************************************************************/
37 
38 /*******************************************************************************
39 **
40 ** Function         NFA_P2pRegisterServer
41 **
42 ** Description      This function is called to listen to a SAP as server on
43 **                  LLCP.
44 **
45 **                  NFA_P2P_REG_SERVER_EVT will be returned with status and
46 **                  handle.
47 **
48 **                  If server_sap is set to NFA_P2P_ANY_SAP, then NFA will
49 **                  allocate a SAP between LLCP_LOWER_BOUND_SDP_SAP and
50 **                  LLCP_UPPER_BOUND_SDP_SAP Otherwise, server_sap must be
51 **                  between (LLCP_SDP_SAP + 1) and LLCP_UPPER_BOUND_SDP_SAP
52 **
53 **                  link_type : NFA_P2P_LLINK_TYPE and/or NFA_P2P_DLINK_TYPE
54 **
55 ** Note:            If RF discovery is started,
56 **                  NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
57 **                  happen before calling this function
58 **
59 ** Returns          NFA_STATUS_OK if successfully initiated
60 **                  NFA_STATUS_FAILED otherwise
61 **
62 *******************************************************************************/
NFA_P2pRegisterServer(uint8_t server_sap,tNFA_P2P_LINK_TYPE link_type,char * p_service_name,tNFA_P2P_CBACK * p_cback)63 tNFA_STATUS NFA_P2pRegisterServer(uint8_t server_sap,
64                                   tNFA_P2P_LINK_TYPE link_type,
65                                   char* p_service_name,
66                                   tNFA_P2P_CBACK* p_cback) {
67   tNFA_P2P_API_REG_SERVER* p_msg;
68 
69   DLOG_IF(INFO, nfc_debug_enabled)
70       << StringPrintf("server_sap:0x%02x, link_type:0x%x, SN:<%s>", server_sap,
71                       link_type, p_service_name);
72 
73   if ((server_sap != NFA_P2P_ANY_SAP) &&
74       ((server_sap <= LLCP_SAP_SDP) ||
75        (server_sap > LLCP_UPPER_BOUND_SDP_SAP))) {
76     LOG(ERROR) << StringPrintf("server_sap must be between %d and %d",
77                                LLCP_SAP_SDP + 1, LLCP_UPPER_BOUND_SDP_SAP);
78     return (NFA_STATUS_FAILED);
79   } else if (((link_type & NFA_P2P_LLINK_TYPE) == 0x00) &&
80              ((link_type & NFA_P2P_DLINK_TYPE) == 0x00)) {
81     LOG(ERROR) << StringPrintf("link type (0x%x) must be specified", link_type);
82     return (NFA_STATUS_FAILED);
83   }
84 
85   if ((p_msg = (tNFA_P2P_API_REG_SERVER*)GKI_getbuf(
86            sizeof(tNFA_P2P_API_REG_SERVER))) != nullptr) {
87     p_msg->hdr.event = NFA_P2P_API_REG_SERVER_EVT;
88 
89     p_msg->server_sap = server_sap;
90     p_msg->link_type = link_type;
91 
92     strncpy(p_msg->service_name, p_service_name, LLCP_MAX_SN_LEN);
93     p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
94 
95     p_msg->p_cback = p_cback;
96 
97     nfa_sys_sendmsg(p_msg);
98 
99     return (NFA_STATUS_OK);
100   }
101 
102   return (NFA_STATUS_FAILED);
103 }
104 
105 /*******************************************************************************
106 **
107 ** Function         NFA_P2pRegisterClient
108 **
109 ** Description      This function is called to register a client service on
110 **                  LLCP.
111 **
112 **                  NFA_P2P_REG_CLIENT_EVT will be returned with status and
113 **                  handle.
114 **
115 **                  link_type : NFA_P2P_LLINK_TYPE and/or NFA_P2P_DLINK_TYPE
116 **
117 ** Returns          NFA_STATUS_OK if successfully initiated
118 **                  NFA_STATUS_FAILED otherwise
119 **
120 *******************************************************************************/
NFA_P2pRegisterClient(tNFA_P2P_LINK_TYPE link_type,tNFA_P2P_CBACK * p_cback)121 tNFA_STATUS NFA_P2pRegisterClient(tNFA_P2P_LINK_TYPE link_type,
122                                   tNFA_P2P_CBACK* p_cback) {
123   tNFA_P2P_API_REG_CLIENT* p_msg;
124 
125   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("link_type:0x%x", link_type);
126 
127   if (((link_type & NFA_P2P_LLINK_TYPE) == 0x00) &&
128       ((link_type & NFA_P2P_DLINK_TYPE) == 0x00)) {
129     LOG(ERROR) << StringPrintf("link type (0x%x) must be specified", link_type);
130     return (NFA_STATUS_FAILED);
131   }
132 
133   if ((p_msg = (tNFA_P2P_API_REG_CLIENT*)GKI_getbuf(
134            sizeof(tNFA_P2P_API_REG_CLIENT))) != nullptr) {
135     p_msg->hdr.event = NFA_P2P_API_REG_CLIENT_EVT;
136 
137     p_msg->p_cback = p_cback;
138     p_msg->link_type = link_type;
139 
140     nfa_sys_sendmsg(p_msg);
141 
142     return (NFA_STATUS_OK);
143   }
144 
145   return (NFA_STATUS_FAILED);
146 }
147 
148 /*******************************************************************************
149 **
150 ** Function         NFA_P2pDeregister
151 **
152 ** Description      This function is called to stop listening to a SAP as server
153 **                  or stop client service on LLCP.
154 **
155 ** Note:            If this function is called to de-register a server and RF
156 **                  discovery is started,
157 **                  NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT should
158 **                  happen before calling this function
159 **
160 ** Returns          NFA_STATUS_OK if successfully initiated
161 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
162 **                  NFA_STATUS_FAILED otherwise
163 **
164 *******************************************************************************/
NFA_P2pDeregister(tNFA_HANDLE handle)165 tNFA_STATUS NFA_P2pDeregister(tNFA_HANDLE handle) {
166   tNFA_P2P_API_DEREG* p_msg;
167   tNFA_HANDLE xx;
168 
169   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%02X", handle);
170 
171   xx = handle & NFA_HANDLE_MASK;
172 
173   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
174     LOG(ERROR) << StringPrintf("Handle is invalid or not registered");
175     return (NFA_STATUS_BAD_HANDLE);
176   }
177 
178   if ((p_msg = (tNFA_P2P_API_DEREG*)GKI_getbuf(sizeof(tNFA_P2P_API_DEREG))) !=
179       nullptr) {
180     p_msg->hdr.event = NFA_P2P_API_DEREG_EVT;
181 
182     p_msg->handle = handle;
183 
184     nfa_sys_sendmsg(p_msg);
185 
186     return (NFA_STATUS_OK);
187   }
188 
189   return (NFA_STATUS_FAILED);
190 }
191 
192 /*******************************************************************************
193 **
194 ** Function         NFA_P2pAcceptConn
195 **
196 ** Description      This function is called to accept a request of data link
197 **                  connection to a listening SAP on LLCP after receiving
198 **                  NFA_P2P_CONN_REQ_EVT.
199 **
200 ** Returns          NFA_STATUS_OK if successfully initiated
201 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
202 **                  NFA_STATUS_FAILED otherwise
203 **
204 *******************************************************************************/
NFA_P2pAcceptConn(tNFA_HANDLE handle,uint16_t miu,uint8_t rw)205 tNFA_STATUS NFA_P2pAcceptConn(tNFA_HANDLE handle, uint16_t miu, uint8_t rw) {
206   tNFA_P2P_API_ACCEPT_CONN* p_msg;
207   tNFA_HANDLE xx;
208 
209   DLOG_IF(INFO, nfc_debug_enabled)
210       << StringPrintf("handle:0x%02X, MIU:%d, RW:%d", handle, miu, rw);
211 
212   xx = handle & NFA_HANDLE_MASK;
213 
214   if (!(xx & NFA_P2P_HANDLE_FLAG_CONN)) {
215     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
216     return (NFA_STATUS_BAD_HANDLE);
217   } else {
218     xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
219   }
220 
221   if ((xx >= LLCP_MAX_DATA_LINK) || (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
222     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
223     return (NFA_STATUS_BAD_HANDLE);
224   }
225 
226   if ((miu < LLCP_DEFAULT_MIU) || (nfa_p2p_cb.local_link_miu < miu)) {
227     LOG(ERROR) << StringPrintf("MIU(%d) must be between %d and %d", miu,
228                                LLCP_DEFAULT_MIU, nfa_p2p_cb.local_link_miu);
229   } else if ((p_msg = (tNFA_P2P_API_ACCEPT_CONN*)GKI_getbuf(
230                   sizeof(tNFA_P2P_API_ACCEPT_CONN))) != nullptr) {
231     p_msg->hdr.event = NFA_P2P_API_ACCEPT_CONN_EVT;
232 
233     p_msg->conn_handle = handle;
234     p_msg->miu = miu;
235     p_msg->rw = rw;
236 
237     nfa_sys_sendmsg(p_msg);
238 
239     return (NFA_STATUS_OK);
240   }
241 
242   return (NFA_STATUS_FAILED);
243 }
244 
245 /*******************************************************************************
246 **
247 ** Function         NFA_P2pRejectConn
248 **
249 ** Description      This function is called to reject a request of data link
250 **                  connection to a listening SAP on LLCP after receiving
251 **                  NFA_P2P_CONN_REQ_EVT.
252 **
253 ** Returns          NFA_STATUS_OK if successfully initiated
254 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
255 **                  NFA_STATUS_FAILED otherwise
256 **
257 *******************************************************************************/
NFA_P2pRejectConn(tNFA_HANDLE handle)258 tNFA_STATUS NFA_P2pRejectConn(tNFA_HANDLE handle) {
259   tNFA_P2P_API_REJECT_CONN* p_msg;
260   tNFA_HANDLE xx;
261 
262   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%02X", handle);
263 
264   xx = handle & NFA_HANDLE_MASK;
265 
266   if (!(xx & NFA_P2P_HANDLE_FLAG_CONN)) {
267     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
268     return (NFA_STATUS_BAD_HANDLE);
269   } else {
270     xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
271   }
272 
273   if ((xx >= LLCP_MAX_DATA_LINK) || (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
274     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
275     return (NFA_STATUS_BAD_HANDLE);
276   }
277 
278   if ((p_msg = (tNFA_P2P_API_REJECT_CONN*)GKI_getbuf(
279            sizeof(tNFA_P2P_API_REJECT_CONN))) != nullptr) {
280     p_msg->hdr.event = NFA_P2P_API_REJECT_CONN_EVT;
281 
282     p_msg->conn_handle = handle;
283 
284     nfa_sys_sendmsg(p_msg);
285 
286     return (NFA_STATUS_OK);
287   }
288 
289   return (NFA_STATUS_FAILED);
290 }
291 
292 /*******************************************************************************
293 **
294 ** Function         NFA_P2pDisconnect
295 **
296 ** Description      This function is called to disconnect an existing or
297 **                  connecting data link connection.
298 **
299 **                  discard any pending data on data link connection if flush is
300 **                  set to TRUE
301 **
302 **                  NFA_P2P_DISC_EVT will be returned after data link connection
303 **                  is disconnected
304 **
305 ** Returns          NFA_STATUS_OK if successfully initiated
306 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
307 **                  NFA_STATUS_FAILED otherwise
308 **
309 *******************************************************************************/
NFA_P2pDisconnect(tNFA_HANDLE handle,bool flush)310 tNFA_STATUS NFA_P2pDisconnect(tNFA_HANDLE handle, bool flush) {
311   tNFA_P2P_API_DISCONNECT* p_msg;
312   tNFA_HANDLE xx;
313 
314   DLOG_IF(INFO, nfc_debug_enabled)
315       << StringPrintf("handle:0x%02X, flush=%d", handle, flush);
316 
317   xx = handle & NFA_HANDLE_MASK;
318 
319   if (xx & NFA_P2P_HANDLE_FLAG_CONN) {
320     xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
321 
322     if ((xx >= LLCP_MAX_DATA_LINK) || (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
323       LOG(ERROR) << StringPrintf("Connection Handle is not valid");
324       return (NFA_STATUS_BAD_HANDLE);
325     }
326   } else {
327     LOG(ERROR) << StringPrintf("Handle is not valid");
328     return (NFA_STATUS_BAD_HANDLE);
329   }
330 
331   if ((p_msg = (tNFA_P2P_API_DISCONNECT*)GKI_getbuf(
332            sizeof(tNFA_P2P_API_DISCONNECT))) != nullptr) {
333     p_msg->hdr.event = NFA_P2P_API_DISCONNECT_EVT;
334 
335     p_msg->conn_handle = handle;
336     p_msg->flush = flush;
337 
338     nfa_sys_sendmsg(p_msg);
339 
340     return (NFA_STATUS_OK);
341   }
342 
343   return (NFA_STATUS_FAILED);
344 }
345 
346 /*******************************************************************************
347 **
348 ** Function         NFA_P2pConnectByName
349 **
350 ** Description      This function is called to create a connection-oriented
351 **                  transport by a service name.
352 **                  NFA_P2P_CONNECTED_EVT if success
353 **                  NFA_P2P_DISC_EVT if failed
354 **
355 ** Returns          NFA_STATUS_OK if successfully initiated
356 **                  NFA_STATUS_BAD_HANDLE if client is not registered
357 **                  NFA_STATUS_FAILED otherwise
358 **
359 *******************************************************************************/
NFA_P2pConnectByName(tNFA_HANDLE client_handle,char * p_service_name,uint16_t miu,uint8_t rw)360 tNFA_STATUS NFA_P2pConnectByName(tNFA_HANDLE client_handle,
361                                  char* p_service_name, uint16_t miu,
362                                  uint8_t rw) {
363   tNFA_P2P_API_CONNECT* p_msg;
364   tNFA_HANDLE xx;
365 
366   DLOG_IF(INFO, nfc_debug_enabled)
367       << StringPrintf("client_handle:0x%x, SN:<%s>, MIU:%d, RW:%d",
368                       client_handle, p_service_name, miu, rw);
369 
370   xx = client_handle & NFA_HANDLE_MASK;
371 
372   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
373     LOG(ERROR) << StringPrintf("Client Handle is not valid");
374     return (NFA_STATUS_BAD_HANDLE);
375   }
376 
377   if ((miu < LLCP_DEFAULT_MIU) ||
378       (nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED) ||
379       (nfa_p2p_cb.local_link_miu < miu)) {
380     LOG(ERROR) << StringPrintf(
381         "MIU(%d) must be between %d and %d or LLCP "
382         "link is not activated",
383         miu, LLCP_DEFAULT_MIU, nfa_p2p_cb.local_link_miu);
384   } else if ((p_msg = (tNFA_P2P_API_CONNECT*)GKI_getbuf(
385                   sizeof(tNFA_P2P_API_CONNECT))) != nullptr) {
386     p_msg->hdr.event = NFA_P2P_API_CONNECT_EVT;
387 
388     strncpy(p_msg->service_name, p_service_name, LLCP_MAX_SN_LEN);
389     p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
390 
391     p_msg->dsap = LLCP_INVALID_SAP;
392     p_msg->miu = miu;
393     p_msg->rw = rw;
394     p_msg->client_handle = client_handle;
395 
396     nfa_sys_sendmsg(p_msg);
397 
398     return (NFA_STATUS_OK);
399   }
400 
401   return (NFA_STATUS_FAILED);
402 }
403 
404 /*******************************************************************************
405 **
406 ** Function         NFA_P2pConnectBySap
407 **
408 ** Description      This function is called to create a connection-oriented
409 **                  transport by a SAP.
410 **                  NFA_P2P_CONNECTED_EVT if success
411 **                  NFA_P2P_DISC_EVT if failed
412 **
413 ** Returns          NFA_STATUS_OK if successfully initiated
414 **                  NFA_STATUS_BAD_HANDLE if client is not registered
415 **                  NFA_STATUS_FAILED otherwise
416 **
417 *******************************************************************************/
NFA_P2pConnectBySap(tNFA_HANDLE client_handle,uint8_t dsap,uint16_t miu,uint8_t rw)418 tNFA_STATUS NFA_P2pConnectBySap(tNFA_HANDLE client_handle, uint8_t dsap,
419                                 uint16_t miu, uint8_t rw) {
420   tNFA_P2P_API_CONNECT* p_msg;
421   tNFA_HANDLE xx;
422 
423   DLOG_IF(INFO, nfc_debug_enabled)
424       << StringPrintf("client_handle:0x%x, DSAP:0x%02X, MIU:%d, RW:%d",
425                       client_handle, dsap, miu, rw);
426 
427   xx = client_handle & NFA_HANDLE_MASK;
428 
429   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
430     LOG(ERROR) << StringPrintf("Client Handle is not valid");
431     return (NFA_STATUS_BAD_HANDLE);
432   }
433 
434   if ((miu < LLCP_DEFAULT_MIU) ||
435       (nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED) ||
436       (nfa_p2p_cb.local_link_miu < miu)) {
437     LOG(ERROR) << StringPrintf(
438         "MIU(%d) must be between %d and %d, or LLCP "
439         "link is not activated",
440         miu, LLCP_DEFAULT_MIU, nfa_p2p_cb.local_link_miu);
441   } else if ((p_msg = (tNFA_P2P_API_CONNECT*)GKI_getbuf(
442                   sizeof(tNFA_P2P_API_CONNECT))) != nullptr) {
443     p_msg->hdr.event = NFA_P2P_API_CONNECT_EVT;
444 
445     p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
446 
447     p_msg->dsap = dsap;
448     p_msg->miu = miu;
449     p_msg->rw = rw;
450     p_msg->client_handle = client_handle;
451 
452     nfa_sys_sendmsg(p_msg);
453 
454     return (NFA_STATUS_OK);
455   }
456 
457   return (NFA_STATUS_FAILED);
458 }
459 
460 /*******************************************************************************
461 **
462 ** Function         NFA_P2pSendUI
463 **
464 ** Description      This function is called to send data on connectionless
465 **                  transport.
466 **
467 ** Returns          NFA_STATUS_OK if successfully initiated
468 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
469 **                  NFA_STATUS_BAD_LENGTH if data length is more than remote
470 **                  link MIU
471 **                  NFA_STATUS_CONGESTED  if congested
472 **                  NFA_STATUS_FAILED otherwise
473 **
474 *******************************************************************************/
NFA_P2pSendUI(tNFA_HANDLE handle,uint8_t dsap,uint16_t length,uint8_t * p_data)475 tNFA_STATUS NFA_P2pSendUI(tNFA_HANDLE handle, uint8_t dsap, uint16_t length,
476                           uint8_t* p_data) {
477   tNFA_P2P_API_SEND_UI* p_msg;
478   tNFA_STATUS ret_status = NFA_STATUS_FAILED;
479   tNFA_HANDLE xx;
480 
481   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
482       "handle:0x%X, DSAP:0x%02X, length:%d", handle, dsap, length);
483 
484   GKI_sched_lock();
485 
486   xx = handle & NFA_HANDLE_MASK;
487 
488   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
489     LOG(ERROR) << StringPrintf("Handle (0x%X) is not valid", handle);
490     ret_status = NFA_STATUS_BAD_HANDLE;
491   } else if (length > nfa_p2p_cb.remote_link_miu) {
492     LOG(ERROR) << StringPrintf(
493         "handle:0x%X, length(%d) must be less than remote "
494         "link MIU(%d)",
495         handle, length, nfa_p2p_cb.remote_link_miu);
496     ret_status = NFA_STATUS_BAD_LENGTH;
497   } else if (nfa_p2p_cb.sap_cb[xx].flags & NFA_P2P_SAP_FLAG_LLINK_CONGESTED) {
498     LOG(WARNING) << StringPrintf(
499         "handle:0x%X, logical data link is already congested", handle);
500     ret_status = NFA_STATUS_CONGESTED;
501   } else if (LLCP_IsLogicalLinkCongested(
502                  (uint8_t)xx, nfa_p2p_cb.sap_cb[xx].num_pending_ui_pdu,
503                  nfa_p2p_cb.total_pending_ui_pdu,
504                  nfa_p2p_cb.total_pending_i_pdu)) {
505     nfa_p2p_cb.sap_cb[xx].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
506 
507     LOG(WARNING) << StringPrintf("handle:0x%X, logical data link is congested",
508                                  handle);
509     ret_status = NFA_STATUS_CONGESTED;
510   } else if ((p_msg = (tNFA_P2P_API_SEND_UI*)GKI_getbuf(
511                   sizeof(tNFA_P2P_API_SEND_UI))) != nullptr) {
512     p_msg->hdr.event = NFA_P2P_API_SEND_UI_EVT;
513 
514     p_msg->handle = handle;
515     p_msg->dsap = dsap;
516 
517     p_msg->p_msg = (NFC_HDR*)GKI_getpoolbuf(LLCP_POOL_ID);
518     if (p_msg->p_msg != nullptr) {
519       p_msg->p_msg->len = length;
520       p_msg->p_msg->offset = LLCP_MIN_OFFSET;
521       memcpy(((uint8_t*)(p_msg->p_msg + 1) + p_msg->p_msg->offset), p_data,
522              length);
523 
524       /* increase number of tx UI PDU which is not processed by NFA for
525        * congestion control */
526       nfa_p2p_cb.sap_cb[xx].num_pending_ui_pdu++;
527       nfa_p2p_cb.total_pending_ui_pdu++;
528       nfa_sys_sendmsg(p_msg);
529 
530       ret_status = NFA_STATUS_OK;
531     } else {
532       GKI_freebuf(p_msg);
533 
534       nfa_p2p_cb.sap_cb[xx].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
535       ret_status = NFA_STATUS_CONGESTED;
536     }
537   }
538 
539   GKI_sched_unlock();
540 
541   return (ret_status);
542 }
543 
544 /*******************************************************************************
545 **
546 ** Function         NFA_P2pReadUI
547 **
548 ** Description      This function is called to read data on connectionless
549 **                  transport when receiving NFA_P2P_DATA_EVT with
550 **                  NFA_P2P_LLINK_TYPE.
551 **
552 **                  - Remote SAP who sent UI PDU is returned.
553 **                  - Information of UI PDU up to max_data_len is copied into
554 **                    p_data.
555 **                  - If more information of UI PDU or more UI PDU in queue then
556 **                    more is returned to TRUE.
557 **                  - Information of next UI PDU is not concatenated.
558 **
559 ** Returns          NFA_STATUS_OK if successfully initiated
560 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
561 **
562 *******************************************************************************/
NFA_P2pReadUI(tNFA_HANDLE handle,uint32_t max_data_len,uint8_t * p_remote_sap,uint32_t * p_data_len,uint8_t * p_data,bool * p_more)563 tNFA_STATUS NFA_P2pReadUI(tNFA_HANDLE handle, uint32_t max_data_len,
564                           uint8_t* p_remote_sap, uint32_t* p_data_len,
565                           uint8_t* p_data, bool* p_more) {
566   tNFA_STATUS ret_status;
567   tNFA_HANDLE xx;
568 
569   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%X", handle);
570 
571   GKI_sched_lock();
572 
573   xx = handle & NFA_HANDLE_MASK;
574 
575   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
576     LOG(ERROR) << StringPrintf("Handle (0x%X) is not valid", handle);
577     ret_status = NFA_STATUS_BAD_HANDLE;
578   } else {
579     *p_more = LLCP_ReadLogicalLinkData((uint8_t)xx, max_data_len, p_remote_sap,
580                                        p_data_len, p_data);
581     ret_status = NFA_STATUS_OK;
582   }
583 
584   GKI_sched_unlock();
585 
586   return (ret_status);
587 }
588 
589 /*******************************************************************************
590 **
591 ** Function         NFA_P2pFlushUI
592 **
593 ** Description      This function is called to flush data on connectionless
594 **                  transport.
595 **
596 ** Returns          NFA_STATUS_OK if successfully initiated
597 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
598 **
599 *******************************************************************************/
NFA_P2pFlushUI(tNFA_HANDLE handle,uint32_t * p_length)600 tNFA_STATUS NFA_P2pFlushUI(tNFA_HANDLE handle, uint32_t* p_length) {
601   tNFA_STATUS ret_status;
602   tNFA_HANDLE xx;
603 
604   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%X", handle);
605 
606   GKI_sched_lock();
607 
608   xx = handle & NFA_HANDLE_MASK;
609 
610   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
611     LOG(ERROR) << StringPrintf("Handle (0x%X) is not valid", handle);
612     ret_status = NFA_STATUS_BAD_HANDLE;
613     *p_length = 0;
614   } else {
615     *p_length = LLCP_FlushLogicalLinkRxData((uint8_t)xx);
616     ret_status = NFA_STATUS_OK;
617   }
618 
619   GKI_sched_unlock();
620 
621   return (ret_status);
622 }
623 
624 /*******************************************************************************
625 **
626 ** Function         NFA_P2pSendData
627 **
628 ** Description      This function is called to send data on connection-oriented
629 **                  transport.
630 **
631 ** Returns          NFA_STATUS_OK if successfully initiated
632 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
633 **                  NFA_STATUS_BAD_LENGTH if data length is more than remote MIU
634 **                  NFA_STATUS_CONGESTED  if congested
635 **                  NFA_STATUS_FAILED otherwise
636 **
637 *******************************************************************************/
NFA_P2pSendData(tNFA_HANDLE handle,uint16_t length,uint8_t * p_data)638 tNFA_STATUS NFA_P2pSendData(tNFA_HANDLE handle, uint16_t length,
639                             uint8_t* p_data) {
640   tNFA_P2P_API_SEND_DATA* p_msg;
641   tNFA_STATUS ret_status = NFA_STATUS_FAILED;
642   tNFA_HANDLE xx;
643 
644   DLOG_IF(INFO, nfc_debug_enabled)
645       << StringPrintf("handle:0x%X, length:%d", handle, length);
646 
647   GKI_sched_lock();
648 
649   xx = handle & NFA_HANDLE_MASK;
650   xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
651 
652   if ((!(handle & NFA_P2P_HANDLE_FLAG_CONN)) || (xx >= LLCP_MAX_DATA_LINK) ||
653       (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
654     LOG(ERROR) << StringPrintf("Handle(0x%X) is not valid", handle);
655     ret_status = NFA_STATUS_BAD_HANDLE;
656   } else if (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO) {
657     LOG(ERROR) << StringPrintf("handle:0x%X, Remote set RW to 0 (flow off)",
658                                handle);
659     ret_status = NFA_STATUS_FAILED;
660   } else if (nfa_p2p_cb.conn_cb[xx].remote_miu < length) {
661     LOG(ERROR) << StringPrintf("handle:0x%X, Data more than remote MIU(%d)",
662                                handle, nfa_p2p_cb.conn_cb[xx].remote_miu);
663     ret_status = NFA_STATUS_BAD_LENGTH;
664   } else if (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED) {
665     LOG(WARNING) << StringPrintf(
666         "handle:0x%X, data link connection is already "
667         "congested",
668         handle);
669     ret_status = NFA_STATUS_CONGESTED;
670   } else if (LLCP_IsDataLinkCongested(nfa_p2p_cb.conn_cb[xx].local_sap,
671                                       nfa_p2p_cb.conn_cb[xx].remote_sap,
672                                       nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu,
673                                       nfa_p2p_cb.total_pending_ui_pdu,
674                                       nfa_p2p_cb.total_pending_i_pdu)) {
675     nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
676 
677     LOG(WARNING) << StringPrintf(
678         "handle:0x%X, data link connection is congested", handle);
679     ret_status = NFA_STATUS_CONGESTED;
680   } else if ((p_msg = (tNFA_P2P_API_SEND_DATA*)GKI_getbuf(
681                   sizeof(tNFA_P2P_API_SEND_DATA))) != nullptr) {
682     p_msg->hdr.event = NFA_P2P_API_SEND_DATA_EVT;
683 
684     p_msg->conn_handle = handle;
685 
686     p_msg->p_msg = (NFC_HDR*)GKI_getpoolbuf(LLCP_POOL_ID);
687     if (p_msg->p_msg != nullptr) {
688       p_msg->p_msg->len = length;
689       p_msg->p_msg->offset = LLCP_MIN_OFFSET;
690       memcpy(((uint8_t*)(p_msg->p_msg + 1) + p_msg->p_msg->offset), p_data,
691              length);
692 
693       /* increase number of tx I PDU which is not processed by NFA for
694        * congestion control */
695       nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu++;
696       nfa_p2p_cb.total_pending_i_pdu++;
697       nfa_sys_sendmsg(p_msg);
698 
699       ret_status = NFA_STATUS_OK;
700     } else {
701       GKI_freebuf(p_msg);
702       nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
703       ret_status = NFA_STATUS_CONGESTED;
704     }
705   }
706 
707   GKI_sched_unlock();
708 
709   return (ret_status);
710 }
711 
712 /*******************************************************************************
713 **
714 ** Function         NFA_P2pReadData
715 **
716 ** Description      This function is called to read data on connection-oriented
717 **                  transport when receiving NFA_P2P_DATA_EVT with
718 **                  NFA_P2P_DLINK_TYPE.
719 **
720 **                  - Information of I PDU is copied into p_data up to
721 **                    max_data_len.
722 **                  - If more information of I PDU or more I PDU in queue, then
723 **                    more is returned to TRUE.
724 **                  - Information of next I PDU is not concatenated.
725 **
726 ** Returns          NFA_STATUS_OK if successfully initiated
727 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
728 **
729 *******************************************************************************/
NFA_P2pReadData(tNFA_HANDLE handle,uint32_t max_data_len,uint32_t * p_data_len,uint8_t * p_data,bool * p_more)730 tNFA_STATUS NFA_P2pReadData(tNFA_HANDLE handle, uint32_t max_data_len,
731                             uint32_t* p_data_len, uint8_t* p_data,
732                             bool* p_more) {
733   tNFA_STATUS ret_status;
734   tNFA_HANDLE xx;
735 
736   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%X", handle);
737 
738   GKI_sched_lock();
739 
740   xx = handle & NFA_HANDLE_MASK;
741   xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
742 
743   if ((!(handle & NFA_P2P_HANDLE_FLAG_CONN)) || (xx >= LLCP_MAX_DATA_LINK) ||
744       (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
745     LOG(ERROR) << StringPrintf("Handle(0x%X) is not valid", handle);
746     ret_status = NFA_STATUS_BAD_HANDLE;
747   } else {
748     *p_more = LLCP_ReadDataLinkData(nfa_p2p_cb.conn_cb[xx].local_sap,
749                                     nfa_p2p_cb.conn_cb[xx].remote_sap,
750                                     max_data_len, p_data_len, p_data);
751     ret_status = NFA_STATUS_OK;
752   }
753 
754   GKI_sched_unlock();
755 
756   return (ret_status);
757 }
758 
759 /*******************************************************************************
760 **
761 ** Function         NFA_P2pFlushData
762 **
763 ** Description      This function is called to flush data on connection-oriented
764 **                  transport.
765 **
766 ** Returns          NFA_STATUS_OK if successfully initiated
767 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
768 **
769 *******************************************************************************/
NFA_P2pFlushData(tNFA_HANDLE handle,uint32_t * p_length)770 tNFA_STATUS NFA_P2pFlushData(tNFA_HANDLE handle, uint32_t* p_length) {
771   tNFA_STATUS ret_status;
772   tNFA_HANDLE xx;
773 
774   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%X", handle);
775 
776   GKI_sched_lock();
777 
778   xx = handle & NFA_HANDLE_MASK;
779   xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
780 
781   if ((!(handle & NFA_P2P_HANDLE_FLAG_CONN)) || (xx >= LLCP_MAX_DATA_LINK) ||
782       (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
783     LOG(ERROR) << StringPrintf("Handle(0x%X) is not valid", handle);
784     ret_status = NFA_STATUS_BAD_HANDLE;
785   } else {
786     *p_length = LLCP_FlushDataLinkRxData(nfa_p2p_cb.conn_cb[xx].local_sap,
787                                          nfa_p2p_cb.conn_cb[xx].remote_sap);
788     ret_status = NFA_STATUS_OK;
789   }
790 
791   GKI_sched_unlock();
792 
793   return (ret_status);
794 }
795 
796 /*******************************************************************************
797 **
798 ** Function         NFA_P2pSetLocalBusy
799 **
800 ** Description      This function is called to stop or resume incoming data on
801 **                  connection-oriented transport.
802 **
803 ** Returns          NFA_STATUS_OK if successfully initiated
804 **                  NFA_STATUS_BAD_HANDLE if handle is not valid
805 **                  NFA_STATUS_FAILED otherwise
806 **
807 *******************************************************************************/
NFA_P2pSetLocalBusy(tNFA_HANDLE conn_handle,bool is_busy)808 tNFA_STATUS NFA_P2pSetLocalBusy(tNFA_HANDLE conn_handle, bool is_busy) {
809   tNFA_P2P_API_SET_LOCAL_BUSY* p_msg;
810   tNFA_HANDLE xx;
811 
812   DLOG_IF(INFO, nfc_debug_enabled)
813       << StringPrintf("conn_handle:0x%02X, is_busy:%d", conn_handle, is_busy);
814 
815   xx = conn_handle & NFA_HANDLE_MASK;
816 
817   if (!(xx & NFA_P2P_HANDLE_FLAG_CONN)) {
818     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
819     return (NFA_STATUS_BAD_HANDLE);
820   } else {
821     xx &= ~NFA_P2P_HANDLE_FLAG_CONN;
822   }
823 
824   if ((xx >= LLCP_MAX_DATA_LINK) || (nfa_p2p_cb.conn_cb[xx].flags == 0)) {
825     LOG(ERROR) << StringPrintf("Connection Handle is not valid");
826     return (NFA_STATUS_BAD_HANDLE);
827   }
828 
829   if ((p_msg = (tNFA_P2P_API_SET_LOCAL_BUSY*)GKI_getbuf(
830            sizeof(tNFA_P2P_API_SET_LOCAL_BUSY))) != nullptr) {
831     p_msg->hdr.event = NFA_P2P_API_SET_LOCAL_BUSY_EVT;
832 
833     p_msg->conn_handle = conn_handle;
834     p_msg->is_busy = is_busy;
835 
836     nfa_sys_sendmsg(p_msg);
837 
838     return (NFA_STATUS_OK);
839   }
840 
841   return (NFA_STATUS_FAILED);
842 }
843 
844 /*******************************************************************************
845 **
846 ** Function         NFA_P2pGetLinkInfo
847 **
848 ** Description      This function is called to get local/remote link MIU and
849 **                  Well-Known Service list encoded as a 16-bit field of
850 **                  connected LLCP. NFA_P2P_LINK_INFO_EVT will be returned.
851 **
852 ** Returns          NFA_STATUS_OK if successfully initiated
853 **                  NFA_STATUS_BAD_HANDLE if server or client is not registered
854 **                  NFA_STATUS_FAILED otherwise
855 **
856 *******************************************************************************/
NFA_P2pGetLinkInfo(tNFA_HANDLE handle)857 tNFA_STATUS NFA_P2pGetLinkInfo(tNFA_HANDLE handle) {
858   tNFA_P2P_API_GET_LINK_INFO* p_msg;
859   tNFA_HANDLE xx;
860 
861   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("handle:0x%x", handle);
862 
863   if (nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED) {
864     LOG(ERROR) << StringPrintf("LLCP link is not activated");
865     return (NFA_STATUS_FAILED);
866   }
867 
868   xx = handle & NFA_HANDLE_MASK;
869 
870   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
871     LOG(ERROR) << StringPrintf("Handle is invalid or not registered");
872     return (NFA_STATUS_BAD_HANDLE);
873   }
874 
875   if ((p_msg = (tNFA_P2P_API_GET_LINK_INFO*)GKI_getbuf(
876            sizeof(tNFA_P2P_API_GET_LINK_INFO))) != nullptr) {
877     p_msg->hdr.event = NFA_P2P_API_GET_LINK_INFO_EVT;
878 
879     p_msg->handle = handle;
880 
881     nfa_sys_sendmsg(p_msg);
882 
883     return (NFA_STATUS_OK);
884   }
885 
886   return (NFA_STATUS_FAILED);
887 }
888 
889 /*******************************************************************************
890 **
891 ** Function         NFA_P2pGetRemoteSap
892 **
893 ** Description      This function is called to get SAP associated by service
894 **                  name on connected remote LLCP.
895 **                  NFA_P2P_SDP_EVT will be returned.
896 **
897 ** Returns          NFA_STATUS_OK if successfully initiated
898 **                  NFA_STATUS_BAD_HANDLE if server or client is not registered
899 **                  NFA_STATUS_FAILED otherwise
900 **
901 *******************************************************************************/
NFA_P2pGetRemoteSap(tNFA_HANDLE handle,char * p_service_name)902 tNFA_STATUS NFA_P2pGetRemoteSap(tNFA_HANDLE handle, char* p_service_name) {
903   tNFA_P2P_API_GET_REMOTE_SAP* p_msg;
904   tNFA_HANDLE xx;
905 
906   DLOG_IF(INFO, nfc_debug_enabled)
907       << StringPrintf("handle:0x%x, SN:<%s>", handle, p_service_name);
908 
909   if (nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED) {
910     LOG(ERROR) << StringPrintf("LLCP link is not activated");
911     return (NFA_STATUS_FAILED);
912   }
913 
914   xx = handle & NFA_HANDLE_MASK;
915 
916   if ((xx >= NFA_P2P_NUM_SAP) || (nfa_p2p_cb.sap_cb[xx].p_cback == nullptr)) {
917     LOG(ERROR) << StringPrintf("Handle is invalid or not registered");
918     return (NFA_STATUS_BAD_HANDLE);
919   }
920 
921   if ((p_msg = (tNFA_P2P_API_GET_REMOTE_SAP*)GKI_getbuf(
922            sizeof(tNFA_P2P_API_GET_REMOTE_SAP))) != nullptr) {
923     p_msg->hdr.event = NFA_P2P_API_GET_REMOTE_SAP_EVT;
924 
925     p_msg->handle = handle;
926 
927     strncpy(p_msg->service_name, p_service_name, LLCP_MAX_SN_LEN);
928     p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
929 
930     nfa_sys_sendmsg(p_msg);
931 
932     return (NFA_STATUS_OK);
933   }
934 
935   return (NFA_STATUS_FAILED);
936 }
937 
938 /*******************************************************************************
939 **
940 ** Function         NFA_P2pSetLLCPConfig
941 **
942 ** Description      This function is called to change LLCP config parameters.
943 **                  Application must call while LLCP is not activated.
944 **
945 **                  Parameters descriptions (default value)
946 **                  - Local Link MIU (LLCP_MIU)
947 **                  - Option parameter (LLCP_OPT_VALUE)
948 **                  - Response Waiting Time Index (LLCP_WAITING_TIME)
949 **                  - Local Link Timeout (LLCP_LTO_VALUE)
950 **                  - Inactivity Timeout as initiator role
951 **                    (LLCP_INIT_INACTIVITY_TIMEOUT)
952 **                  - Inactivity Timeout as target role
953 **                    (LLCP_TARGET_INACTIVITY_TIMEOUT)
954 **                  - Delay SYMM response (LLCP_DELAY_RESP_TIME)
955 **                  - Data link connection timeout
956 **                    (LLCP_DATA_LINK_CONNECTION_TOUT)
957 **                  - Delay timeout to send first PDU as initiator
958 **                    (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU)
959 **
960 ** Returns          NFA_STATUS_OK if successfully initiated
961 **                  NFA_STATUS_FAILED otherwise
962 **
963 *******************************************************************************/
NFA_P2pSetLLCPConfig(uint16_t link_miu,uint8_t opt,uint8_t wt,uint16_t link_timeout,uint16_t inact_timeout_init,uint16_t inact_timeout_target,uint16_t symm_delay,uint16_t data_link_timeout,uint16_t delay_first_pdu_timeout)964 tNFA_STATUS NFA_P2pSetLLCPConfig(uint16_t link_miu, uint8_t opt, uint8_t wt,
965                                  uint16_t link_timeout,
966                                  uint16_t inact_timeout_init,
967                                  uint16_t inact_timeout_target,
968                                  uint16_t symm_delay,
969                                  uint16_t data_link_timeout,
970                                  uint16_t delay_first_pdu_timeout) {
971   tNFA_P2P_API_SET_LLCP_CFG* p_msg;
972 
973   DLOG_IF(INFO, nfc_debug_enabled)
974       << StringPrintf("link_miu:%d, opt:0x%02X, wt:%d, link_timeout:%d",
975                       link_miu, opt, wt, link_timeout);
976   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
977       "                       inact_timeout(init:%d, target:%d), "
978       "symm_delay:%d, data_link_timeout:%d",
979       inact_timeout_init, inact_timeout_target, symm_delay, data_link_timeout);
980   DLOG_IF(INFO, nfc_debug_enabled)
981       << StringPrintf("                       delay_first_pdu_timeout:%d",
982                       delay_first_pdu_timeout);
983 
984   if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED) {
985     LOG(ERROR) << StringPrintf("LLCP link is activated");
986     return (NFA_STATUS_FAILED);
987   }
988 
989   if ((p_msg = (tNFA_P2P_API_SET_LLCP_CFG*)GKI_getbuf(
990            sizeof(tNFA_P2P_API_SET_LLCP_CFG))) != nullptr) {
991     p_msg->hdr.event = NFA_P2P_API_SET_LLCP_CFG_EVT;
992 
993     p_msg->link_miu = link_miu;
994     p_msg->opt = opt;
995     p_msg->wt = wt;
996     p_msg->link_timeout = link_timeout;
997     p_msg->inact_timeout_init = inact_timeout_init;
998     p_msg->inact_timeout_target = inact_timeout_target;
999     p_msg->symm_delay = symm_delay;
1000     p_msg->data_link_timeout = data_link_timeout;
1001     p_msg->delay_first_pdu_timeout = delay_first_pdu_timeout;
1002 
1003     nfa_sys_sendmsg(p_msg);
1004 
1005     return (NFA_STATUS_OK);
1006   }
1007 
1008   return (NFA_STATUS_FAILED);
1009 }
1010 
1011 /*******************************************************************************
1012 **
1013 ** Function         NFA_P2pGetLLCPConfig
1014 **
1015 ** Description      This function is called to read LLCP config parameters.
1016 **
1017 **                  Parameters descriptions
1018 **                  - Local Link MIU
1019 **                  - Option parameter
1020 **                  - Response Waiting Time Index
1021 **                  - Local Link Timeout
1022 **                  - Inactivity Timeout as initiator role
1023 **                  - Inactivity Timeout as target role
1024 **                  - Delay SYMM response
1025 **                  - Data link connection timeout
1026 **                  - Delay timeout to send first PDU as initiator
1027 **
1028 ** Returns          None
1029 **
1030 *******************************************************************************/
NFA_P2pGetLLCPConfig(uint16_t * p_link_miu,uint8_t * p_opt,uint8_t * p_wt,uint16_t * p_link_timeout,uint16_t * p_inact_timeout_init,uint16_t * p_inact_timeout_target,uint16_t * p_symm_delay,uint16_t * p_data_link_timeout,uint16_t * p_delay_first_pdu_timeout)1031 void NFA_P2pGetLLCPConfig(uint16_t* p_link_miu, uint8_t* p_opt, uint8_t* p_wt,
1032                           uint16_t* p_link_timeout,
1033                           uint16_t* p_inact_timeout_init,
1034                           uint16_t* p_inact_timeout_target,
1035                           uint16_t* p_symm_delay, uint16_t* p_data_link_timeout,
1036                           uint16_t* p_delay_first_pdu_timeout) {
1037   LLCP_GetConfig(p_link_miu, p_opt, p_wt, p_link_timeout, p_inact_timeout_init,
1038                  p_inact_timeout_target, p_symm_delay, p_data_link_timeout,
1039                  p_delay_first_pdu_timeout);
1040 
1041   DLOG_IF(INFO, nfc_debug_enabled)
1042       << StringPrintf("link_miu:%d, opt:0x%02X, wt:%d, link_timeout:%d",
1043                       *p_link_miu, *p_opt, *p_wt, *p_link_timeout);
1044   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
1045       "                       inact_timeout(init:%d, target:%d), "
1046       "symm_delay:%d, data_link_timeout:%d",
1047       *p_inact_timeout_init, *p_inact_timeout_target, *p_symm_delay,
1048       *p_data_link_timeout);
1049   DLOG_IF(INFO, nfc_debug_enabled)
1050       << StringPrintf("                       delay_first_pdu_timeout:%d",
1051                       *p_delay_first_pdu_timeout);
1052 }
1053