xref: /external/libnfc-nxp/src/phHciNfc_Generic.c

/*
 * 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_Generic.c                                                   *
* \brief Generic HCI Source for the HCI Management.                           *
*                                                                             *
*                                                                             *
* Project: NFC-FRI-1.1                                                        *
*                                                                             *
* $Date: Tue Jun  8 09:31:49 2010 $                                           *
* $Author: ing04880 $                                                         *
* $Revision: 1.108 $                                                           *
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
*                                                                             *
* =========================================================================== *
*/

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

#include <phNfcCompId.h>
#include <phHciNfc_Sequence.h>
#include <phHciNfc_Pipe.h>
#include <phHciNfc_AdminMgmt.h>
#include <phHciNfc_IDMgmt.h>
#include <phHciNfc_LinkMgmt.h>
#include <phHciNfc_PollingLoop.h>
#include <phHciNfc_RFReader.h>
#include <phHciNfc_RFReaderA.h>
#include <phOsalNfc.h>

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

/* HCI timeout value */
uint32_t nxp_nfc_hci_response_timeout = NXP_NFC_HCI_TIMEOUT;

/*
################################################################################
************************ Static Variable Definitions ***************************
################################################################################
*/


#if  (NXP_NFC_HCI_TIMER == 1)

#define NXP_HCI_RESPONSE_TIMEOUT  (NXP_NFC_HCI_TIMEOUT)

#include <phOsalNfc_Timer.h>
/** \internal HCI Response Timer to detect the
 * Stalled HCI Response */
static uint32_t                    hci_resp_timer_id = NXP_INVALID_TIMER_ID;
static phHciNfc_sContext_t        *gpsHciContext= NULL;

#endif /* (NXP_NFC_HCI_TIMER == 1) */


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

#if  (NXP_NFC_HCI_TIMER == 1)

static
void
phHciNfc_Response_Timeout (
                uint32_t resp_timer_id, void *pContext
                );

#endif /* (NXP_NFC_HCI_TIMER == 1) */

/**
 * \ingroup grp_hci_nfc
 *
 *  The phHciNfc_Send function sends the HCI Commands to the
 *  corresponding peripheral device, described by the HCI Context Structure.
 *
 *  \param[in]  psContext               psContext is the context of
 *                                      the HCI Layer.
 *  \param[in]  pHwRef                  pHwRef is the Information of
 *                                      the Device Interface Link .
 *  \param[in]  pdata                   Pointer to the buffer containing
 *                                      the command to be sent.
 *  \param[in] length                   Variable that receives
 *                                      the number of bytes actually sent.
 *
 *  \retval NFCSTATUS_PENDING           Command successfully sent.
 *  \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
 *                                      could not be interpreted properly.
 *  \retval Other errors                Errors related to the lower layers
 *
 */

static
 NFCSTATUS
 phHciNfc_Send(
                    void                    *psContext,
                    void                    *pHwRef,
                    uint8_t                 *pdata,
#ifdef ONE_BYTE_LEN
                    uint8_t                 length
#else
                    uint16_t                length
#endif
              );

 static
 NFCSTATUS
 phHciNfc_Process_HCP (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                      );


static
NFCSTATUS
phHciNfc_Process_Response (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                         );

static
NFCSTATUS
phHciNfc_Error_Response (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                         );

static
NFCSTATUS
phHciNfc_Process_Event (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                         );


static
NFCSTATUS
phHciNfc_Process_Command (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                         );


static
void
phHciNfc_Reset_Pipe_MsgInfo(
                            phHciNfc_Pipe_Info_t    *p_pipe_info
                        );

static
void
phHciNfc_Build_HCPMessage(
                                phHciNfc_HCP_Packet_t *hcp_packet,
                                uint8_t             msg_type,
                                uint8_t             instruction
                          );

static
void
phHciNfc_Build_HCPHeader(
                                phHciNfc_HCP_Packet_t *hcp_packet,
                                uint8_t             chainbit,
                                uint8_t             pipe_id
                          );
/**
 * \ingroup grp_hci_nfc
 *
 *  The phHciNfc_Receive_HCP function receive the HCI Host Control Packet
 *  Frames from the device.
 *
 *  \param[in]  psHciContext            psHciContext is the context of
 *                                      the HCI Layer.
 *  \param[in]  pHwRef                  pHwRef is the Information of
 *                                      the Device Interface Link .
 *  \param[in] pdata                    Pointer to the response buffer that
 *                                      receives the response read.
 *  \param[in] length                   Variable that receives
 *                                      the number of bytes read.
 *
 *  \retval NFCSTATUS_PENDING           HCP Frame receive pending.
 *  \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_Receive_HCP (
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            uint8_t                 *pdata,
#ifdef ONE_BYTE_LEN
                            uint8_t                 length
#else
                            uint16_t                length
#endif
                     );


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


#if  (NXP_NFC_HCI_TIMER == 1)

static
void
phHciNfc_Response_Timeout (
                    uint32_t resp_timer_id, void *pContext
                )
{
    phNfc_sCompletionInfo_t  comp_info = {0,0,0};

    if ( ( NULL != gpsHciContext)
            && (resp_timer_id == hci_resp_timer_id ))
    {
        pphNfcIF_Notification_CB_t  p_upper_notify =
            gpsHciContext->p_upper_notify;
        void                        *p_upper_context =
                                gpsHciContext->p_upper_context;
        phHal_sHwReference_t        *pHwRef = gpsHciContext->p_hw_ref;
		uint32_t				i = 0;


        HCI_DEBUG(" HCI TIMEOUT: HCI Response Timeout Occurred in %X Timer\n"
                                                                 ,resp_timer_id);
        /* Stop the Response Timer */
        phOsalNfc_Timer_Stop( hci_resp_timer_id );

		comp_info.status = PHNFCSTVAL(CID_NFC_HCI,
                        NFCSTATUS_BOARD_COMMUNICATION_ERROR);
        /* Roll Back to the Select State */
        phHciNfc_FSM_Rollback(gpsHciContext);

		for(i=0;i < PHHCINFC_MAX_PIPE; i++)
		{
			phHciNfc_Reset_Pipe_MsgInfo(gpsHciContext->p_pipe_list[i]);
		}

        /* Notify the Error/Success Scenario to the upper layer */
        phHciNfc_Notify( p_upper_notify, p_upper_context,
                    pHwRef, (uint8_t) NFC_NOTIFY_DEVICE_ERROR, &comp_info );
    }

    return ;

}

#endif /* (NXP_NFC_HCI_TIMER == 1) */



/*!
 * \brief Allocation of the HCI Interface resources.
 *
 * This function releases and frees all the resources used by HCI Command and
 * Response Mechanism
 */

 NFCSTATUS
 phHciNfc_Allocate_Resource (
                                void                **ppBuffer,
                                uint16_t            size
                            )
{
    NFCSTATUS           status = NFCSTATUS_SUCCESS;

    *ppBuffer = (void *) phOsalNfc_GetMemory(size);
    if( *ppBuffer != NULL )
    {
        (void )memset(((void *)*ppBuffer), 0,
                                    size);
    }
    else
    {
        *ppBuffer = NULL;
        status = PHNFCSTVAL(CID_NFC_HCI,
                        NFCSTATUS_INSUFFICIENT_RESOURCES);
    }
    return status;
}



/*!
 * \brief Release of the HCI Interface resources.
 *
 * This function releases and frees all the resources used by HCI Command and
 * Response Mechanism
 */
 void
 phHciNfc_Release_Resources (
                                phHciNfc_sContext_t **ppsHciContext
                            )
{
    uint8_t i = 0;


#if  (NXP_NFC_HCI_TIMER == 1)

    if ( NXP_INVALID_TIMER_ID != hci_resp_timer_id )
    {
        /* Stop and Un-Intialise the Response Timer */
        phOsalNfc_Timer_Stop( hci_resp_timer_id );
        phOsalNfc_Timer_Delete( hci_resp_timer_id );
        HCI_DEBUG(" HCI : Timer %X Stopped and Released\n",
                                            hci_resp_timer_id);
        hci_resp_timer_id = NXP_INVALID_TIMER_ID;
    }
    gpsHciContext = NULL;

#endif /* (NXP_NFC_HCI_TIMER == 1) */


    if(NULL != (*ppsHciContext)->p_admin_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_admin_info);
        (*ppsHciContext)->p_admin_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_link_mgmt_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_link_mgmt_info);
        (*ppsHciContext)->p_link_mgmt_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_identity_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_identity_info);
        (*ppsHciContext)->p_identity_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_device_mgmt_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_device_mgmt_info);
        (*ppsHciContext)->p_device_mgmt_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_reader_mgmt_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_reader_mgmt_info);
        (*ppsHciContext)->p_reader_mgmt_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_poll_loop_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_poll_loop_info);
        (*ppsHciContext)->p_poll_loop_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_reader_a_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_reader_a_info);
        (*ppsHciContext)->p_reader_a_info = NULL;
    }
#ifdef TYPE_B
    if(NULL !=(*ppsHciContext)->p_reader_b_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_reader_b_info);
        (*ppsHciContext)->p_reader_b_info = NULL;
    }
#endif
#ifdef TYPE_FELICA
    if(NULL !=(*ppsHciContext)->p_felica_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_felica_info);
        (*ppsHciContext)->p_felica_info = NULL;
    }
#endif
#ifdef TYPE_JEWEL
    if(NULL !=(*ppsHciContext)->p_jewel_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_jewel_info);
        (*ppsHciContext)->p_jewel_info = NULL;
    }
#endif
#ifdef  TYPE_ISO15693
    if(NULL !=(*ppsHciContext)->p_iso_15693_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_iso_15693_info);
        (*ppsHciContext)->p_iso_15693_info = NULL;
    }
#endif /* #ifdef    TYPE_ISO15693 */
#ifdef ENABLE_P2P
    if(NULL !=(*ppsHciContext)->p_nfcip_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_nfcip_info);
        (*ppsHciContext)->p_nfcip_info = NULL;
    }
#endif
    if(NULL !=(*ppsHciContext)->p_emulation_mgmt_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_emulation_mgmt_info);
        (*ppsHciContext)->p_emulation_mgmt_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_wi_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_wi_info);
        (*ppsHciContext)->p_wi_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_swp_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_swp_info);
        (*ppsHciContext)->p_swp_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_uicc_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_uicc_info);
        (*ppsHciContext)->p_uicc_info = NULL;
    }
#ifdef HOST_EMULATION
    if(NULL !=(*ppsHciContext)->p_ce_a_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_ce_a_info);
        (*ppsHciContext)->p_ce_a_info = NULL;
    }
    if(NULL !=(*ppsHciContext)->p_ce_b_info)
    {
        phOsalNfc_FreeMemory((*ppsHciContext)->p_ce_b_info);
        (*ppsHciContext)->p_ce_b_info = NULL;
    }
#endif

    for(i=0;i < PHHCINFC_MAX_PIPE; i++)
    {
        if(NULL != (*ppsHciContext)->p_pipe_list[i])
        {
            phOsalNfc_FreeMemory((*ppsHciContext)->p_pipe_list[i]);
        }
    }


    phOsalNfc_FreeMemory((*ppsHciContext));
    (*ppsHciContext) = NULL;

    return ;
}

static
void
phHciNfc_Reset_Pipe_MsgInfo(
                            phHciNfc_Pipe_Info_t    *p_pipe_info
                        )
{
    if (p_pipe_info != NULL)
    {
        p_pipe_info->sent_msg_type = HCP_MSG_TYPE_RESERVED;
        p_pipe_info->prev_msg = MSG_INSTRUCTION_UNKNWON;
        p_pipe_info->prev_status = NFCSTATUS_INVALID_HCI_INSTRUCTION;
        p_pipe_info->param_info = NULL;
        p_pipe_info->param_length = FALSE ;
    }
    return;
}


void
phHciNfc_Release_Lower(
                    phHciNfc_sContext_t         *psHciContext,
                    void                        *pHwRef
               )
{
    phNfc_sLowerIF_t            *plower_if =
                                    &(psHciContext->lower_interface);
    NFCSTATUS            status = NFCSTATUS_SUCCESS;

    PHNFC_UNUSED_VARIABLE(status);
    if(NULL != plower_if->release)
    {
        status = plower_if->release((void *)plower_if->pcontext,
                                        (void *)pHwRef);
        (void) memset((void *)plower_if, 0, sizeof(phNfc_sLowerIF_t));
        HCI_DEBUG(" HCI Releasing the Lower Layer Resources: Status = %02X\n"
                                                                    ,status);
    }

    return;
}



/*!
 * \brief Sends the HCI Commands to the corresponding peripheral device.
 *
 * This function sends the HCI Commands to the connected NFC Pheripheral device
 */
 static
 NFCSTATUS
 phHciNfc_Send (
                      void                  *psContext,
                      void                  *pHwRef,
                      uint8_t               *pdata,
#ifdef ONE_BYTE_LEN
                      uint8_t               length
#else
                      uint16_t              length
#endif
                     )
{
    phHciNfc_sContext_t     *psHciContext= (phHciNfc_sContext_t  *)psContext;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    phNfc_sLowerIF_t        *plower_if = &(psHciContext->lower_interface);

    if( (NULL != plower_if)
        && (NULL != plower_if->send)
      )
    {
        HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);
        HCI_DEBUG("HCI: Response Pending status --> %s \n",
            (psHciContext->response_pending)?"TRUE":"FALSE");
        HCI_PRINT_BUFFER("Send Buffer",pdata,length);
        /* psHciContext->hci_transact_state = NFC_TRANSACT_SEND_IN_PROGRESS; */

#if  (NXP_NFC_HCI_TIMER == 1)

    if (
        (TRUE != psHciContext->tx_hcp_chaining)
        &&  (TRUE == psHciContext->response_pending)
        && ( NXP_INVALID_TIMER_ID != hci_resp_timer_id )
       )
    {
        /* Start the HCI Response Timer */
        phOsalNfc_Timer_Start( hci_resp_timer_id,
                nxp_nfc_hci_response_timeout, phHciNfc_Response_Timeout, NULL );
        HCI_DEBUG(" HCI : Timer %X Started \n", hci_resp_timer_id);
    }

#endif /* (NXP_NFC_HCI_TIMER == 1) */

        status = plower_if->send((void *)plower_if->pcontext,
                                (void *)pHwRef, pdata, length);
    }

    return status;
}


/*!
 * \brief Receives the HCI Response from the corresponding peripheral device.
 *
 * This function receives the HCI Command Response to the connected NFC
 * Pheripheral device.
 */

NFCSTATUS
phHciNfc_Receive(
                        void                *psContext,
                        void                *pHwRef,
                        uint8_t             *pdata,
#ifdef ONE_BYTE_LEN
                        uint8_t             length
#else
                        uint16_t            length
#endif
                    )
{
    phHciNfc_sContext_t     *psHciContext= (phHciNfc_sContext_t  *)psContext;
    phNfc_sLowerIF_t *plower_if = NULL ;
    NFCSTATUS         status = NFCSTATUS_SUCCESS;

    if(NULL == psHciContext )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else
    {
        plower_if = &(psHciContext->lower_interface);

        if( (NULL != plower_if)
            && (NULL != plower_if->receive)
          )
        {
            /* psHciContext->hci_transact_state = NFC_TRANSACT_RECV_IN_PROGRESS; */
            status = plower_if->receive((void *)plower_if->pcontext,
                                    (void *)pHwRef, pdata, length);
        }
    }
    return status;
}


/*!
 * \brief Sends the HCP Packet to the lower link layer .
 *
 * This function Sends the HCI Data in the HCP packet format to the below
 * Link layer.
 */

 NFCSTATUS
 phHciNfc_Send_HCP (
                                phHciNfc_sContext_t *psHciContext,
                                void                *pHwRef
                   )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    phHciNfc_HCP_Packet_t   *tx_data = (phHciNfc_HCP_Packet_t *)
                                    psHciContext->send_buffer;
    /* Skip the HCP Header Byte initially */
    uint16_t                tx_length = psHciContext->tx_total - 1 ;
    uint16_t                hcp_index = HCP_ZERO_LEN;
    uint8_t                 pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
    static  uint8_t         chain_bit = HCP_CHAINBIT_DEFAULT;

    pipe_id =  (uint8_t) GET_BITS8( tx_data->hcp_header,
        HCP_PIPEID_OFFSET, HCP_PIPEID_LEN);

    /* Fragmentation of the HCP Frames */
    if ( tx_length > PHHCINFC_MAX_PACKET_DATA )
    {
        tx_data = &psHciContext->tx_packet;
        (void)memset((void *)tx_data, FALSE,
                        sizeof(phHciNfc_HCP_Packet_t));
        if (HCP_CHAINBIT_DEFAULT == chain_bit)
        {
            /* HCI Chaining Needs to be Done */
            psHciContext->tx_remain = tx_length;
            psHciContext->tx_hcp_frgmnt_index = HCP_ZERO_LEN ;
            chain_bit = HCP_CHAINBIT_BEGIN;
            /* Increment the Fragment index to skip the HCP Header */
            psHciContext->tx_hcp_frgmnt_index++;
            psHciContext->tx_hcp_chaining = TRUE ;
            tx_length = PHHCINFC_MAX_PACKET_DATA ;
        }
        else if ( psHciContext->tx_remain > PHHCINFC_MAX_PACKET_DATA )
        {
			/* Intermediate Chained HCI Frames */
            tx_length = PHHCINFC_MAX_PACKET_DATA ;
        }
        else
        {
            /* End of Chaining Reached */
            chain_bit = HCP_CHAINBIT_END;
            tx_length = psHciContext->tx_remain ;
            psHciContext->tx_hcp_chaining = FALSE ;
        }

        /* Build the HCP Header to have Chaining Enabled */
        phHciNfc_Build_HCPHeader(tx_data, chain_bit , pipe_id );

        phHciNfc_Append_HCPFrame((uint8_t *)tx_data->msg.payload, hcp_index,
            (&psHciContext->send_buffer[psHciContext->tx_hcp_frgmnt_index])
            , tx_length );
    }
    else
    {
        /* No Chaining Required */
        chain_bit = HCP_CHAINBIT_DEFAULT;

        psHciContext->tx_hcp_chaining = FALSE ;

        psHciContext->tx_remain = tx_length ;
    }

    /* Include the Skipped HCP Header Byte */
    tx_length++;

    status = phHciNfc_Send ( (void *) psHciContext, pHwRef,
                        (uint8_t *)tx_data, tx_length );

    return status;
}


/*!
 * \brief Receives the HCP Packet from the lower link layer .
 *
 * This function receives the HCI Data in the HCP packet format from the below
 * Link layer.
 */
 static
 NFCSTATUS
 phHciNfc_Receive_HCP (
                                phHciNfc_sContext_t *psHciContext,
                                void                *pHwRef,
                                uint8_t             *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t             length
#else
                                uint16_t            length
#endif
                   )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    phHciNfc_HCP_Packet_t   *packet = NULL;
    uint8_t                 chainbit = HCP_CHAINBIT_DEFAULT;
    uint16_t                hcp_index = 0;

    packet = (phHciNfc_HCP_Packet_t *)pdata;
    chainbit = (uint8_t) GET_BITS8( packet->hcp_header,
        HCP_CHAINBIT_OFFSET, HCP_CHAINBIT_LEN);
    hcp_index = psHciContext->rx_hcp_frgmnt_index;
    HCI_PRINT_BUFFER("Receive Buffer",((uint8_t *)pdata),length);
    if (HCP_CHAINBIT_BEGIN == chainbit)
    {
        /* pdata = (uint8_t *)&psHciContext->rx_packet; */
        /* De Fragmentation of the Received HCP Frames */
        /* Subsequent Chaining Frames */
        if( hcp_index  > 0 )
        {
            /* Copy the obtained fragment and receive the next fragment */
            phHciNfc_Append_HCPFrame(
                psHciContext->recv_buffer, hcp_index,
                    (uint8_t *)&pdata[HCP_MESSAGE_LEN],
                            (length - HCP_MESSAGE_LEN) );
            psHciContext->rx_hcp_frgmnt_index =(uint16_t)
                        (hcp_index + length - HCP_MESSAGE_LEN);
        }
        /* First Chaining Frame*/
        else
        {
            psHciContext->rx_hcp_chaining = TRUE ;
            /* Copy the obtained fragment and receive the next fragment */
            phHciNfc_Append_HCPFrame(psHciContext->recv_buffer,
                hcp_index, pdata, length);
            psHciContext->rx_hcp_frgmnt_index = ( hcp_index + length ) ;

        }
        status = phHciNfc_Receive ( (void *) psHciContext, pHwRef,
                                                pdata, length);
    }
    else
    {
        if(TRUE == psHciContext->rx_hcp_chaining)
        {
            /* If the chaining was done earlier */
            psHciContext->rx_hcp_chaining = FALSE ;
            /* Copy the Remaining buffer to the RX_BUFFER */
            phHciNfc_Append_HCPFrame(
                psHciContext->recv_buffer, hcp_index,
                    (uint8_t *)&pdata[HCP_MESSAGE_LEN],
                            (length - HCP_MESSAGE_LEN) );
            /* If there is chaining done the return the same data */
            psHciContext->rx_total =
                        (hcp_index + length - HCP_MESSAGE_LEN);
            psHciContext->rx_hcp_frgmnt_index = FALSE ;
        }
        else
        {
            (void) memcpy( psHciContext->recv_buffer, pdata, length);
            /* If there is no chaining done then return the same data */
            psHciContext->rx_total = (hcp_index + length);

        }
    }

    return status;
}


/*!
 * \brief Receives the HCP Packet from the lower link layer .
 *
 * This function receives the HCI Data in the HCP packet format from the below
 * Link layer.
 */

 static
 NFCSTATUS
 phHciNfc_Process_HCP (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t             length
#else
                                uint16_t            length
#endif
                      )
{
    phHciNfc_HCP_Packet_t   *packet = NULL;
    phHciNfc_HCP_Message_t  *message = NULL;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    uint8_t                 msg_type = 0;

    if( (NULL == pdata)
        || ( length < HCP_HEADER_LEN )
      )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else
    {
        status = phHciNfc_Receive_HCP( psHciContext, pHwRef, pdata, length );
    }/* End of the Valid Data Handling */

    if( NFCSTATUS_SUCCESS  == status )
    {
        packet = (phHciNfc_HCP_Packet_t *)psHciContext->recv_buffer;
        length =
#ifdef ONE_BYTE_LEN
            (uint8_t)
#endif
            psHciContext->rx_total ;
        message = &packet->msg.message;
        /* HCI_PRINT_BUFFER("Total Receive Buffer",((uint8_t *)pdata),length); */
        msg_type = (uint8_t) GET_BITS8( message->msg_header,
            HCP_MSG_TYPE_OFFSET, HCP_MSG_TYPE_LEN);
        switch ( msg_type )
        {
            case HCP_MSG_TYPE_RESPONSE:
            {
                status = phHciNfc_Process_Response( psHciContext,
                                                pHwRef, (void *)packet, length );
                break;
            }
            case HCP_MSG_TYPE_EVENT:
            {
                status = phHciNfc_Process_Event( psHciContext,
                                                pHwRef,(void *)packet, length );
                break;
            }
            case HCP_MSG_TYPE_COMMAND:
            {

                status = phHciNfc_Process_Command( psHciContext,
                                                pHwRef, (void *)packet, length );
                break;
            }
            /* case HCP_MSG_TYPE_RESERVED: */
            default:
            {
                status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
                break;
            }
        }
    }/* End of Receive HCP Status */
    return status;
}


 static
 NFCSTATUS
 phHciNfc_Process_Response (
                                 phHciNfc_sContext_t    *psHciContext,
                                 void                   *pHwRef,
                                 void                   *pdata,
#ifdef ONE_BYTE_LEN
                                 uint8_t             length
#else
                                 uint16_t            length
#endif
                             )
{
    phHciNfc_HCP_Packet_t   *packet = NULL;
    phHciNfc_HCP_Message_t  *message = NULL;
    uint8_t                 instruction=0;
    uint8_t                 pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
    phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;

    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    packet = (phHciNfc_HCP_Packet_t *)pdata;
    message = &packet->msg.message;
    /* Get the instruction bits from the Message Header */
    instruction = (uint8_t) GET_BITS8( message->msg_header,
                                HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
    /* Get the Pipe ID from the HCP Header */
    pipe_id =  (uint8_t) GET_BITS8( packet->hcp_header,
                                HCP_PIPEID_OFFSET, HCP_PIPEID_LEN);

#if  (NXP_NFC_HCI_TIMER == 1)

    if ( NXP_INVALID_TIMER_ID != hci_resp_timer_id )
    {
        /* Stop the HCI Response Timer */
        HCI_DEBUG(" HCI : Timer %X Stopped \n", hci_resp_timer_id);
        phOsalNfc_Timer_Stop( hci_resp_timer_id );
    }

#endif /* (NXP_NFC_HCI_TIMER == 1) */

    if (pipe_id >=  PHHCINFC_MAX_PIPE )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if( ((uint8_t) ANY_OK != instruction)
        && ( (pipe_id !=    PIPETYPE_STATIC_ADMIN )
        && ( ADM_CLEAR_ALL_PIPE != (psHciContext->p_pipe_list[pipe_id])->prev_msg ))
        )
    {
        status = phHciNfc_Error_Response( psHciContext, pHwRef, pdata, length );
    }
    else
    {
        p_pipe_info = psHciContext->p_pipe_list[pipe_id];
        if( ( NULL != p_pipe_info )
            &&   ( HCP_MSG_TYPE_COMMAND == p_pipe_info->sent_msg_type  )
            &&   ( NULL != p_pipe_info->recv_resp )
        )
        {
            status = psHciContext->p_pipe_list[pipe_id]->recv_resp( psHciContext,
                                                            pHwRef, pdata, length );
        }
        else
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
        }
        /* There is no Pending Response */
        psHciContext->response_pending = FALSE ;
        HCI_DEBUG("HCI: Response Pending status --> FALSE, %s \n",
            __FUNCTION__);
        if( NFCSTATUS_SUCCESS == status )
        {
            phHciNfc_Reset_Pipe_MsgInfo(psHciContext->p_pipe_list[pipe_id]);
            status = phHciNfc_Resume_Sequence(psHciContext, pHwRef);

        }/* End of Success Status validation */
        else
        {
            HCI_DEBUG("HCI: Status --> %X \n", status );
        }

    } /* End of the Valid Response handling */
    return status;
}


static
 NFCSTATUS
 phHciNfc_Error_Response (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                         )
{

    phHciNfc_HCP_Packet_t   *packet = (phHciNfc_HCP_Packet_t *)pdata;
    phHciNfc_HCP_Message_t  *message = &packet->msg.message;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    uint8_t                 pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
#if defined(HCI_TRACE) || defined (ERROR_INSTRUCTION)
    uint8_t                 instruction = 0;
    instruction = (uint8_t) GET_BITS8(message->msg_header,
                            HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
#endif

    /* Get the Pipe ID from the HCP Header */
    pipe_id =  (uint8_t) GET_BITS8( packet->hcp_header,
                                HCP_PIPEID_OFFSET, HCP_PIPEID_LEN);
    /* Process the Error Response based on the obtained instruction */
#ifdef ERROR_INSTRUCTION
    switch(instruction)
    {
        case ANY_E_NOT_CONNECTED:
        case ANY_E_CMD_PAR_UNKNOWN:
        case ANY_E_NOK:
        case ANY_E_PIPES_FULL:
        case ANY_E_REG_PAR_UNKNOWN:
        case ANY_E_PIPE_NOT_OPENED:
        case ANY_E_CMD_NOT_SUPPORTED:
        case ANY_E_TIMEOUT:
        case ANY_E_REG_ACCESS_DENIED:
        case ANY_E_PIPE_ACCESS_DENIED:
        {
            /* Receive Error Notification to the Upper Layer */
            status = PHNFCSTVAL( CID_NFC_HCI, \
                            message->msg_header);
            phHciNfc_Error_Sequence(psHciContext, pHwRef, status , pdata, length );
            /* Return Success as the Error Sequence is already handled */
            psHciContext->response_pending = FALSE ;
            HCI_DEBUG("HCI: Response Pending status --> FALSE, %s \n",
            __FUNCTION__);
            status = NFCSTATUS_SUCCESS;
            break;
        }
            /* The Statement should not reach this case */
        /* case ANY_OK: */
        default:
        {
            /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE); */
            break;
        }
    }
#else
    status = PHNFCSTVAL( CID_NFC_HCI, message->msg_header);
    HCI_DEBUG("HCI Error Response(%u) from the Device \n", instruction);
    psHciContext->response_pending = FALSE ;
    HCI_DEBUG("HCI: Response Pending status --> FALSE, %s \n",
        __FUNCTION__);
    phHciNfc_Reset_Pipe_MsgInfo(psHciContext->p_pipe_list[pipe_id]);
    phHciNfc_Error_Sequence(psHciContext, pHwRef, status , pdata, (uint8_t) length );
    /* Return Success as the Error Sequence is already handled */
    status = NFCSTATUS_SUCCESS;
#endif

    return status;
}


static
 NFCSTATUS
 phHciNfc_Process_Event (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                        )
{
    phHciNfc_HCP_Packet_t   *packet = NULL;
    phHciNfc_HCP_Message_t  *message = NULL;
    phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;
    uint8_t                 instruction=0;
    uint8_t                 pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;

    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    packet = (phHciNfc_HCP_Packet_t *)pdata;
    message = &packet->msg.message;
    /* Get the instruction bits from the Message Header */
    PHNFC_UNUSED_VARIABLE(instruction);
    instruction = (uint8_t) GET_BITS8( message->msg_header,
                                HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
    /* Get the Pipe ID from the HCP Header */
    pipe_id =  (uint8_t) GET_BITS8( packet->hcp_header,
                                HCP_PIPEID_OFFSET, HCP_PIPEID_LEN);

    if (pipe_id >=  PHHCINFC_MAX_PIPE )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else
    {
        p_pipe_info = psHciContext->p_pipe_list[pipe_id];
    }

    if( (p_pipe_info != NULL ) )
    {
        if( NULL != p_pipe_info->recv_event)
        {
            status = p_pipe_info->recv_event( psHciContext, pHwRef,
                                                        pdata, length );
        }
        else
        {
            HCI_DEBUG(" Event Handling Not Supported by the #%u Pipe \n",
                                                        pipe_id);
            status = PHNFCSTVAL(CID_NFC_HCI,
                                        NFCSTATUS_FEATURE_NOT_SUPPORTED);
        }
    }
    else
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }

    HCI_DEBUG("HCI: In Function: %s \n",
        __FUNCTION__);
    HCI_DEBUG("HCI: Response Pending status --> %s \n",
        (psHciContext->response_pending)?"TRUE":"FALSE");
    HCI_DEBUG("HCI: Event Pending status --> %s \n",
        (psHciContext->event_pending)?"TRUE":"FALSE");

        if ((TRUE == psHciContext->response_pending)
        || (TRUE == psHciContext->event_pending))
    {
        (void)memset(psHciContext->recv_buffer,
            FALSE, PHHCINFC_MAX_BUFFERSIZE);
        (void)memset((void *)&psHciContext->rx_packet,
            FALSE, sizeof(phHciNfc_HCP_Packet_t));

        /* Reset the Received Data Index */
        psHciContext->rx_index = ZERO;
        /* Reset the size of the total response data received */
        psHciContext->rx_total = ZERO;

        /* psHciContext->hci_transact_state = NFC_TRANSACT_SEND_COMPLETE;*/
        /* Receive the Response Packet */

        status = phHciNfc_Receive( psHciContext, pHwRef,
                    (uint8_t *)(&psHciContext->rx_packet),
                    sizeof(phHciNfc_HCP_Packet_t) );

        /* HCI_DEBUG("HCI Lower Layer Send Completion After Receive,\
        Status = %02X\n",status); */
    }
    else
    {
        if(
/* #define EVENT_NOTIFY */
#ifndef EVENT_NOTIFY
            ( NFCSTATUS_SUCCESS == status  )
            || ( NFCSTATUS_RF_TIMEOUT == status  )
            || (( NFCSTATUS_MORE_INFORMATION == status  )
#else
            ((FALSE == psHciContext->event_pending )
#endif
            && ( pipe_id <= PHHCINFC_MAX_PIPE ))
            )
        {
            /* phHciNfc_Reset_Pipe_MsgInfo(psHciContext->p_pipe_list[pipe_id]); */
            status = phHciNfc_Resume_Sequence(psHciContext, pHwRef);

        }/* End of Success Status validation */
        else
        {
            HCI_DEBUG(" HCI: Pipe-ID --> %02X  \n", pipe_id);
            HCI_DEBUG(" HCI: PROCESS EVENT - Pending/Invalid Status : %X\n", status);
        }
    }

    return status;
}

static
 NFCSTATUS
 phHciNfc_Process_Command (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                void                    *pdata,
#ifdef ONE_BYTE_LEN
                                uint8_t                 length
#else
                                uint16_t                length
#endif
                             )
{
    phHciNfc_HCP_Packet_t   *packet = NULL;
    phHciNfc_HCP_Message_t  *message = NULL;
    phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;
    uint8_t                 instruction=0;
    uint8_t                 pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;

    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    packet = (phHciNfc_HCP_Packet_t *)pdata;
    message = &packet->msg.message;
    /* Get the instruction bits from the Message Header */
    PHNFC_UNUSED_VARIABLE(instruction);

    instruction = (uint8_t) GET_BITS8( message->msg_header,
                                HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
    /* Get the Pipe ID from the HCP Header */
    pipe_id =  (uint8_t) GET_BITS8( packet->hcp_header,
                                HCP_PIPEID_OFFSET, HCP_PIPEID_LEN);
    if (pipe_id >=  PHHCINFC_MAX_PIPE )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else
    {
        p_pipe_info = psHciContext->p_pipe_list[pipe_id];
    }

    if( (p_pipe_info != NULL )
        )
    {
        if( NULL != p_pipe_info->recv_cmd)
        {
            status = p_pipe_info->recv_cmd( psHciContext,   pHwRef,
                                                        pdata, length );
        }
        else
        {
            HCI_DEBUG(" Command Handling Not Supported by the #%u Pipe \n",
                                                        pipe_id);
            status = PHNFCSTVAL(CID_NFC_HCI,
                                        NFCSTATUS_FEATURE_NOT_SUPPORTED);
        }
    }
    else
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }

    HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);
    HCI_DEBUG("HCI: Response Pending status --> %s \n",
        (psHciContext->response_pending)?"TRUE":"FALSE");

    if(( NFCSTATUS_SUCCESS == status )
        && (TRUE != psHciContext->response_pending)
        )
    {
        /* Reset the Pipe Information Stored in the particular Pipe */
        /* phHciNfc_Reset_Pipe_MsgInfo(psHciContext->p_pipe_list[pipe_id]); */
        /* Resume the Execution Sequence */
        status = phHciNfc_Resume_Sequence(psHciContext, pHwRef);

    }/* End of Success Status validation */

    return status;
}


static
void
phHciNfc_Build_HCPMessage(
                                phHciNfc_HCP_Packet_t *hcp_packet,
                                uint8_t             msg_type,
                                uint8_t             instruction
                          )
{
    phHciNfc_HCP_Message_t  *hcp_message = NULL;

    hcp_message = &(hcp_packet->msg.message);
    /* Set the type to the provided message type in the HCP Message Header */
    hcp_message->msg_header = (uint8_t) SET_BITS8(hcp_message->msg_header,HCP_MSG_TYPE_OFFSET,
                HCP_MSG_TYPE_LEN, msg_type);
    /* Set the instruction to the kind of instruction in the HCP Message Header */
    hcp_message->msg_header  = (uint8_t) SET_BITS8(hcp_message->msg_header,HCP_MSG_INSTRUCTION_OFFSET,
                HCP_MSG_INSTRUCTION_LEN, instruction);
    /* hcp_message->msg_header = hcp_message->msg_header | temp ; */

}


static
void
phHciNfc_Build_HCPHeader(
                                phHciNfc_HCP_Packet_t *hcp_packet,
                                uint8_t             chainbit,
                                uint8_t             pipe_id
                          )
{
    /* Set the Chaining bit to the default type */
    hcp_packet->hcp_header = (uint8_t) SET_BITS8(hcp_packet->hcp_header,
                HCP_CHAINBIT_OFFSET, HCP_CHAINBIT_LEN, chainbit);
    /* Populate the Pipe ID to the HCP Header */
    hcp_packet->hcp_header  = (uint8_t) SET_BITS8(hcp_packet->hcp_header,HCP_PIPEID_OFFSET,
                HCP_PIPEID_LEN, pipe_id);

}

/*!
 * \brief Builds the HCP Frame Packet.
 *
 * This function builds the HCP Frame in the HCP packet format to send to the
 * connected reader device.
 */

void
 phHciNfc_Build_HCPFrame (
                                phHciNfc_HCP_Packet_t *hcp_packet,
                                uint8_t             chainbit,
                                uint8_t             pipe_id,
                                uint8_t             msg_type,
                                uint8_t             instruction
                          )
{
    /* Fills the HCP Header in the packet */
    phHciNfc_Build_HCPHeader( hcp_packet,chainbit,pipe_id );
    /* Fills the HCP Message in the packet */
    phHciNfc_Build_HCPMessage( hcp_packet,msg_type,instruction );
}

/*!
 * \brief Appends the HCP Frame Packet.
 *
 * This function Appends the HCP Frame of the HCP packet to complete the
 * entire HCP Packet.
 */

void
 phHciNfc_Append_HCPFrame (
/*                              phHciNfc_sContext_t     *psHciContext, */
                                uint8_t                 *hcp_data,
                                uint16_t                hcp_index,
                                uint8_t                 *src_data,
                                uint16_t                src_len
                          )
{
    uint16_t src_index = 0;
    if( (NULL != src_data)
        /* && (hcp_index >= 0) */
        && (src_len > 0)
        )
    {
        for(src_index=0; src_index < src_len ; src_index++)
        {
            hcp_data[hcp_index + src_index] = src_data[src_index];
        }
    }
    return;
}


/*!
 * \brief Sends the Generic HCI Commands to the connected reader device.
 *
 * This function Sends the Generic HCI Command frames in the HCP packet format to the
 * connected reader device.
 */

 NFCSTATUS
 phHciNfc_Send_Generic_Cmd (
                                phHciNfc_sContext_t *psHciContext,
                                void                *pHwRef,
                                uint8_t             pipe_id,
                                uint8_t             cmd
                    )
 {
    phHciNfc_HCP_Packet_t   *hcp_packet = NULL;
    phHciNfc_HCP_Message_t  *hcp_message = NULL;
    phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;
    uint16_t                 length = 0;
    uint16_t                 i=0;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    if((NULL == psHciContext)
        || ( pipe_id > PHHCINFC_MAX_PIPE)
        ||(NULL == psHciContext->p_pipe_list[pipe_id])
      )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
        HCI_DEBUG("%s: Invalid Arguments passed \n",
                                                "phHciNfc_Send_Generic_Cmd");
    }
    else
    {
        p_pipe_info = (phHciNfc_Pipe_Info_t *)
                                psHciContext->p_pipe_list[pipe_id];
        psHciContext->tx_total = 0 ;
        length +=  HCP_HEADER_LEN ;
        switch( cmd )
        {
            case ANY_SET_PARAMETER:
            {

                hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
                /* Construct the HCP Frame */
                phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
                                        (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
                hcp_message = &(hcp_packet->msg.message);
                hcp_message->payload[i++] = p_pipe_info->reg_index ;
                phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
                                            i, (uint8_t *)p_pipe_info->param_info,
                                            p_pipe_info->param_length);
                length =(uint16_t)(length + i + p_pipe_info->param_length);
                break;
            }
            case ANY_GET_PARAMETER:
            {

                hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
                /* Construct the HCP Frame */
                phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
                                        (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
                hcp_message = &(hcp_packet->msg.message);
                hcp_message->payload[i++] = p_pipe_info->reg_index ;
                length =(uint16_t)(length + i);
                break;
            }
            case ANY_OPEN_PIPE:
            case ANY_CLOSE_PIPE:
            {

                hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
                /* Construct the HCP Frame */
                phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
                                        (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
                break;
            }
            default:
            {
                status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED );
                HCI_DEBUG("%s: Statement Should Not Occur \n","phHciNfc_Send_Generic_Cmd");
                break;
            }
        }
        if( NFCSTATUS_SUCCESS == status )
        {
            p_pipe_info->sent_msg_type = HCP_MSG_TYPE_COMMAND;
            p_pipe_info->prev_msg = cmd;
            psHciContext->tx_total = length;
            psHciContext->response_pending = TRUE ;
            /* Send the Constructed HCP packet to the lower layer */
            status = phHciNfc_Send_HCP( psHciContext, pHwRef );
            p_pipe_info->prev_status = NFCSTATUS_PENDING;
        }
    }

    return status;
}


/*!
 * \brief Sets the parameter of the registers in a particular Pipe.
 *
 * This function configures the registers in a particular Pipe.
 */

NFCSTATUS
phHciNfc_Set_Param (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                phHciNfc_Pipe_Info_t    *p_pipe_info,
                                uint8_t                 reg_index,
                                void                    *p_param,
                                uint16_t                 param_length
                    )
 {
    NFCSTATUS               status = NFCSTATUS_SUCCESS ;

    if( (NULL == p_pipe_info)
        || (NULL == p_param)
        || (0 == param_length)
        )
    {
        status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION );
    }
    else
    {
        p_pipe_info->param_info = (uint8_t *)p_param;
        p_pipe_info->param_length =  param_length;
        p_pipe_info->reg_index = reg_index;
        status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
            (uint8_t)p_pipe_info->pipe.pipe_id,
                (uint8_t)ANY_SET_PARAMETER);
        p_pipe_info->prev_status = status;
    }

    return status;
 }


#if 0
 /*!
 * \brief Gets the parameter of the registers in a particular Pipe.
 *
 * This function configures the registers in a particular Pipe.
 */

 NFCSTATUS
 phHciNfc_Get_Param (
                                phHciNfc_sContext_t     *psHciContext,
                                void                    *pHwRef,
                                phHciNfc_Pipe_Info_t    *p_pipe_info,
                                uint8_t                 reg_index,
                    )
 {
    NFCSTATUS               status = NFCSTATUS_SUCCESS ;

    return status;
 }
#endif


void
phHciNfc_Send_Complete (
                                void                    *psContext,
                                void                    *pHwRef,
                                phNfc_sTransactionInfo_t *pInfo
                       )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS ;
    uint16_t                length = 0;

    HCI_PRINT("HCI Send Completion....\n");
    if ( (NULL != psContext)
        && (NULL != pInfo)
        && (NULL != pHwRef)
        )
    {
        phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;
        status = pInfo->status ;
        length = pInfo->length ;
        /* HCI_DEBUG("HCI Lower Layer Send Completion Before Receive,\
                                                Status = %02X\n",status); */
        if(status != NFCSTATUS_SUCCESS)
        {
            /* Handle the Error Scenario */
            (void)memset(psHciContext->send_buffer,
                                            FALSE, PHHCINFC_MAX_BUFFERSIZE);
            /* psHciContext->hci_transact_state = NFC_TRANSACT_COMPLETE;*/
            phHciNfc_Error_Sequence( psHciContext, pHwRef, status, NULL, 0 );
        }
        else
        {
	        HCI_DEBUG("HCI Send Completion... Length = %02X\n", length);
            /* To complete the send complete with the send
             * or receive with chaining.
             */
            if( (TRUE == psHciContext->tx_hcp_chaining)
                &&( psHciContext->tx_remain > HCP_ZERO_LEN ))
            {
                /* Skip the HCP Header Byte Sent */
                psHciContext->tx_remain -= length - 1;

                /* Skip the HCP Header Byte Sent */
                psHciContext->tx_hcp_frgmnt_index += length - 1;

                /* Send the Remaining HCP Data Frames */
                status = phHciNfc_Send_HCP( psHciContext, pHwRef );

                HCI_DEBUG("HCI (Chaining) Send Resume: Status = %02X\n", status);

                if( ( NFCSTATUS_SUCCESS != status )
                    && (NFCSTATUS_PENDING != status )
                    )
                {
                    phHciNfc_Error_Sequence( psHciContext, pHwRef, status, NULL, 0 );
                }/* End of the Status check */
            }
            else
            {
                psHciContext->tx_total = HCP_ZERO_LEN ;
                psHciContext->tx_remain = HCP_ZERO_LEN ;
                psHciContext->tx_hcp_frgmnt_index = HCP_ZERO_LEN ;
                HCI_DEBUG("HCI: %s: response_pending=%s, event_pending=%s",
                        __FUNCTION__,
                        (psHciContext->response_pending)?"TRUE":"FALSE",
                        (psHciContext->event_pending)?"TRUE":"FALSE"
                         );
                if ((TRUE == psHciContext->response_pending)
                    || (TRUE == psHciContext->event_pending))
                {
                    (void) memset(psHciContext->recv_buffer,
                        FALSE, PHHCINFC_MAX_BUFFERSIZE);
                    (void) memset((void *)&psHciContext->rx_packet,
                        FALSE, sizeof(phHciNfc_HCP_Packet_t));

                    /* Reset the Received Data Index */
                    psHciContext->rx_index = ZERO;
                    /* Reset the size of the total response data received */
                    psHciContext->rx_total = ZERO;

                    /* psHciContext->hci_transact_state = NFC_TRANSACT_SEND_COMPLETE;*/
                    /* Receive the Response Packet */
                    status = phHciNfc_Receive( psHciContext, pHwRef,
                                (uint8_t *)(&psHciContext->rx_packet),
                                sizeof(phHciNfc_HCP_Packet_t) );

                    /* HCI_DEBUG("HCI Lower Layer Send Completion After Receive,\
                    Status = %02X\n",status); */

                    if( ( NFCSTATUS_SUCCESS != status )
                         && (NFCSTATUS_PENDING != status )
                        )
                    {
                        phHciNfc_Error_Sequence( psHciContext, pHwRef, status, NULL, 0 );
                    }/* End of the Status check */
                }
                else
                {
                    status = phHciNfc_Resume_Sequence(psHciContext, pHwRef );
                }
            }

        } /* End of status != Success */

    } /* End of Context != NULL  */
}


void
phHciNfc_Receive_Complete (
                                void                    *psContext,
                                void                    *pHwRef,
                                phNfc_sTransactionInfo_t *pInfo
                                )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS ;
    void                    *pdata = NULL ;
    uint16_t                length = 0 ;

    HCI_PRINT("HCI Receive Completion....\n");
    if ( (NULL != psContext)
        && (NULL != pInfo)
        && (NULL != pHwRef)
        )
    {
        phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;

        status = pInfo->status ;
        pdata = pInfo->buffer ;
        length = pInfo->length ;
        HCI_DEBUG("HCI Lower Layer Receive Completion, Status = %02X\n",status);
        if( NFCSTATUS_SUCCESS != status )
        {
            /* Handle the Error Scenario */
            /* psHciContext->hci_transact_state = NFC_TRANSACT_COMPLETE; */
            phHciNfc_Error_Sequence(psHciContext, pHwRef, status , pdata, (uint8_t)length );
        }
        else
        {
             /* Receive the remaining Response Packet */
            /* psHciContext->hci_transact_state = NFC_TRANSACT_RECV_COMPLETE; */
            status = phHciNfc_Process_HCP( psHciContext, pHwRef, pdata,(uint8_t) length );
            if( ( NFCSTATUS_SUCCESS != status )
                && (NFCSTATUS_PENDING != status )
              )
            {
                phHciNfc_Error_Sequence(psHciContext, pHwRef, status , pdata, (uint8_t) length );
            }
        }
    }
}

void
phHciNfc_Notify(
                    pphNfcIF_Notification_CB_t  p_upper_notify,
                    void                        *p_upper_context,
                    void                        *pHwRef,
                    uint8_t                     type,
                    void                        *pInfo
               )
{
    if( ( NULL != p_upper_notify) )
    {
        /* Notify the to the Upper Layer */
        (p_upper_notify)(p_upper_context, pHwRef, type, pInfo);
    }

}


void
phHciNfc_Tag_Notify(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            uint8_t                 type,
                            void                    *pInfo
               )
{
    phNfc_sCompletionInfo_t *psCompInfo =
                                (phNfc_sCompletionInfo_t *)pInfo;
    pphNfcIF_Notification_CB_t  p_upper_notify = psHciContext->p_upper_notify;
    void                        *pcontext = psHciContext->p_upper_context;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    switch( psHciContext->hci_state.next_state )
    {
        case hciState_Activate:
        {
            /* Roll Back to the Select State */
            phHciNfc_FSM_Rollback(psHciContext);
            break;
        }
        case hciState_Select:
        {
            status = phHciNfc_FSM_Complete(psHciContext);
            break;
        }
        default:
        {
            /* Roll Back to the Select State */
            phHciNfc_FSM_Rollback(psHciContext);
            break;
        }

    }

    if(NFCSTATUS_SUCCESS == status )
    {
            /* Notify the Tag Events to the Upper layer */
        phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
                                type, psCompInfo);
    }
    else
    {
        phHciNfc_Error_Sequence( psHciContext, pHwRef, status, NULL, 0 );
    }
}


void
phHciNfc_Target_Select_Notify(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            uint8_t                 type,
                            void                    *pInfo
               )
{
    phNfc_sCompletionInfo_t *psCompInfo =
                                (phNfc_sCompletionInfo_t *)pInfo;
    pphNfcIF_Notification_CB_t  p_upper_notify = psHciContext->p_upper_notify;
    void                        *pcontext = psHciContext->p_upper_context;
    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    switch( psHciContext->hci_state.next_state )
    {
        case hciState_Listen:
        {
            /* Roll Back to the Select State */
            status = phHciNfc_FSM_Complete(psHciContext);
            break;
        }
        case hciState_Select:
        {
            status = phHciNfc_FSM_Complete(psHciContext);
            break;
        }
        default:
        {
            /* Roll Back to the Select State */
            phHciNfc_FSM_Rollback(psHciContext);
            break;
        }

    }

    if(NFCSTATUS_SUCCESS == status )
    {
            /* Notify the Tag Events to the Upper layer */
        phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
                                type, psCompInfo);
    }
    else
    {
        phHciNfc_Error_Sequence( psHciContext, pHwRef, status, NULL, 0 );
    }

}




void
phHciNfc_Release_Notify(
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef,
                            uint8_t                 type,
                            void                    *pInfo
               )
{
    phNfc_sCompletionInfo_t *psCompInfo =
                                (phNfc_sCompletionInfo_t *)pInfo;
    pphNfcIF_Notification_CB_t  p_upper_notify = psHciContext->p_upper_notify;
    void                        *pcontext = psHciContext->p_upper_context;
    phHciNfc_Release_Resources( &psHciContext );
        /* Notify the Failure to the Upper Layer */
    phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
                            type, psCompInfo);
}


void
phHciNfc_Notify_Event(
                            void                    *psContext,
                            void                    *pHwRef,
                            uint8_t                 type,
                            void                    *pInfo
                    )
{
    NFCSTATUS            status = NFCSTATUS_SUCCESS;

    if ( (NULL != psContext)
        && (NULL != pInfo)
        && (NULL != pHwRef)
        )
    {
        phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;

        /* Process based on the Notification type */
        switch(type)
        {
            case NFC_NOTIFY_INIT_COMPLETED:
            {
                phNfc_sCompletionInfo_t *psCompInfo =
                                            (phNfc_sCompletionInfo_t *)pInfo;
                if(NFCSTATUS_SUCCESS == psCompInfo->status)
                {

#if  (NXP_NFC_HCI_TIMER == 1)
                    if ( NXP_INVALID_TIMER_ID == hci_resp_timer_id )
                    {
                        /* Create and Intialise the Response Timer */
                        hci_resp_timer_id = phOsalNfc_Timer_Create( );
                        HCI_DEBUG(" HCI : Timer %X Created \n",
                                                            hci_resp_timer_id);
                    }
                    else
                    {
                        HCI_DEBUG(" HCI : Timer Already Created, Timer ID : %X\n",
                                                                hci_resp_timer_id);
                    }
                    gpsHciContext = psHciContext;

#endif /* (NXP_NFC_HCI_TIMER == 1) */

                     /* Complete the Initialisation Sequence */
                    status = phHciNfc_Resume_Sequence(psContext ,pHwRef);
                }
                else
                {
                    /* Notify the Error Scenario to the Upper Layer */
                    phHciNfc_Notify(psHciContext->p_upper_notify,
                                    psHciContext->p_upper_context, pHwRef,
                                            NFC_NOTIFY_ERROR, psCompInfo);
                }
                break;
            }
            case NFC_NOTIFY_INIT_FAILED:
            {
                 /* Notify the Failure to the Upper Layer */
                phHciNfc_Release_Notify( psContext,pHwRef,
                                        type, pInfo );
                break;
            }
            case NFC_NOTIFY_RECV_COMPLETED:
            {
                /* Receive Completed from the Lower Layer */
                phHciNfc_Receive_Complete(psContext,pHwRef,pInfo);

                break;
            }
            case NFC_NOTIFY_SEND_COMPLETED:
            {
                /* Receive Completed from the Lower Layer */
                phHciNfc_Send_Complete(psContext,pHwRef,pInfo);

                break;
            }
            case NFC_NOTIFY_TRANSCEIVE_COMPLETED:
            {
                /* TODO: TO handle Both Send and Receive Complete */
                break;
            }
            case NFC_NOTIFY_TARGET_DISCOVERED:
            {
                HCI_PRINT(" PICC Discovery ! Obtain PICC Info .... \n");
                /* psHciContext->hci_seq = PL_DURATION_SEQ; */
                if ( hciState_Unknown == psHciContext->hci_state.next_state )
                {

                    status = phHciNfc_FSM_Update ( psHciContext, hciState_Select );


                    if (NFCSTATUS_SUCCESS != status)
                    {
                       status = phHciNfc_ReaderMgmt_Deselect(
                            psHciContext, pHwRef, phHal_eISO14443_A_PICC, FALSE);
                    }
                }
                else
                {
#ifdef SW_RELEASE_TARGET
                    /*status = phHciNfc_ReaderMgmt_Deselect(
                        psHciContext, pHwRef, phHal_eISO14443_A_PICC, FALSE); */
                    psHciContext->target_release = TRUE;
#else
                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
#endif
                }
                break;
            }
            /* To Notify the Target Released Notification
             * to the Above Layer */
            case NFC_NOTIFY_TARGET_RELEASED:
            /* To Notify the NFC Secure Element Transaction
             * Information to the Above Layer */
            /* case NFC_NOTIFY_TRANSACTION: */
            /* To Notify the Generic Events To the Upper
             * Layer */
            case NFC_NOTIFY_EVENT:
            /* To Notify the Data Receive  Notification
             * to the Above Layer */
            case NFC_NOTIFY_RECV_EVENT:
            {
                phNfc_sCompletionInfo_t *psCompInfo =
		                (phNfc_sCompletionInfo_t *)pInfo;

                if (((TRUE == psHciContext->event_pending) ||
                    (NFCSTATUS_RF_TIMEOUT == psCompInfo->status))
                    && ( hciState_Transact == psHciContext->hci_state.next_state))
                {
                    /* Rollback due to Transmission Error */
                    phHciNfc_FSM_Rollback(psHciContext);
                }
                psHciContext->event_pending = FALSE;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                                type, pInfo);
                break;
            }
            case NFC_NOTIFY_DEVICE_ACTIVATED:
            {
                HCI_PRINT("  Device Activated! Obtaining Remote Reader Info .... \n");
                if ( hciState_Unknown == psHciContext->hci_state.next_state )
                {
                    switch (psHciContext->host_rf_type)
                    {
                        case phHal_eISO14443_A_PCD:
                        case phHal_eISO14443_B_PCD:
                        case phHal_eISO14443_BPrime_PCD:
                        case phHal_eFelica_PCD:
                        {
                            break;
                        }
                        case phHal_eNfcIP1_Initiator:
                        case phHal_eNfcIP1_Target:
                        {
                            break;
                        }
                        case phHal_eUnknown_DevType:
                        default:
                        {
                            status = PHNFCSTVAL(CID_NFC_HCI,
                                        NFCSTATUS_INVALID_PARAMETER);
                            break;
                        }

                    }
                    status = phHciNfc_FSM_Update ( psHciContext, hciState_Listen );
                }
                else
                {
                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
                }
                break;
            }
            case NFC_NOTIFY_DEVICE_DEACTIVATED:
            {
                HCI_PRINT(" Device De-Activated! \n");
                if ( hciState_Unknown == psHciContext->hci_state.next_state )
                {
                    status = phHciNfc_FSM_Update ( psHciContext, hciState_Initialise );
                    if(NFCSTATUS_SUCCESS == status)
                    {
                        /* Complete to the Select State */
                        status = phHciNfc_FSM_Complete(psHciContext);
                    }
                    else
                    {
                        HCI_PRINT(" Device Deactivated.. But Invalid State \n");
                        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
                    }
                }
                else
                {
                    status = phHciNfc_ReaderMgmt_Update_Sequence(
                                                psHciContext, INFO_SEQ );

                    if(( hciState_Listen == psHciContext->hci_state.next_state)
                        || (hciState_Transact == psHciContext->hci_state.next_state))
                    {
                        psHciContext->hci_state.next_state = hciState_Initialise;
                        /* Roll Back to the Default State */
                        status = phHciNfc_FSM_Complete(psHciContext);
                    }
                }
                psHciContext->event_pending = FALSE;
                phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            NFC_NOTIFY_EVENT, pInfo);
                break;
            }
            case NFC_NOTIFY_DEVICE_ERROR:
            {
                phNfc_sCompletionInfo_t *psCompInfo =
                                            (phNfc_sCompletionInfo_t *)pInfo;

                psCompInfo->status = ( NFCSTATUS_BOARD_COMMUNICATION_ERROR
                                        != PHNFCSTATUS(psCompInfo->status))?
                                            NFCSTATUS_BOARD_COMMUNICATION_ERROR:
                                                psCompInfo->status ;

#if  (NXP_NFC_HCI_TIMER == 1)

                if ( NXP_INVALID_TIMER_ID != hci_resp_timer_id )
                {
                    HCI_DEBUG(" HCI : Response Timer Stop, Status:%02X",
                                                          psCompInfo->status);
                    /* Stop and Un-Intialise the Response Timer */
                    phOsalNfc_Timer_Stop( hci_resp_timer_id );
                }

#endif /* (NXP_NFC_HCI_TIMER == 1) */

                phHciNfc_Notify(psHciContext->p_upper_notify,
                            psHciContext->p_upper_context, pHwRef,
                            (uint8_t) NFC_NOTIFY_DEVICE_ERROR, pInfo);

                break;
            }

            case NFC_NOTIFY_ERROR:
            default:
            {
                phNfc_sCompletionInfo_t *psCompInfo =
                                            (phNfc_sCompletionInfo_t *)pInfo;

#if  (NXP_NFC_HCI_TIMER == 1)

                if (( NFCSTATUS_BOARD_COMMUNICATION_ERROR == PHNFCSTATUS(psCompInfo->status))
                        && ( NXP_INVALID_TIMER_ID != hci_resp_timer_id ))
                {
                    HCI_DEBUG(" HCI : Response Timer Stop, Status:%02X",
                                                          psCompInfo->status);
                    /* Stop the HCI Response Timer */
                    phOsalNfc_Timer_Stop( hci_resp_timer_id );
                }

#endif /* (NXP_NFC_HCI_TIMER == 1) */

                phHciNfc_Error_Sequence( psHciContext, pHwRef,
                                                        psCompInfo->status, NULL, 0);
                break;
            }
        } /* End of Switch */
    } /* End of Context != NULL  */
}