/*
 * 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_NfcIPMgmt.c                                                 *
* \brief HCI NFCIP-1 management routines.                                     *
*                                                                             *
*                                                                             *
* Project: NFC-FRI-1.1                                                        *
*                                                                             *
* $Date: Tue Jun  8 09:32:31 2010 $                                           *
* $Author: ing04880 $                                                         *
* $Revision: 1.33 $                                                           *
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
*                                                                             *
* =========================================================================== *
*/

/*
***************************** Header File Inclusion ****************************
*/
#include <phNfcCompId.h>
#include <phNfcHalTypes.h>
#include <phHciNfc_Pipe.h>
#include <phHciNfc_RFReader.h>
#include <phHciNfc_Emulation.h>
#include <phOsalNfc.h>

#if defined (ENABLE_P2P)
#include <phHciNfc_NfcIPMgmt.h>
/*
****************************** Macro Definitions *******************************
*/
/* RF Error */
#define NFCIP_RF_NO_ERROR                   0x00U
#define NFCIP_STATUS_MAX_VALUE              0x01U

/* Read and write to the below registry for initiator and target */
#define NXP_NFCIP_MODE                      0x01U
#define NXP_NFCIP_ATR_REQ                   0x02U
#define NXP_NFCIP_ATR_RES                   0x03U
#define NXP_NFCIP_PSL1                      0x04U
#define NXP_NFCIP_PSL2                      0x05U
#define NXP_NFCIP_DID                       0x06U
#define NXP_NFCIP_NAD                       0x07U
#define NXP_NFCIP_OPTIONS                   0x08U
#define NXP_NFCIP_STATUS                    0x09U
#define NXP_NFCIP_NFCID3I                   0x0AU
#define NXP_NFCIP_NFCID3T                   0x0BU
#define NXP_NFCIP_PARAM                     0x0CU
#define NXP_NFCIP_MERGE                     0x0DU

/* command */
#define NXP_NFCIP_ATTREQUEST                0x12U
#define NXP_NFCI_CONTINUE_ACTIVATION        0x13U

/* Event */
#define NXP_EVT_NFC_SND_DATA                0x01U
#define NXP_EVT_NFC_ACTIVATED               0x02U
#define NXP_EVT_NFC_DEACTIVATED             0x03U
#define NXP_EVT_NFC_RCV_DATA                0x04U
#define NXP_EVT_NFC_CONTINUE_MI             0x05U

#define NFCIP_DATE_RATE_FACTOR              0x40U
#define NFCIP_DATE_RATE_SHIFT               0x06U
#define NFCIP_DATA_RATE_CALC(val) \
        ((((uint8_t)(val) >> NFCIP_DATE_RATE_SHIFT) + \
        0x01U) * NFCIP_DATE_RATE_FACTOR)
#define NFCIP_COMM_INITIATOR_SHIFT          0x03
#define NFCIP_COMM_FACTOR                   0x03
/*
*************************** Structure and Enumeration ***************************
*/

/*
*************************** Static Function Declaration **************************
*/
static
NFCSTATUS
phHciNfc_NfcIP_InfoUpdate(
                              phHciNfc_sContext_t     *psHciContext,
                              uint8_t                 index,
                              uint8_t                 *reg_value,
                              uint8_t                 reg_length
                              );

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

static
NFCSTATUS
phHciNfc_Recv_NfcIP_Response(
                             phHciNfc_sContext_t    *psHciContext,
                             phHciNfc_Pipe_Info_t   *ppipe_info, 
                             uint8_t                *pResponse,
#ifdef ONE_BYTE_LEN
                             uint8_t                length
#else
                             uint16_t               length
#endif
                             );

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

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

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

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

static
NFCSTATUS
phHciNfc_Recv_Target_Response(
                           void                 *psContext,
                           void                 *pHwRef,
                           uint8_t              *pResponse,
#ifdef ONE_BYTE_LEN
                           uint8_t              length
#else
                           uint16_t             length
#endif
                           );
/*
*************************** Function Definitions ***************************
*/

NFCSTATUS
phHciNfc_Initiator_Init_Resources(
                                  phHciNfc_sContext_t     *psHciContext
                                  )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_NfcIP_Info_t       *p_init_info=NULL;
    if( NULL == psHciContext )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else
    {
        if (NULL != psHciContext->p_nfcip_info)
        {
            status = NFCSTATUS_SUCCESS;
        } 
        else if(( NULL == psHciContext->p_nfcip_info ) &&
            (phHciNfc_Allocate_Resource((void **)(&p_init_info),
            sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
            )
        {
            psHciContext->p_nfcip_info = p_init_info;
            p_init_info->nfcip_type = NFCIP_INVALID;
            p_init_info->current_seq = NFCIP_INVALID_SEQUENCE;
            p_init_info->next_seq = NFCIP_INVALID_SEQUENCE;
            p_init_info->p_init_pipe_info = NULL;
            p_init_info->p_tgt_pipe_info = NULL;
        }
        else
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
        }

    }
    return status;
}

NFCSTATUS
phHciNfc_Initiator_Get_PipeID(
                              phHciNfc_sContext_t     *psHciContext,
                              uint8_t                 *ppipe_id
                              )
{
    NFCSTATUS       status = NFCSTATUS_SUCCESS;
    if( (NULL != psHciContext)
        && ( NULL != ppipe_id )
        && ( NULL != psHciContext->p_nfcip_info ) 
        )
    {
        phHciNfc_NfcIP_Info_t     *p_init_info=NULL;
        p_init_info = (phHciNfc_NfcIP_Info_t *)
                            psHciContext->p_nfcip_info ;
        *ppipe_id =  p_init_info->p_init_pipe_info->pipe.pipe_id  ;
    }
    else 
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    return status;
}

NFCSTATUS
phHciNfc_Initiator_Update_PipeInfo(
                                   phHciNfc_sContext_t     *psHciContext,
                                   uint8_t                 pipeID,
                                   phHciNfc_Pipe_Info_t    *pPipeInfo
                                   )
{
    NFCSTATUS       status = NFCSTATUS_SUCCESS;
    if( NULL == psHciContext )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_init_info=NULL;
        p_init_info = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        /* Update the pipe_id of the NFCIP-1 initiator Gate obtained from 
        the HCI Response */
        p_init_info->p_init_pipe_info = pPipeInfo;
        p_init_info->p_init_pipe_info->pipe.pipe_id = pipeID;        
        /* Update the Response Receive routine of the NFCIP-1 initiator Gate */
        pPipeInfo->recv_resp = &phHciNfc_Recv_Initiator_Response;
        /* Update the event Receive routine of the NFCIP-1 initiator Gate */
        pPipeInfo->recv_event = &phHciNfc_Recv_Initiator_Event;
    }
    return status;
}

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

    if( (NULL == psHciContext) || (NULL == pHwRef) )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if((NULL == psHciContext->p_nfcip_info) || 
        (NFCIP_INVALID == 
        ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))        
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 
                        p_nfcipinfo->p_init_pipe_info : 
                        p_nfcipinfo->p_tgt_pipe_info);

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }            
        else
        {
            phHciNfc_HCP_Packet_t       *hcp_packet = NULL;
            uint16_t                    length = HCP_HEADER_LEN;
            uint8_t                     pipeid = 0;

            pipeid = p_pipe_info->pipe.pipe_id;
            psHciContext->tx_total = 0 ;
            hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
            /* Construct the HCP Frame */
            phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
                            (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND, 
                            (uint8_t)NXP_NFCIP_ATTREQUEST);

            p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
            p_pipe_info->prev_msg = (uint8_t)NXP_NFCIP_ATTREQUEST;
            psHciContext->tx_total = length;
            psHciContext->response_pending = (uint8_t)TRUE;

            /* Send the Constructed HCP packet to the lower layer */
            status = phHciNfc_Send_HCP( psHciContext, pHwRef);
            p_pipe_info->prev_status = status;
        }
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_Initiator_Response(
                                 void                *pContext,
                                 void                *pHwRef,
                                 uint8_t             *pResponse,
#ifdef ONE_BYTE_LEN
                                 uint8_t             length
#else
                                 uint16_t            length
#endif
                              )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_sContext_t         *psHciContext = 
                                (phHciNfc_sContext_t *)pContext ;

    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
        || (0 == length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t   *p_nfcip_info=NULL;
        phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;        

        p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = p_nfcip_info->p_init_pipe_info;
        if( NULL == p_pipe_info)
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            status = phHciNfc_Recv_NfcIP_Response(psHciContext,  
                                                p_pipe_info, pResponse, 
                                                length);
            if (NFCSTATUS_SUCCESS == status)
            {
                status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext, 
                                                            UPDATE_SEQ);
            }
        }
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_Initiator_Event(
                              void               *psContext,
                              void               *pHwRef,
                              uint8_t            *pEvent,
#ifdef ONE_BYTE_LEN
                              uint8_t             length
#else
                              uint16_t            length
#endif
                              )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_sContext_t         *psHciContext = 
                                (phHciNfc_sContext_t *)psContext ;
    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
        || (0 == length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_HCP_Packet_t       *p_packet = NULL;
        phHciNfc_NfcIP_Info_t       *p_nfcip_info=NULL;
        phHciNfc_HCP_Message_t      *message = NULL;
        uint8_t                     instruction=0;

        p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
        message = &p_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);
        if (NXP_EVT_NFC_ACTIVATED == instruction)
        {
            p_nfcip_info->nfcip_type = NFCIP_INITIATOR;
            psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
            p_nfcip_info->rem_nfcip_tgt_info.RemDevType = phHal_eNfcIP1_Target;
        }

        status = phHciNfc_Recv_NfcIP_Event(psHciContext,
                                        pHwRef, pEvent, length);        
    }
    return status;
}

NFCSTATUS
phHciNfc_Target_Init_Resources(
                               phHciNfc_sContext_t     *psHciContext
                               )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_NfcIP_Info_t      *p_target_info=NULL;
    if( NULL == psHciContext )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else
    {
        if (NULL != psHciContext->p_nfcip_info)
        {
            status = NFCSTATUS_SUCCESS;
        } 
        else if(
            ( NULL == psHciContext->p_nfcip_info ) &&
            (phHciNfc_Allocate_Resource((void **)(&p_target_info),
            sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
            )
        {
            psHciContext->p_nfcip_info = p_target_info;
            p_target_info->nfcip_type = NFCIP_INVALID;
            p_target_info->current_seq = NFCIP_INVALID_SEQUENCE;
            p_target_info->next_seq = NFCIP_INVALID_SEQUENCE;
            p_target_info->p_tgt_pipe_info = NULL;
            p_target_info->p_tgt_pipe_info = NULL;
        }
        else
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
        }

    }
    return status;
}

NFCSTATUS
phHciNfc_Target_Get_PipeID(
                           phHciNfc_sContext_t     *psHciContext,
                           uint8_t                 *ppipe_id
                           )
{
    NFCSTATUS       status = NFCSTATUS_SUCCESS;
    if( (NULL != psHciContext)
        && ( NULL != ppipe_id )
        && ( NULL != psHciContext->p_nfcip_info ) 
        )
    {
        phHciNfc_NfcIP_Info_t     *p_target_info=NULL;
        p_target_info = (phHciNfc_NfcIP_Info_t *)
                            psHciContext->p_nfcip_info ;
        *ppipe_id =  p_target_info->p_tgt_pipe_info->pipe.pipe_id;
    }
    else 
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    return status;
}

NFCSTATUS
phHciNfc_Target_Update_PipeInfo(
                                phHciNfc_sContext_t     *psHciContext,
                                uint8_t                 pipeID,
                                phHciNfc_Pipe_Info_t    *pPipeInfo
                                )
{
    NFCSTATUS       status = NFCSTATUS_SUCCESS;
    if( NULL == psHciContext )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_target_info=NULL;
        p_target_info = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        /* Update the pipe_id of the NFCIP-1 target Gate obtained from 
        the HCI Response */
        p_target_info->p_tgt_pipe_info = pPipeInfo;
        p_target_info->p_tgt_pipe_info->pipe.pipe_id = pipeID;
        /* Update the Response Receive routine of the NFCIP-1 target Gate */
        pPipeInfo->recv_resp = &phHciNfc_Recv_Target_Response;
        /* Update the event Receive routine of the NFCIP-1 target Gate */
        pPipeInfo->recv_event = &phHciNfc_Recv_Target_Event;
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_Target_Response(
                             void                *pContext,
                             void                *pHwRef,
                             uint8_t             *pResponse,
#ifdef ONE_BYTE_LEN
                             uint8_t             length
#else
                             uint16_t            length
#endif
                             )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_sContext_t         *psHciContext = 
                                (phHciNfc_sContext_t *)pContext ;

    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
        || (0 == length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t   *p_nfcip_info=NULL;
        phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;        

        p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = p_nfcip_info->p_tgt_pipe_info;
        if( NULL == p_pipe_info)
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            status = phHciNfc_Recv_NfcIP_Response(psHciContext,  
                                                p_pipe_info, pResponse, 
                                                length);
            if (NFCSTATUS_SUCCESS == status)
            {
                status = phHciNfc_EmuMgmt_Update_Seq(psHciContext, 
                                                    UPDATE_SEQ);
            }
        }
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_Target_Event(
                           void                     *psContext,
                           void                     *pHwRef,
                           uint8_t                  *pEvent,
#ifdef ONE_BYTE_LEN
                           uint8_t                  length
#else
                           uint16_t                 length
#endif
                           )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_sContext_t         *psHciContext = 
                                (phHciNfc_sContext_t *)psContext ;
    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
        || (0 == length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_HCP_Packet_t       *p_packet = NULL;
        phHciNfc_NfcIP_Info_t       *p_nfcip_info=NULL;
        phHciNfc_HCP_Message_t      *message = NULL;
        uint8_t                     instruction=0;

        p_nfcip_info = (phHciNfc_NfcIP_Info_t *)psHciContext->p_nfcip_info ;
        p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
        message = &p_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);
        if (NXP_EVT_NFC_ACTIVATED == instruction)
        {
            p_nfcip_info->nfcip_type = NFCIP_TARGET;
            psHciContext->host_rf_type = phHal_eNfcIP1_Target;
            p_nfcip_info->rem_nfcip_tgt_info.RemDevType = 
                                            phHal_eNfcIP1_Initiator;
        }
        status = phHciNfc_Recv_NfcIP_Event(psHciContext,
                                        pHwRef, pEvent, length);        
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_NfcIP_Response(
                             phHciNfc_sContext_t    *psHciContext,
                             phHciNfc_Pipe_Info_t   *ppipe_info, 
                             uint8_t                *pResponse,
#ifdef ONE_BYTE_LEN
                             uint8_t                length
#else
                             uint16_t               length
#endif
                             )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;    
    uint8_t                     prev_cmd = ANY_GET_PARAMETER;

    p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                    psHciContext->p_nfcip_info ;    
    prev_cmd = ppipe_info->prev_msg ;
    switch(prev_cmd)
    {
        case ANY_OPEN_PIPE:
        {
            HCI_PRINT("NFCIP-1 NFCIP open pipe complete\n");
            p_nfcipinfo->next_seq = NFCIP_NFCID3I;
            break;
        }
        case ANY_CLOSE_PIPE:
        {
            HCI_PRINT("NFCIP-1 NFCIP close pipe complete\n");
            p_nfcipinfo->next_seq = NFCIP_NFCID3I;
            break;
        }
        case ANY_GET_PARAMETER:
        {
            HCI_PRINT("NFCIP-1 NFCIP get parameter complete\n");
            if (length >= HCP_HEADER_LEN)
            {
                status = phHciNfc_NfcIP_InfoUpdate(psHciContext,
                                    ppipe_info->reg_index, 
                                    &pResponse[HCP_HEADER_LEN],
                                    (uint8_t)(length - HCP_HEADER_LEN));
            }
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }            
            break;
        }
        case ANY_SET_PARAMETER:
        {
            HCI_PRINT("NFCIP-1 NFCIP Parameter Set \n");            
            p_nfcipinfo->next_seq = NFCIP_NFCID3I;
            break;
        }
        case NXP_NFCI_CONTINUE_ACTIVATION:
        case NXP_NFCIP_ATTREQUEST:
        {
            p_nfcipinfo->next_seq = NFCIP_NFCID3I;            
            break;
        }
        default:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
            break;
        }
    }
    
    if( NFCSTATUS_SUCCESS == status )
    {
        ppipe_info->prev_status = NFCSTATUS_SUCCESS;
        p_nfcipinfo->current_seq = p_nfcipinfo->next_seq;
    }
    return status;
}

static
NFCSTATUS
phHciNfc_Recv_NfcIP_Event(
                          phHciNfc_sContext_t       *psHciContext,
                          void                      *pHwRef,
                          uint8_t                   *pEvent,
#ifdef ONE_BYTE_LEN
                          uint8_t                   length
#else
                          uint16_t                  length
#endif
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_HCP_Packet_t       *p_packet = NULL;
    phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
    phHciNfc_HCP_Message_t      *message = NULL;
    phNfc_sCompletionInfo_t     pCompInfo;
    uint8_t                     instruction=0;
    uint8_t                     type = 0;

    p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                    psHciContext->p_nfcip_info ;
    p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
    message = &p_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);

    switch(instruction)
    {
        case NXP_EVT_NFC_ACTIVATED:
        {
            HCI_PRINT("NFCIP-1 device discovered\n");
            
            if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
            {
                pCompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
                type = NFC_NOTIFY_TARGET_DISCOVERED;
            }
            else
            {
                type = NFC_NOTIFY_DEVICE_ACTIVATED;
            }

            if(length > HCP_HEADER_LEN)
            {
                HCI_DEBUG("NfcIP-1 activation mode : %d\n", pEvent[HCP_HEADER_LEN]);
                /* Mode indicates in which mode the current activation 
                    as be done
                        - 0x00: Passive mode
                        - 0x01: Active */
                p_nfcipinfo->activation_mode = pEvent[HCP_HEADER_LEN];
            }
            pCompInfo.status = NFCSTATUS_SUCCESS;
            /* Notify to the HCI Generic layer To Update the FSM */
            phHciNfc_Notify_Event(psHciContext, pHwRef, 
                                type, &pCompInfo);            
            break;
        }
        case NXP_EVT_NFC_DEACTIVATED:
        {
            static phHal_sEventInfo_t   event_info;

            event_info.eventHost = phHal_eHostController;
            event_info.eventType = NFC_EVT_DEACTIVATED;
            p_nfcipinfo->activation_mode = FALSE;
            if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
            {
                p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 
                                        phHal_eNfcIP1_Target;
                event_info.eventSource = phHal_eNfcIP1_Initiator;
            }
            else
            {
                p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 
                                        phHal_eNfcIP1_Initiator;
                event_info.eventSource = phHal_eNfcIP1_Target;
            }
            /* Reset the sequence */
            p_nfcipinfo->current_seq = NFCIP_NFCID3I;
            p_nfcipinfo->next_seq = NFCIP_NFCID3I;

            HCI_PRINT("NFCIP-1 Target Deactivated\n");
            phHciNfc_Notify_Event(psHciContext, pHwRef, 
                                NFC_NOTIFY_DEVICE_DEACTIVATED, 
                                &event_info);
            break;
        }
        case NXP_EVT_NFC_RCV_DATA:
        {
            status = phHciNfc_NfcIP_RecvData(psHciContext, 
                                pHwRef,
                                &pEvent[HCP_HEADER_LEN],
                                (length - HCP_HEADER_LEN));
            break;
        }
        case NXP_EVT_NFC_CONTINUE_MI:
        {
            /* psHciContext->response_pending = FALSE; */
            psHciContext->event_pending = FALSE;
            break;
        }
        default:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
            break;
        }
    }

    return status;
}

static 
NFCSTATUS
phHciNfc_NfcIP_RecvData(
                  phHciNfc_sContext_t  *psHciContext,
                  void                 *pHwRef,
                  uint8_t              *pResponse,
#ifdef ONE_BYTE_LEN
                  uint8_t              length
#else
                  uint16_t             length
#endif
                  )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    uint8_t                     index = 0;

    if( (NULL == psHciContext) 
        || (NULL == pHwRef)
        || (NULL == pResponse)
        || (0 == length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else 
    {
        phNfc_sTransactionInfo_t    transInfo;
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo = NULL;
        uint8_t                     type = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info;
        HCI_PRINT("NFCIP-1 received bytes :");        
        if (NFCIP_RF_NO_ERROR == pResponse[index])
        {
            HCI_PRINT_BUFFER("device ", &pResponse[index], (length - index));
            transInfo.status = NFCSTATUS_SUCCESS;
            index++;
            if (TRUE == pResponse[index])
            {                
                /* Update the more information bit to the upper layer */
                transInfo.status = NFCSTATUS_MORE_INFORMATION;
            }
            index++;

            
            transInfo.buffer = &pResponse[index];
            transInfo.length = (length - index);            
            type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
        }
        else
        {
            HCI_PRINT("NFCIP-1 receive RF ERROR ");
            p_nfcipinfo->activation_mode = FALSE;
            type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
            transInfo.status = NFCSTATUS_RF_TIMEOUT;
            transInfo.buffer = NULL;
            transInfo.length = 0;
        }
        status = NFCSTATUS_PENDING;
        /* Event NXP_EVT_NFC_RCV_DATA: so give received data to 
           the upper layer */
        phHciNfc_Notify_Event(psHciContext, pHwRef,
                                type, 
                                &transInfo );
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_Send_Data (
                         phHciNfc_sContext_t    *psHciContext,
                         void                   *pHwRef, 
                         phHciNfc_XchgInfo_t    *sData
                         )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == sData) || 
        (NULL == sData->tx_buffer) || (0 == sData->tx_length))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if((NULL == psHciContext->p_nfcip_info) || 
        (NFCIP_INVALID == 
        ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))        
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 
                        p_nfcipinfo->p_init_pipe_info : 
                        p_nfcipinfo->p_tgt_pipe_info);

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }          
        else
        {
            phHciNfc_HCP_Packet_t       *hcp_packet = NULL;
            phHciNfc_HCP_Message_t      *hcp_message = NULL;
            uint16_t                    length = HCP_HEADER_LEN;
            uint8_t                     pipeid = 0, 
                                        i = 0;

            HCI_PRINT_BUFFER("HCI NFCIP-1 Send Data: ", sData->tx_buffer, sData->tx_length);

            psHciContext->tx_total = 0 ;
            pipeid = p_pipe_info->pipe.pipe_id;
            hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
            hcp_message = &(hcp_packet->msg.message);
            hcp_message->payload[i] = sData->params.nfc_info.more_info;
            i++;
            
            /* Construct the HCP Frame */
            phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
                            (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_EVENT, 
                            (uint8_t)NXP_EVT_NFC_SND_DATA);

            phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
                            i, (uint8_t *)sData->tx_buffer,
                            (uint8_t)sData->tx_length);

            length =(uint16_t)(length + i + sData->tx_length);

            p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_EVENT;
            p_pipe_info->prev_msg = NXP_EVT_NFC_SND_DATA;
            psHciContext->tx_total = length;
            /* Send the Constructed HCP packet to the lower layer */
            status = phHciNfc_Send_HCP( psHciContext, pHwRef);
#if !defined (ENABLE_CONTINUE_MI)
            if ((TRUE == sData->params.nfc_info.more_info) && 
                (NFCSTATUS_PENDING == status))
            {
                /* If more information bit is set, then wait for the event 
                    NXP_EVT_NFC_CONTINUE_MI */
                /* psHciContext->response_pending = TRUE; */
                psHciContext->event_pending = TRUE;
            }
#endif /* #if defined (ENABLE_CONTINUE_MI) */
            p_pipe_info->prev_status = status;
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_Info_Sequence (
                                  phHciNfc_sContext_t   *psHciContext,
                                  void                  *pHwRef
#ifdef NOTIFY_REQD
                                  , 
                                  uint8_t               notify_reqd
#endif /* #ifdef NOTIFY_REQD */
                                  )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS;
    
    if( (NULL == psHciContext) 
        || (NULL == pHwRef)
        )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if((NULL == psHciContext->p_nfcip_info) || 
        (NFCIP_INVALID == 
        ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->
        nfcip_type))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }   
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 
                        p_nfcipinfo->p_init_pipe_info: 
                        p_nfcipinfo->p_tgt_pipe_info);
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            switch(p_nfcipinfo->current_seq)
            {
                case NFCIP_NFCID3I:
                {
                    p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3I;
                    /* Fill the data buffer and send the command to the 
                    device */
                    status = 
                        phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                            p_pipe_info->pipe.pipe_id, 
                                            ANY_GET_PARAMETER);
                    if(NFCSTATUS_PENDING == status )
                    {
                        p_nfcipinfo->next_seq = NFCIP_NFCID3T;
                    }
                    break;
                }
                case NFCIP_NFCID3T:
                {
                    p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3T;
                    /* Fill the data buffer and send the command to the 
                    device */
                    status = 
                        phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                                p_pipe_info->pipe.pipe_id, 
                                                ANY_GET_PARAMETER);
                    if(NFCSTATUS_PENDING == status )
                    {
                        p_nfcipinfo->next_seq = NFCIP_PARAM;
                    }
                    break;
                }
                case NFCIP_PARAM:
                {
                    p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
                    /* Fill the data buffer and send the command to the 
                    device */
                    status = 
                        phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                                p_pipe_info->pipe.pipe_id, 
                                                ANY_GET_PARAMETER);
                    if(NFCSTATUS_PENDING == status )
                    {
                        p_nfcipinfo->next_seq = NFCIP_ATR_INFO;
                    }
                    break;
                }
                case NFCIP_ATR_INFO:
                {
                    p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == 
                            p_nfcipinfo->nfcip_type)?
                            NXP_NFCIP_ATR_RES : 
                            NXP_NFCIP_ATR_REQ);
                    status = 
                        phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                                p_pipe_info->pipe.pipe_id, 
                                                ANY_GET_PARAMETER);

                    if(NFCSTATUS_PENDING == status )
                    {
                        p_nfcipinfo->next_seq = NFCIP_STATUS;
                    }
                    break;
                }
                case NFCIP_STATUS:
                {
                    p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
                    /* Fill the data buffer and send the command to the 
                    device */
                    status = 
                        phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                                p_pipe_info->pipe.pipe_id, 
                                                ANY_GET_PARAMETER);
                    if(NFCSTATUS_PENDING == status )
                    {
#ifdef NOTIFY_REQD
                        if(FALSE == notify_reqd)
#else /* #ifdef NOTIFY_REQD */
                        if (NULL != psHciContext->p_target_info)
#endif /* #ifdef NOTIFY_REQD */
                        {
                            p_nfcipinfo->next_seq = NFCIP_NFCID3I;
                            status = NFCSTATUS_SUCCESS;
                        }
                        else
                        {
                            p_nfcipinfo->next_seq = NFCIP_END_SEQUENCE;
                        }
                    }
                    break;
                }
                case NFCIP_END_SEQUENCE:
                {                    
                    phHal_uRemoteDevInfo_t          *rem_nfcipinfo = NULL;

                    if (NULL != psHciContext->p_target_info)
                    {
                        /* This is given to user */
                        rem_nfcipinfo = 
                                &(psHciContext->p_target_info->RemoteDevInfo);                        
                    }
                    else
                    {
                        rem_nfcipinfo = 
                                &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo);
                    }

                    /* Update maximum frame length */
                    rem_nfcipinfo->NfcIP_Info.MaxFrameLength = 
                                        p_nfcipinfo->max_frame_len;

                    p_nfcipinfo->current_seq = NFCIP_NFCID3I;
                    p_nfcipinfo->next_seq = NFCIP_NFCID3I;

                    rem_nfcipinfo->NfcIP_Info.Nfcip_Active = 
                                            p_nfcipinfo->activation_mode;
                    
                    
                    if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
                    {
                        phNfc_sCompletionInfo_t         CompInfo;

                        p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 
                                                    phHal_eNfcIP1_Target;

                        /* Update initiator speed */
                        rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate = 
                                            (phHalNfc_eDataRate_t)
                                            (p_nfcipinfo->initiator_speed);

                        
                        /* Update ATR info */
                        rem_nfcipinfo->NfcIP_Info.ATRInfo_Length = 
                                                    p_nfcipinfo->atr_res_length;
                        (void)memcpy(
                                (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo, 
                                (void *)p_nfcipinfo->atr_res_info, 
                                rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);

                        /* Update NFCID */
                        rem_nfcipinfo->NfcIP_Info.NFCID_Length = 
                                        p_nfcipinfo->nfcid3i_length;
                        (void)memcpy(
                                (void *)rem_nfcipinfo->NfcIP_Info.NFCID, 
                                (void *)p_nfcipinfo->nfcid3i, 
                                rem_nfcipinfo->NfcIP_Info.NFCID_Length);

                        CompInfo.status = status = NFCSTATUS_SUCCESS;
                        if (NULL != psHciContext->p_target_info)
                        {
                            CompInfo.info = &(psHciContext->p_target_info);
                        }
                        else
                        {
                            CompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
                        }
                        /* Notify to the upper layer */
                        phHciNfc_Tag_Notify(psHciContext, pHwRef, 
                                            NFC_NOTIFY_TARGET_DISCOVERED, 
                                            &CompInfo);
                    } 
                    else
                    {
                        static phHal_sEventInfo_t   event_info;                        
                        
                        p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 
                                                    phHal_eNfcIP1_Initiator;

                        /* Update target speed  */
                        rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate = 
                                            (phHalNfc_eDataRate_t)
                                            (p_nfcipinfo->target_speed);
                        /* Update ATR info */
                        rem_nfcipinfo->NfcIP_Info.ATRInfo_Length = 
                                                    p_nfcipinfo->atr_req_length;
                        (void)memcpy(
                                (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo, 
                                (void *)p_nfcipinfo->atr_req_info, 
                                rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);

                        /* Update NFCID */
                        rem_nfcipinfo->NfcIP_Info.NFCID_Length = 
                                        p_nfcipinfo->nfcid3t_length;
                        (void)memcpy(
                                (void *)rem_nfcipinfo->NfcIP_Info.NFCID, 
                                (void *)p_nfcipinfo->nfcid3t, 
                                rem_nfcipinfo->NfcIP_Info.NFCID_Length);

                        event_info.eventHost = phHal_eHostController;
                        event_info.eventType = NFC_EVT_ACTIVATED;
                        event_info.eventSource = phHal_eNfcIP1_Target;
                        event_info.eventInfo.pRemoteDevInfo = 
                                            &(p_nfcipinfo->rem_nfcip_tgt_info);

                        phHciNfc_Target_Select_Notify((void *)psHciContext, 
                                                    pHwRef, 
                                                    NFC_NOTIFY_EVENT, 
                                                    &(event_info));
                    }
                    break;
                }
                default:
                {
                    status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
                    break;
                }
            }           
        }
    }
    return status;
}

static
NFCSTATUS
phHciNfc_NfcIP_InfoUpdate(
                          phHciNfc_sContext_t     *psHciContext,
                          uint8_t                 index,
                          uint8_t                 *reg_value,
                          uint8_t                 reg_length
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    phHciNfc_NfcIP_Info_t       *p_nfcipinfo = NULL;                                
    phHal_sNfcIPInfo_t          *p_rem_nfcipinfo = NULL;   

    p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info );
    p_rem_nfcipinfo = &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo.NfcIP_Info);  


    switch(index)
    {
        case NXP_NFCIP_ATR_RES:
        {
            if (reg_length <= NFCIP_ATR_MAX_LENGTH)
            {                
                /* Remote device info provided by the user */
                
                HCI_PRINT_BUFFER("\tNFCIP ATR_RES", reg_value, reg_length);

                p_rem_nfcipinfo->ATRInfo_Length = 
                p_nfcipinfo->atr_res_length = reg_length;

                (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo, 
                                    (void *)reg_value, 
                                    p_rem_nfcipinfo->ATRInfo_Length);

                (void)memcpy((void *)p_nfcipinfo->atr_res_info, 
                                    (void *)reg_value, 
                                    p_nfcipinfo->atr_res_length);
                if (NULL != psHciContext->p_target_info)
                {
                    phHal_sNfcIPInfo_t       *p_remtgt_info = NULL;
                    /* This is given to user */
                    p_remtgt_info = 
                    &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
                    p_remtgt_info->ATRInfo_Length = reg_length;
                    (void)memcpy((void *)p_remtgt_info->ATRInfo, 
                                        (void *)reg_value, 
                                        p_remtgt_info->ATRInfo_Length);
                }
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_STATUS:
        {
            if (sizeof(*reg_value) == reg_length) 
#ifdef STATUS_BUFFER_CHECK
                && (*reg_value <= NFCIP_STATUS_MAX_VALUE))
#endif /* #ifdef STATUS_ERROR */
            {
                HCI_PRINT_BUFFER("\tNFCIP STATUS", reg_value, reg_length);
                p_nfcipinfo->linkstatus = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_NFCID3I:
        {
            if (reg_length <= NFCIP_NFCID_LENGTH)
            {
                HCI_PRINT_BUFFER("\tNFCIP NFCID3I", reg_value, reg_length);
                p_nfcipinfo->nfcid3i_length = 
                p_rem_nfcipinfo->NFCID_Length = reg_length;
                (void)memcpy((void *)p_rem_nfcipinfo->NFCID, 
                                    (void *)reg_value, 
                                    p_rem_nfcipinfo->NFCID_Length);
                (void)memcpy((void *)p_nfcipinfo->nfcid3i, 
                                    (void *)reg_value, 
                                    reg_length);
                if ((NULL != psHciContext->p_target_info) && 
                    (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type))
                {
                    phHal_sNfcIPInfo_t       *p_remtgt_info = NULL;
                    /* This is given to user */
                    p_remtgt_info = 
                    &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
                    p_remtgt_info->NFCID_Length = reg_length;
                    (void)memcpy((void *)p_remtgt_info->NFCID, 
                                        (void *)reg_value, 
                                        p_remtgt_info->NFCID_Length);
                }
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_NFCID3T:
        {
            if (reg_length <= NFCIP_NFCID_LENGTH)
            {
                HCI_PRINT_BUFFER("\tNFCIP NFCID3T", reg_value, reg_length);
                p_nfcipinfo->nfcid3t_length = 
                p_rem_nfcipinfo->NFCID_Length = reg_length;
                (void)memcpy((void *)p_rem_nfcipinfo->NFCID, 
                                    (void *)reg_value, 
                                    p_rem_nfcipinfo->NFCID_Length);
                (void)memcpy((void *)p_nfcipinfo->nfcid3t, 
                                    (void *)reg_value, 
                                    reg_length);
                if ((NULL != psHciContext->p_target_info) && 
                    (NFCIP_TARGET == p_nfcipinfo->nfcip_type))
                {
                    phHal_sNfcIPInfo_t       *p_remtgt_info = NULL;
                    /* This is given to user */
                    p_remtgt_info = 
                    &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
                    p_remtgt_info->NFCID_Length = reg_length;
                    (void)memcpy((void *)p_remtgt_info->NFCID, 
                                        (void *)reg_value, 
                                        p_remtgt_info->NFCID_Length);
                }
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_PARAM:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP PARAMS", reg_value, reg_length);
                p_nfcipinfo->initiator_speed = (phHciNfc_eP2PSpeed_t)
                                ((*reg_value >> NFCIP_COMM_INITIATOR_SHIFT)
                                & NFCIP_COMM_FACTOR);
                p_nfcipinfo->target_speed = (phHciNfc_eP2PSpeed_t)
                                (*reg_value & NFCIP_COMM_FACTOR);
                p_nfcipinfo->max_frame_len = NFCIP_DATA_RATE_CALC(*reg_value);

                if (NULL != psHciContext->p_target_info)
                {
                    phHal_sNfcIPInfo_t       *p_remtgt_info = NULL;
                    /* This is given to user */
                    p_remtgt_info = 
                    &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
                    p_remtgt_info->MaxFrameLength = p_nfcipinfo->max_frame_len;
                    p_remtgt_info->Nfcip_Datarate = (phHalNfc_eDataRate_t)
                                                p_nfcipinfo->initiator_speed;
                }
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_MODE:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP MODE", reg_value, reg_length);
                p_nfcipinfo->nfcip_mode = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_ATR_REQ:
        {
            if (reg_length <= NFCIP_ATR_MAX_LENGTH)
            {
                HCI_PRINT_BUFFER("\tNFCIP ATR_REQ", reg_value, reg_length);
                p_rem_nfcipinfo->ATRInfo_Length = 
                        p_nfcipinfo->atr_req_length = reg_length;
                (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo, 
                                    (void *)reg_value, 
                                    p_rem_nfcipinfo->ATRInfo_Length);
                (void)memcpy((void *)p_nfcipinfo->atr_req_info, 
                                    (void *)reg_value, 
                                    p_nfcipinfo->atr_req_length);
                if (NULL != psHciContext->p_target_info)
                {
                    phHal_sNfcIPInfo_t       *p_remtgt_info = NULL;
                    /* This is given to user */
                    p_remtgt_info = 
                    &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
                    p_remtgt_info->NFCID_Length = reg_length;
                    (void)memcpy((void *)p_remtgt_info->ATRInfo, 
                                        (void *)reg_value, 
                                        p_remtgt_info->ATRInfo_Length);
                }
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_PSL1:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP PSL1", reg_value, reg_length);
                p_nfcipinfo->psl1 = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_PSL2:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP PSL2", reg_value, reg_length);
                p_nfcipinfo->psl2 = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_DID:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP DID", reg_value, reg_length);
                p_nfcipinfo->did = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_NAD:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP NAD", reg_value, reg_length);
                p_nfcipinfo->nad = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        case NXP_NFCIP_OPTIONS:
        {
            if (sizeof(*reg_value) == reg_length)
            {
                HCI_PRINT_BUFFER("\tNFCIP OPTIONS", reg_value, reg_length);
                p_nfcipinfo->options = *reg_value;
            } 
            else
            {
                status = PHNFCSTVAL(CID_NFC_HCI, 
                                    NFCSTATUS_INVALID_HCI_RESPONSE);
            }
            break;
        }
        default:
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_RESPONSE);
            break;
        }
    }
    return status;
}


NFCSTATUS
phHciNfc_NfcIP_SetMode(
                        phHciNfc_sContext_t     *psHciContext,
                        void                    *pHwRef,
                        phHciNfc_eNfcIPType_t   nfciptype,
                        uint8_t                 nfcip_mode                      
                        )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef) || 
        (nfcip_mode > (uint8_t)NFCIP_MODE_ALL))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info: 
                        p_nfcipinfo->p_tgt_pipe_info);

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MODE;

            p_pipe_info->param_info = &nfcip_mode;
            p_pipe_info->param_length = sizeof(uint8_t);
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetNAD(
                       phHciNfc_sContext_t      *psHciContext,
                       void                     *pHwRef,
                       phHciNfc_eNfcIPType_t    nfciptype,
                       uint8_t                  nad
                       )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info: 
                        p_nfcipinfo->p_tgt_pipe_info);
        
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NAD;

            p_pipe_info->param_info = &nad;
            p_pipe_info->param_length = sizeof(uint8_t);        
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetDID(
                      phHciNfc_sContext_t   *psHciContext,
                      void                  *pHwRef,
                      uint8_t               did
                      )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
    
    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = p_nfcipinfo->p_init_pipe_info;
        
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_DID;

            p_pipe_info->param_info = &did;
            p_pipe_info->param_length = sizeof(uint8_t);        
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                        pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetOptions(
                      phHciNfc_sContext_t       *psHciContext,
                      void                      *pHwRef,
                      phHciNfc_eNfcIPType_t     nfciptype,
                      uint8_t                   nfcip_options
                      )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 
                        p_nfcipinfo->p_init_pipe_info: 
                        p_nfcipinfo->p_tgt_pipe_info);
        pipeid = p_pipe_info->pipe.pipe_id ;
        p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_OPTIONS;

        p_pipe_info->param_info = &nfcip_options;
        p_pipe_info->param_length = sizeof(uint8_t);
        status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                pipeid, (uint8_t)ANY_SET_PARAMETER);
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetATRInfo(
                          phHciNfc_sContext_t       *psHciContext,
                          void                      *pHwRef,
                          phHciNfc_eNfcIPType_t     nfciptype,
                          phHal_sNfcIPCfg_t         *atr_info
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == atr_info) || 
        (atr_info->generalBytesLength > NFCIP_ATR_MAX_LENGTH))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                    psHciContext->p_nfcip_info ;
        p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info: 
                        p_nfcipinfo->p_tgt_pipe_info);

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)? 
                                        NXP_NFCIP_ATR_REQ : 
                                        NXP_NFCIP_ATR_RES);

            p_pipe_info->param_info = atr_info->generalBytes;
            p_pipe_info->param_length = (uint8_t)
                                        atr_info->generalBytesLength;        
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetPSL1(
                          phHciNfc_sContext_t   *psHciContext,
                          void                  *pHwRef,
                          uint8_t               psl1
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = p_nfcipinfo->p_init_pipe_info;

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL1;

            p_pipe_info->param_info = &psl1;
            p_pipe_info->param_length = sizeof(uint8_t);        
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_SetPSL2(
                       phHciNfc_sContext_t  *psHciContext,
                       void                 *pHwRef,
                       uint8_t              psl2
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info = p_nfcipinfo->p_init_pipe_info;

        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL2;

            p_pipe_info->param_info = &psl2;
            p_pipe_info->param_length = sizeof(uint8_t);        
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_GetStatus(
                       phHciNfc_sContext_t      *psHciContext,
                       void                     *pHwRef,
                       phHciNfc_eNfcIPType_t    nfciptype
                          )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info =  ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info : 
                        p_nfcipinfo->p_tgt_pipe_info);
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;

            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                        pipeid, (uint8_t)ANY_GET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS
phHciNfc_NfcIP_GetParam(
                         phHciNfc_sContext_t    *psHciContext,
                         void                   *pHwRef, 
                         phHciNfc_eNfcIPType_t  nfciptype
                         )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info) 
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_pipe_info =  ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info : 
                        p_nfcipinfo->p_tgt_pipe_info);
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = p_pipe_info->pipe.pipe_id ;
            p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;

            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_GET_PARAMETER);
        }
    }
    return status;
}

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

    if( (NULL == psHciContext) || (NULL == pHwRef) )
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t     *p_nfcipinfo = NULL;
        phHciNfc_Pipe_Info_t      *p_pipe_info=NULL;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        p_nfcipinfo->nfcip_type = NFCIP_INITIATOR;
        psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
        p_pipe_info =  p_nfcipinfo->p_init_pipe_info;
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            phHciNfc_HCP_Packet_t       *hcp_packet = NULL;
            uint16_t                    length = HCP_HEADER_LEN; 
            uint8_t                     pipeid = 0;

            pipeid = p_pipe_info->pipe.pipe_id;
            psHciContext->tx_total = 0 ;
            hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
            /* Construct the HCP Frame */
            phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
                            (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND, 
                            (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION);

            p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
            p_pipe_info->prev_msg = (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION;
            psHciContext->tx_total = length;
            psHciContext->response_pending = (uint8_t)TRUE;

            /* Send the Constructed HCP packet to the lower layer */
            status = phHciNfc_Send_HCP( psHciContext, pHwRef);
            p_pipe_info->prev_status = status;
        }       
    }
    return status;
}


NFCSTATUS
phHciNfc_NfcIP_GetATRInfo (
                           phHciNfc_sContext_t      *psHciContext,
                           void                     *pHwRef, 
                           phHciNfc_eNfcIPType_t    nfciptype
                           )
{
    NFCSTATUS               status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) 
        || (NULL == pHwRef))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if (NFCIP_INVALID == nfciptype)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }   
    else
    {
        phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;

        p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 
                        p_nfcipinfo->p_init_pipe_info : 
                        p_nfcipinfo->p_tgt_pipe_info);
        
        if(NULL == p_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
                                    NXP_NFCIP_ATR_RES : 
                                    NXP_NFCIP_ATR_REQ);
            pipeid = p_pipe_info->pipe.pipe_id ;
            /* Fill the data buffer and send the command to the 
                device */
            status = 
                phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                pipeid, (uint8_t)ANY_GET_PARAMETER);
        }
    }
    return status;
}

NFCSTATUS 
phHciNfc_NfcIP_SetMergeSak( 
                            phHciNfc_sContext_t     *psHciContext,
                            void                    *pHwRef, 
                            uint8_t                 sak_value
                           )
{
    NFCSTATUS                   status = NFCSTATUS_SUCCESS;

    if( (NULL == psHciContext) || (NULL == pHwRef) || 
        (sak_value > (uint8_t)TRUE))
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
    }
    else if(NULL == psHciContext->p_nfcip_info)
    {
        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
    }
    else
    {
        phHciNfc_NfcIP_Info_t       *ps_nfcipinfo=NULL;
        phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
        uint8_t                     pipeid = 0;

        ps_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
                        psHciContext->p_nfcip_info ;
        ps_pipe_info = ps_nfcipinfo->p_tgt_pipe_info;

        if(NULL == ps_pipe_info )
        {
            status = PHNFCSTVAL(CID_NFC_HCI, 
                                NFCSTATUS_INVALID_HCI_INFORMATION);
        }
        else
        {
            pipeid = ps_pipe_info->pipe.pipe_id ;
            ps_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MERGE;

            ps_pipe_info->param_info = &sak_value;
            ps_pipe_info->param_length = sizeof(uint8_t);
            status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 
                                    pipeid, (uint8_t)ANY_SET_PARAMETER);
        }
    }
    return status;
}

#endif /* #if defined (ENABLE_P2P) */