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