Initial libnfc checkin

Source: Trusted_NFC_Device_Host_AA03.01e02_google.zip code drop (23-Sep-2010)

Change-Id: Ie47f18423f949a8d3e0815d13f55c814312add24
Signed-off-by: Nick Pelly <npelly@google.com>

1 files changed, 1593 insertions, 0 deletions

diff --git a/src/phHciNfc_DevMgmt.c b/src/phHciNfc_DevMgmt.c
new file mode 100644
index 0000000..32662c1
--- /dev/null
+++ b/src/phHciNfc_DevMgmt.c
@@ -0,0 +1,1593 @@
+/*
+ * 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_DevMgmt.c                                                   *
+* \brief HCI PN544 Device Management Gate Routines.                           *
+*                                                                             *
+*                                                                             *
+* Project: NFC-FRI-1.1                                                        *
+*                                                                             *
+* $Date: Fri Mar 12 10:21:54 2010 $                                           *
+* $Author: ing04880 $                                                         *
+* $Revision: 1.29 $                                                            *
+* $Aliases: NFC_FRI1.1_WK1007_R33_3,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $                                                                *
+*                                                                             *
+* =========================================================================== *
+*/
+
+/*
+***************************** Header File Inclusion ****************************
+*/
+#include <phNfcConfig.h>
+#include <phNfcCompId.h>
+#include <phHciNfc_Pipe.h>
+#include <phHciNfc_DevMgmt.h>
+#include <phHciNfc_Emulation.h>
+#include <phOsalNfc.h>
+
+/*
+****************************** Macro Definitions *******************************
+*/
+
+/*  Commands for System Management module */
+#define NXP_RF_CHECK_SETTINGS   0x10U
+#define NXP_RF_UPDATE_SETTINGS  0x11U
+
+/* Self Test Commands */
+#define NXP_SELF_TEST_ANTENNA   0x20U
+#define NXP_SELF_TEST_SWP       0x21U
+#define NXP_SELF_TEST_NFCWI     0x22U
+#define NXP_SELF_TEST_PRBS      0x25U
+
+/* System Management propreitary control */
+#define NXP_DBG_READ            0x3EU
+#define NXP_DBG_WRITE           0x3FU
+
+/* System Management Events */
+#define NXP_EVT_SET_AUTONOMOUS   0x01U
+#define NXP_EVT_CLF_WAKEUP       0x02U
+
+/* System Management Information Events */
+#define NXP_EVT_INFO_TXLDO_OVERCUR   0x10U
+#define NXP_EVT_INFO_PMUVCC          0x11U
+#define NXP_EVT_INFO_EXT_RF_FIELD    0x12U
+#define NXP_EVT_INFO_MEM_VIOLATION   0x13U
+#define NXP_EVT_INFO_TEMP_OVERHEAT   0x14U
+
+#define NFC_DEV_TXLDO_MASK           0x03U
+
+
+/*
+*************************** Structure and Enumeration ***************************
+*/
+
+
+/** \defgroup grp_hci_nfc HCI PN544 Device Management Component
+ *
+ *
+ */
+
+typedef enum phHciNfc_DevMgmt_Seq{
+    DEV_MGMT_PIPE_OPEN      = 0x00U,
+    DEV_MGMT_SET_PWR_STATUS,
+    DEV_MGMT_SET_INFO_EVT,
+    DEV_MGMT_GET_EEPROM_INFO,
+    DEV_MGMT_GPIO_PDIR,
+    DEV_MGMT_GPIO_PEN,
+    DEV_MGMT_TX_LDO,
+    DEV_MGMT_IFC_TO_RX_H,
+    DEV_MGMT_IFC_TO_RX_L,
+    DEV_MGMT_IFC_TO_TX_H,
+    DEV_MGMT_IFC_TO_TX_L,
+    DEV_MGMT_ANAIRQ_CONF,
+    DEV_MGMT_PMOS_MOD,
+    DEV_MGMT_CLK_REQ,
+    DEV_MGMT_INPUT_CLK,
+    DEV_MGMT_UICC_PWR_REQUEST,
+    DEV_MGMT_ACTIVE_GUARD_TO,
+    DEV_MGMT_MAX_ACT_TO_LOW,
+    DEV_MGMT_MAX_ACT_TO_HIGH,
+    DEV_MGMT_UICC_CE_A_ACCESS,
+    DEV_MGMT_UICC_CE_B_ACCESS,
+    DEV_MGMT_UICC_CE_BP_ACCESS,
+    DEV_MGMT_UICC_CE_F_ACCESS,
+    DEV_MGMT_UICC_RD_A_ACCESS,
+    DEV_MGMT_UICC_RD_B_ACCESS,
+    DEV_MGMT_UICC_BIT_RATE,
+    DEV_MGMT_UICC_RX_ERR_CNT,
+    DEV_MGMT_UICC_TX_ERR_CNT,
+    DEV_MGMT_LLC_GRD_TO_H,
+    DEV_MGMT_LLC_GRD_TO_L,
+    DEV_MGMT_LLC_ACK_TO_H,
+    DEV_MGMT_LLC_ACK_TO_L,
+    DEV_MGMT_EVT_AUTONOMOUS,
+    DEV_MGMT_PIPE_CLOSE
+} phHciNfc_DevMgmt_Seq_t;
+
+
+typedef struct phHciNfc_DevMgmt_Info{
+    phHciNfc_DevMgmt_Seq_t  current_seq;
+    phHciNfc_DevMgmt_Seq_t  next_seq;
+    phHciNfc_Pipe_Info_t    *p_pipe_info;
+    uint8_t                 test_status;
+    uint8_t                 value;
+    uint8_t                 rf_status;
+    uint8_t                 pmuvcc_status;
+    uint8_t                 overheat_status;
+    uint8_t                 *p_val;
+    uint8_t                 eeprom_crc;
+    phNfc_sData_t           test_result;
+
+} phHciNfc_DevMgmt_Info_t;
+
+
+/*
+*************************** Static Function Declaration **************************
+*/
+
+static
+NFCSTATUS
+phHciNfc_DevMgmt_InfoUpdate(
+                                phHciNfc_sContext_t     *psHciContext,
+                                phHal_sHwReference_t    *pHwRef,
+                                uint8_t                 index,
+                                uint8_t                 *reg_value,
+                                uint8_t                 reg_length
+                         );
+
+static
+NFCSTATUS
+phHciNfc_Recv_DevMgmt_Response(
+                        void                *psHciContext,
+                        void                *pHwRef,
+                        uint8_t             *pResponse,
+#ifdef ONE_BYTE_LEN
+                        uint8_t             length
+#else
+                        uint16_t            length
+#endif
+                       );
+
+static
+NFCSTATUS
+phHciNfc_Recv_DevMgmt_Event(
+                        void                *psContext,
+                        void                *pHwRef,
+                        uint8_t             *pEvent,
+#ifdef ONE_BYTE_LEN
+                        uint8_t             length
+#else
+                        uint16_t            length
+#endif
+                    );
+
+
+static
+NFCSTATUS
+phHciNfc_Send_DevMgmt_Command (
+                            phHciNfc_sContext_t *psHciContext,
+                            void                *pHwRef,
+                            uint8_t             pipe_id,
+                            uint8_t             cmd
+                );
+
+static
+ NFCSTATUS
+ phHciNfc_Send_DevMgmt_Event (
+                                phHciNfc_sContext_t *psHciContext,
+                                void                *pHwRef,
+                                uint8_t             pipe_id,
+                                uint8_t             event
+                    );
+
+/*
+*************************** Function Definitions ***************************
+*/
+
+
+NFCSTATUS
+phHciNfc_DevMgmt_Init_Resources(
+                           phHciNfc_sContext_t  *psHciContext
+                          )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHciNfc_DevMgmt_Info_t          *p_device_mgmt_info=NULL;
+   
+    if( NULL == psHciContext )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else
+    {
+        if(( NULL == psHciContext->p_device_mgmt_info ) &&
+             (phHciNfc_Allocate_Resource((void **)(&p_device_mgmt_info),
+            sizeof(phHciNfc_DevMgmt_Info_t))== NFCSTATUS_SUCCESS))
+        {
+            psHciContext->p_device_mgmt_info = p_device_mgmt_info;
+            p_device_mgmt_info->current_seq = DEV_MGMT_PIPE_OPEN;
+            p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN;
+            p_device_mgmt_info->p_pipe_info = NULL;
+        }
+        else
+        {
+            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
+        }
+    }
+    return status;
+}
+
+
+NFCSTATUS
+phHciNfc_DevMgmt_Get_PipeID(
+                            phHciNfc_sContext_t        *psHciContext,
+                            uint8_t                    *ppipe_id
+                            )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+
+    if( (NULL != psHciContext)
+        && ( NULL != ppipe_id )
+        && ( NULL != psHciContext->p_device_mgmt_info ) 
+        )
+    {
+        phHciNfc_Pipe_Info_t     *p_pipe_info = NULL;
+        p_pipe_info = ((phHciNfc_DevMgmt_Info_t *)
+            psHciContext->p_device_mgmt_info)->p_pipe_info ;
+        if (NULL != p_pipe_info)
+        {
+            *ppipe_id = p_pipe_info->pipe.pipe_id ;
+        }
+        else
+        {
+            *ppipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
+        }
+
+    }
+    else 
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    return status;
+}
+
+
+NFCSTATUS
+phHciNfc_DevMgmt_Get_Test_Result(
+                                phHciNfc_sContext_t        *psHciContext,
+                                phNfc_sData_t              *p_test_result
+                            )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+
+    if( (NULL != psHciContext)
+        && ( NULL != p_test_result )
+        && ( NULL != psHciContext->p_device_mgmt_info ) 
+        )
+    {
+        phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL;
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+        p_test_result->buffer = p_device_mgmt_info->test_result.buffer;
+        p_test_result->length = p_device_mgmt_info->test_result.length;
+
+    }
+    else 
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+
+    return status;
+}
+
+
+NFCSTATUS
+phHciNfc_DevMgmt_Set_Test_Result(
+                                phHciNfc_sContext_t        *psHciContext,
+                                uint8_t                    test_status
+                            )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+
+    if( (NULL != psHciContext)
+        && ( NULL != psHciContext->p_device_mgmt_info ) 
+        )
+    {
+        phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL;
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+        p_device_mgmt_info->test_status = test_status;
+        
+    }
+    else 
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+
+    return status;
+}
+
+
+
+NFCSTATUS
+phHciNfc_DevMgmt_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_device_mgmt_info)
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
+    }
+    else
+    {
+        phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL;
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+        /* Update the pipe_info of the Device Management Gate obtained 
+         * from HCI Response */
+        p_device_mgmt_info->p_pipe_info = pPipeInfo;
+        if (( NULL != pPipeInfo)
+            && ((uint8_t)HCI_UNKNOWN_PIPE_ID != pipeID)
+            )
+        {
+            /* Update the Response Receive routine of the Device 
+             * Managment Gate */
+            pPipeInfo->recv_resp = &phHciNfc_Recv_DevMgmt_Response;
+            pPipeInfo->recv_event = &phHciNfc_Recv_DevMgmt_Event;
+        }
+    }
+
+    return status;
+}
+
+
+ NFCSTATUS
+ phHciNfc_DevMgmt_Configure (
+                                phHciNfc_sContext_t *psHciContext,
+                                void                *pHwRef,
+                                uint16_t            address,
+                                uint8_t             value
+                    )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHciNfc_Pipe_Info_t        *p_pipe_info = NULL;
+    uint8_t                     pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
+    uint8_t                     i=0;
+    uint8_t                     params[5];
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if(  NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    else
+    {
+        p_pipe_info = ((phHciNfc_DevMgmt_Info_t *)
+                       psHciContext->p_device_mgmt_info)->p_pipe_info ;
+
+        if(NULL == p_pipe_info )
+        {
+            status = PHNFCSTVAL(CID_NFC_HCI, 
+                            NFCSTATUS_INVALID_HCI_SEQUENCE);
+        }
+        else
+        {
+            pipe_id = p_pipe_info->pipe.pipe_id ;
+            params[i++] = 0x00;
+            params[i++] = (uint8_t)(address >> BYTE_SIZE);
+            params[i++] = (uint8_t)address;
+            params[i++] = value;
+            p_pipe_info->param_info = &params;
+            p_pipe_info->param_length = i ;
+            status = phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 
+                                                pipe_id, (uint8_t)NXP_DBG_WRITE );
+        }
+    }
+    return status;
+}
+
+
+ NFCSTATUS
+ phHciNfc_DevMgmt_Get_Info (
+                                phHciNfc_sContext_t *psHciContext,
+                                void                *pHwRef,
+                                uint16_t            address,
+                                uint8_t             *p_val
+                    )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHciNfc_Pipe_Info_t        *p_pipe_info = NULL;
+    uint8_t                     pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
+    uint8_t                     i=0;
+    uint8_t                     params[5];
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if(  NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    else
+    {
+        p_pipe_info = ((phHciNfc_DevMgmt_Info_t *)
+                       psHciContext->p_device_mgmt_info)->p_pipe_info ;
+
+        if(NULL == p_pipe_info )
+        {
+            status = PHNFCSTVAL(CID_NFC_HCI, 
+                            NFCSTATUS_INVALID_HCI_SEQUENCE);
+        }
+        else
+        {
+            ((phHciNfc_DevMgmt_Info_t *)
+                    psHciContext->p_device_mgmt_info)->p_val = p_val;
+            pipe_id = p_pipe_info->pipe.pipe_id ;
+            params[i++] = 0x00;
+            params[i++] = (uint8_t)(address >> BYTE_SIZE);
+            params[i++] = (uint8_t) address;
+            p_pipe_info->param_info = &params;
+            p_pipe_info->param_length = i ;
+            status = phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 
+                                            pipe_id, (uint8_t)NXP_DBG_READ );
+        }
+    }
+    return status;
+
+}
+
+/*!
+ * \brief Initialisation of PN544 Device Managment Gate.
+ *
+ * This function initialses the PN544 Device Management gate and 
+ * populates the PN544 Device Management Information Structure
+ * 
+ */
+
+NFCSTATUS
+phHciNfc_DevMgmt_Initialise(
+                                phHciNfc_sContext_t     *psHciContext,
+                                void                    *pHwRef
+                         )
+{
+    NFCSTATUS                       status = NFCSTATUS_SUCCESS;
+    phHciNfc_Pipe_Info_t            *p_pipe_info = NULL;
+    phHciNfc_DevMgmt_Info_t         *p_device_mgmt_info=NULL;
+    static uint8_t                   config = 0x10;
+
+    if( ( NULL == psHciContext )
+        || (NULL == pHwRef )
+        )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if (NULL == psHciContext->p_device_mgmt_info)
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI,
+                    NFCSTATUS_INVALID_HCI_INFORMATION);
+    }/* End of the PN544 Device Info Memory Check */
+    else
+    {
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+        p_pipe_info = p_device_mgmt_info->p_pipe_info;
+
+        if (NULL == p_pipe_info)
+        {
+            status = PHNFCSTVAL(CID_NFC_HCI, 
+                            NFCSTATUS_INVALID_HCI_SEQUENCE);
+        }
+        else
+        {
+            switch(p_device_mgmt_info->current_seq )
+            {
+                /* PN544 Device Mgmt pipe open sequence */
+                case DEV_MGMT_PIPE_OPEN:
+                {
+                    status = phHciNfc_Open_Pipe( psHciContext,
+                                                    pHwRef, p_pipe_info );
+                    if(status == NFCSTATUS_SUCCESS)
+                    {
+                        
+                        if (HCI_SELF_TEST == psHciContext->init_mode )
+                        {
+                            p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_GPIO_PDIR;
+                        }
+                        else
+                        {
+                            p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_GET_EEPROM_INFO;
+                        }
+                        status = NFCSTATUS_PENDING;
+                    }
+                    break;
+                }
+                case DEV_MGMT_GET_EEPROM_INFO:
+                {
+                    p_pipe_info->reg_index = DEVICE_INFO_EEPROM_INDEX;
+                    status = phHciNfc_Send_Generic_Cmd( psHciContext, 
+                            pHwRef, (uint8_t)p_pipe_info->pipe.pipe_id,
+                                (uint8_t)ANY_GET_PARAMETER);
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if  ( NXP_NFC_IFC_TIMEOUT & 0x01 )
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_IFC_TO_TX_H;
+#else
+                        p_device_mgmt_info->next_seq =
+                                        DEV_MGMT_TX_LDO;
+#endif /* #if  ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */
+                    }
+                    break;
+                }
+                case DEV_MGMT_GPIO_PDIR:
+                {
+                    config = 0x00;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_GPIO_PDIR , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_GPIO_PEN;
+                    }
+                    break;
+                }
+                case DEV_MGMT_GPIO_PEN:
+                {
+                    config = NXP_NFC_GPIO_MASK(NXP_DOWNLOAD_GPIO)| 0x03 ;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_GPIO_PEN , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if  ( NXP_NFC_IFC_TIMEOUT & 0x01 )
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_IFC_TO_TX_H;
+#else
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_TX_LDO;
+#endif /* #if  ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */
+                    }
+                    break;
+                }
+                
+#if  ( NXP_NFC_IFC_TIMEOUT & 0x01 )
+
+                case DEV_MGMT_IFC_TO_TX_H:
+                {
+                    config =  (uint8_t)
+                        ( NXP_NFC_IFC_CONFIG_DEFAULT >> BYTE_SIZE ) /* 0x03 */;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                        NFC_ADDRESS_IFC_TO_TX_H , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_IFC_TO_TX_L;
+                    }
+                    break;
+                }
+                case DEV_MGMT_IFC_TO_TX_L:
+                {
+                    config = (uint8_t)
+                        ( NXP_NFC_IFC_CONFIG_DEFAULT & BYTE_MASK ) /* 0xE8 */;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_IFC_TO_TX_L , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if  ( NXP_NFC_IFC_TIMEOUT & 0x02 )
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_IFC_TO_RX_H;
+#else
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_TX_LDO;
+#endif /* #if  ( NXP_NFC_IFC_TIMEOUT & 0x02 ) */
+                    }
+                    break;
+                }
+                case DEV_MGMT_IFC_TO_RX_H:
+                {
+                    config = 0x10;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_IFC_TO_RX_H , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_IFC_TO_RX_L;
+                    }
+                    break;
+                }
+                case DEV_MGMT_IFC_TO_RX_L:
+                {
+                    config = 0x1E;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_IFC_TO_RX_L , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_TX_LDO;
+                    }
+                    break;
+                }
+
+#endif /* #if  ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */
+                case DEV_MGMT_TX_LDO:
+                {
+                    config = (NFC_DEV_HWCONF_DEFAULT |
+                                    (NXP_DEFAULT_TX_LDO & NFC_DEV_TXLDO_MASK));
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_HW_CONF , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if ( SW_TYPE_RF_TUNING_BF & 0x01)
+                        p_device_mgmt_info->next_seq = DEV_MGMT_ANAIRQ_CONF;
+#else
+                        p_device_mgmt_info->next_seq = DEV_MGMT_CLK_REQ;
+#endif
+                        /* status = NFCSTATUS_SUCCESS; */
+                    }
+                    break;
+                }
+#if ( SW_TYPE_RF_TUNING_BF & 0x01)
+                /* The Analogue IRQ Configuartion */
+                case DEV_MGMT_ANAIRQ_CONF:
+                {
+                    config = 0x04;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_ANAIRQ_CONF , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_PMOS_MOD;
+                        /* status = NFCSTATUS_SUCCESS; */
+                    }
+                    break;
+                }
+                /* The PMOS Modulation Index */
+                case DEV_MGMT_PMOS_MOD:
+                {
+                    config = NFC_DEV_PMOS_MOD_DEFAULT;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_PMOS_MOD , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_CLK_REQ;
+                        /* status = NFCSTATUS_SUCCESS; */
+                    }
+                    break;
+                }
+#endif /* #if ( SW_TYPE_RF_TUNING_BF & 0x01) */
+                case DEV_MGMT_CLK_REQ:
+                {
+                    config = ((phHal_sHwConfig_t *)
+                                    psHciContext->p_config_params)->clk_req ;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_CLK_REQ , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_INPUT_CLK;
+                        /* status = NFCSTATUS_SUCCESS; */
+                    }
+                    break;
+                }
+                case DEV_MGMT_INPUT_CLK:
+                {
+                    config = ((phHal_sHwConfig_t *)
+                                    psHciContext->p_config_params)->input_clk;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_CLK_INPUT , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_PWR_REQUEST;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_PWR_REQUEST:
+                {
+                    config = NXP_UICC_PWR_REQUEST;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_SWP_PWR_REQ , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_RD_A_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_RD_A_ACCESS:
+                {
+#if ( NXP_UICC_RD_RIGHTS & 0x01 )
+                    config = (uint8_t) phHciNfc_RFReaderAGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_RD_RIGHTS & 0x01 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_RD_A_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_RD_B_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_RD_B_ACCESS:
+                {
+#if ( NXP_UICC_RD_RIGHTS & 0x02 )
+                    config = (uint8_t) phHciNfc_RFReaderBGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_RD_RIGHTS & 0x02 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_RD_B_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_CE_A_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_CE_A_ACCESS:
+                {
+#if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x01 )
+                    config = (uint8_t) phHciNfc_CETypeAGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_CE_RIGHTS & 0x01 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_CE_A_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_CE_B_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_CE_B_ACCESS:
+                {
+#if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x02 )
+                    config = (uint8_t) phHciNfc_CETypeBGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_CE_RIGHTS & 0x02 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_CE_B_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_CE_BP_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_CE_BP_ACCESS:
+                {
+#if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x04 )
+                    config = (uint8_t) phHciNfc_CETypeBPrimeGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_CE_RIGHTS & 0x04 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_CE_BP_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_CE_F_ACCESS;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_CE_F_ACCESS:
+                {
+#if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x08 )
+                    config = (uint8_t) phHciNfc_CETypeFGate;
+#else
+                    config = 0xFFU;
+#endif /* #if ( NXP_UICC_CE_RIGHTS & 0x08 ) */
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_UICC_CE_F_ACCESS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_UICC_BIT_RATE;
+                    }
+                    break;
+                }
+                case DEV_MGMT_UICC_BIT_RATE:
+                {
+                    config = NXP_UICC_BIT_RATE;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_SWP_BITRATE , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if defined (CFG_PWR_STATUS) 
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_SET_PWR_STATUS;
+#else
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_SET_INFO_EVT;
+#endif
+                    }
+                    break;
+                }
+#ifdef CFG_PWR_STATUS
+                case DEV_MGMT_SET_PWR_STATUS:
+                {
+                    config = NXP_SYSTEM_PWR_STATUS;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_PWR_STATUS , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_SET_INFO_EVT;
+                    }
+                    break;
+                }
+#endif
+                case DEV_MGMT_SET_INFO_EVT:
+                {
+                    config = NXP_SYSTEM_EVT_INFO;
+                    status = phHciNfc_Set_Param(psHciContext, pHwRef,
+                                    p_pipe_info, DEVICE_INFO_EVT_INDEX, 
+                                    (uint8_t *)&config, sizeof(config) );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if  ( HOST_LINK_TIMEOUT & 0x01 )
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_LLC_GRD_TO_H;
+#else
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_EVT_AUTONOMOUS;
+                        status = NFCSTATUS_SUCCESS;
+#endif /* #if ( HOST_LINK_TIMEOUT & 0x01 ) */
+                    }
+                    break;
+                }
+#if  ( HOST_LINK_TIMEOUT & 0x01 )
+
+                case DEV_MGMT_LLC_GRD_TO_H:
+                {
+                    config =(uint8_t)
+                        ( NXP_NFC_LINK_GRD_CFG_DEFAULT >> BYTE_SIZE ) /* 0x00 */;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_LLC_GRD_TO_H , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_LLC_GRD_TO_L;
+                    }
+                    break;
+                }
+                case DEV_MGMT_LLC_GRD_TO_L:
+                {
+                    config = (uint8_t)
+                        ( NXP_NFC_LINK_GRD_CFG_DEFAULT & BYTE_MASK ) /* 0x32 */;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_LLC_GRD_TO_L , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+#if  ( HOST_LINK_TIMEOUT & 0x02 )
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_LLC_ACK_TO_H;
+#else
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_EVT_AUTONOMOUS;
+                        status = NFCSTATUS_SUCCESS;
+#endif /* #if ( HOST_LINK_TIMEOUT & 0x02 ) */
+                    }
+                    break;
+                }
+                case DEV_MGMT_LLC_ACK_TO_H:
+                {
+                    config = (uint8_t)
+                        ( NXP_NFC_LINK_ACK_CFG_DEFAULT >> BYTE_SIZE )/* 0x00 */;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_LLC_ACK_TO_H , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_LLC_ACK_TO_L;
+                    }
+                    break;
+                }
+                case DEV_MGMT_LLC_ACK_TO_L:
+                {
+                    config = (uint8_t)
+                        ( NXP_NFC_LINK_ACK_CFG_DEFAULT & BYTE_MASK ) /* 0x00 */;;
+                    status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef,
+                            NFC_ADDRESS_LLC_ACK_TO_L , config );
+                    if(NFCSTATUS_PENDING == status )
+                    {
+                        p_device_mgmt_info->next_seq =
+                                                DEV_MGMT_EVT_AUTONOMOUS;
+                        status = NFCSTATUS_SUCCESS;
+                    }
+                    break;
+                }
+
+#endif /* #if ( HOST_LINK_TIMEOUT & 0x01 ) */
+                default:
+                {
+                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
+                    break;
+                }
+
+            }/* End of the Sequence Switch */
+        }
+
+    } /* End of Null Context Check */
+
+    return status;
+}
+
+/*!
+ * \brief Releases the resources allocated the PN544 Device Management.
+ *
+ * This function Releases the resources allocated the PN544 Device Management
+ * and resets the hardware to the reset state.
+ */
+
+NFCSTATUS
+phHciNfc_DevMgmt_Release(
+                                phHciNfc_sContext_t     *psHciContext,
+                                void                    *pHwRef
+                             )
+{
+    NFCSTATUS                           status = NFCSTATUS_SUCCESS;
+    phHciNfc_Pipe_Info_t                *p_pipe_info = NULL;
+    phHciNfc_DevMgmt_Info_t         *p_device_mgmt_info=NULL;
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else
+    {
+        if( NULL != psHciContext->p_device_mgmt_info )
+        {
+            p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+            switch(p_device_mgmt_info->current_seq)
+            {
+                
+                /* PN544 Device pipe close sequence */
+                case DEV_MGMT_EVT_AUTONOMOUS:
+                {
+                    p_pipe_info = p_device_mgmt_info->p_pipe_info;
+
+                    p_pipe_info->param_info = NULL;
+                    p_pipe_info->param_length = HCP_ZERO_LEN;
+
+                    status = phHciNfc_Send_DevMgmt_Event(psHciContext, pHwRef, 
+                                p_pipe_info->pipe.pipe_id, NXP_EVT_SET_AUTONOMOUS);
+                    if(status == NFCSTATUS_PENDING)
+                    {
+                        p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN;
+                        status = NFCSTATUS_SUCCESS;
+                    }
+                    break;
+                }
+                /* PN544 Device pipe close sequence */
+                case DEV_MGMT_PIPE_CLOSE:
+                {
+                    p_pipe_info = p_device_mgmt_info->p_pipe_info;
+
+                    status = phHciNfc_Close_Pipe( psHciContext,
+                                                        pHwRef, p_pipe_info );
+                    if(status == NFCSTATUS_SUCCESS)
+                    {
+                        p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN;
+                        /* status = NFCSTATUS_PENDING; */
+                    }
+                    break;
+                }
+                default:
+                {
+                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
+                    break;
+                }
+
+            }/* End of the Sequence Switch */
+
+        }/* End of the PN544 Device Info Memory Check */
+
+    } /* End of Null Context Check */
+
+    return status;
+}
+
+NFCSTATUS
+phHciNfc_DevMgmt_Update_Sequence(
+                                phHciNfc_sContext_t     *psHciContext,
+                                phHciNfc_eSeqType_t     DevMgmt_seq
+                             )
+{
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHciNfc_DevMgmt_Info_t          *p_device_mgmt_info=NULL;
+    if( NULL == psHciContext )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if ( NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, 
+                        NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    else
+    {
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                            psHciContext->p_device_mgmt_info ;
+        switch(DevMgmt_seq)
+        {
+            case RESET_SEQ:
+            case INIT_SEQ:
+            {
+                p_device_mgmt_info->current_seq = DEV_MGMT_PIPE_OPEN;
+                p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN ;
+            }break;
+            case UPDATE_SEQ:
+            {
+                p_device_mgmt_info->current_seq = p_device_mgmt_info->next_seq;
+            
+            }break;
+            case REL_SEQ:
+            {
+                p_device_mgmt_info->current_seq = DEV_MGMT_EVT_AUTONOMOUS;
+                p_device_mgmt_info->next_seq = DEV_MGMT_EVT_AUTONOMOUS ;
+            }break;
+            default:
+            {
+                break;
+            }
+        }/* End of Update Sequence Switch */
+    }
+    return status;
+
+}
+
+
+
+/*!
+ * \brief Perform the System Management Tests  
+ * provided by the corresponding peripheral device.
+ *
+ * This function performs the System Management Tests provided by the NFC
+ * Peripheral device.
+ */
+
+NFCSTATUS
+phHciNfc_DevMgmt_Test(
+                    void                            *psContext,
+                    void                            *pHwRef,
+                    uint8_t                         test_type,
+                    phNfc_sData_t                   *test_param
+                 )
+{
+    phHciNfc_sContext_t         *psHciContext = 
+                                    (phHciNfc_sContext_t *)psContext ;
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHciNfc_Pipe_Info_t        *p_pipe_info = NULL;
+    uint8_t                     pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if(  NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    else
+    {
+        p_pipe_info = ((phHciNfc_DevMgmt_Info_t *)
+                       psHciContext->p_device_mgmt_info)->p_pipe_info ;
+        switch(test_type)
+        {
+            case NXP_SELF_TEST_ANTENNA:
+            case NXP_SELF_TEST_SWP:
+            case NXP_SELF_TEST_PRBS:
+            /* case NXP_SELF_TEST_NFCWI: */
+            {
+                if (NULL != p_pipe_info)
+                {
+                    pipe_id = p_pipe_info->pipe.pipe_id ;
+                    if ( NULL != test_param )
+                    {
+                        p_pipe_info->param_info = test_param->buffer;
+                        p_pipe_info->param_length = (uint8_t)test_param->length;
+                    }
+                    status = 
+                        phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 
+                            pipe_id, (uint8_t)test_type );
+                }
+                else
+                {
+                    status = PHNFCSTVAL(CID_NFC_HCI, 
+                                        NFCSTATUS_INVALID_HCI_INFORMATION);
+                }
+                break;
+            }
+            default:
+            {
+                status = PHNFCSTVAL(CID_NFC_HCI,
+                            NFCSTATUS_FEATURE_NOT_SUPPORTED);
+                break;
+            }
+        }
+
+    }
+    return status;
+}
+
+
+/*!
+ * \brief Receives the HCI Response from the corresponding peripheral device.
+ *
+ * This function receives the HCI Command Response from the connected NFC
+ * Peripheral device.
+ */
+static
+NFCSTATUS
+phHciNfc_Recv_DevMgmt_Response(
+                        void                *psContext,
+                        void                *pHwRef,
+                        uint8_t             *pResponse,
+#ifdef ONE_BYTE_LEN
+                        uint8_t             length
+#else
+                        uint16_t            length
+#endif
+                    )
+{
+    phHciNfc_sContext_t         *psHciContext = 
+                                    (phHciNfc_sContext_t *)psContext ;
+    phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL;
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    uint8_t                     prev_cmd = ANY_GET_PARAMETER;
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if(  NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
+    }
+    else
+    {
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                            psHciContext->p_device_mgmt_info ;
+        prev_cmd = p_device_mgmt_info->p_pipe_info->prev_msg ;
+        switch(prev_cmd)
+        {
+            case ANY_GET_PARAMETER:
+            {
+                status = phHciNfc_DevMgmt_InfoUpdate(psHciContext,
+                            (phHal_sHwReference_t *)pHwRef,
+                            p_device_mgmt_info->p_pipe_info->reg_index, 
+                            &pResponse[HCP_HEADER_LEN],
+                                (uint8_t)(length - HCP_HEADER_LEN));
+                break;
+            }
+            case ANY_SET_PARAMETER:
+            {
+                break;
+            }
+            case ANY_OPEN_PIPE:
+            {
+                break;
+            }
+            case ANY_CLOSE_PIPE:
+            {
+                phOsalNfc_FreeMemory(p_device_mgmt_info->p_pipe_info);
+                p_device_mgmt_info->p_pipe_info = NULL;
+                psHciContext->p_pipe_list[PIPETYPE_STATIC_LINK] = NULL;
+                break;
+            }
+            case NXP_DBG_READ:
+            {
+                *p_device_mgmt_info->p_val = (uint8_t)( length > HCP_HEADER_LEN ) ?
+                                    pResponse[HCP_HEADER_LEN]: 0;
+                p_device_mgmt_info->p_val = NULL;
+
+            }
+            /* fall through */
+            case NXP_DBG_WRITE:
+            {
+                break;
+            }
+            /* Self Test Commands */
+            case NXP_SELF_TEST_ANTENNA:
+            case NXP_SELF_TEST_SWP:
+            case NXP_SELF_TEST_NFCWI:
+            case NXP_SELF_TEST_PRBS:
+            {
+                p_device_mgmt_info->test_status = (uint8_t) ( length > HCP_HEADER_LEN ) ?
+                                    pResponse[HCP_HEADER_LEN]: 0;
+                p_device_mgmt_info->test_result.buffer = (uint8_t)( length > HCP_HEADER_LEN ) ?
+                                    &pResponse[HCP_HEADER_LEN]: NULL;
+                p_device_mgmt_info->test_result.length = ( length - HCP_HEADER_LEN );
+                break;
+            }
+            default:
+            {
+                status = PHNFCSTVAL(CID_NFC_HCI,
+                                        NFCSTATUS_INVALID_HCI_RESPONSE);
+                break;
+            }
+        }
+        if( NFCSTATUS_SUCCESS == status )
+        {
+            if( NULL != p_device_mgmt_info->p_pipe_info)
+            {
+                p_device_mgmt_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
+            }
+            p_device_mgmt_info->current_seq = p_device_mgmt_info->next_seq;
+        }
+
+    }
+    return status;
+}
+
+/*!
+ * \brief Receives the HCI Event from the corresponding peripheral device.
+ *
+ * This function receives the HCI Event from the connected NFC
+ * Peripheral device.
+ */
+
+static
+NFCSTATUS
+phHciNfc_Recv_DevMgmt_Event(
+                        void                *psContext,
+                        void                *pHwRef,
+                        uint8_t             *pEvent,
+#ifdef ONE_BYTE_LEN
+                        uint8_t             length
+#else
+                        uint16_t            length
+#endif
+                    )
+{
+    phHciNfc_sContext_t         *psHciContext = 
+                                    (phHciNfc_sContext_t *)psContext ;
+    phHciNfc_DevMgmt_Info_t     *p_device_mgmt_info=NULL;
+    phHciNfc_HCP_Packet_t       *hcp_packet = NULL;
+    phHciNfc_HCP_Message_t      *hcp_message = NULL;
+    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
+    phHal_sEventInfo_t          event_info;
+    uint8_t                     event = (uint8_t) HCP_MSG_INSTRUCTION_INVALID;
+
+    if( (NULL == psHciContext) || (NULL == pHwRef) )
+    {
+      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if(  NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
+    }
+    else
+    {
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                            psHciContext->p_device_mgmt_info ;
+        hcp_packet = (phHciNfc_HCP_Packet_t *)pEvent;
+        hcp_message = &hcp_packet->msg.message;
+
+        /* Get the Event instruction bits from the Message Header */
+        event = (uint8_t) GET_BITS8( hcp_message->msg_header,
+            HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
+        event_info.eventHost = phHal_eHostController ;
+        event_info.eventSource = phHal_ePCD_DevType;
+
+        switch(event)
+        {
+            /* Information Events */
+            case NXP_EVT_INFO_TXLDO_OVERCUR:
+            {
+                event_info.eventType = NFC_INFO_TXLDO_OVERCUR;
+                break;
+            }
+            case NXP_EVT_INFO_PMUVCC:
+            {
+                p_device_mgmt_info->pmuvcc_status = (uint8_t) ( length > HCP_HEADER_LEN ) ?
+                                    pEvent[HCP_HEADER_LEN]: 0;
+                break;
+            }
+            case NXP_EVT_INFO_EXT_RF_FIELD:
+            {
+                event_info.eventSource = phHal_ePICC_DevType ;
+                p_device_mgmt_info->rf_status = (uint8_t) ( length > HCP_HEADER_LEN ) ?
+                                    pEvent[HCP_HEADER_LEN]: 0;
+#ifdef EVT_INFO_EXT_EVT_DIRECT
+                event_info.eventType = ( CE_EVT_NFC_FIELD_ON == 
+                                (p_device_mgmt_info->rf_status & 0x1FU))?
+                                    NFC_EVT_FIELD_ON : NFC_EVT_FIELD_OFF;
+#else
+                event_info.eventType = (TRUE == p_device_mgmt_info->rf_status)?
+                                    NFC_EVT_FIELD_ON : NFC_EVT_FIELD_OFF;
+#endif
+                break;
+            }
+            case NXP_EVT_INFO_MEM_VIOLATION:
+            {
+                event_info.eventType = NFC_INFO_MEM_VIOLATION;
+                break;
+            }
+            case NXP_EVT_INFO_TEMP_OVERHEAT:
+            {
+                p_device_mgmt_info->overheat_status = (uint8_t)( length > HCP_HEADER_LEN ) ?
+                                    pEvent[HCP_HEADER_LEN]: 0;
+                event_info.eventType = NFC_INFO_TEMP_OVERHEAT;
+                event_info.eventInfo.overheat_status = 
+                                    p_device_mgmt_info->overheat_status;
+                break;
+            }
+            default:
+            {
+                status = PHNFCSTVAL(CID_NFC_HCI,
+                                        NFCSTATUS_INVALID_HCI_RESPONSE);
+                break;
+            }
+        }
+        if( NFCSTATUS_SUCCESS == status )
+        {
+            if( NULL != p_device_mgmt_info->p_pipe_info)
+            {
+                p_device_mgmt_info->p_pipe_info->prev_status = 
+                                                    NFCSTATUS_SUCCESS;
+            }
+            p_device_mgmt_info->current_seq = 
+                                        p_device_mgmt_info->next_seq;
+            phHciNfc_Notify_Event(psHciContext, pHwRef, 
+                                        NFC_NOTIFY_EVENT, &event_info);
+        }
+    }
+    return status;
+}
+
+
+static
+NFCSTATUS
+phHciNfc_DevMgmt_InfoUpdate(
+                                phHciNfc_sContext_t     *psHciContext,
+                                phHal_sHwReference_t    *pHwRef,
+                                uint8_t                 index,
+                                uint8_t                 *reg_value,
+                                uint8_t                 reg_length
+                          )
+{
+    phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL;
+    NFCSTATUS               status = NFCSTATUS_SUCCESS;
+    uint8_t                 i=0;
+
+    PHNFC_UNUSED_VARIABLE(pHwRef);
+    if( (NULL == psHciContext)
+        || (NULL == reg_value)
+        || (reg_length == 0)
+      )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
+    }
+    else if ( NULL == psHciContext->p_device_mgmt_info )
+    {
+        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
+    }
+    else
+    {
+        p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *)
+                                psHciContext->p_device_mgmt_info ;
+
+        switch(index)
+        {
+            case DEVICE_INFO_EEPROM_INDEX:
+            {
+                p_device_mgmt_info->eeprom_crc = reg_value[i];
+                break;
+            }
+            default:
+            {
+                break;
+            }
+        }
+
+    } /* End of Context and the PN544 Device information validity check */
+
+    return status;
+}
+
+
+
+/*!
+ * \brief Sends the RF Settings HCI Additonal Commands to the connected 
+ * reader device.
+ *
+ * This function Sends the RF Settings HCI Command frames in the HCP packet 
+ * format to the connected reader device.
+ */
+static
+ NFCSTATUS
+ phHciNfc_Send_DevMgmt_Command (
+                                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;
+    uint8_t                 length=0;
+    uint8_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_DevMgmt_Command");
+    }
+    else
+    {
+        p_pipe_info = (phHciNfc_Pipe_Info_t *) 
+                                psHciContext->p_pipe_list[pipe_id];
+        psHciContext->tx_total = 0 ;
+        length +=  HCP_HEADER_LEN ;
+        switch( cmd )
+        {
+            /* Self Test Commands */
+            case NXP_SELF_TEST_ANTENNA:
+            case NXP_SELF_TEST_SWP:
+            case NXP_SELF_TEST_NFCWI:
+            case NXP_SELF_TEST_PRBS:
+            /* Internal Properietary Commands */
+            case NXP_DBG_READ:
+            case NXP_DBG_WRITE:
+            {
+                
+                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);
+                /* Append the RF Setting Parameter also the optional Value */
+                phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
+                                            i, p_pipe_info->param_info,
+                                            p_pipe_info->param_length);
+                length =(uint8_t)(length + i + p_pipe_info->param_length);
+                break;
+            }
+            default:
+            {
+                status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED );
+                HCI_DEBUG("%s: Statement Should Not Occur \n",
+                                                "phHciNfc_Send_DevMgmt_Command");
+                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 Sends the RF Settings HCI Additonal Events to the connected 
+ * reader device.
+ *
+ * This function Sends the RF Settings HCI Events frames in the HCP packet 
+ * format to the connected reader device.
+ */
+
+static
+ NFCSTATUS
+ phHciNfc_Send_DevMgmt_Event (
+                                phHciNfc_sContext_t *psHciContext,
+                                void                *pHwRef,
+                                uint8_t             pipe_id,
+                                uint8_t             event
+                    )
+ {
+    phHciNfc_HCP_Packet_t   *hcp_packet = NULL;
+    phHciNfc_HCP_Message_t  *hcp_message = NULL;
+    phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;
+    uint8_t                 length=0;
+    uint8_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_DevMgmt_Event");
+    }
+    else
+    {
+        p_pipe_info = (phHciNfc_Pipe_Info_t *) 
+                                psHciContext->p_pipe_list[pipe_id];
+        psHciContext->tx_total = 0 ;
+        length +=  HCP_HEADER_LEN ;
+        if( NXP_EVT_SET_AUTONOMOUS == event )
+        {
+            
+            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_EVENT, event);
+            hcp_message = &(hcp_packet->msg.message);
+            /* Append the RF Setting Parameter also the optional Value */
+            phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
+                                        i, p_pipe_info->param_info,
+                                        p_pipe_info->param_length);
+            length =(uint8_t)(length + i + p_pipe_info->param_length);
+        }
+        else
+        {
+            status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED );
+            HCI_DEBUG("%s: Statement Should Not Occur \n",
+                                            "phHciNfc_Send_DevMgmt_Event");
+        }
+        if( NFCSTATUS_SUCCESS == status )
+        {
+            p_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT;
+            p_pipe_info->prev_msg = event;
+            psHciContext->tx_total = length;
+
+            /* Send the Constructed HCP packet to the lower layer */
+            status = phHciNfc_Send_HCP( psHciContext, pHwRef );
+            p_pipe_info->prev_status = NFCSTATUS_PENDING;
+        }
+    }
+
+    return status;
+}
+
+
+
+
+