/*
 * Copyright (C) 2010 NXP Semiconductors
 *
 * 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.
 */


/*!
* =========================================================================== *
*                                                                             *
*                                                                             *
* \file  phHciNfc_Sequence.c                                                  *
* \brief State Machine Implementation for the HCI Management and              *
* and the Function Sequence for a particular State                            *
*                                                                             *
*                                                                             *
* Project: NFC-FRI-1.1                                                        *
*                                                                             *
* $Date: Tue Jun  8 09:33:46 2010 $                                           *
* $Author: ing04880 $                                                         *
* $Revision: 1.85 $                                                           *
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $  
*                                                                             *
* =========================================================================== *
*/

/*
################################################################################
***************************** Header File Inclusion ****************************
################################################################################
*/

#include <phNfcCompId.h>
#include <phNfcConfig.h>
#include <phHciNfc.h>
#include <phHciNfc_Sequence.h>
#include <phHciNfc_AdminMgmt.h>
#include <phHciNfc_IDMgmt.h>
#include <phHciNfc_LinkMgmt.h>
#include <phHciNfc_DevMgmt.h>
#include <phHciNfc_PollingLoop.h>
#include <phHciNfc_RFReader.h>
#include <phHciNfc_RFReaderA.h>
#include <phHciNfc_Emulation.h>
#ifdef ENABLE_P2P
#include <phHciNfc_NfcIPMgmt.h>
#endif
#include <phHciNfc_SWP.h>
#include <phHciNfc_WI.h>
#include <phOsalNfc.h>

/*
################################################################################
****************************** Macro Definitions *******************************
################################################################################
*/

/* Address Definitions for HAL Configuration */
#define NFC_ADDRESS_HAL_CONF            0x9FD0U


/*
################################################################################
********************** Structure/Enumeration Definitions ***********************
################################################################################
*/


#ifdef VALIDATE_FSM

typedef struct phHciNfc_sFsm
{
    phHciNfc_eState_t from_state;
    phHciNfc_eState_t to_state;
    uint8_t           valid;
}phHciNfc_sFsm_t;

static phHciNfc_sFsm_t phHciNfc_Valid_Fsm[] = {
    {hciState_Reset,        hciState_Initialise ,   TRUE},
        /*  {hciState_Reset,        hciState_Config,            FALSE}, */
    {hciState_Initialise,   hciState_Config,            TRUE},
    {hciState_Initialise,   hciState_Release,       TRUE},
    {hciState_Config,       hciState_Connect,       TRUE},
    {hciState_Config,       hciState_Release,       TRUE},
    {hciState_Connect,      hciState_Activate,      TRUE},
    {hciState_Connect,      hciState_Transact,      TRUE},
    {hciState_Connect,      hciState_Disconnect,    TRUE},
    {hciState_Disconnect,   hciState_Config,            TRUE},
    /*  {hciState_Disconnect,   hciState_Release,       TRUE}, */
    {hciState_Reset,        hciState_Initialise,    TRUE},
};

#endif


/*
################################################################################
************************* Function Prototype Declaration ***********************
################################################################################
*/


static
NFCSTATUS
phHciNfc_Config_Sequence(
                         phHciNfc_sContext_t        *psHciContext,
                         void                   *pHwRef
                         );


/**
 * \ingroup grp_hci_nfc
 *
 *  The phHciNfc_Connect_Sequence function sequence selects the  
 *  discovered target for performing the transaction.
 *
 *  \param[in]  psHciContext            psHciContext is the context of
 *                                      the HCI Layer.
 *  \param[in]  pHwRef                  pHwRef is the Information of
 *                                      the Device Interface Link .
 *
 *  \retval NFCSTATUS_SUCCESS           HCI target selection sequence successful.
 *  \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
 *                                      could not be interpreted properly.
 *  \retval Other errors                Other related errors
 *
 */

static
NFCSTATUS
phHciNfc_Transact_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         );

/**
 * \ingroup grp_hci_nfc
 *
 *  The phHciNfc_Info_Sequence function sequence selects the  
 *  discovered target for performing the transaction.
 *
 *  \param[in]  psHciContext            psHciContext is the context of
 *                                      the HCI Layer.
 *  \param[in]  pHwRef                  pHwRef is the Information of
 *                                      the Device Interface Link .
 *
 *  \retval NFCSTATUS_SUCCESS           HCI target selection sequence successful.
 *  \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
 *                                      could not be interpreted properly.
 *  \retval Other errors                Other related errors
 *
 */

static
NFCSTATUS
phHciNfc_Info_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                   );

static
NFCSTATUS
phHciNfc_Test_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            NFCSTATUS               test_status,
                            uint8_t                 *pdata,
                            uint8_t                 length
                         );

#ifdef HCI_FSM_RESET

static
void
phHciNfc_FSM_Reset(
                        phHciNfc_sContext_t *psHciContext
                    );

#endif

static
NFCSTATUS
phHciNfc_IO_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            NFCSTATUS               test_status,
                            uint8_t                 *pdata,
                            uint8_t                 length
                    );

static
NFCSTATUS
phHciNfc_Pending_Sequence(
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef
                          );


/*
################################################################################
***************************** Function Definitions *****************************
################################################################################
*/

NFCSTATUS 
phHciNfc_FSM_Validate( 
                      phHciNfc_sContext_t *psHciContext,  
                      phHciNfc_eState_t state,  
                      uint8_t validate_type
                    )
{
    NFCSTATUS           status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
    phHciNfc_eState_t   cur_state = (phHciNfc_eState_t) 
        psHciContext->hci_state.cur_state;

    switch(validate_type)
    {
        case NFC_FSM_CURRENT:
        {
            if( cur_state == (uint8_t) state )
            {
                status = NFCSTATUS_SUCCESS;
            }
            break;
        }
        case NFC_FSM_NEXT:
        {
            phHciNfc_eState_t   next_state = state;
            switch (cur_state)
            {
                case hciState_Reset:
                {
                    switch(next_state)
                    {
                        /* Specifies the Starting of the init Sequence */
                        case hciState_Initialise:
                        /* Initialise to Perform Test on 
                           the Antenna/SWP Link */
                        case hciState_Test:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Initialise:
                {
                    switch(next_state)
                    {
                        /* Discovery Resume after connect failure */
                        case hciState_Initialise:
                        /* Configuring the Discovery/Emulation */
                        case hciState_Config:
                        /* Configuring the Memory */
                        case hciState_IO:
                        /* Occurence of the Tag Discovered Event */
                        case hciState_Select:
                        /* Occurence of the Target Activated Event */
                        case hciState_Listen:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Test:
                {
                    if ((hciState_Test == next_state )
                        || (hciState_IO == next_state)
                        || (hciState_Release == next_state))
                    {
                        /*  Next Test/Reset Sequence */
                        status = NFCSTATUS_SUCCESS;
                    }
                    break;
                }
                case hciState_Select:
                {
                    switch(next_state)
                    {
                        /* Restart the Wheel */
                        case hciState_Initialise:
                            /* Select the next Tag in the Field or 
                             * already Selected Tag Again 
                             */
                        /* Configuring the Memory */
                        case hciState_IO:
                        case hciState_Select:
                        /* Configuring the Discovery/Emulation */
                        case hciState_Config:
                            /* Re-Activate the Target or 
                             * Discover the next target 
                             */
                        case hciState_Reactivate:
                        /* Connect the Discovered Target */
                        case hciState_Connect:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Connect:
                {
                    switch(next_state)
                    {
                        /* Disabling the Tag Discovery */
                        case hciState_Initialise:
                            /* Configuring the Discovery/Emulation */
                            /* This should not be allowed if the target
                            * is connected.
                            */
                        /* Configuring the Memory */
                        case hciState_IO:
                        case hciState_Config:
                            /* Re-Activate the Target or 
                             * Discover the next target 
                             */
                        case hciState_Reactivate:
                        /* Intermediate Transceive State */
                        case hciState_Transact:
                        /* Intermediate Presence Check State */
                        case hciState_Presence:
                        /* Disconnect the Target Connected */
                        case hciState_Disconnect:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Listen:
                {
                    switch(next_state)
                    {
                        /* Releasing from the Emulation/Target Mode */
                        case hciState_Initialise:
                        /* Occurence of the Tag Discovered Event 
                        * after the Disconnect Operation
                        */
                        case hciState_Select:
                        /* Configuring the Memory */
                        case hciState_IO:
                        /* Configuring the Discovery/Emulation */
                        case hciState_Config:
                        /* Intermediate Transceive State */
                        case hciState_Transact:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Reactivate:
                {
                    switch(next_state)
                    {
                        /* Restart/Discovery after the Target is removed
                         * after Reactivation.
                        */
                        /* case hciState_Initialise: */
                        /* Re-Connect the Re-Activated Target */
                        case hciState_Connect:
                        /* Configuring the Memory */
                        case hciState_IO:
                        /* Configuring the Discovery/Emulation */
                        case hciState_Config:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                            break;
                    }
                    break;
                }
                case hciState_Disconnect:
                {
                    switch(next_state)
                    {
                        /* Discovery Resume after connect failure 
                           after the disconnect */
                        case hciState_Initialise:
                        /* Configuring the Memory */
                        case hciState_IO:
                        /* Configuring the Discovery/Emulation */
                        case hciState_Config:
                        /* Occurence of the Tag Discovered Event 
                        * after the Disconnect Operation
                        */
                        case hciState_Select:
                        /* Occurence of the Target Activated Event */
                        case hciState_Listen:
                        /* Specifies the Starting of the Release Sequence */
                        case hciState_Release:
                        {
                            status = NFCSTATUS_SUCCESS;
                            break;
                        }
                        default:
                        {
                            break;
                    }
                    }
                    break;
                }
#ifdef USE_M5
                case hciState_Presence:
                case hciState_Transact:
                case hciState_Release:
                {
                    break;
                }
#endif
                /* case phHciNfc_Unknown: */
                default:
                {
                    /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); */
                    break;
                }
            } /* End of State Validation Switch */
            if( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
            {
                status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
            }
            break;
        }
        default:
        {
            HCI_DEBUG("State Validate Type:%x is Unknown/Incorrect \n",
                                                            validate_type);
            break;
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_FSM_Update(
                    phHciNfc_sContext_t *psHciContext,
                    phHciNfc_eState_t   next_state
                    )
{
    NFCSTATUS       status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);

    HCI_DEBUG(" HCI: Current State --> %02u \n", 
                            psHciContext->hci_state.cur_state );
    HCI_DEBUG(" HCI: Transition Before FSM Update --> %02u \n", 
                    psHciContext->hci_state.transition );
    HCI_DEBUG(" HCI: Next State Before FSM Update --> %02u \n", 
                            psHciContext->hci_state.next_state );

    status = phHciNfc_FSM_Validate(psHciContext, next_state, NFC_FSM_NEXT );
    if(NFCSTATUS_SUCCESS == status)
    {
        psHciContext->hci_state.next_state = (uint8_t) next_state;
        psHciContext->hci_state.transition = NFC_FSM_IN_PROGRESS;
        psHciContext->response_pending = FALSE;
        HCI_DEBUG(" HCI: Next State After FSM Update --> %02u \n", 
                                psHciContext->hci_state.next_state );
    }
    else
    {
        HCI_DEBUG(" HCI: FSM - Invalid next state --> %02u \n", 
                                next_state );
    }

    return status;
}


NFCSTATUS
phHciNfc_FSM_Complete(
                        phHciNfc_sContext_t *psHciContext
                    )
{
    NFCSTATUS       status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);

    HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);

    HCI_DEBUG(" HCI: Transition Before FSM Complete --> %02u \n", 
                    psHciContext->hci_state.transition );
 
    HCI_DEBUG(" HCI: Current State Before FSM Complete --> %02u \n", 
                            psHciContext->hci_state.cur_state );

    HCI_DEBUG(" HCI: Next State Before FSM Complete  --> %02u \n", 
                            psHciContext->hci_state.next_state );

    if( (NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition)
      )
    {
        psHciContext->hci_state.cur_state = 
                                    psHciContext->hci_state.next_state ;
        psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
        psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
        /* Reset the HCI Sequence */
        psHciContext->response_pending = FALSE;
        psHciContext->hci_seq = HCI_INVALID_SEQ;
        status = NFCSTATUS_SUCCESS;
    }

    HCI_DEBUG(" HCI: Current State After FSM Complete --> %02u \n", 
                            psHciContext->hci_state.cur_state );

    return status;
}

void
phHciNfc_FSM_Rollback(
                        phHciNfc_sContext_t *psHciContext
                    )
{

    HCI_DEBUG("HCI: %s: transition=%02u, cur_state=%02u, next_state=%02u\n",
            __func__,
            psHciContext->hci_state.transition,
            psHciContext->hci_state.cur_state,
            psHciContext->hci_state.next_state);


    if( (NFC_FSM_IN_PROGRESS  == psHciContext->hci_state.transition)
      )
    {
        psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
        psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
        /* Reset the HCI Sequence */
        psHciContext->hci_seq = HCI_INVALID_SEQ;
        psHciContext->response_pending = FALSE;
    }
}

#ifdef HCI_FSM_RESET
static
void
phHciNfc_FSM_Reset(
                        phHciNfc_sContext_t *psHciContext
                    )
{

    if( (hciState_Reset  != psHciContext->hci_state.cur_state )
      )
    {
        psHciContext->hci_state.cur_state = (uint8_t) hciState_Initialise ;
        psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
        psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
        /* Reset the HCI Sequence */
        psHciContext->hci_seq = HCI_INVALID_SEQ;
    }

}
#endif


static
NFCSTATUS
phHciNfc_Pending_Sequence(
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef
                          )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    PHNFC_UNUSED_VARIABLE(status);

    HCI_DEBUG("HCI: psHciContext->target_release --> %s \n",
            (psHciContext->target_release)?"TRUE":"FALSE");
    if(TRUE == psHciContext->target_release)
    {
#ifdef SW_RELEASE_TARGET
        status = phHciNfc_ReaderMgmt_Deselect( 
            psHciContext, pHwRef, phHal_eISO14443_A_PICC, TRUE);
        if(NFCSTATUS_PENDING == status )
        {
            psHciContext->target_release = FALSE ;
        }
    }
    else
    {
        status = psHciContext->error_status;
#else
      psHciContext->target_release = FALSE ;
#endif
    }

    return status;
}


void
phHciNfc_Error_Sequence(
                                void            *psContext,
                                void            *pHwRef,
                                NFCSTATUS       error_status,
                                void            *pdata,
                                uint8_t         length
                        )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;

    PHNFC_UNUSED_VARIABLE(status);

    HCI_DEBUG("HCI: In Function: %s \n",
        __FUNCTION__);

    HCI_DEBUG ("HCI : Error Status : %04X\n", error_status);

    HCI_DEBUG(" HCI: Current HCI State --> %02u \n", 
                            psHciContext->hci_state.cur_state );
    HCI_DEBUG(" HCI: Next HCI State --> %02u \n", 
                            psHciContext->hci_state.next_state );


    if ( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
    {
        switch(psHciContext->hci_state.next_state)
        {
            case hciState_Initialise:
            {
                if (hciState_Reset == psHciContext->hci_state.cur_state)
                {
                    phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                    phHciNfc_Release_Lower( psHciContext, pHwRef );
                    /* Release all the resources and 
                    * Notify the Receive Error Scenario to the Upper Layer 
                    */
                    comp_info.status = error_status ;
                    phHciNfc_Release_Notify (psHciContext, pHwRef,
                        NFC_NOTIFY_INIT_FAILED, &comp_info);
                }
                else if (hciState_Config == psHciContext->hci_state.cur_state)
                {
                    /* Notify the Poll/Emulation Configure failure to the upper layer */

                    phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                    comp_info.status = error_status ;

                    psHciContext->error_status = error_status;
                    status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                    /* Rollback the FSM as the Poll/Emulation configuration Failed */
                    phHciNfc_FSM_Rollback(psHciContext);
                    psHciContext->error_status = NFCSTATUS_SUCCESS;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_CONFIG_ERROR, &comp_info);
                }
                else
                {

                    /* Notify the Poll Configure failure to the upper layer */
                    phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};


                    psHciContext->error_status = error_status;
                    status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                    /* Rollback the FSM as the Poll Disable Failed */
                    phHciNfc_FSM_Rollback(psHciContext);
                    comp_info.status = error_status ;
                    psHciContext->error_status = NFCSTATUS_SUCCESS;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_ERROR, &comp_info);
                }
                break;
            }
            case hciState_Test:
            {
                status = phHciNfc_Test_Sequence( psHciContext, pHwRef , error_status, 
                                                            (uint8_t *)pdata, length );
                break;
            }
            case hciState_IO:
            {
                status = phHciNfc_IO_Sequence( psHciContext, pHwRef , error_status, 
                                                            (uint8_t *)pdata, length );
                break;
            }
            case hciState_Config:
            {
                /* Notify the Configure failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                psHciContext->error_status = error_status;
                status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                /* Rollback the FSM as the Poll Failed */
                phHciNfc_FSM_Rollback(psHciContext);
                comp_info.status = psHciContext->error_status ;
                psHciContext->error_status = NFCSTATUS_SUCCESS;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_CONFIG_ERROR, &comp_info);
                break;
            }
            case hciState_Select:
            {
                /* Notify the Configure failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                /* Rollback the FSM as the Target Discovery Failed */
                phHciNfc_FSM_Rollback(psHciContext);
                status = phHciNfc_ReaderMgmt_Update_Sequence(
                                                psHciContext, INFO_SEQ );
                comp_info.status = error_status ;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_DISCOVERY_ERROR, &comp_info);

#if 0
                /* Polling Wheel will be restarted by the upper layer 
                 * to Rediscover again */
                if(NFCSTATUS_SUCCESS == status)
                {
                    status = phHciNfc_ReaderMgmt_Deselect( 
                        psHciContext, pHwRef, phHal_eISO14443_A_PICC, FALSE);
                }
                phHciNfc_FSM_Rollback(psHciContext);
#endif
                break;
            }
            case hciState_Transact:
                /* Notify the Transceive failure to the upper layer */
            {
                phNfc_sTransactionInfo_t        transact_info={FALSE,0,NULL,NULL,0};

                /* Rollback the FSM as the Transceive Failed */
                phHciNfc_FSM_Rollback(psHciContext);
                transact_info.status = error_status;
                transact_info.buffer = NULL;
                transact_info.length = FALSE;
                psHciContext->p_xchg_info = NULL ;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_TRANSCEIVE_ERROR, &transact_info);
                break;

            }
            case hciState_Connect:
            {
                /* Notify the General failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                /* psHciContext->host_rf_type = phHal_eUnknown_DevType; */
                status = phHciNfc_ReaderMgmt_Update_Sequence(
                                                psHciContext, INFO_SEQ );
                psHciContext->p_target_info = NULL;
                psHciContext->hci_state.cur_state = hciState_Select;
                phHciNfc_FSM_Rollback(psHciContext);
                comp_info.status = error_status ;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_CONNECT_FAILED, &comp_info);
                break;
            }
            case hciState_Reactivate:
            {
                /* Notify the General failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                /* psHciContext->host_rf_type = phHal_eUnknown_DevType; 
                status = phHciNfc_ReaderMgmt_Update_Sequence(
                                                psHciContext, INFO_SEQ );
                psHciContext->p_target_info = NULL;
                psHciContext->hci_state.cur_state = hciState_Select;  */
                phHciNfc_FSM_Rollback(psHciContext);
                comp_info.status = error_status ;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_CONNECT_FAILED, &comp_info);
                break;
            }
            case hciState_Presence:
            {
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                /* Roll Back to Connect State as Presence Check is Complete */
                phHciNfc_FSM_Rollback(psHciContext);

                /* Initialisation Complete Notification to the Upper Layer */
                comp_info.status = error_status;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                             NFC_NOTIFY_ERROR, &comp_info);
                HCI_PRINT(" HCI Remote Target Removed from the Field. \n");
                break;
            }
            /* Notify the Connect or Disconnect failure to the upper layer */
            case hciState_Disconnect:
            {
                /* Notify the General failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                phHciNfc_FSM_Rollback(psHciContext);
                comp_info.status = error_status ;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                    psHciContext->p_upper_context, pHwRef,
                    NFC_NOTIFY_DISCONNECT_FAILED, &comp_info);
                break;
            }
            case hciState_Release:
            {
#ifdef NXP_HCI_SHUTDOWN_OVERRIDE
                status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
#else
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                phHciNfc_Release_Lower( psHciContext, pHwRef );
                /* Release all the resources and 
                * Notify the Receive Error Scenario to the Upper Layer 
                */
                comp_info.status = error_status ;
                phHciNfc_Release_Notify (psHciContext, pHwRef,
                    NFC_NOTIFY_DEINIT_FAILED, &comp_info);
#endif
                break;
            }
            default:
            {
                /* Notify the General failure to the upper layer */
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                phHciNfc_FSM_Rollback(psHciContext);
                comp_info.status = error_status ;
                psHciContext->error_status = error_status;
                status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                if (NFCSTATUS_PENDING != status)
                {
                    psHciContext->error_status = NFCSTATUS_SUCCESS;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_ERROR, &comp_info);
                }
                break;
            }

        } /* End of the Processing of HCI State*/
    }
    else
    {
        /* Notify the General failure to the upper layer */
        phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};
        phHciNfc_FSM_Rollback(psHciContext);
        comp_info.status = error_status ;
        /* Disable the Notification to the Upper Layer */
        if(NFCSTATUS_BOARD_COMMUNICATION_ERROR
                            == PHNFCSTATUS(error_status))
        {
            phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_ERROR, &comp_info);
        }
        else
        {
            psHciContext->error_status = error_status;
            status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
            if (NFCSTATUS_PENDING != status)
            {
                psHciContext->error_status = NFCSTATUS_SUCCESS;
            }
        }
    }
    return;
}


NFCSTATUS
phHciNfc_Resume_Sequence(
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef
                          )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    HCI_DEBUG("HCI: %s: cur_state=%02u, next_state=%02u",
        __FUNCTION__,
        psHciContext->hci_state.cur_state,
        psHciContext->hci_state.next_state);


    switch(psHciContext->hci_state.next_state)
    {
        /* Process the Admin Gate Response based on the HCI State */
        case hciState_Initialise:
        {
            switch (psHciContext->hci_state.cur_state)
            {
                /* Initialise State after Power on */
                case hciState_Reset:
                {
                    status = phHciNfc_Initialise_Sequence(psHciContext ,pHwRef);
                    break;
                }
                /* Initialise State after Power on */
                case hciState_Config:
                {
                    status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
                    break;
                }
                /* Discovery Resume after connect failure */
                case hciState_Initialise:
                case hciState_Select:
                case hciState_Connect:
                {
                    phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                    /* Update to the Intialise state as the discovery wheel is 
                     * restarted.
                     */
                    status = phHciNfc_FSM_Complete(psHciContext);

                    psHciContext->host_rf_type = phHal_eUnknown_DevType;
                    psHciContext->p_target_info = NULL;
                    psHciContext->p_xchg_info = NULL;

                    /* Initialisation Complete Notification to the Upper Layer */
                    comp_info.status = status;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                psHciContext->p_upper_context, pHwRef,
                                NFC_NOTIFY_POLL_RESTARTED , &comp_info);
                    HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
                    break;
                }
                default:
                {
                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
                    break;
                }
            }
            break;
        }
        case hciState_Release:
        {
            status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
            break;
        }
        case hciState_Config:
        {
            status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
            break;
        }
        case hciState_Listen:
        case hciState_Select:
        {
            status = phHciNfc_Info_Sequence( psHciContext, pHwRef );
            break;
        }
        case hciState_Reactivate:
        case hciState_Connect:
        {
            status = phHciNfc_Connect_Sequence( psHciContext, pHwRef );
            break;
        }
        case hciState_Transact:
        {
            status = phHciNfc_Transact_Sequence( 
                                            psHciContext, pHwRef );
            break;
        }
        case hciState_Presence:
        {
            phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

            /* Roll Back to Connect State as Presence Check is Complete */
            phHciNfc_FSM_Rollback(psHciContext);

            /* Initialisation Complete Notification to the Upper Layer */
            comp_info.status = NFCSTATUS_SUCCESS;
            phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_TARGET_PRESENT , &comp_info);
            HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
            break;
        }
        case hciState_Disconnect:
        {
            status = phHciNfc_Disconnect_Sequence( psHciContext, pHwRef );
            break;
        }
        case hciState_Test:
        {
            status = phHciNfc_Test_Sequence( psHciContext, pHwRef , status, NULL, 0 );
            break;
        }
        case hciState_IO:
        {
            status = phHciNfc_IO_Sequence( psHciContext, pHwRef , status, NULL, 0 );
            break;
        }
        case hciState_Unknown:
        {
            break;
        }
        default:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
            break;
        }
    } /* End of the Processing of HCI State*/

    return status;
}


NFCSTATUS
phHciNfc_Initialise_Sequence(
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef
                             )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    static  uint8_t             config = 0;

    PHNFC_UNUSED_VARIABLE(config);

    switch(psHciContext->hci_seq)
    {
        case ADMIN_INIT_SEQ:
        {
            status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
#ifdef ESTABLISH_SESSION
                if( hciMode_Session == psHciContext->hci_mode)
                {
                    /* TODO: Initialise Link Management 
                            Gate Resources */
                    NFCSTATUS info_status = NFCSTATUS_SUCCESS;
                    PHNFC_UNUSED_VARIABLE(info_status);
                    info_status = phHciNfc_IDMgmt_Update_Sequence( 
                                                psHciContext, INFO_SEQ );

                    if(NFCSTATUS_SUCCESS == info_status)
                    {
                        psHciContext->hci_seq = PL_STOP_SEQ;
                    }
                    else
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                        status = PHNFCSTVAL(CID_NFC_HCI,
                                    NFCSTATUS_INVALID_HCI_SEQUENCE);
                    }
                }
                else
#endif
                {
                    psHciContext->hci_seq = LINK_MGMT_INIT_SEQ;
                }
            }
            break;
        }
        case LINK_MGMT_INIT_SEQ:
        {
            status = phHciNfc_LinkMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = IDENTITY_INIT_SEQ;
            }
            break;
        }
        case IDENTITY_INIT_SEQ:
        {
            status = phHciNfc_IDMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = DEV_INIT_SEQ;
            }
            break;
        }
        case DEV_INIT_SEQ:
        {
            status = phHciNfc_DevMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                if (HCI_SELF_TEST != psHciContext->init_mode)
                {
                    psHciContext->hci_seq = PL_INIT_SEQ;
                }
                else
                {
#if defined( ESTABLISH_SESSION )
                    NFCSTATUS info_status = NFCSTATUS_SUCCESS;
                    PHNFC_UNUSED_VARIABLE(info_status);
                    info_status = phHciNfc_IDMgmt_Update_Sequence( 
                                                psHciContext, INFO_SEQ );

                    if(NFCSTATUS_SUCCESS == info_status)
                    {
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
                        psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
#else
                        psHciContext->hci_seq = IDENTITY_INFO_SEQ;
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
                    }
                    else
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                        status = PHNFCSTVAL(CID_NFC_HCI,
                                    NFCSTATUS_INVALID_HCI_SEQUENCE);
                    }
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
                    psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
#else
                    psHciContext->hci_seq = HCI_END_SEQ;
#endif /* #ifdef ESTABLISH_SESSION */
                }

            }
            break;
        }
        case PL_INIT_SEQ:
        {
            status = phHciNfc_PollLoop_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
                PHNFC_UNUSED_VARIABLE(reset_status);
                reset_status = phHciNfc_ReaderMgmt_Update_Sequence(
                                                    psHciContext, RESET_SEQ );
                psHciContext->hci_seq = READER_MGMT_INIT_SEQ;
            }
            break;
        }
        case READER_MGMT_INIT_SEQ:
        {
            status = phHciNfc_ReaderMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
                PHNFC_UNUSED_VARIABLE(reset_status);
                reset_status =  phHciNfc_EmuMgmt_Update_Seq( 
                                                psHciContext, RESET_SEQ );
                psHciContext->hci_seq = EMULATION_INIT_SEQ;
            }
            break;
        }
        case EMULATION_INIT_SEQ:
        {
            status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
#if defined( ESTABLISH_SESSION )
                psHciContext->hci_seq = ADMIN_SESSION_SEQ;
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
                psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
#else
                psHciContext->hci_seq = HCI_END_SEQ;
#endif
            }
            break;
        }
#ifdef ESTABLISH_SESSION
        case ADMIN_SESSION_SEQ:
        {
            status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
                psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
#else
                psHciContext->hci_seq = IDENTITY_INFO_SEQ;
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
            }
            break;
        }
        case PL_STOP_SEQ:
        {
            status = phHciNfc_ReaderMgmt_Disable_Discovery( 
                                                psHciContext, pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
#if defined( SW_AUTO_ACTIVATION )
                psHciContext->hci_seq = READER_SW_AUTO_SEQ;
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
                psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
#else
                psHciContext->hci_seq = IDENTITY_INFO_SEQ;
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
            }
            break;
        }
#ifdef SW_AUTO_ACTIVATION
        case READER_SW_AUTO_SEQ:
        {
            uint8_t     activate_enable = FALSE;
            uint8_t     rdr_enable = TRUE;

            status = phHciNfc_ReaderA_Update_Info( 
                    psHciContext, HCI_READER_A_ENABLE, 
                                            &rdr_enable);
            if(status == NFCSTATUS_SUCCESS)
            {
                status = phHciNfc_ReaderA_Auto_Activate( psHciContext,
                                                pHwRef, activate_enable );
                if(status == NFCSTATUS_SUCCESS)
                {
                    psHciContext->hci_seq = IDENTITY_INFO_SEQ;
                }
            }
            break;
        }
#endif
        /* fall through */
        case IDENTITY_INFO_SEQ:
        {
            status = phHciNfc_IDMgmt_Info_Sequence( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                if ((HCI_SELF_TEST != psHciContext->init_mode)
                    /* && ( TRUE == ((phHal_sHwReference_t *)pHwRef)->se_detect ) */
                    && (HCI_CUSTOM_INIT != psHciContext->init_mode)
                    && (HCI_NFC_DEVICE_TEST != psHciContext->init_mode))
                {
                    NFCSTATUS info_status = NFCSTATUS_SUCCESS;
                    PHNFC_UNUSED_VARIABLE(info_status);
                    info_status = phHciNfc_EmuMgmt_Update_Seq( 
                                                psHciContext, INFO_SEQ );

                    if(NFCSTATUS_SUCCESS == info_status)
                    {
                        psHciContext->hci_seq = EMULATION_SWP_SEQ;
                    }
                }
                else
                {
                    psHciContext->hci_seq = HCI_END_SEQ;
                }
            }
            break;
        }
        case EMULATION_SWP_SEQ:
        {
            status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = HCI_END_SEQ;
            }
            break;
        }
#endif /* #ifdef ESTABLISH_SESSION */

#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
        case DEV_HAL_INFO_SEQ:
        {
            static uint8_t      mem_index = 0;
            status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
                        (NFC_ADDRESS_HAL_CONF + mem_index),
                            (psHciContext->hal_mem_info + mem_index));
            if(NFCSTATUS_PENDING == status)
            {
                mem_index++;
                if (NXP_HAL_MEM_INFO_SIZE <= mem_index )
                {
                    NFCSTATUS info_status = NFCSTATUS_SUCCESS;
                    PHNFC_UNUSED_VARIABLE(info_status);
                    info_status = phHciNfc_IDMgmt_Update_Sequence(
                                                psHciContext, INFO_SEQ );
                    mem_index = 0;
                    psHciContext->hci_seq = IDENTITY_INFO_SEQ;
                    /* psHciContext->hci_seq =
                            (HCI_SELF_TEST != psHciContext->init_mode)?
                                    IDENTITY_INFO_SEQ : HCI_END_SEQ; */
                }
            }
            break;
        }
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
        case HCI_END_SEQ:
        {
            phHal_sMemInfo_t    *p_mem_info =
                    (phHal_sMemInfo_t *) ( psHciContext->hal_mem_info );
            if (
                (HCI_SELF_TEST == psHciContext->init_mode )
                || (HCI_NFC_DEVICE_TEST == psHciContext->init_mode )
                )
            {
                psHciContext->hci_state.next_state
                    = (uint8_t) hciState_Test;
            }
            status = phHciNfc_FSM_Complete ( psHciContext );
#ifdef UICC_CONNECTIVITY_PATCH
            phHciNfc_Uicc_Connectivity( psHciContext, pHwRef );
#endif /* #ifdef UICC_CONNECTIVITY_PATCH */

#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
            if(NXP_FW_UPLOAD_SUCCESS != p_mem_info->fw_magic )
            {
                status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FAILED );
            }
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */

            /* Initialisation Complete Notification to the Upper Layer */
            if(NFCSTATUS_SUCCESS == status)
            {
                phNfc_sCompletionInfo_t     comp_info={FALSE,0, NULL};

                comp_info.status = status;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                                NFC_NOTIFY_INIT_COMPLETED, &comp_info);
                HCI_PRINT("HCI Initialisation Completed \n");
            }
            else
            {
                pphNfcIF_Notification_CB_t  p_upper_notify = psHciContext->p_upper_notify;
                void                        *pcontext = psHciContext->p_upper_context;
                phNfc_sCompletionInfo_t     comp_info;


                phHciNfc_Release_Lower( psHciContext, pHwRef );
                phHciNfc_Release_Resources( &psHciContext );
                 /* Notify the Failure to the Upper Layer */
                comp_info.status = status;
                phHciNfc_Notify( p_upper_notify, pcontext, pHwRef,
                                NFC_NOTIFY_INIT_FAILED, &comp_info);
                HCI_PRINT("HCI FSM Initialisation Error \n");
            }
            break;
        }
        default:
            break;
    }

    return status;
}


NFCSTATUS
phHciNfc_Release_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    switch(psHciContext->hci_seq)
    {
        case PL_STOP_SEQ:
        {
            status = phHciNfc_ReaderMgmt_Disable_Discovery( 
                                                psHciContext, pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                (void)phHciNfc_EmuMgmt_Update_Seq( 
                                    psHciContext, REL_SEQ );
                psHciContext->hci_seq = EMULATION_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case EMULATION_REL_SEQ:
        {
            status = phHciNfc_EmuMgmt_Release( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                (void)phHciNfc_DevMgmt_Update_Sequence( 
                                    psHciContext, REL_SEQ );
                psHciContext->hci_seq = ADMIN_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case DEV_REL_SEQ:
        {
            NFCSTATUS info_status = NFCSTATUS_SUCCESS;
            PHNFC_UNUSED_VARIABLE(info_status);
            info_status = phHciNfc_DevMgmt_Update_Sequence(
                                            psHciContext, REL_SEQ );
            status = phHciNfc_DevMgmt_Release( psHciContext, pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = HCI_END_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case READER_MGMT_REL_SEQ:
        {
            status = phHciNfc_ReaderMgmt_Release( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = PL_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case PL_REL_SEQ:
        {
            status = phHciNfc_PollLoop_Release( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = IDENTITY_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case IDENTITY_REL_SEQ:
        {
            status = phHciNfc_IDMgmt_Release( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = LINK_MGMT_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case LINK_MGMT_REL_SEQ:
        {
            status = phHciNfc_LinkMgmt_Release( psHciContext,pHwRef );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = ADMIN_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case ADMIN_REL_SEQ:
        {
            /*  Admin Management Release Sequence */
            status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_TerminalHostID );
            if(NFCSTATUS_SUCCESS == status)
            {
                psHciContext->hci_seq = DEV_REL_SEQ;
                status = NFCSTATUS_PENDING;
            }
            break;
        }
        case HCI_END_SEQ:
        {
            pphNfcIF_Notification_CB_t  p_upper_notify = 
                                            psHciContext->p_upper_notify;
            phNfc_sLowerIF_t            *plower_if = 
                                            &(psHciContext->lower_interface);
            void                        *pcontext = 
                                                psHciContext->p_upper_context;
            phNfc_sCompletionInfo_t     comp_info;


            status = plower_if->release((void *)plower_if->pcontext,
                                            (void *)pHwRef);

            phHciNfc_Release_Resources( &psHciContext );
            /* De-Initialisation Complete Notification to the Upper Layer */
            comp_info.status = status;
            phHciNfc_Notify(p_upper_notify, pcontext, pHwRef,
                                    NFC_NOTIFY_DEINIT_COMPLETED, &comp_info);

            HCI_PRINT("HCI Release Completed \n");
            break;
        }
        default:
        {
            /* psHciContext->hci_seq = HCI_END_SEQ; */
            break;
        }
    }

    return status;
}


static
NFCSTATUS
phHciNfc_Config_Sequence(
                           phHciNfc_sContext_t      *psHciContext,
                           void                 *pHwRef
                        )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phNfc_sCompletionInfo_t     comp_info = {FALSE,0,NULL};

    switch(psHciContext->config_type)
    {
        case POLL_LOOP_CFG:
        {
            status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef );
            break;
        }
        case SMX_WI_MODE:
        {
            status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef );
            break;
        }
#ifdef ENABLE_P2P
        case NFC_GENERAL_CFG:
        {
            if(TARGET_GENERAL_SEQ == psHciContext->hci_seq)
            {
                status = phHciNfc_NfcIP_SetATRInfo( psHciContext,
                                        pHwRef, NFCIP_TARGET, 
                                        psHciContext->p_config_params);
                    if( NFCSTATUS_PENDING != status )
                    {
                        /* Roll Back the State Machine to its Original State */
                        phHciNfc_FSM_Rollback ( psHciContext );
                    }
                    else
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                    }
            }
            else
            {
                status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                if (NFCSTATUS_PENDING != status)
                {
                    /* Roll Back to its Current State as Configuration is Complete */
                    phHciNfc_FSM_Rollback(psHciContext); 

                    HCI_PRINT(" NFC-IP(P2P) Configuration Completed. \n");
                    comp_info.status = status;
                    psHciContext->error_status = NFCSTATUS_SUCCESS;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                    psHciContext->p_upper_context, pHwRef,
                                        NFC_NOTIFY_CONFIG_SUCCESS , &comp_info);
                }
            }
            break;
        }
#endif
        case SWP_PROTECT_CFG:
        case SWP_EVT_CFG:
        case SMX_WI_CFG:
        {
            /* Roll Back to its Current State as Configuration is Complete */
            phHciNfc_FSM_Rollback(psHciContext); 

            HCI_DEBUG(" %s Configuration Completed. \n",
                  ((SMX_WI_CFG == psHciContext->config_type)?
                        "SmartMX" : "SWP Event/Protection"));

            comp_info.status = status;
            phHciNfc_Notify(psHciContext->p_upper_notify,
                                psHciContext->p_upper_context, pHwRef,
                                NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
            break;
        }
        case NFC_TARGET_CFG:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
            break;
        }
        case UICC_SWP_CFG:
#if 0
        {
            phHal_sEmulationCfg_t   *p_emulation_cfg = 
                                        (phHal_sEmulationCfg_t * )
                                                psHciContext->p_config_params;
            if (NULL != p_emulation_cfg)
            {
                phHal_sUiccEmuCfg_t   *uicc_config = 
                                    &p_emulation_cfg->config.uiccEmuCfg;
                if( TRUE == uicc_config->enableUicc )
                {
                    status = phHciNfc_Uicc_Connect_Status(psHciContext,pHwRef);
                    if( NFCSTATUS_PENDING == status )
                    {
                        break;
                    } /* Or Else Fall through to notify the above layer */
                }
            }
        }
#endif
        /* fall through */
        case NFC_CE_A_CFG:
        case NFC_CE_B_CFG:
        {
            status = phHciNfc_EmulationCfg_Sequence( psHciContext, pHwRef );
            break;
        }
        default:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);       
            break;
        }
    }
    
    return status;
}


NFCSTATUS
phHciNfc_PollLoop_Sequence(
                           phHciNfc_sContext_t      *psHciContext,
                           void                 *pHwRef
                           )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    phHal_sADD_Cfg_t    *p_poll_config = (phHal_sADD_Cfg_t * )
        psHciContext->p_config_params;
    if (NULL != p_poll_config)
    {
        uint8_t speed = 
                p_poll_config->NfcIP_Mode;
        switch(psHciContext->hci_seq)
        {
            case PL_DURATION_SEQ:
            {
                status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
                    (uint8_t)PL_DURATION , NULL);
                if(NFCSTATUS_SUCCESS == status)
                {
#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
                    psHciContext->hci_seq = TARGET_SPEED_SEQ;
#elif defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
                    psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
#elif defined (ENABLE_P2P) &&  defined (NFCIP_TGT_DISABLE_CFG)
                    psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
#else
                    psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;  
#endif

                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
            case TARGET_SPEED_SEQ:
            {
#define NFCIP_ACTIVE_SHIFT	0x03U
#define NFCIP_PASSIVE_MASK	0x07U
                uint8_t mode = ( NXP_NFCIP_ACTIVE_DEFAULT << NFCIP_ACTIVE_SHIFT ) |
									( DEFAULT_NFCIP_TARGET_MODE_SUPPORT & NFCIP_PASSIVE_MASK );
                status = 
                    phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_TARGET,
                     (uint8_t) mode );
                if(NFCSTATUS_PENDING == status)
                {
#if defined (INITIATOR_SPEED)
                    psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
#elif defined (NFCIP_TGT_DISABLE_CFG)
                    psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
#else
                    psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;  
#endif
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#endif
#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
            case INITIATOR_SPEED_SEQ:
            {
                status = 
                    phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_INITIATOR,
                     (uint8_t) (speed & DEFAULT_NFCIP_INITIATOR_MODE_SUPPORT));
                if(NFCSTATUS_PENDING == status)
                {
#if defined (NFCIP_TGT_DISABLE_CFG)
                    psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
#else
                    psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;  
#endif
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#endif
#if defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
            case PL_TGT_DISABLE_SEQ:
            {
                /* Configure the Polling Loop Target Disable Parameter */
                status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
                (uint8_t)PL_DISABLE_TARGET, &p_poll_config->NfcIP_Tgt_Disable );
                if(NFCSTATUS_SUCCESS == status)
                {
                    psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;  
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#endif
            case PL_CONFIG_PHASE_SEQ:
            {
                phHal_sPollDevInfo_t *p_poll_info = 
                                &(p_poll_config->PollDevInfo.PollCfgInfo);

                p_poll_info->EnableIso14443A = 
                    ( (p_poll_info->EnableIso14443A)
                                    || ( speed & (uint8_t)phHal_ePassive106 ) 
                                    );
                p_poll_info->EnableFelica212 = 
                            ( (p_poll_info->EnableFelica212)
                                    || ( speed & (uint8_t)phHal_ePassive212 ) 
                                    );
                p_poll_info->EnableFelica424 = 
                            ( (p_poll_info->EnableFelica424)
                                    || ( speed & (uint8_t)phHal_ePassive424 ) 
                                    );
                /* Configure the Polling Loop Gate Parameters */
                status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
                    (uint8_t)PL_RD_PHASES, NULL );
                if(NFCSTATUS_SUCCESS == status)
                {
                    if(((~(PL_RD_PHASES_DISABLE)) & 
                            p_poll_config->PollDevInfo.PollEnabled)!= 0)
                    {
                        psHciContext->hci_seq = READER_ENABLE_SEQ;
                    }
                    else
                    {
                        /* psHciContext->hci_seq = READER_DISABLE_SEQ; */
                        psHciContext->hci_seq = HCI_END_SEQ;
                    }
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case READER_ENABLE_SEQ:
            {
                status = 
                    phHciNfc_ReaderMgmt_Enable_Discovery( 
                    psHciContext, pHwRef );
                if(NFCSTATUS_SUCCESS == status)
                {
                    /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
                    psHciContext->hci_seq = HCI_END_SEQ;  
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case READER_DISABLE_SEQ:
            {
                status = phHciNfc_ReaderMgmt_Disable_Discovery( 
                    psHciContext, pHwRef );

                if(NFCSTATUS_SUCCESS == status)
                {
                    if((~(PL_RD_PHASES_DISABLE) & 
                            p_poll_config->PollDevInfo.PollEnabled)!= 0)
                    {
                        psHciContext->hci_seq = PL_DURATION_SEQ;
                    }
                    else
                    {
#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
                        psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
#elif defined (ENABLE_P2P) &&  defined (NFCIP_TGT_DISABLE_CFG)
                        psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
#else
                        psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;  
#endif
                        /* psHciContext->hci_seq = HCI_END_SEQ; */
                    }
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case HCI_END_SEQ:
            {
                phNfc_sCompletionInfo_t     comp_info;
                status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                if (NFCSTATUS_PENDING != status)
                {
                    /* status = phHciNfc_FSM_Complete ( psHciContext );*/
                    phHciNfc_FSM_Rollback ( psHciContext );
                    /* Poll Configuration Notification to the Upper Layer */
                    if((~(PL_RD_PHASES_DISABLE) & 
                            p_poll_config->PollDevInfo.PollEnabled)!= 0)
                    {
                        comp_info.status = status;
                        phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_POLL_ENABLED, &comp_info);
                    } 
                    else
                    {
                        comp_info.status = status;
                        phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_POLL_DISABLED, &comp_info);
                    }
                    HCI_PRINT("HCI Discovery Configuration Completed \n");
                }
                break;
            }
            default:
            {
                /* psHciContext->hci_seq = HCI_END_SEQ; */
                break;
            }
        }/* End of the Poll Sequence Switch */
    }/* End of the Poll Config info Check */

    return status;
}


NFCSTATUS
phHciNfc_EmulationCfg_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    static phNfc_sCompletionInfo_t      comp_info = {FALSE,0,NULL};
#if defined(HOST_EMULATION)
    phHciNfc_GateID_t       ce_gate = phHciNfc_UnknownGate;
#endif  /* #ifdef HOST_EMULATION */
    phHal_sEmulationCfg_t   *p_emulation_cfg = (phHal_sEmulationCfg_t * )
                                        psHciContext->p_config_params;
#ifdef UICC_SESSION_RESET
    uint8_t                 uicc_clear_pipes = FALSE;
#endif


    if (NULL != p_emulation_cfg)
    {
#if defined(HOST_EMULATION)
        if(NFC_HOST_CE_A_EMULATION == p_emulation_cfg->emuType)
        {
            psHciContext->config_type = NFC_CE_A_CFG;
            if (NULL == psHciContext->p_ce_a_info)
            {
                ce_gate = phHciNfc_CETypeAGate;
            }
        }
        else if (NFC_HOST_CE_B_EMULATION == p_emulation_cfg->emuType)
        {
            psHciContext->config_type = NFC_CE_B_CFG;
            if (NULL == psHciContext->p_ce_b_info)
            {
                ce_gate = phHciNfc_CETypeBGate;
            }
        }
#ifdef UICC_SESSION_RESET
        else if ((NFC_UICC_EMULATION == p_emulation_cfg->emuType)
            &&(FALSE == p_emulation_cfg->config.uiccEmuCfg.enableUicc)
            )
        {
            uicc_clear_pipes = TRUE;
        }
#endif
        else
        {
            ;
        }
#endif  /* #ifdef HOST_EMULATION */

        switch(psHciContext->hci_seq)
        {
#if defined(HOST_EMULATION)
            case ADMIN_CE_SEQ:
            {
                if(phHciNfc_UnknownGate != ce_gate)
                {
                    status = phHciNfc_Admin_CE_Init(psHciContext, pHwRef, ce_gate);
                }
                else
                {
                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
                }

                if(NFCSTATUS_SUCCESS == status)
                {
                    psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
                    /* psHciContext->hci_seq = HCI_END_SEQ; */
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#endif
            case EMULATION_CONFIG_SEQ:
            {
                status = phHciNfc_Emulation_Cfg(psHciContext, pHwRef, 
                                                psHciContext->config_type);
                if(NFCSTATUS_SUCCESS == status)
                {
                    /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
#ifdef UICC_SESSION_RESET
                    if(UICC_SWP_CFG == psHciContext->config_type)
                    {
                        psHciContext->hci_seq = ADMIN_REL_SEQ;
                    }
                    else
#endif /* UICC_SESSION_RESET */
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                    }
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
#ifdef UICC_SESSION_RESET
            case ADMIN_REL_SEQ:
            {
                if (TRUE == uicc_clear_pipes)
                {
                    /*  Admin Management UICC Release Sequence */
                    status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_UICCHostID );
                    if(NFCSTATUS_SUCCESS == status)
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                        if (UICC_SWP_CFG == psHciContext->config_type)
                        {
                            (void)phHciNfc_SWP_Update_Sequence(psHciContext, 
                                                                        CONFIG_SEQ );
                        }
                        status = NFCSTATUS_PENDING;
                    }
                    break;
                }
            }
#endif /* UICC_SESSION_RESET */
            /* fall through */
            case HCI_END_SEQ:
            {
                phHciNfc_FSM_Rollback(psHciContext); 

                HCI_PRINT(" Emulation Configuration Completed. \n");

                comp_info.status = status;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                                 psHciContext->p_upper_context, pHwRef,
                                   NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
                break;
            }
            default:
            {
                /* psHciContext->hci_seq = HCI_END_SEQ; */
                break;
            }
        }
        /*
            NFC_CE_A_CFG;
            NFC_CE_B_CFG; */

    }/* End of the Emulation Config info Check */
    
    return status;
}


NFCSTATUS
phHciNfc_SmartMx_Mode_Sequence(
                           phHciNfc_sContext_t      *psHciContext,
                           void                     *pHwRef
                          )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    phHal_sADD_Cfg_t    *p_poll_config = (phHal_sADD_Cfg_t * )
        psHciContext->p_config_params;
    phNfc_sCompletionInfo_t     comp_info = {FALSE,0,NULL};
    if (NULL != p_poll_config)
    {
        switch(psHciContext->hci_seq)
        {
            case READER_DISABLE_SEQ:
            {
                status = phHciNfc_ReaderMgmt_Disable_Discovery( 
                    psHciContext, pHwRef );
                if(NFCSTATUS_SUCCESS == status)
                {
                    psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
                    /* psHciContext->hci_seq = HCI_END_SEQ; */
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case EMULATION_CONFIG_SEQ:
            {
                status = phHciNfc_WI_Configure_Mode( 
                    psHciContext, pHwRef,psHciContext->smx_mode );
                if(NFCSTATUS_SUCCESS == status)
                {
                    psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
                    /* psHciContext->hci_seq = HCI_END_SEQ; */
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case PL_CONFIG_PHASE_SEQ:
            {
                /* Configure the Polling Loop Gate Parameters */
                status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
                    (uint8_t)PL_RD_PHASES, NULL );
                if(NFCSTATUS_SUCCESS == status)
                {
                    psHciContext->hci_seq = READER_ENABLE_SEQ;
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case READER_ENABLE_SEQ:
            {
                status = 
                    phHciNfc_ReaderMgmt_Enable_Discovery( 
                    psHciContext, pHwRef );
                if(NFCSTATUS_SUCCESS == status)
                {
                    /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
                    psHciContext->hci_seq = HCI_END_SEQ;  
                    status = NFCSTATUS_PENDING;
                }
                break;
            }
            case HCI_END_SEQ:
            {
                status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
                if (NFCSTATUS_PENDING != status)
                {
                    /* status = phHciNfc_FSM_Complete ( psHciContext );*/
                    phHciNfc_FSM_Rollback ( psHciContext );
                    if( hciState_Disconnect == psHciContext->hci_state.cur_state)
                    {
                        psHciContext->host_rf_type = phHal_eUnknown_DevType;
                        psHciContext->p_target_info = NULL;
                        psHciContext->p_xchg_info = NULL;
                    }
                    /* Poll Configuration Notification to the Upper Layer */
                    if((~(PL_RD_PHASES_DISABLE) & 
                            p_poll_config->PollDevInfo.PollEnabled)!= 0)
                    {
                        comp_info.status = status;
                        phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_POLL_ENABLED, &comp_info);
                    } 
                    else
                    {
                        comp_info.status = status;
                        phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_POLL_DISABLED, &comp_info);
                    }
                    HCI_PRINT("HCI Discovery Configuration Completed \n");
                }
                break;
            }
            default:
            {
                /* psHciContext->hci_seq = HCI_END_SEQ; */
                break;
            }
        }/* End of the Poll Sequence Switch */
    }/* End of the Poll Config info Check */

    return status;
}


NFCSTATUS
phHciNfc_Connect_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    static phNfc_sCompletionInfo_t      comp_info = {FALSE,0,NULL};
    phHal_eRemDevType_t         target_type = phHal_eUnknown_DevType;

    if( NULL != psHciContext->p_target_info )
    {

        target_type = psHciContext->p_target_info->RemDevType;
        switch(psHciContext->hci_seq)
        {
            case READER_REACTIVATE_SEQ:
            {
                /* Complete the Reactivate Sequence and notify the HAL */
                status = phHciNfc_FSM_Complete ( psHciContext );
                /* Reactivate Complete Notification to the Upper Layer */
                if(NFCSTATUS_SUCCESS == status)
                {
                    comp_info.status = status;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                    psHciContext->p_upper_context, pHwRef,
                                    NFC_NOTIFY_TARGET_REACTIVATED , &comp_info);
                    HCI_PRINT(" HCI Remote Target Reactivated. \n");
                }
                else
                {
                    comp_info.status = status;
                    phHciNfc_FSM_Rollback ( psHciContext );
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_ERROR , &comp_info);
                    HCI_PRINT("HCI FSM Invalid Selection State \n");
                    HCI_PRINT("HCI Remote Target Reactivation Failed \n");
                }
                break;
            }
            case READER_SELECT_SEQ:
            {
                /* If the Target is Mifare then it should fall through */
                if(( phHal_eMifare_PICC != target_type ) 
                    &&(phHal_eISO14443_3A_PICC != target_type)
#ifdef TYPE_B
                    &&  ( phHal_eISO14443_B_PICC != target_type )
                    &&  ( phHal_eISO14443_4B_PICC != target_type )
#endif
#ifdef TYPE_FELICA
                    &&  ( phHal_eFelica_PICC != target_type )
#endif
#ifdef TYPE_JEWEL
                    &&  ( phHal_eJewel_PICC != target_type )
#endif /* #ifdef TYPE_JEWEL */
#ifdef TYPE_ISO15693
                    &&  ( phHal_eISO15693_PICC != target_type )
#endif /* #ifdef TYPE_ISO15693 */

                    )
                {
                    status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
                    if(NFCSTATUS_SUCCESS == status)
                    {
                        psHciContext->hci_seq = HCI_END_SEQ;
                        status = NFCSTATUS_PENDING;
                    }
                    break;
                }
            }
            /* fall through */
            case HCI_END_SEQ:
            {
                /* Complete the Connect Sequence and notify the HAL */
                status = phHciNfc_FSM_Complete ( psHciContext );
                /* Connection Complete Notification to the Upper Layer */
                if(NFCSTATUS_SUCCESS == status)
                {
                    /* Invalidate the previously polled RF Reader Type */
                    /* psHciContext->host_rf_type = phHal_eInvalidRFType;*/
                    comp_info.status = status;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                    psHciContext->p_upper_context, pHwRef,
                                    NFC_NOTIFY_TARGET_CONNECTED , &comp_info);
                    HCI_PRINT(" HCI Remote Target Selected for Transaction. \n");
                }
                else
                {
                    comp_info.status = status;
                    /* phHciNfc_FSM_Rollback ( psHciContext ); */
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_ERROR , &comp_info);
                    HCI_PRINT("HCI FSM Invalid Selection State \n");
                    HCI_PRINT("HCI Remote Target Selection Failed \n");
                }
                break;
            }
            default:
            {
                HCI_PRINT("\t Invalid HCI Connect Sequence \n");
                /* psHciContext->hci_seq = HCI_END_SEQ; */
                break;
            }
        }/* End of the Connect Sequence Switch */
    }

    return status;
}


NFCSTATUS
phHciNfc_Disconnect_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    static phNfc_sCompletionInfo_t      comp_info = {FALSE, 0 , NULL};
    phHal_eRemDevType_t         target_type = phHal_eUnknown_DevType;
    uint8_t             re_poll = 0;

    if( NULL != psHciContext->p_target_info )
    {

        target_type = psHciContext->p_target_info->RemDevType;
        switch(psHciContext->hci_seq)
        {
            case READER_UICC_DISPATCH_SEQ:
            {
                status = phHciNfc_ReaderMgmt_UICC_Dispatch( 
                                psHciContext, pHwRef, target_type );
                psHciContext->hci_seq = READER_DESELECT_SEQ;
                if(NFCSTATUS_PENDING == status)
                {
                    break;
                }
            }
            /* fall through */
            case READER_DESELECT_SEQ:
            {
                re_poll = (uint8_t) ( NULL != psHciContext->p_config_params )?
                                *((uint8_t *)psHciContext->p_config_params):FALSE;
                status = phHciNfc_ReaderMgmt_Deselect( 
                                psHciContext, pHwRef, target_type, re_poll);
                if(NFCSTATUS_PENDING == status)
                {
                    psHciContext->hci_seq = HCI_END_SEQ;
                    psHciContext->p_config_params = NULL;
                }
                break;
            }
            case HCI_END_SEQ:
            {
                /* Complete the Disconnect Sequence and notify the HAL */
                status = phHciNfc_FSM_Complete ( psHciContext );
                /* Disconnect Notification to the Upper Layer */
                if(NFCSTATUS_SUCCESS == status)
                {
                    /* Invalidate the previously polled RF Reader Type */
                    psHciContext->host_rf_type = phHal_eUnknown_DevType;
                    psHciContext->p_target_info = NULL;
                    psHciContext->p_xchg_info = NULL;
                    comp_info.status = status;
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                    psHciContext->p_upper_context, pHwRef,
                                    NFC_NOTIFY_TARGET_DISCONNECTED , &comp_info);
                    HCI_PRINT(" HCI Remote Target De-Selected. \n");
                }
                else
                {
                    comp_info.status = status;
                    /* phHciNfc_FSM_Rollback ( psHciContext ); */
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_ERROR , &comp_info);
                    HCI_PRINT("HCI FSM Invalid De-Selection State \n");
                    HCI_PRINT("HCI Remote Target De-Selection Failed \n");
                }

                break;
            }
            default:
            {
                HCI_PRINT("\t Invalid HCI Connect Sequence \n");
                /* psHciContext->hci_seq = HCI_END_SEQ; */
                break;
            }
        }/* End of the Connect Sequence Switch */
    }

    return status;
}


static
NFCSTATUS
phHciNfc_Transact_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    static phNfc_sTransactionInfo_t transact_info = {FALSE,0,NULL,NULL,0};

    pphNfcIF_Notification_CB_t  p_upper_notify = psHciContext->p_upper_notify;
    void                        *pcontext = psHciContext->p_upper_context;
    uint8_t                     transact_result = NFC_NOTIFY_ERROR;

    /* Roll Back to Connect State as Transceive is Complete */
    phHciNfc_FSM_Rollback(psHciContext); 

    switch (psHciContext->host_rf_type)
    {
        case phHal_eISO14443_A_PCD:
#ifdef TYPE_B
        case phHal_eISO14443_B_PCD:
#endif
        case phHal_eISO14443_BPrime_PCD:
#ifdef TYPE_FELICA
        case phHal_eFelica_PCD:
#endif
#ifdef TYPE_ISO15693
        case phHal_eISO15693_PCD:
#endif
        {
            if(ZERO != psHciContext->rx_index)
            {
                transact_info.status = NFCSTATUS_SUCCESS;
                transact_info.buffer = 
                                &psHciContext->recv_buffer[psHciContext->rx_index];
                transact_info.length = 
                                psHciContext->rx_total - psHciContext->rx_index;
                transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
            }
            else
            {
                transact_info.status = NFCSTATUS_FAILED;
                transact_result = NFC_NOTIFY_TRANSCEIVE_ERROR;
            }
            HCI_PRINT(" HCI Transceive operation Completed. \n");
            psHciContext->p_xchg_info = NULL ;
            break;
        }
#ifdef TYPE_JEWEL
        /* fall through */
        case phHal_eJewel_PCD:
#endif
        {
            transact_info.status = NFCSTATUS_SUCCESS;
            transact_info.buffer = 
                            &psHciContext->recv_buffer[psHciContext->rx_index];
            transact_info.length = 
                            psHciContext->rx_total - psHciContext->rx_index;
            transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
            HCI_PRINT(" HCI Transceive operation Completed. \n");
            psHciContext->p_xchg_info = NULL ;
            break;
        }
#if defined(ENABLE_P2P)
        case phHal_eNfcIP1_Initiator:
        case phHal_eNfcIP1_Target:
#endif
        {
            HCI_PRINT(" HCI Send operation Completed. \n");
            transact_info.status = NFCSTATUS_SUCCESS;
            transact_result = NFC_NOTIFY_SEND_COMPLETED;
            break;
        }
        case phHal_eUnknown_DevType:
        default:
        {
            transact_info.status  = 
                        PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
            break;
        }

    }
    /* Notify the Transceive Completion to the Upper layer */
    phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
                    transact_result, &transact_info);

    return (NFCSTATUS)NFCSTATUS_SUCCESS;
}

static
NFCSTATUS
phHciNfc_Info_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    HCI_DEBUG(" HCI: Info Sequence Entry --> Reader Type : %02X \n",
                                            psHciContext->host_rf_type);
    switch (psHciContext->host_rf_type)
    {
        case phHal_eISO14443_A_PCD:
#ifdef TYPE_B
        case phHal_eISO14443_B_PCD:
#endif
        case phHal_eISO14443_BPrime_PCD:
#ifdef TYPE_FELICA
        case phHal_eFelica_PCD:
#endif
#ifdef TYPE_JEWEL
        case phHal_eJewel_PCD:
#endif
#ifdef TYPE_ISO15693
        case phHal_eISO15693_PCD:
#endif
        {
            /* To update the select sequence to retrieve
            * the target information using the reader type.
            */
            status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
            break;
        }
#if defined(ENABLE_P2P)
        case phHal_eNfcIP1_Initiator:
        case phHal_eNfcIP1_Target:
        {
            status = phHciNfc_NfcIP_Info_Sequence( psHciContext, pHwRef );
            break;
        }
#endif
        case phHal_eUnknown_DevType:
        default:
        {
            status  = 
                    PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
            break;
        }

    }
    return status;
}

static
NFCSTATUS
phHciNfc_Test_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            NFCSTATUS               test_status,
                            uint8_t                 *pdata,
                            uint8_t                 length
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    static phNfc_sCompletionInfo_t      comp_info = {0};
    static phNfc_sData_t test_result= {NULL,0};

    /* Complete the Test Sequence and notify the HAL */
    status = phHciNfc_FSM_Complete ( psHciContext );
    /* Test Results to the Upper Layer */
    if(NFCSTATUS_SUCCESS == status)
    {
        comp_info.status = test_status;
        if ( (NULL != pdata) && (length >= HCP_HEADER_LEN) )
        {
            test_result.buffer = ( pdata + HCP_HEADER_LEN);
            test_result.length = length - HCP_HEADER_LEN;
        }
        else
        {
            status = phHciNfc_DevMgmt_Get_Test_Result( 
                                        psHciContext, &test_result );
        }
        comp_info.info = &test_result;
        phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_NOTIFY_RESULT , &comp_info);
        HCI_DEBUG(" HCI System Test Completed : Status = %u\n", test_status);
    }
    else
    {
        comp_info.status = status;
        phHciNfc_FSM_Rollback ( psHciContext );
        phHciNfc_Notify(psHciContext->p_upper_notify,
            psHciContext->p_upper_context, pHwRef,
            NFC_NOTIFY_ERROR , &comp_info);
        HCI_PRINT("HCI FSM Invalid Test State \n");
    }

    return status;
}

static
NFCSTATUS
phHciNfc_IO_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            NFCSTATUS               io_status,
                            uint8_t                 *pdata,
                            uint8_t                 length
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;
    static phNfc_sCompletionInfo_t      comp_info = {0};

    /* To remove "warning (VS 4100) : unreferenced formal parameter" */
    PHNFC_UNUSED_VARIABLE(pdata);
    PHNFC_UNUSED_VARIABLE(length);
    /* Complete the Test Sequence and notify the HAL */
    phHciNfc_FSM_Rollback ( psHciContext );
    /* Test Results to the Upper Layer */
    comp_info.status = io_status;
    status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
    if(NFCSTATUS_SUCCESS == io_status)
    {
        phHciNfc_Notify(psHciContext->p_upper_notify,
                        psHciContext->p_upper_context, pHwRef,
                        NFC_IO_SUCCESS , &comp_info);
        HCI_PRINT(" HCI System IO Successful. \n");
    }
    else
    {
        phHciNfc_Notify(psHciContext->p_upper_notify,
            psHciContext->p_upper_context, pHwRef,
            NFC_IO_ERROR , &comp_info);
        HCI_PRINT("HCI IO Error \n");
    }
    return status;
}


#ifdef OTHER_TAGS

NFCSTATUS
phHciNfc_Activate_Sequence(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef
                         )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    return status;
}


#endif