/******************************************************************************
 *
 *  Copyright (C) 2010-2012 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 state implementation file for the NFA Connection Handover.
 *
 ******************************************************************************/
#include <string.h>
#include "nfc_api.h"
#include "llcp_api.h"
#include "llcp_defs.h"
#include "nfa_sys.h"
#include "nfa_sys_int.h"
#include "nfa_cho_api.h"
#include "nfa_cho_int.h"
#include "nfa_mem_co.h"

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

/*****************************************************************************
**  Static Functions
*****************************************************************************/
static void nfa_cho_sm_disabled (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data);
static void nfa_cho_sm_idle (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data);
static void nfa_cho_sm_w4_cc (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data);
static void nfa_cho_sm_connected (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data);
static void nfa_cho_proc_rx_handover_msg (void);

/* debug functions type */
#if (BT_TRACE_VERBOSE == TRUE)
static char *nfa_cho_state_code (tNFA_CHO_STATE state_code);
static char *nfa_cho_evt_code (tNFA_CHO_INT_EVT evt_code);
#endif

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

/*******************************************************************************
**
** Function         nfa_cho_sm_llcp_cback
**
** Description      Processing event from LLCP
**
**
** Returns          None
**
*******************************************************************************/
void nfa_cho_sm_llcp_cback (tLLCP_SAP_CBACK_DATA *p_data)
{
    tNFA_CHO_RX_NDEF_STATUS rx_status;

    CHO_TRACE_DEBUG2 ("nfa_cho_sm_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:
        /* check if we received complete Handover Message */
        rx_status = nfa_cho_reassemble_ho_msg (p_data->data_ind.local_sap,
                                               p_data->data_ind.remote_sap);

        if (rx_status == NFA_CHO_RX_NDEF_COMPLETE)
        {
            nfa_cho_sm_execute (NFA_CHO_RX_HANDOVER_MSG_EVT, NULL);
        }
        break;

    case LLCP_SAP_EVT_CONNECT_IND:
        nfa_cho_sm_execute (NFA_CHO_LLCP_CONNECT_IND_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

    case LLCP_SAP_EVT_CONNECT_RESP:
        nfa_cho_sm_execute (NFA_CHO_LLCP_CONNECT_RESP_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

    case LLCP_SAP_EVT_DISCONNECT_IND:
        nfa_cho_sm_execute (NFA_CHO_LLCP_DISCONNECT_IND_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

    case LLCP_SAP_EVT_DISCONNECT_RESP:
        nfa_cho_sm_execute (NFA_CHO_LLCP_DISCONNECT_RESP_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

    case LLCP_SAP_EVT_CONGEST:
        nfa_cho_sm_execute (NFA_CHO_LLCP_CONGEST_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

    case LLCP_SAP_EVT_LINK_STATUS:
        nfa_cho_sm_execute (NFA_CHO_LLCP_LINK_STATUS_EVT, (tNFA_CHO_INT_EVENT_DATA *) p_data);
        break;

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

/*******************************************************************************
**
** Function         nfa_cho_sm_disabled
**
** Description      Process event in disabled state
**
** Returns          None
**
*******************************************************************************/
static void nfa_cho_sm_disabled (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data)
{
    tNFA_CHO_EVT_DATA evt_data;
    UINT16            remote_link_miu;

    switch (event)
    {
    case NFA_CHO_API_REG_EVT:

        evt_data.status = nfa_cho_proc_api_reg (p_data);

        if (evt_data.status == NFA_STATUS_OK)
        {
            nfa_cho_cb.state = NFA_CHO_ST_IDLE;
        }
        p_data->api_reg.p_cback (NFA_CHO_REG_EVT, &evt_data);

        if (evt_data.status == NFA_STATUS_OK)
        {
            /* check if LLCP is already activated */
            LLCP_GetLinkMIU (&nfa_cho_cb.local_link_miu, &remote_link_miu);

            if (nfa_cho_cb.local_link_miu > 0)
            {
                nfa_cho_cb.flags |= NFA_CHO_FLAGS_LLCP_ACTIVATED;

                /* Notify application LLCP link activated */
                evt_data.activated.is_initiator = FALSE;
                nfa_cho_cb.p_cback (NFA_CHO_ACTIVATED_EVT, &evt_data);
            }
        }
        break;

    default:
        CHO_TRACE_ERROR0 ("Unknown event");
        break;
    }
}

/*******************************************************************************
**
** Function         nfa_cho_sm_idle
**
** Description      Process event in idle state
**
** Returns          None
**
*******************************************************************************/
static void nfa_cho_sm_idle (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data)
{
    UINT16                  remote_link_miu;
    tNFA_CHO_EVT_DATA       evt_data;
    tLLCP_CONNECTION_PARAMS params;

    switch (event)
    {
    case NFA_CHO_API_REG_EVT:
        evt_data.status = NFA_STATUS_FAILED;
        p_data->api_reg.p_cback (NFA_CHO_REG_EVT, &evt_data);
        break;

    case NFA_CHO_API_DEREG_EVT:
        nfa_cho_proc_api_dereg ();
        nfa_cho_cb.state = NFA_CHO_ST_DISABLED;
        break;

    case NFA_CHO_API_CONNECT_EVT:
        /* if LLCP activated then create data link connection */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_LLCP_ACTIVATED)
        {
            if (nfa_cho_create_connection () == NFA_STATUS_OK)
            {
                /* waiting for connection confirm */
                nfa_cho_cb.state = NFA_CHO_ST_W4_CC;
            }
            else
            {
                evt_data.disconnected.reason = NFA_CHO_DISC_REASON_CONNECTION_FAIL;
                nfa_cho_cb.p_cback (NFA_CHO_DISCONNECTED_EVT, &evt_data);
            }
        }
        else
        {
            evt_data.disconnected.reason = NFA_CHO_DISC_REASON_LINK_DEACTIVATED;
            nfa_cho_cb.p_cback (NFA_CHO_DISCONNECTED_EVT, &evt_data);
        }
        break;

    case NFA_CHO_API_DISCONNECT_EVT:
        /* Nothing to disconnect */
        nfa_cho_process_disconnection (NFA_CHO_DISC_REASON_API_REQUEST);
        break;

    case NFA_CHO_LLCP_CONNECT_IND_EVT:

        /* accept connection request */
        params.miu = (UINT16) (nfa_cho_cb.local_link_miu >= NFA_CHO_MIU ? NFA_CHO_MIU : nfa_cho_cb.local_link_miu);
        params.rw  = NFA_CHO_RW;
        params.sn[0] = 0;

        LLCP_ConnectCfm (p_data->llcp_cback_data.connect_ind.local_sap,
                         p_data->llcp_cback_data.connect_ind.remote_sap,
                         &params);

        nfa_cho_cb.remote_miu = p_data->llcp_cback_data.connect_ind.miu;
        nfa_cho_cb.remote_sap = p_data->llcp_cback_data.connect_ind.remote_sap;
        nfa_cho_cb.local_sap  = p_data->llcp_cback_data.connect_ind.local_sap;

        nfa_cho_cb.substate  = NFA_CHO_SUBSTATE_W4_REMOTE_HR;
        nfa_cho_cb.state     = NFA_CHO_ST_CONNECTED;
        nfa_cho_cb.congested = FALSE;

        evt_data.connected.initial_role = NFA_CHO_ROLE_SELECTOR;
        nfa_cho_cb.p_cback (NFA_CHO_CONNECTED_EVT, &evt_data);
        break;

    case NFA_CHO_LLCP_LINK_STATUS_EVT:
        /*
        **  LLCP sends NFA_CHO_LLCP_DISCONNECT_IND_EVT for all data link connection
        **  before sending NFA_CHO_LLCP_LINK_STATUS_EVT for deactivation.
        **  This event can be received only in this state.
        */

        if (p_data->llcp_cback_data.link_status.is_activated == TRUE)
        {
            nfa_cho_cb.flags |= NFA_CHO_FLAGS_LLCP_ACTIVATED;

            /* store local link MIU to decide MIU of data link connection later */
            LLCP_GetLinkMIU (&nfa_cho_cb.local_link_miu, &remote_link_miu);

            /* Notify application LLCP link activated */
            evt_data.activated.is_initiator = p_data->llcp_cback_data.link_status.is_initiator;
            nfa_cho_cb.p_cback (NFA_CHO_ACTIVATED_EVT, &evt_data);
        }
        else
        {
            /* the other flags had been cleared by NFA_CHO_LLCP_DISCONNECT_IND_EVT */
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_LLCP_ACTIVATED;

            /* Notify application LLCP link deactivated */
            evt_data.status = NFA_STATUS_OK;
            nfa_cho_cb.p_cback (NFA_CHO_DEACTIVATED_EVT, &evt_data);
        }
        break;

    case NFA_CHO_API_SEND_HR_EVT:
        GKI_freebuf (p_data->api_send_hr.p_ndef);
        break;

    case NFA_CHO_API_SEND_HS_EVT:
        GKI_freebuf (p_data->api_send_hs.p_ndef);
        break;

    case NFA_CHO_NDEF_TYPE_HANDLER_EVT:
        nfa_cho_proc_ndef_type_handler_evt (p_data);
        break;

    default:
        CHO_TRACE_ERROR0 ("Unknown event");
        break;
    }
}

/*******************************************************************************
**
** Function         nfa_cho_sm_w4_cc
**
** Description      Process event in waiting for connection confirm state
**
** Returns          None
**
*******************************************************************************/
static void nfa_cho_sm_w4_cc (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data)
{
    tNFA_CHO_EVT_DATA       evt_data;
    tLLCP_CONNECTION_PARAMS params;

    switch (event)
    {
    case NFA_CHO_API_REG_EVT:
        evt_data.status = NFA_STATUS_FAILED;
        p_data->api_reg.p_cback (NFA_CHO_REG_EVT, &evt_data);
        break;

    case NFA_CHO_API_DEREG_EVT:
        nfa_cho_proc_api_dereg ();
        nfa_cho_cb.state = NFA_CHO_ST_DISABLED;
        break;

    case NFA_CHO_API_CONNECT_EVT:
        evt_data.disconnected.reason = NFA_CHO_DISC_REASON_ALEADY_CONNECTED;
        nfa_cho_cb.p_cback (NFA_CHO_DISCONNECTED_EVT, &evt_data);
        break;

    case NFA_CHO_API_DISCONNECT_EVT:
        /* disconnect collision connection accepted by local device */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
        {
            LLCP_DisconnectReq (nfa_cho_cb.collision_local_sap,
                                nfa_cho_cb.collision_remote_sap,
                                FALSE);

            /* clear collision flag */
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
        }

        nfa_cho_cb.state = NFA_CHO_ST_IDLE;

        /* we cannot send DISC because we don't know remote SAP */
        nfa_cho_process_disconnection (NFA_CHO_DISC_REASON_API_REQUEST);
        break;

    case NFA_CHO_LLCP_CONNECT_RESP_EVT:
        /* peer accepted connection request */
        nfa_cho_cb.state     = NFA_CHO_ST_CONNECTED;
        nfa_cho_cb.substate  = NFA_CHO_SUBSTATE_W4_LOCAL_HR;
        nfa_cho_cb.congested = FALSE;

        /* store data link connection parameters */
        nfa_cho_cb.remote_miu = p_data->llcp_cback_data.connect_resp.miu;
        nfa_cho_cb.remote_sap = p_data->llcp_cback_data.connect_resp.remote_sap;
        nfa_cho_cb.local_sap  = nfa_cho_cb.client_sap;

        evt_data.connected.initial_role = NFA_CHO_ROLE_REQUESTER;
        nfa_cho_cb.p_cback (NFA_CHO_CONNECTED_EVT, &evt_data);
        break;

    case NFA_CHO_LLCP_CONNECT_IND_EVT:
        /* if already collision of connection */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
        {
            LLCP_ConnectReject (p_data->llcp_cback_data.connect_ind.local_sap,
                                p_data->llcp_cback_data.connect_ind.remote_sap,
                                LLCP_SAP_DM_REASON_TEMP_REJECT_THIS);
        }
        else
        {
            /*
            ** accept connection request and set collision flag
            ** wait for accepting connection request from peer or Hr message
            */
            params.miu = (UINT16) (nfa_cho_cb.local_link_miu >= NFA_CHO_MIU ? NFA_CHO_MIU : nfa_cho_cb.local_link_miu);
            params.rw  = NFA_CHO_RW;
            params.sn[0] = 0;

            LLCP_ConnectCfm (p_data->llcp_cback_data.connect_ind.local_sap,
                             p_data->llcp_cback_data.connect_ind.remote_sap,
                             &params);

            nfa_cho_cb.flags |= NFA_CHO_FLAGS_CONN_COLLISION;

            nfa_cho_cb.collision_remote_miu = p_data->llcp_cback_data.connect_ind.miu;
            nfa_cho_cb.collision_remote_sap = p_data->llcp_cback_data.connect_ind.remote_sap;
            nfa_cho_cb.collision_local_sap  = p_data->llcp_cback_data.connect_ind.local_sap;
            nfa_cho_cb.collision_congested  = FALSE;
        }
        break;

    case NFA_CHO_RX_HANDOVER_MSG_EVT:
        /* peer device sent handover message before accepting connection */
        /* clear collision flag */
        nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;

        nfa_cho_cb.remote_miu = nfa_cho_cb.collision_remote_miu;
        nfa_cho_cb.remote_sap = nfa_cho_cb.collision_remote_sap;
        nfa_cho_cb.local_sap  = nfa_cho_cb.collision_local_sap;
        nfa_cho_cb.congested  = nfa_cho_cb.collision_congested;

        nfa_cho_cb.substate  = NFA_CHO_SUBSTATE_W4_REMOTE_HR;
        nfa_cho_cb.state     = NFA_CHO_ST_CONNECTED;

        evt_data.connected.initial_role = NFA_CHO_ROLE_SELECTOR;
        nfa_cho_cb.p_cback (NFA_CHO_CONNECTED_EVT, &evt_data);

        /* process handover message in nfa_cho_cb.p_rx_ndef_msg */
        nfa_cho_proc_rx_handover_msg ();
        break;

    case NFA_CHO_LLCP_DISCONNECT_RESP_EVT:
        /*
        ** if peer rejected our connection request or there is no handover service in peer
        ** but we already accepted connection from peer
        */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
        {
            /* clear collision flag */
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;

            nfa_cho_cb.remote_miu = nfa_cho_cb.collision_remote_miu;
            nfa_cho_cb.remote_sap = nfa_cho_cb.collision_remote_sap;
            nfa_cho_cb.local_sap  = nfa_cho_cb.collision_local_sap;
            nfa_cho_cb.congested  = nfa_cho_cb.collision_congested;

            nfa_cho_cb.substate  = NFA_CHO_SUBSTATE_W4_REMOTE_HR;
            nfa_cho_cb.state     = NFA_CHO_ST_CONNECTED;

            evt_data.connected.initial_role = NFA_CHO_ROLE_SELECTOR;
            nfa_cho_cb.p_cback (NFA_CHO_CONNECTED_EVT, &evt_data);
        }
        else
        {
            nfa_cho_cb.state = NFA_CHO_ST_IDLE;
            nfa_cho_process_disconnection (NFA_CHO_DISC_REASON_CONNECTION_FAIL);
        }
        break;

    case NFA_CHO_LLCP_DISCONNECT_IND_EVT:
        /* if peer disconnects collision connection */
        if (  (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
            &&(p_data->llcp_cback_data.disconnect_ind.local_sap == nfa_cho_cb.collision_local_sap)
            &&(p_data->llcp_cback_data.disconnect_ind.remote_sap == nfa_cho_cb.collision_remote_sap)  )
        {
            /* clear collision flag */
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
        }
        else    /* Link failure before peer accepts or rejects connection request */
        {
            nfa_cho_cb.state = NFA_CHO_ST_IDLE;
            nfa_cho_process_disconnection (NFA_CHO_DISC_REASON_CONNECTION_FAIL);
        }
        break;

    case NFA_CHO_LLCP_CONGEST_EVT:
        /* if collision connection is congested */
        if (  (p_data->llcp_cback_data.congest.link_type == LLCP_LINK_TYPE_DATA_LINK_CONNECTION)
            &&(nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION))
        {
            nfa_cho_cb.collision_congested = p_data->llcp_cback_data.congest.is_congested;
        }
        break;

    case NFA_CHO_API_SEND_HR_EVT:
        GKI_freebuf (p_data->api_send_hr.p_ndef);
        break;

    case NFA_CHO_API_SEND_HS_EVT:
        GKI_freebuf (p_data->api_send_hs.p_ndef);
        break;

    case NFA_CHO_NDEF_TYPE_HANDLER_EVT:
        nfa_cho_proc_ndef_type_handler_evt (p_data);
        break;

    default:
        CHO_TRACE_ERROR0 ("Unknown event");
        break;
    }
}

/*******************************************************************************
**
** Function         nfa_cho_sm_connected
**
** Description      Process event in connected state
**
** Returns          None
**
*******************************************************************************/
static void nfa_cho_sm_connected (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data)
{
    tNFA_CHO_EVT_DATA evt_data;
    tNFA_STATUS       status;

    switch (event)
    {
    case NFA_CHO_API_REG_EVT:
        evt_data.status = NFA_STATUS_FAILED;
        p_data->api_reg.p_cback (NFA_CHO_REG_EVT, &evt_data);
        break;

    case NFA_CHO_API_DEREG_EVT:
        nfa_cho_proc_api_dereg ();
        nfa_cho_cb.state = NFA_CHO_ST_DISABLED;
        break;

    case NFA_CHO_API_CONNECT_EVT:
        /* it could be race condition, let app know outgoing connection failed */
        evt_data.disconnected.reason = NFA_CHO_DISC_REASON_ALEADY_CONNECTED;
        nfa_cho_cb.p_cback (NFA_CHO_DISCONNECTED_EVT, &evt_data);
        break;

    case NFA_CHO_API_DISCONNECT_EVT:
        /* disconnect collision connection accepted by local device */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
        {
            LLCP_DisconnectReq (nfa_cho_cb.collision_local_sap,
                                nfa_cho_cb.collision_remote_sap,
                                FALSE);

            /* clear collision flag */
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
        }

        LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                            nfa_cho_cb.remote_sap,
                            FALSE);

        /* store disconnect reason */
        nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_API_REQUEST;
        break;

    case NFA_CHO_API_SEND_HR_EVT:
        if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_LOCAL_HR)
        {
            /* Send Handover Request Message */
            status = nfa_cho_send_hr (&p_data->api_send_hr);

            if (status == NFA_STATUS_OK)
            {
                nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_REMOTE_HS;
                /* start timer for Handover Select Message */
                nfa_sys_start_timer (&nfa_cho_cb.timer, 0, NFA_CHO_TIMEOUT_FOR_HS);
            }
            else
            {
                CHO_TRACE_ERROR0 ("NFA CHO failed to send Hr");
                nfa_cho_notify_tx_fail_evt (status);
            }
        }
        else
        {
            CHO_TRACE_ERROR0 ("NFA CHO got unexpected NFA_CHO_API_SEND_HR_EVT");
            nfa_cho_notify_tx_fail_evt (NFA_STATUS_SEMANTIC_ERROR);
        }
        GKI_freebuf (p_data->api_send_hr.p_ndef);
        break;

    case NFA_CHO_API_SEND_HS_EVT:
        if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_LOCAL_HS)
        {
            /* send Handover Select Message */
            status = nfa_cho_send_hs (&p_data->api_send_hs);
            if (status == NFA_STATUS_OK)
            {
                nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_REMOTE_HR;
            }
            else
            {
                CHO_TRACE_ERROR0 ("NFA CHO failed to send Hs");
                nfa_cho_notify_tx_fail_evt (status);
            }
        }
        else
        {
            CHO_TRACE_ERROR0 ("NFA CHO got unexpected NFA_CHO_API_SEND_HS_EVT");
            nfa_cho_notify_tx_fail_evt (NFA_STATUS_SEMANTIC_ERROR);
        }
        GKI_freebuf (p_data->api_send_hs.p_ndef);
        break;

    case NFA_CHO_API_SEL_ERR_EVT:
        /* application detected error */
        if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_LOCAL_HS)
        {
            /* Send Handover Select Error record */
            status = nfa_cho_send_hs_error (p_data->api_sel_err.error_reason,
                                            p_data->api_sel_err.error_data);
            if (status == NFA_STATUS_OK)
            {
                nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_REMOTE_HR;
            }
            else
            {
                CHO_TRACE_ERROR0 ("Failed to send Hs Error record");
                nfa_cho_notify_tx_fail_evt (status);
            }
        }
        else
        {
            CHO_TRACE_ERROR0 ("NFA CHO got unexpected NFA_CHO_API_SEL_ERR_EVT");
            nfa_cho_notify_tx_fail_evt (NFA_STATUS_SEMANTIC_ERROR);
        }
        break;

    case NFA_CHO_LLCP_CONNECT_RESP_EVT:
        /* peer accepted connection after we accepted and received Hr */
        /* disconnect data link connection created by local device    */
        LLCP_DisconnectReq (p_data->llcp_cback_data.connect_resp.local_sap,
                            p_data->llcp_cback_data.connect_resp.remote_sap,
                            FALSE);
        break;

    case NFA_CHO_LLCP_CONNECT_IND_EVT:
        LLCP_ConnectReject (p_data->llcp_cback_data.connect_ind.local_sap,
                            p_data->llcp_cback_data.connect_ind.remote_sap,
                            LLCP_SAP_DM_REASON_TEMP_REJECT_THIS);
        break;

    case NFA_CHO_RX_HANDOVER_MSG_EVT:
        /* process handover message in nfa_cho_cb.p_rx_ndef_msg */
        nfa_cho_proc_rx_handover_msg ();
        break;

    case NFA_CHO_LLCP_DISCONNECT_IND_EVT:
        if (  (p_data->llcp_cback_data.disconnect_ind.local_sap  == nfa_cho_cb.local_sap)
            &&(p_data->llcp_cback_data.disconnect_ind.remote_sap == nfa_cho_cb.remote_sap)  )
        {
            nfa_cho_cb.state = NFA_CHO_ST_IDLE;
            nfa_cho_process_disconnection (NFA_CHO_DISC_REASON_PEER_REQUEST);
        }
        else  /* if disconnection of collision conneciton */
        {
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
        }
        break;

    case NFA_CHO_LLCP_DISCONNECT_RESP_EVT:
        if (  (p_data->llcp_cback_data.disconnect_ind.local_sap  == nfa_cho_cb.local_sap)
            &&(p_data->llcp_cback_data.disconnect_ind.remote_sap == nfa_cho_cb.remote_sap)  )
        {
            nfa_cho_cb.state = NFA_CHO_ST_IDLE;
            nfa_cho_process_disconnection (nfa_cho_cb.disc_reason);
        }
        else  /* if disconnection of collision conneciton */
        {
            nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
        }
        break;

    case NFA_CHO_LLCP_CONGEST_EVT:
        /* if data link connection is congested */
        if ( (p_data->llcp_cback_data.congest.link_type  == LLCP_LINK_TYPE_DATA_LINK_CONNECTION)
           &&(p_data->llcp_cback_data.congest.local_sap  == nfa_cho_cb.local_sap)
           &&(p_data->llcp_cback_data.congest.remote_sap == nfa_cho_cb.remote_sap)  )
        {
            nfa_cho_cb.congested = p_data->llcp_cback_data.congest.is_congested;

            if (!nfa_cho_cb.congested)
            {
                /* send remaining message if any */
                if (  (nfa_cho_cb.p_tx_ndef_msg)
                    &&(nfa_cho_cb.tx_ndef_sent_size < nfa_cho_cb.tx_ndef_cur_size)  )
                {
                    nfa_cho_send_handover_msg ();
                }
            }
        }
        break;

    case NFA_CHO_TIMEOUT_EVT:
        if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HS)
        {
            CHO_TRACE_ERROR0 ("Failed to receive Hs message");
        }
        else if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
        {
            /* we didn't get complete Hr, don't need to notify application */
            CHO_TRACE_ERROR0 ("Failed to receive Hr message");
        }

        /* store disconnect reason and disconnect */
        nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_TIMEOUT;
        LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                            nfa_cho_cb.remote_sap,
                            FALSE);
        break;

    case NFA_CHO_NDEF_TYPE_HANDLER_EVT:
        nfa_cho_proc_ndef_type_handler_evt (p_data);
        break;

    default:
        CHO_TRACE_ERROR0 ("Unknown event");
        break;
    }
}
/*******************************************************************************
**
** Function         nfa_cho_sm_execute
**
** Description      Process event in state machine
**
** Returns          None
**
*******************************************************************************/
void nfa_cho_sm_execute (tNFA_CHO_INT_EVT event, tNFA_CHO_INT_EVENT_DATA *p_data)
{
#if (BT_TRACE_VERBOSE == TRUE)
    CHO_TRACE_DEBUG2 ("nfa_cho_sm_execute (): State[%s], Event[%s]",
                       nfa_cho_state_code (nfa_cho_cb.state),
                       nfa_cho_evt_code (event));
#else
    CHO_TRACE_DEBUG2 ("nfa_cho_sm_execute (): State[%d], Event[%d]",
                       nfa_cho_cb.state, event);
#endif


    switch (nfa_cho_cb.state)
    {
    case NFA_CHO_ST_DISABLED:
        nfa_cho_sm_disabled (event, p_data);
        break;

    case NFA_CHO_ST_IDLE:
        nfa_cho_sm_idle (event, p_data);
        break;

    case NFA_CHO_ST_W4_CC:
        nfa_cho_sm_w4_cc (event, p_data);
        break;

    case NFA_CHO_ST_CONNECTED:
        nfa_cho_sm_connected (event, p_data);
        break;

    default:
        CHO_TRACE_ERROR0 ("Unknown state");
        break;
    }
}

/*******************************************************************************
**
** Function         nfa_cho_resolve_collision
**
** Description      Resolve collision by random number in Hr
**
** Returns          None
**
*******************************************************************************/
void nfa_cho_resolve_collision (BOOLEAN *p_free_hr)
{
    tNFA_CHO_ROLE_TYPE role;
    tNFA_STATUS        status;

    /* resolve collistion by random number */
    role = nfa_cho_get_local_device_role (nfa_cho_cb.rx_ndef_cur_size,
                                          nfa_cho_cb.p_rx_ndef_msg);

    /* if local device becomes selector */
    if (role == NFA_CHO_ROLE_SELECTOR)
    {
        /* peer device is winner so clean up any collision */
        if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
        {
            /* disconnect data link connection created by local device */
            LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                                nfa_cho_cb.remote_sap,
                                FALSE);

            nfa_cho_cb.remote_miu = nfa_cho_cb.collision_remote_miu;
            nfa_cho_cb.remote_sap = nfa_cho_cb.collision_remote_sap;
            nfa_cho_cb.local_sap  = nfa_cho_cb.collision_local_sap;
            nfa_cho_cb.congested  = nfa_cho_cb.collision_congested;
        }

        nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_LOCAL_HS;

        nfa_cho_proc_hr (nfa_cho_cb.rx_ndef_cur_size,
                         nfa_cho_cb.p_rx_ndef_msg);

        *p_free_hr = TRUE;
    }
    /* if both random numbers are equal */
    else if (role == NFA_CHO_ROLE_UNDECIDED)
    {
        /* send Hr with new random number */
        if (nfa_cho_cb.p_tx_ndef_msg)
        {
            status = nfa_cho_update_random_number (nfa_cho_cb.p_tx_ndef_msg);

            if (status == NFA_STATUS_OK)
            {
                nfa_cho_cb.tx_ndef_sent_size = 0;
                status = nfa_cho_send_handover_msg ();
            }
        }
        else
        {
            status = NFA_STATUS_FAILED;
        }

        if (status == NFA_STATUS_FAILED)
        {
            CHO_TRACE_ERROR0 ("Failed to send Hr record with new random number");

            nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_INTERNAL_ERROR;

            /* disconnect and notify application */
            LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                                nfa_cho_cb.remote_sap,
                                FALSE);
        }
        else
        {
            /* restart timer */
            nfa_sys_start_timer (&nfa_cho_cb.timer, 0, NFA_CHO_TIMEOUT_FOR_HS);

            /* Don't free previous tx NDEF message because we are reusing it */
            *p_free_hr = FALSE;
        }
    }
    else /* if (role == NFA_CHO_ROLE_REQUESTER) */
    {
        /* wait for "Hs" record */
        *p_free_hr = TRUE;
    }
}

/*******************************************************************************
**
** Function         nfa_cho_check_disconnect_collision
**
** Description      Disconnect any collision connection
**
** Returns          None
**
*******************************************************************************/
void nfa_cho_check_disconnect_collision (void)
{
    if (nfa_cho_cb.flags & NFA_CHO_FLAGS_CONN_COLLISION)
    {
        /* disconnect collision connection */
        LLCP_DisconnectReq (nfa_cho_cb.collision_local_sap,
                            nfa_cho_cb.collision_remote_sap,
                            FALSE);
    }
}

/*******************************************************************************
**
** Function         nfa_cho_proc_rx_handover_msg
**
** Description      Process received Handover Message
**
** Returns          None
**
*******************************************************************************/
void nfa_cho_proc_rx_handover_msg (void)
{
    tNFA_CHO_MSG_TYPE msg_type;
    BOOLEAN           free_tx_ndef_msg = TRUE;

    /* get message type before processing to check collision */
    msg_type = nfa_cho_get_msg_type (nfa_cho_cb.rx_ndef_cur_size,
                                     nfa_cho_cb.p_rx_ndef_msg);

    if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HS)
    {
        /* if we sent "Hr" but received "Hr", collision */
        if (msg_type == NFA_CHO_MSG_HR)
        {
            nfa_cho_resolve_collision (&free_tx_ndef_msg);
        }
        else if (msg_type == NFA_CHO_MSG_HS)
        {
            /* parse and report application */
            nfa_cho_proc_hs (nfa_cho_cb.rx_ndef_cur_size,
                             nfa_cho_cb.p_rx_ndef_msg);

            nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_LOCAL_HR;
        }
        else
        {
            CHO_TRACE_ERROR0 ("nfa_cho_proc_rx_handover_msg (): Unknown Message Type");

            nfa_cho_check_disconnect_collision ();

            nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_UNKNOWN_MSG;

            LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                                nfa_cho_cb.remote_sap,
                                FALSE);
        }
    }
    else if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
    {
        if (msg_type == NFA_CHO_MSG_HR)
        {
            /* parse and notify NFA_CHO_REQ_EVT to application */
            nfa_cho_proc_hr (nfa_cho_cb.rx_ndef_cur_size,
                             nfa_cho_cb.p_rx_ndef_msg);

            /* In case of parsing error, let peer got timeout (1 sec) */

            /* wait for application selection */
            nfa_cho_cb.substate = NFA_CHO_SUBSTATE_W4_LOCAL_HS;
        }
        else
        {
            CHO_TRACE_ERROR0 ("nfa_cho_proc_rx_handover_msg (): Expecting Handover Request");

            nfa_cho_check_disconnect_collision ();

            nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_SEMANTIC_ERROR;

            LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                                nfa_cho_cb.remote_sap,
                                FALSE);
        }
    }
    else
    {
        CHO_TRACE_ERROR1 ("nfa_cho_proc_rx_handover_msg (): Unexpected data in substate (0x%x)", nfa_cho_cb.substate);

        nfa_cho_check_disconnect_collision ();

        nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_SEMANTIC_ERROR;

        LLCP_DisconnectReq (nfa_cho_cb.local_sap,
                            nfa_cho_cb.remote_sap,
                            FALSE);
    }

    if ((free_tx_ndef_msg) && (nfa_cho_cb.p_tx_ndef_msg))
    {
        GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
        nfa_cho_cb.p_tx_ndef_msg = NULL;
    }

    /* processing rx message is done, free buffer for rx handover message */
    if (nfa_cho_cb.p_rx_ndef_msg)
    {
        GKI_freebuf (nfa_cho_cb.p_rx_ndef_msg);
        nfa_cho_cb.p_rx_ndef_msg = NULL;
    }
}

#if (BT_TRACE_VERBOSE == TRUE)
/*******************************************************************************
**
** Function         nfa_cho_state_code
**
** Description
**
** Returns          string of state
**
*******************************************************************************/
static char *nfa_cho_state_code (tNFA_CHO_STATE state_code)
{
    switch (state_code)
    {
    case NFA_CHO_ST_DISABLED:
        return "DISABLED";
    case NFA_CHO_ST_IDLE:
        return "IDLE";
    case NFA_CHO_ST_CONNECTED:
        return "CONNECTED";
    default:
        return "unknown state";
    }
}

/*******************************************************************************
**
** Function         nfa_cho_evt_code
**
** Description
**
** Returns          string of event
**
*******************************************************************************/
char *nfa_cho_evt_code (tNFA_CHO_INT_EVT evt_code)
{
    switch (evt_code)
    {
    case NFA_CHO_API_REG_EVT:
        return "API_REG";
    case NFA_CHO_API_DEREG_EVT:
        return "API_DEREG";
    case NFA_CHO_API_CONNECT_EVT:
        return "API_CONNECT";
    case NFA_CHO_API_DISCONNECT_EVT:
        return "API_DISCONNECT";
    case NFA_CHO_API_SEND_HR_EVT:
        return "API_SEND_HR";
    case NFA_CHO_API_SEND_HS_EVT:
        return "API_SEND_HS";
    case NFA_CHO_API_SEL_ERR_EVT:
        return "API_SEL_ERR";

    case NFA_CHO_RX_HANDOVER_MSG_EVT:
        return "RX_HANDOVER_MSG";

    case NFA_CHO_LLCP_CONNECT_IND_EVT:
        return "LLCP_CONNECT_IND";
    case NFA_CHO_LLCP_CONNECT_RESP_EVT:
        return "LLCP_CONNECT_RESP";
    case NFA_CHO_LLCP_DISCONNECT_IND_EVT:
        return "LLCP_DISCONNECT_IND";
    case NFA_CHO_LLCP_DISCONNECT_RESP_EVT:
        return "LLCP_DISCONNECT_RESP";
    case NFA_CHO_LLCP_CONGEST_EVT:
        return "LLCP_CONGEST";
    case NFA_CHO_LLCP_LINK_STATUS_EVT:
        return "LLCP_LINK_STATUS";

    case NFA_CHO_NDEF_TYPE_HANDLER_EVT:
        return "NDEF_TYPE_HANDLER";
    case NFA_CHO_TIMEOUT_EVT:
        return "TIMEOUT";

    default:
        return "unknown event";
    }
}
#endif  /* Debug Functions */