/******************************************************************************
 *
 *  Copyright (C) 2010-2014 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/


/******************************************************************************
 *
 *  This is the implementation file for the NFA P2P.
 *
 ******************************************************************************/

#include "string.h"
#include "nfc_api.h"
#include "nfa_sys.h"
#include "nfa_sys_int.h"
#include "nfa_dm_int.h"
#include "llcp_defs.h"
#include "llcp_api.h"
#include "nfa_p2p_api.h"
#include "nfa_p2p_int.h"

/*****************************************************************************
**  Global Variables
*****************************************************************************/

/*****************************************************************************
**  Static Functions
*****************************************************************************/

/*****************************************************************************
**  Constants
*****************************************************************************/

/*******************************************************************************
**
** Function         nfa_p2p_allocate_conn_cb
**
** Description      Allocate data link connection control block
**
**
** Returns          UINT8
**
*******************************************************************************/
static UINT8 nfa_p2p_allocate_conn_cb (UINT8 local_sap)
{
    UINT8 xx;

    for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++)
    {
        if (nfa_p2p_cb.conn_cb[xx].flags == 0)
        {
            nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_IN_USE;
            nfa_p2p_cb.conn_cb[xx].local_sap = local_sap;

            return (xx);
        }
    }

    P2P_TRACE_ERROR0 ("nfa_p2p_allocate_conn_cb (): No resource");

    return LLCP_MAX_DATA_LINK;
}

/*******************************************************************************
**
** Function         nfa_p2p_deallocate_conn_cb
**
** Description      Deallocate data link connection control block
**
**
** Returns          void
**
*******************************************************************************/
static void nfa_p2p_deallocate_conn_cb (UINT8 xx)
{
    if (xx < LLCP_MAX_DATA_LINK)
    {
        nfa_p2p_cb.conn_cb[xx].flags = 0;
    }
    else
    {
        P2P_TRACE_ERROR1 ("nfa_p2p_deallocate_conn_cb (): Invalid index (%d)", xx);
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_find_conn_cb
**
** Description      Find data link connection control block by local/remote SAP
**
**
** Returns          UINT8
**
*******************************************************************************/
static UINT8 nfa_p2p_find_conn_cb (UINT8 local_sap, UINT8 remote_sap)
{
    UINT8 xx;

    for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++)
    {
        if (  (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE)
            &&(nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)
            &&(nfa_p2p_cb.conn_cb[xx].remote_sap == remote_sap)  )
        {
            return (xx);
        }
    }

    return (LLCP_MAX_DATA_LINK);
}

/*******************************************************************************
**
** Function         nfa_p2p_llcp_cback
**
** Description      Processing SAP callback events from LLCP
**
**
** Returns          None
**
*******************************************************************************/
static void nfa_p2p_llcp_cback (tLLCP_SAP_CBACK_DATA *p_data)
{
    P2P_TRACE_DEBUG2 ("nfa_p2p_llcp_cback (): event:0x%02X, local_sap:0x%02X", p_data->hdr.event, p_data->hdr.local_sap);

    switch (p_data->hdr.event)
    {
    case LLCP_SAP_EVT_DATA_IND:
         nfa_p2p_proc_llcp_data_ind (p_data);
        break;

    case LLCP_SAP_EVT_CONNECT_IND:
        nfa_p2p_proc_llcp_connect_ind (p_data);
        break;

    case LLCP_SAP_EVT_CONNECT_RESP:
        nfa_p2p_proc_llcp_connect_resp (p_data);
        break;

    case LLCP_SAP_EVT_DISCONNECT_IND:
        nfa_p2p_proc_llcp_disconnect_ind (p_data);
        break;

    case LLCP_SAP_EVT_DISCONNECT_RESP:
        nfa_p2p_proc_llcp_disconnect_resp (p_data);
        break;

    case LLCP_SAP_EVT_CONGEST:
        nfa_p2p_proc_llcp_congestion (p_data);
        break;

    case LLCP_SAP_EVT_LINK_STATUS:
        nfa_p2p_proc_llcp_link_status (p_data);
        break;

    default:
        P2P_TRACE_ERROR1 ("nfa_p2p_llcp_cback (): Unknown event:0x%02X", p_data->hdr.event);
        return;
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_sdp_cback
**
** Description      Process SDP callback event from LLCP
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_sdp_cback (UINT8 tid, UINT8 remote_sap)
{
    UINT8             local_sap;
    UINT8             xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG2 ("nfa_p2p_sdp_cback (): tid:0x%02X, remote_sap:0x%02X", tid, remote_sap);

    /* search for callback function to process */
    for (xx = 0; xx < LLCP_MAX_SDP_TRANSAC; xx++)
    {
        if (  (nfa_p2p_cb.sdp_cb[xx].local_sap != LLCP_INVALID_SAP)
            &&(nfa_p2p_cb.sdp_cb[xx].tid == tid)  )
        {
            local_sap = nfa_p2p_cb.sdp_cb[xx].local_sap;

            evt_data.sdp.handle     = (NFA_HANDLE_GROUP_P2P | local_sap);
            evt_data.sdp.remote_sap = remote_sap;
            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_SDP_EVT, &evt_data);

            nfa_p2p_cb.sdp_cb[xx].local_sap = LLCP_INVALID_SAP;
            break;
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_start_sdp
**
** Description      Initiate SDP
**
**
** Returns          TRUE if success
**
*******************************************************************************/
BOOLEAN nfa_p2p_start_sdp (char *p_service_name, UINT8 local_sap)
{
    int xx;

    P2P_TRACE_DEBUG1 ("nfa_p2p_start_sdp (): SN:<%s>", p_service_name);

    /* search for empty slot */
    for (xx = 0; xx < LLCP_MAX_SDP_TRANSAC; xx++)
    {
        if (nfa_p2p_cb.sdp_cb[xx].local_sap == LLCP_INVALID_SAP)
        {
            if (LLCP_DiscoverService (p_service_name,
                                      nfa_p2p_sdp_cback,
                                      &(nfa_p2p_cb.sdp_cb[xx].tid)) == LLCP_STATUS_SUCCESS)
            {
                nfa_p2p_cb.sdp_cb[xx].local_sap    = local_sap;
                return TRUE;
            }
            else
            {
                /* failure of SDP */
                return FALSE;
            }
        }
    }
    return FALSE;
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_data_ind
**
** Description      Processing incoming data event from LLCP
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_data_ind (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_proc_llcp_data_ind ()");

    local_sap = p_data->data_ind.local_sap;

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        evt_data.data.handle    = 0;
        /* if connectionless */
        if (p_data->data_ind.link_type == NFA_P2P_LLINK_TYPE)
        {
            evt_data.data.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
        }
        else
        {
            xx = nfa_p2p_find_conn_cb (p_data->data_ind.local_sap,
                                       p_data->data_ind.remote_sap);

            if (xx != LLCP_MAX_DATA_LINK)
            {
                evt_data.data.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
            }
        }

        evt_data.data.remote_sap = p_data->data_ind.remote_sap;
        evt_data.data.link_type  = p_data->data_ind.link_type;

        /* notify upper layer that there are data at LLCP */
        nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DATA_EVT, &evt_data);
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_connect_ind
**
** Description      Processing connection request from peer
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_connect_ind (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             server_sap, local_sap;
    tNFA_P2P_EVT_DATA evt_data;
    UINT8             xx;

    P2P_TRACE_DEBUG1 ("nfa_p2p_proc_llcp_connect_ind () server_sap:0x%x",
                       p_data->connect_ind.server_sap);

    server_sap = p_data->connect_ind.server_sap;
    local_sap  = p_data->connect_ind.local_sap;

    if (nfa_p2p_cb.sap_cb[server_sap].p_cback)
    {
        xx = nfa_p2p_allocate_conn_cb (server_sap);

        if (xx != LLCP_MAX_DATA_LINK)
        {
            nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_ind.remote_sap;
            nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_ind.miu;

            /* peer will not receive any data */
            if (p_data->connect_ind.rw == 0)
                nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;

            evt_data.conn_req.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
            evt_data.conn_req.conn_handle   = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
            evt_data.conn_req.remote_sap    = p_data->connect_ind.remote_sap;
            evt_data.conn_req.remote_miu    = p_data->connect_ind.miu;
            evt_data.conn_req.remote_rw     = p_data->connect_ind.rw;

            nfa_p2p_cb.sap_cb[server_sap].p_cback (NFA_P2P_CONN_REQ_EVT, &evt_data);
        }
    }
    else
    {
        P2P_TRACE_ERROR0 ("nfa_p2p_proc_llcp_connect_ind (): Not registered");
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_connect_resp
**
** Description      Processing connection response from peer
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_connect_resp (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_proc_llcp_connect_resp ()");

    local_sap  = p_data->connect_resp.local_sap;

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        xx = nfa_p2p_allocate_conn_cb (local_sap);

        if (xx != LLCP_MAX_DATA_LINK)
        {
            nfa_p2p_cb.conn_cb[xx].remote_sap = p_data->connect_resp.remote_sap;
            nfa_p2p_cb.conn_cb[xx].remote_miu = p_data->connect_resp.miu;

            /* peer will not receive any data */
            if (p_data->connect_resp.rw == 0)
                nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_REMOTE_RW_ZERO;

            evt_data.connected.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
            evt_data.connected.conn_handle   = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
            evt_data.connected.remote_sap    = p_data->connect_resp.remote_sap;
            evt_data.connected.remote_miu    = p_data->connect_resp.miu;
            evt_data.connected.remote_rw     = p_data->connect_resp.rw;

            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONNECTED_EVT, &evt_data);
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_disconnect_ind
**
** Description      Processing disconnection request from peer
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_disconnect_ind (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_proc_llcp_disconnect_ind ()");

    local_sap  = p_data->disconnect_ind.local_sap;

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        xx = nfa_p2p_find_conn_cb (p_data->disconnect_ind.local_sap,
                                   p_data->disconnect_ind.remote_sap);

        if (xx != LLCP_MAX_DATA_LINK)
        {
            evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
            evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_INITIATE;

            nfa_p2p_deallocate_conn_cb (xx);

            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
        }
        else
        {
            /*
            ** LLCP link has been deactivated before receiving CC or DM.
            ** Return NFA_P2P_DISC_EVT to indicate failure of creating connection
            */

            evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
            evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;

            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);

            P2P_TRACE_ERROR0 ("nfa_p2p_proc_llcp_disconnect_ind (): Link deactivated");
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_disconnect_resp
**
** Description      Processing rejected connection from peer
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_disconnect_resp (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_proc_llcp_disconnect_resp ()");

    local_sap  = p_data->disconnect_resp.local_sap;

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_RESP_DISC)
        {
            evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;
        }
        else if (  (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_APP_REJECTED)
                 ||(p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_PERM_REJECT_THIS)
                 ||(p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_PERM_REJECT_ANY)
                 ||(p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_TEMP_REJECT_THIS)
                 ||(p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_TEMP_REJECT_ANY)  )
        {
            evt_data.disc.reason = NFA_P2P_DISC_REASON_REMOTE_REJECT;
        }
        else if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_NO_SERVICE)
        {
            evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_SERVICE;
        }
        else if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_NO_ACTIVE_CONNECTION)
        {
            evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;
        }
        else
        {
            evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;
        }

        if (evt_data.disc.reason == NFA_P2P_DISC_REASON_LOCAL_INITITATE)
        {
            xx = nfa_p2p_find_conn_cb (p_data->disconnect_resp.local_sap,
                                       p_data->disconnect_resp.remote_sap);

            if (xx != LLCP_MAX_DATA_LINK)
            {
                evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);

                nfa_p2p_deallocate_conn_cb (xx);

                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
            }
            else
            {
                P2P_TRACE_ERROR0 ("nfa_p2p_proc_llcp_disconnect_resp (): No connection found");
            }
        }
        else
        {
            evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_congest
**
** Description      Processing LLCP congestion event
**
**
** Returns          None
**
*******************************************************************************/
void nfa_p2p_proc_llcp_congestion (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, remote_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    local_sap  = p_data->congest.local_sap;
    remote_sap = p_data->congest.remote_sap;

    evt_data.congest.link_type    = p_data->congest.link_type;
    evt_data.congest.is_congested = p_data->congest.is_congested;

    if (p_data->congest.is_congested)
    {
        P2P_TRACE_DEBUG2 ("nfa_p2p_proc_llcp_congestion () START SAP=(0x%x,0x%x)",
                          local_sap, remote_sap);

    }
    else
    {
        P2P_TRACE_DEBUG2 ("nfa_p2p_proc_llcp_congestion () END SAP=(0x%x,0x%x)",
                          local_sap, remote_sap);
    }

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        if (evt_data.congest.link_type == NFA_P2P_LLINK_TYPE)
        {
            evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | local_sap);

            if (  (evt_data.congest.is_congested == FALSE)
                &&(nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_LLINK_CONGESTED)  )
            {
                nfa_p2p_cb.sap_cb[local_sap].flags &= ~NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
            }
            else if (  (evt_data.congest.is_congested == TRUE)
                     &&(!(nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_LLINK_CONGESTED))  )
            {
                /* this is overall congestion due to high usage of buffer pool */
                nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;
                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
            }
        }
        else
        {
            xx = nfa_p2p_find_conn_cb (local_sap, remote_sap);

            if (xx != LLCP_MAX_DATA_LINK)
            {
                evt_data.congest.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);

                if (  (evt_data.congest.is_congested == FALSE)
                    &&(nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED)  )
                {
                    nfa_p2p_cb.conn_cb[xx].flags &= ~NFA_P2P_CONN_FLAG_CONGESTED;
                    nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
                }
                else if (  (evt_data.congest.is_congested == TRUE)
                         &&(!(nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED))  )
                {
                    /* this is overall congestion due to high usage of buffer pool */
                    nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;
                    nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
                }
            }
            else
            {
                P2P_TRACE_ERROR0 ("nfa_p2p_proc_llcp_congestion (): No connection found");
            }
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_proc_llcp_link_status
**
** Description      Processing LLCP link status
**
**
** Returns          next state after processing this event
**
*******************************************************************************/
void nfa_p2p_proc_llcp_link_status (tLLCP_SAP_CBACK_DATA  *p_data)
{
    UINT8             local_sap, xx;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG1 ("nfa_p2p_proc_llcp_link_status () is_activated:%d",
                       p_data->link_status.is_activated);

    local_sap  = p_data->link_status.local_sap;

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        if (p_data->link_status.is_activated)
        {
            /* only for server */
            evt_data.activated.handle           = (NFA_HANDLE_GROUP_P2P | local_sap);
            evt_data.activated.local_link_miu   = nfa_p2p_cb.local_link_miu;
            evt_data.activated.remote_link_miu  = nfa_p2p_cb.remote_link_miu;

            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_ACTIVATED_EVT, &evt_data);
        }
        else /* if LLCP link is deactivated */
        {
            for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++)
            {
                if (  (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE)
                    &&(nfa_p2p_cb.conn_cb[xx].local_sap == local_sap))
                {
                    evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
                    evt_data.disc.reason = NFA_P2P_DISC_REASON_LLCP_DEACTIVATED;

                    nfa_p2p_deallocate_conn_cb (xx);
                    nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
                }
            }

            /* notify deactivation and clear flags */
            if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_SERVER)
            {
                evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DEACTIVATED_EVT, &evt_data);

                nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_SERVER;
            }
            else if (nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_CLIENT)
            {
                evt_data.deactivated.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DEACTIVATED_EVT, &evt_data);

                nfa_p2p_cb.sap_cb[local_sap].flags = NFA_P2P_SAP_FLAG_CLIENT;
            }
            else /* if this is not registered service */
            {
                nfa_p2p_cb.sap_cb[local_sap].p_cback = NULL;
            }
        }
    }
}

/*******************************************************************************
**
** Function         nfa_p2p_reg_server
**
** Description      Allocate a service as server and register to LLCP
**
**
** Returns          FALSE if need to keep buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_reg_server (tNFA_P2P_MSG *p_msg)
{
    tNFA_P2P_EVT_DATA  evt_data;
    UINT8              server_sap;

    P2P_TRACE_DEBUG0 ("nfa_p2p_reg_server ()");

    server_sap = LLCP_RegisterServer (p_msg->api_reg_server.server_sap,
                                      p_msg->api_reg_server.link_type,
                                      p_msg->api_reg_server.service_name,
                                      nfa_p2p_llcp_cback);

    if (server_sap == LLCP_INVALID_SAP)
    {
        evt_data.reg_server.server_handle = NFA_HANDLE_INVALID;
        evt_data.reg_server.server_sap    = NFA_P2P_INVALID_SAP;
        BCM_STRNCPY_S (evt_data.reg_server.service_name, sizeof (evt_data.reg_server.service_name),
                       p_msg->api_reg_server.service_name, LLCP_MAX_SN_LEN);
        evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;

        p_msg->api_reg_server.p_cback (NFA_P2P_REG_SERVER_EVT, &evt_data);

        return TRUE;
    }

    /* if need to update WKS in LLCP Gen bytes */
    if (server_sap <= LLCP_UPPER_BOUND_WK_SAP)
    {
        nfa_p2p_enable_listening (NFA_ID_P2P, TRUE);
    }
    else if (!nfa_p2p_cb.is_p2p_listening)
    {
        nfa_p2p_enable_listening (NFA_ID_P2P, FALSE);
    }

    nfa_p2p_cb.sap_cb[server_sap].p_cback    = p_msg->api_reg_server.p_cback;
    nfa_p2p_cb.sap_cb[server_sap].flags      = NFA_P2P_SAP_FLAG_SERVER;

    evt_data.reg_server.server_handle = (NFA_HANDLE_GROUP_P2P | server_sap);
    evt_data.reg_server.server_sap    = server_sap;
    BCM_STRNCPY_S (evt_data.reg_server.service_name, sizeof (evt_data.reg_server.service_name),
                   p_msg->api_reg_server.service_name, LLCP_MAX_SN_LEN);
    evt_data.reg_server.service_name[LLCP_MAX_SN_LEN] = 0;

    /* notify NFA_P2P_REG_SERVER_EVT to server */
    nfa_p2p_cb.sap_cb[server_sap].p_cback (NFA_P2P_REG_SERVER_EVT, &evt_data);

    /* if LLCP is already activated */
    if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED)
    {
        evt_data.activated.handle          = (NFA_HANDLE_GROUP_P2P | server_sap);
        evt_data.activated.local_link_miu  = nfa_p2p_cb.local_link_miu;
        evt_data.activated.remote_link_miu = nfa_p2p_cb.remote_link_miu;

        /* notify NFA_P2P_ACTIVATED_EVT to server */
        nfa_p2p_cb.sap_cb[server_sap].p_cback (NFA_P2P_ACTIVATED_EVT, &evt_data);
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_reg_client
**
** Description      Allocate a service as client and register to LLCP
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_reg_client (tNFA_P2P_MSG *p_msg)
{
    tNFA_P2P_EVT_DATA  evt_data;
    UINT8              local_sap;

    P2P_TRACE_DEBUG0 ("nfa_p2p_reg_client ()");

    local_sap = LLCP_RegisterClient (p_msg->api_reg_client.link_type,
                                     nfa_p2p_llcp_cback);

    if (local_sap == LLCP_INVALID_SAP)
    {
        evt_data.reg_client.client_handle = NFA_HANDLE_INVALID;
        p_msg->api_reg_client.p_cback (NFA_P2P_REG_CLIENT_EVT, &evt_data);
        return TRUE;
    }

    nfa_p2p_cb.sap_cb[local_sap].p_cback = p_msg->api_reg_client.p_cback;
    nfa_p2p_cb.sap_cb[local_sap].flags   = NFA_P2P_SAP_FLAG_CLIENT;

    evt_data.reg_client.client_handle = (NFA_HANDLE_GROUP_P2P | local_sap);
    nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_REG_CLIENT_EVT, &evt_data);

    /* if LLCP is already activated */
    if (nfa_p2p_cb.llcp_state == NFA_P2P_LLCP_STATE_ACTIVATED)
    {
        evt_data.activated.handle           = (NFA_HANDLE_GROUP_P2P | local_sap);
        evt_data.activated.local_link_miu   = nfa_p2p_cb.local_link_miu;
        evt_data.activated.remote_link_miu  = nfa_p2p_cb.remote_link_miu;

        /* notify NFA_P2P_ACTIVATED_EVT to client */
        nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_ACTIVATED_EVT, &evt_data);
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_dereg
**
** Description      Deallocate a service as server or client and deregister to LLCP
**                  LLCP will deallocate data link connection created by this server
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_dereg (tNFA_P2P_MSG *p_msg)
{
    UINT8 local_sap, xx;

    P2P_TRACE_DEBUG0 ("nfa_p2p_dereg ()");

    local_sap = (UINT8) (p_msg->api_dereg.handle & NFA_HANDLE_MASK);

    if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
    {
        for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++)
        {
            if (  (nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_IN_USE)
                &&(nfa_p2p_cb.conn_cb[xx].local_sap == local_sap)  )
            {
                nfa_p2p_deallocate_conn_cb (xx);
            }
        }
    }

    LLCP_Deregister (local_sap);
    nfa_p2p_cb.sap_cb[local_sap].p_cback = NULL;

    if (nfa_p2p_cb.is_p2p_listening)
    {
        /* check if this is the last server on NFA P2P */
        for (xx = 0; xx < NFA_P2P_NUM_SAP; xx++)
        {
            if (  (nfa_p2p_cb.sap_cb[xx].p_cback)
                &&(nfa_p2p_cb.sap_cb[xx].flags & NFA_P2P_SAP_FLAG_SERVER)  )
            {
                break;
            }
        }

        if (xx >= NFA_P2P_NUM_SAP)
        {
            /* if need to update WKS in LLCP Gen bytes */
            if (local_sap <= LLCP_UPPER_BOUND_WK_SAP)
                nfa_p2p_disable_listening (NFA_ID_P2P, TRUE);
            else
                nfa_p2p_disable_listening (NFA_ID_P2P, FALSE);
        }
        /* if need to update WKS in LLCP Gen bytes */
        else if (local_sap <= LLCP_UPPER_BOUND_WK_SAP)
        {
            nfa_p2p_enable_listening (NFA_ID_P2P, TRUE);
        }
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_accept_connection
**
** Description      Connection Confirm from local application
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_accept_connection (tNFA_P2P_MSG *p_msg)
{
    UINT8                   xx;
    tLLCP_CONNECTION_PARAMS params;

    P2P_TRACE_DEBUG0 ("nfa_p2p_accept_connection ()");

    xx  = (UINT8) (p_msg->api_accept.conn_handle & NFA_HANDLE_MASK);
    xx &= ~NFA_P2P_HANDLE_FLAG_CONN;

    params.miu   = p_msg->api_accept.miu;
    params.rw    = p_msg->api_accept.rw;
    params.sn[0] = 0;

    LLCP_ConnectCfm (nfa_p2p_cb.conn_cb[xx].local_sap, nfa_p2p_cb.conn_cb[xx].remote_sap, &params);

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_reject_connection
**
** Description      Reject connection by local application
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_reject_connection (tNFA_P2P_MSG *p_msg)
{
    UINT8 xx;

    P2P_TRACE_DEBUG0 ("nfa_p2p_reject_connection ()");

    xx  = (UINT8) (p_msg->api_reject.conn_handle & NFA_HANDLE_MASK);
    xx &= ~NFA_P2P_HANDLE_FLAG_CONN;

    LLCP_ConnectReject (nfa_p2p_cb.conn_cb[xx].local_sap, nfa_p2p_cb.conn_cb[xx].remote_sap,
                        LLCP_SAP_DM_REASON_APP_REJECTED);

    /* no need to deregister service on LLCP */
    nfa_p2p_deallocate_conn_cb (xx);

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_disconnect
**
** Description      Disconnect data link connection by local application
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_disconnect (tNFA_P2P_MSG *p_msg)
{
    UINT8             local_sap, xx;
    tLLCP_STATUS      status;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_disconnect ()");

    xx = (UINT8) (p_msg->api_disconnect.conn_handle & NFA_HANDLE_MASK);

    /* if this is for data link connection */
    if (xx & NFA_P2P_HANDLE_FLAG_CONN)
    {
        xx &= ~NFA_P2P_HANDLE_FLAG_CONN;

        status = LLCP_DisconnectReq (nfa_p2p_cb.conn_cb[xx].local_sap, nfa_p2p_cb.conn_cb[xx].remote_sap,
                                     p_msg->api_disconnect.flush);

        if (status == LLCP_STATUS_SUCCESS)
        {
            /* wait for disconnect response if successful */
            return TRUE;
        }
        else
        {
            /*
            ** while we are waiting for connect confirm,
            ** we cannot sent DISC because we don't know DSAP yet
            */
            local_sap = nfa_p2p_cb.conn_cb[xx].local_sap;

            if (nfa_p2p_cb.sap_cb[local_sap].p_cback)
            {
                evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
                evt_data.disc.reason = NFA_P2P_DISC_REASON_LOCAL_INITITATE;

                nfa_p2p_deallocate_conn_cb (xx);
                nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
            }
        }
    }
    else
    {
        P2P_TRACE_ERROR0 ("Handle is not for Data link connection");
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_create_data_link_connection
**
** Description      Create data link connection
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_create_data_link_connection (tNFA_P2P_MSG *p_msg)
{
    UINT8                   local_sap;
    tNFA_P2P_EVT_DATA       evt_data;
    tLLCP_CONNECTION_PARAMS conn_params;
    tLLCP_STATUS            status;

    P2P_TRACE_DEBUG0 ("nfa_p2p_create_data_link_connection ()");

    local_sap = (UINT8) (p_msg->api_connect.client_handle & NFA_HANDLE_MASK);

    conn_params.miu = p_msg->api_connect.miu;
    conn_params.rw  = p_msg->api_connect.rw;

    /* NFA_P2pConnectBySap () */
    if (p_msg->api_connect.dsap != LLCP_INVALID_SAP)
    {
        conn_params.sn[0] = 0;
        status = LLCP_ConnectReq (local_sap, p_msg->api_connect.dsap, &conn_params);
    }
    /* NFA_P2pConnectByName () */
    else
    {
        BCM_STRNCPY_S (conn_params.sn, sizeof (conn_params.sn),
                       p_msg->api_connect.service_name, LLCP_MAX_SN_LEN);
        conn_params.sn[LLCP_MAX_SN_LEN] = 0;

        status = LLCP_ConnectReq (local_sap, LLCP_SAP_SDP, &conn_params);
    }

    if (status != LLCP_STATUS_SUCCESS)
    {
        evt_data.disc.handle = (NFA_HANDLE_GROUP_P2P | local_sap);
        evt_data.disc.reason = NFA_P2P_DISC_REASON_NO_INFORMATION;

        nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_DISC_EVT, &evt_data);
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_send_ui
**
** Description      Send UI PDU
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_send_ui (tNFA_P2P_MSG *p_msg)
{
    UINT8             local_sap;
    tLLCP_STATUS      status;
    tNFA_P2P_EVT_DATA evt_data;

    P2P_TRACE_DEBUG0 ("nfa_p2p_send_ui ()");

    local_sap = (UINT8) (p_msg->api_send_ui.handle & NFA_HANDLE_MASK);

    /* decrease number of tx UI PDU which is not processed by NFA for congestion control */
    if (nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu)
        nfa_p2p_cb.sap_cb[local_sap].num_pending_ui_pdu--;

    if (nfa_p2p_cb.total_pending_ui_pdu)
        nfa_p2p_cb.total_pending_ui_pdu--;

    status = LLCP_SendUI (local_sap,
                          p_msg->api_send_ui.dsap,
                          p_msg->api_send_ui.p_msg);

    if (status == LLCP_STATUS_CONGESTED)
    {
        if (!(nfa_p2p_cb.sap_cb[local_sap].flags & NFA_P2P_SAP_FLAG_LLINK_CONGESTED))
        {
            nfa_p2p_cb.sap_cb[local_sap].flags |= NFA_P2P_SAP_FLAG_LLINK_CONGESTED;

            /* notify that this logical link is congested */
            evt_data.congest.link_type    = NFA_P2P_LLINK_TYPE;
            evt_data.congest.handle       = (NFA_HANDLE_GROUP_P2P | local_sap);
            evt_data.congest.is_congested = TRUE;

            nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
        }
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_send_data
**
** Description      Send I PDU
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_send_data (tNFA_P2P_MSG *p_msg)
{
    tNFA_P2P_EVT_DATA evt_data;
    tLLCP_STATUS      status;
    UINT8             xx;

    P2P_TRACE_DEBUG0 ("nfa_p2p_send_data ()");

    xx = (UINT8) (p_msg->api_send_data.conn_handle & NFA_HANDLE_MASK);
    xx &= ~NFA_P2P_HANDLE_FLAG_CONN;

    /* decrease number of tx I PDU which is not processed by NFA for congestion control */
    if (nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu)
        nfa_p2p_cb.conn_cb[xx].num_pending_i_pdu--;

    if (nfa_p2p_cb.total_pending_i_pdu)
        nfa_p2p_cb.total_pending_i_pdu--;

    status = LLCP_SendData (nfa_p2p_cb.conn_cb[xx].local_sap,
                            nfa_p2p_cb.conn_cb[xx].remote_sap,
                            p_msg->api_send_data.p_msg);

    if (status == LLCP_STATUS_CONGESTED)
    {
        if (!(nfa_p2p_cb.conn_cb[xx].flags & NFA_P2P_CONN_FLAG_CONGESTED))
        {
            nfa_p2p_cb.conn_cb[xx].flags |= NFA_P2P_CONN_FLAG_CONGESTED;

            /* notify that this data link is congested */
            evt_data.congest.link_type    = NFA_P2P_DLINK_TYPE;
            evt_data.congest.handle       = (NFA_HANDLE_GROUP_P2P | NFA_P2P_HANDLE_FLAG_CONN | xx);
            evt_data.congest.is_congested = TRUE;

            nfa_p2p_cb.sap_cb[nfa_p2p_cb.conn_cb[xx].local_sap].p_cback (NFA_P2P_CONGEST_EVT, &evt_data);
        }
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_set_local_busy
**
** Description      Set or reset local busy
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_set_local_busy (tNFA_P2P_MSG *p_msg)
{
    UINT8 xx;

    P2P_TRACE_DEBUG0 ("nfa_p2p_set_local_busy ()");

    xx = (UINT8) (p_msg->api_local_busy.conn_handle & NFA_HANDLE_MASK);
    xx &= ~NFA_P2P_HANDLE_FLAG_CONN;

    LLCP_SetLocalBusyStatus (nfa_p2p_cb.conn_cb[xx].local_sap,
                             nfa_p2p_cb.conn_cb[xx].remote_sap,
                             p_msg->api_local_busy.is_busy);

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_get_link_info
**
** Description      Get WKS of remote and link MIU
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_get_link_info (tNFA_P2P_MSG *p_msg)
{
    tNFA_P2P_EVT_DATA evt_data;
    UINT8             local_sap;

    P2P_TRACE_DEBUG0 ("nfa_p2p_get_link_info ()");

    evt_data.link_info.handle          = p_msg->api_link_info.handle;
    evt_data.link_info.wks             = LLCP_GetRemoteWKS ();
    evt_data.link_info.local_link_miu  = nfa_p2p_cb.local_link_miu;
    evt_data.link_info.remote_link_miu = nfa_p2p_cb.remote_link_miu;

    local_sap =  (UINT8) (p_msg->api_link_info.handle & NFA_HANDLE_MASK);
    nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_LINK_INFO_EVT, &evt_data);

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_get_remote_sap
**
** Description      Get remote SAP
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_get_remote_sap (tNFA_P2P_MSG *p_msg)
{
    tNFA_P2P_EVT_DATA evt_data;
    UINT8             local_sap;

    P2P_TRACE_DEBUG0 ("nfa_p2p_get_remote_sap ()");

    local_sap =  (UINT8) (p_msg->api_remote_sap.handle & NFA_HANDLE_MASK);

    if (!nfa_p2p_start_sdp (p_msg->api_remote_sap.service_name,
                            local_sap))
    {
        evt_data.sdp.handle     = p_msg->api_remote_sap.handle;
        evt_data.sdp.remote_sap = 0x00;
        nfa_p2p_cb.sap_cb[local_sap].p_cback (NFA_P2P_SDP_EVT, &evt_data);
    }

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_set_llcp_cfg
**
** Description      Set LLCP configuration
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_set_llcp_cfg (tNFA_P2P_MSG *p_msg)
{
    LLCP_SetConfig (p_msg->api_set_llcp_cfg.link_miu,
                    p_msg->api_set_llcp_cfg.opt,
                    p_msg->api_set_llcp_cfg.wt,
                    p_msg->api_set_llcp_cfg.link_timeout,
                    p_msg->api_set_llcp_cfg.inact_timeout_init,
                    p_msg->api_set_llcp_cfg.inact_timeout_target,
                    p_msg->api_set_llcp_cfg.symm_delay,
                    p_msg->api_set_llcp_cfg.data_link_timeout,
                    p_msg->api_set_llcp_cfg.delay_first_pdu_timeout);

    return TRUE;
}

/*******************************************************************************
**
** Function         nfa_p2p_restart_rf_discovery
**
** Description      Restart RF discovery by deactivating to IDLE
**
**
** Returns          TRUE to deallocate buffer
**
*******************************************************************************/
BOOLEAN nfa_p2p_restart_rf_discovery (tNFA_P2P_MSG *p_msg)
{
    P2P_TRACE_DEBUG0 ("nfa_p2p_restart_rf_discovery ()");

    nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);

    return TRUE;
}