| /* |
| * 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; |
| } |
| |
| |
