/*
* 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_PollingLoop.c *
* \brief HCI polling loop Management Routines. *
* *
* *
* Project: NFC-FRI-1.1 *
* *
* $Date: Mon Mar 29 17:34:48 2010 $ *
* $Author: ing04880 $ *
* $Revision: 1.35 $ *
* $Aliases: 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 <phNfcCompId.h>
#include <phNfcHalTypes.h>
#include <phHciNfc_Pipe.h>
#include <phHciNfc_PollingLoop.h>
#include <phOsalNfc.h>
/*
****************************** Macro Definitions *******************************
*/
/* Registry index to which command has to be sent */
#define PL_PAUSE_INDEX 0x08U
#define PL_EMULATION_INDEX 0x07U
#define PL_RD_PHASES_INDEX 0x06U
#define PL_DISABLE_TARGET_INDEX 0x09U
/* Events */
#define NXP_EVT_CLK_ACK 0x01U
#define NXP_EVT_CLK_REQUEST 0x02U
#define NXP_EVT_ACTIVATE_RDPHASES 0x03U
#define NXP_EVT_DEACTIVATE_RDPHASES 0x04U
/* Command length */
#define PL_DURATION_LENGTH 0x02U
#define PL_BYTE_LEN_1 0x01U
#define PL_BIT_FIELD_ENABLED 0x01U
#define PL_EMULATION_FACTOR 0x0AU
/* Default duration (100 ms * 1000) micro seconds,
always duration shall be less then 3145680
micro seconds */
#define PL_DEFAULT_DURATION 100000U
/* Maximum duration */
#define PL_MAX_DURATION 3145000U
#define PL_DURATION_MIN_VALUE 48U
#define PL_DURATION_CALC(duration) \
((uint16_t)((duration)/PL_DURATION_MIN_VALUE))
/*
*************************** Structure and Enumeration ***************************
*/
typedef enum phHciNfc_Poll_Seq{
PL_PIPE_OPEN = 0x00U,
PL_PIPE_CLOSE,
PL_SET_DURATION,
PL_GET_DURATION,
PL_GET_RD_PHASES,
PL_SET_RD_PHASES,
PL_GET_DISABLE_TARGET,
PL_SET_DISABLE_TARGET,
PL_END_SEQUENCE
} phHciNfc_Poll_Seq_t;
/* Information structure for the polling loop Gate */
typedef struct phHciNfc_PollLoop_Info{
/* Current running Sequence of the polling loop Management */
phHciNfc_Poll_Seq_t current_seq;
/* Next running Sequence of the polling loop Management */
phHciNfc_Poll_Seq_t next_seq;
/* Pointer to the polling loop pipe information */
phHciNfc_Pipe_Info_t *p_pipe_info;
uint8_t pipe_id;
} phHciNfc_PollLoop_Info_t;
/*
*************************** Static Function Declaration **************************
*/
static
NFCSTATUS
phHciNfc_PollLoop_InfoUpdate(
phHciNfc_sContext_t *psHciContext,
uint8_t index,
uint8_t *reg_value,
uint8_t reg_length
);
/**
* \ingroup grp_hci_nfc
*
* The phHciNfc_Recv_Pl_Response function interprets the received polling loop
* response from the Host Controller Gate.
*
* \param[in] psHciContext psHciContext is the pointer to HCI Layer
* context Structure.
* \param[in] pHwRef pHwRef is the Information of
* the Device Interface Link .
* \param[in,out] pResponse Response received from the Host Cotroller
* polling loop gate.
* \param[in] length length contains the length of the
* response received from the Host Controller.
*
* \retval NFCSTATUS_PENDING Polling loop gate Response to be received
* is pending.
* \retval NFCSTATUS_SUCCESS Polling loop gate Response received
* Successfully.
* \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
* could not be interpreted properly.
* \retval Other errors Errors related to the other layers
*
*/
static
NFCSTATUS
phHciNfc_Recv_PollLoop_Response(
void *psContext,
void *pHwRef,
uint8_t *pResponse,
#ifdef ONE_BYTE_LEN
uint8_t length
#else
uint16_t length
#endif
);
static
NFCSTATUS
phHciNfc_Recv_PollLoop_Event(
void *psContext,
void *pHwRef,
uint8_t *pEvent,
#ifdef ONE_BYTE_LEN
uint8_t length
#else
uint16_t length
#endif
);
/*
*************************** Function Definitions ***************************
*/
NFCSTATUS
phHciNfc_PollLoop_Get_PipeID(
phHciNfc_sContext_t *psHciContext,
uint8_t *ppipe_id
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if( (NULL != psHciContext)
&& ( NULL != ppipe_id )
&& ( NULL != psHciContext->p_poll_loop_info )
)
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
*ppipe_id = p_poll_info->pipe_id ;
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
return status;
}
NFCSTATUS
phHciNfc_PollLoop_Init_Resources(
phHciNfc_sContext_t *psHciContext
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
if( NULL == psHciContext )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
if(
( NULL == psHciContext->p_poll_loop_info )
&& (phHciNfc_Allocate_Resource((void **)(&p_poll_info),
sizeof(phHciNfc_PollLoop_Info_t))== NFCSTATUS_SUCCESS)
)
{
psHciContext->p_poll_loop_info = p_poll_info;
p_poll_info->current_seq = PL_PIPE_OPEN;
p_poll_info->next_seq = PL_PIPE_CLOSE;
p_poll_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
}
}
return status;
}
/*!
* \brief Initialisation of polling loop Gate and Establish the Session .
*
* This function initialses the polling loop Gates and
* all the required pipes and sets the Session ID
*
*/
NFCSTATUS
phHciNfc_PollLoop_Initialise(
phHciNfc_sContext_t *psHciContext,
void *pHwRef
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if( NULL == psHciContext )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
if( NULL == psHciContext->p_poll_loop_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_INFORMATION);
}
else
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
p_pipe_info = p_poll_info->p_pipe_info;
if(NULL == p_pipe_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
HCI_PRINT("Polling loop open pipe in progress ...\n");
status = phHciNfc_Open_Pipe( psHciContext,
pHwRef, p_pipe_info );
if(NFCSTATUS_SUCCESS == status)
{
p_poll_info->next_seq = PL_PIPE_CLOSE;
}
}
}
}
return status;
}
NFCSTATUS
phHciNfc_PollLoop_Release(
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_poll_loop_info )
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
if (PL_PIPE_CLOSE == p_poll_info->current_seq)
{
phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
p_pipe_info = p_poll_info->p_pipe_info;
if(NULL == p_pipe_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
HCI_PRINT("Polling loop close pipe in progress ...\n");
status = phHciNfc_Close_Pipe( psHciContext,
pHwRef, p_pipe_info );
if(status == NFCSTATUS_SUCCESS)
{
p_poll_info->next_seq = PL_PIPE_OPEN;
}
}
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
} /* End of if (PL_PIPE_CLOSE == p_pl_info->cur_seq) */
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
} /* End of if( NULL != psHciContext->p_poll_loop_info ) */
} /* End of if( (NULL == psHciContext) || (NULL == pHwRef) ) */
return status;
}
NFCSTATUS
phHciNfc_PollLoop_Cfg (
void *psHciHandle,
void *pHwRef,
uint8_t cfg_type,
void *pcfg_info
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
uint8_t poll_cfg;
static uint16_t pl_duration = 0;
/* To remove "warning (VS C4100) : unreferenced formal parameter" */
PHNFC_UNUSED_VARIABLE(pcfg_info);
if( (NULL == psHciContext)
|| (NULL == pHwRef)
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if(NULL == psHciContext->p_poll_loop_info)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
phHal_sADD_Cfg_t *p_poll_cfg = NULL;
uint8_t pipeid = 0;
p_poll_cfg = (phHal_sADD_Cfg_t*)psHciContext->p_config_params;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
p_pipe_info = p_poll_info->p_pipe_info;
if((NULL == p_pipe_info) || (NULL == p_poll_cfg))
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
switch(cfg_type)
{
case PL_DURATION:
{
/*
Data memory has to be copied to
param_info and also depending on the
CARD_EMULATION or PAUSE, change the
p_pipe_info->reg_index
*/
if(p_poll_cfg->Duration > PL_MAX_DURATION)
{
p_poll_cfg->Duration = PL_MAX_DURATION;
}
if (FALSE ==
p_poll_cfg->PollDevInfo.PollCfgInfo.DisableCardEmulation)
{
p_poll_cfg->Duration = ((p_poll_cfg->Duration <
PL_DURATION_MIN_VALUE)?
(PL_DEFAULT_DURATION *
PL_EMULATION_FACTOR):
p_poll_cfg->Duration );
p_pipe_info->reg_index = PL_EMULATION_INDEX;
}
else
{
p_poll_cfg->Duration = ((p_poll_cfg->Duration <
PL_DURATION_MIN_VALUE)?
PL_DEFAULT_DURATION :
p_poll_cfg->Duration);
p_pipe_info->reg_index = PL_PAUSE_INDEX;
}
p_pipe_info->param_length = PL_DURATION_LENGTH;
/* Calculate duration */
pl_duration = (uint16_t)
PL_DURATION_CALC(p_poll_cfg->Duration);
/* Swap the 2 byte value */
pl_duration = (uint16_t)((pl_duration << BYTE_SIZE) |
((uint8_t)(pl_duration >> BYTE_SIZE)));
/* Copy the duration from poll config structure,
provided by the upper layer */
p_pipe_info->param_info = (void *)&(pl_duration);
pipeid = p_poll_info->pipe_id ;
if (PL_GET_DURATION == p_poll_info->current_seq)
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_GET_PARAMETER);
if (NFCSTATUS_PENDING == status)
{
p_poll_info->next_seq = PL_PIPE_CLOSE;
status = NFCSTATUS_SUCCESS;
}
}
else
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_SET_PARAMETER);
if(NFCSTATUS_PENDING == status )
{
#ifdef ENABLE_VERIFY_PARAM
p_poll_info->next_seq = PL_GET_DURATION;
#else
status = NFCSTATUS_SUCCESS;
#endif /* #ifdef ENABLE_VERIFY_PARAM */
}
}
break;
}
case PL_RD_PHASES:
{
poll_cfg = (uint8_t) p_poll_cfg->PollDevInfo.PollEnabled;
p_pipe_info->param_length = PL_BYTE_LEN_1;
p_pipe_info->reg_index = PL_RD_PHASES_INDEX;
/* Data memory has to be copied to
param_info */
p_pipe_info->param_info = (void *)&(poll_cfg);
pipeid = p_poll_info->pipe_id ;
if (PL_GET_RD_PHASES == p_poll_info->current_seq)
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_GET_PARAMETER);
if (NFCSTATUS_PENDING == status)
{
status = NFCSTATUS_SUCCESS;
}
}
else
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_SET_PARAMETER);
if(NFCSTATUS_PENDING == status )
{
#ifdef ENABLE_VERIFY_PARAM
p_poll_info->next_seq = PL_GET_RD_PHASES;
#else
status = NFCSTATUS_SUCCESS;
#endif /* #ifdef ENABLE_VERIFY_PARAM */
}
}
break;
}
case PL_DISABLE_TARGET:
{
if (NULL == pcfg_info)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* poll_cfg = (uint8_t) p_poll_cfg->NfcIP_Tgt_Disable; */
p_pipe_info->param_length = PL_BYTE_LEN_1;
p_pipe_info->reg_index = PL_DISABLE_TARGET_INDEX;
/* Data memory has to be copied to
param_info */
p_pipe_info->param_info = pcfg_info;
pipeid = p_poll_info->pipe_id ;
if (PL_GET_DISABLE_TARGET == p_poll_info->current_seq)
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_GET_PARAMETER);
if (NFCSTATUS_PENDING == status)
{
status = NFCSTATUS_SUCCESS;
}
}
else
{
status =
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_SET_PARAMETER);
if( NFCSTATUS_PENDING == status )
{
#ifdef ENABLE_VERIFY_PARAM
/* p_poll_info->current_seq = PL_GET_DISABLE_TARGET; */
p_poll_info->next_seq = PL_GET_DISABLE_TARGET;
#else
status = NFCSTATUS_SUCCESS;
#endif /* #ifdef ENABLE_VERIFY_PARAM */
}
}
}
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_PARAMETER);
break;
}
}
}
}
return status;
}
/* Function to assign pipe ID */
NFCSTATUS
phHciNfc_PollLoop_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_poll_loop_info )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
/* Update the pipe_id of the ID Mgmt Gate obtained from the HCI Response */
p_poll_info->pipe_id = pipeID;
p_poll_info->p_pipe_info = pPipeInfo;
if (NULL != pPipeInfo)
{
/* Update the Response Receive routine of the IDMgmt Gate */
pPipeInfo->recv_resp = &phHciNfc_Recv_PollLoop_Response;
/* Update the event Receive routine of the IDMgmt Gate */
pPipeInfo->recv_event = &phHciNfc_Recv_PollLoop_Event;
}
}
return status;
}
static
NFCSTATUS
phHciNfc_Recv_PollLoop_Response(
void *psContext,
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 *)psContext ;
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
|| (length == 0))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if( NULL == psHciContext->p_poll_loop_info )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
uint8_t prev_cmd = ANY_GET_PARAMETER;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
if( NULL == p_poll_info->p_pipe_info)
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
prev_cmd = p_poll_info->p_pipe_info->prev_msg ;
switch(prev_cmd)
{
case ANY_SET_PARAMETER:
{
HCI_PRINT("Polling loop Set Param complete\n");
break;
}
case ANY_GET_PARAMETER:
{
status = phHciNfc_PollLoop_InfoUpdate(psHciContext,
p_poll_info->p_pipe_info->reg_index,
&pResponse[HCP_HEADER_LEN],
(uint8_t)(length - HCP_HEADER_LEN));
break;
}
case ANY_OPEN_PIPE:
{
HCI_PRINT("Polling loop open pipe complete\n");
break;
}
case ANY_CLOSE_PIPE:
{
HCI_PRINT("Polling loop close pipe complete\n");
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
break;
}
}
if( NFCSTATUS_SUCCESS == status )
{
p_poll_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
p_poll_info->current_seq = p_poll_info->next_seq;
}
}
}
return status;
}
static
NFCSTATUS
phHciNfc_Recv_PollLoop_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)
|| (length <= HCP_HEADER_LEN))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if( NULL == psHciContext->p_poll_loop_info )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_HCP_Packet_t *p_packet = NULL;
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
phHciNfc_HCP_Message_t *message = NULL;
static phHal_sEventInfo_t event_info;
uint8_t instruction=0;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
psHciContext->p_poll_loop_info ;
PHNFC_UNUSED_VARIABLE(p_poll_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_CLK_ACK:
{
break;
}
case NXP_EVT_CLK_REQUEST:
{
break;
}
case NXP_EVT_ACTIVATE_RDPHASES:
{
HCI_PRINT("Polling loop activate read phase complete\n");
event_info.eventHost = phHal_eHostController;
event_info.eventType = NFC_UICC_RDPHASES_ACTIVATE_REQ;
event_info.eventInfo.rd_phases = pEvent[HCP_HEADER_LEN];
((phHal_sHwReference_t *)pHwRef)->uicc_rdr_active = TRUE;
phHciNfc_Notify_Event((void *)psHciContext,
pHwRef,
NFC_NOTIFY_EVENT,
&(event_info));
break;
}
case NXP_EVT_DEACTIVATE_RDPHASES:
{
HCI_PRINT("Polling loop deactivate read phase complete\n");
event_info.eventHost = phHal_eHostController;
event_info.eventType = NFC_UICC_RDPHASES_DEACTIVATE_REQ;
event_info.eventInfo.rd_phases = pEvent[HCP_HEADER_LEN];
((phHal_sHwReference_t *)pHwRef)->uicc_rdr_active = FALSE;
phHciNfc_Notify_Event((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_PollLoop_InfoUpdate(
phHciNfc_sContext_t *psHciContext,
uint8_t index,
uint8_t *reg_value,
uint8_t reg_length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phHciNfc_PollLoop_Info_t *p_poll_info=NULL;
p_poll_info = (phHciNfc_PollLoop_Info_t *)
(psHciContext->p_poll_loop_info );
/* To remove "warning (VS 4100) : unreferenced formal parameter" */
PHNFC_UNUSED_VARIABLE(reg_value);
PHNFC_UNUSED_VARIABLE(reg_length);
/* Variable was set but never used (ARM warning) */
PHNFC_UNUSED_VARIABLE(p_poll_info);
switch(index)
{
case PL_EMULATION_INDEX:
case PL_PAUSE_INDEX:
{
HCI_PRINT_BUFFER("\tPoll duration", reg_value, reg_length);
break;
}
case PL_RD_PHASES_INDEX:
{
HCI_PRINT_BUFFER("\tPoll read phase", reg_value, reg_length);
break;
}
#if defined (CLK_REQUEST)
case PL_CLK_REQUEST_INDEX:
{
HCI_PRINT_BUFFER("\tPoll clock request", reg_value, reg_length);
break;
}
#endif /* #if defined (CLK_REQUEST) */
#if defined (INPUT_CLK)
case PL_INPUT_CLK_INDEX:
{
HCI_PRINT_BUFFER("\tPoll input clock", reg_value, reg_length);
break;
}
#endif/* #if defined (INPUT_CLK) */
default:
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
break;
}
}
return status;
}