diff options
Diffstat (limited to 'src/phHciNfc.c')
| -rw-r--r-- | src/phHciNfc.c | 1782 |
1 files changed, 1782 insertions, 0 deletions
diff --git a/src/phHciNfc.c b/src/phHciNfc.c new file mode 100644 index 0000000..9400820 --- /dev/null +++ b/src/phHciNfc.c @@ -0,0 +1,1782 @@ +/* + * 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.c * +* \brief HCI Interface Source for the HCI Management. * +* * +* * +* Project: NFC-FRI-1.1 * +* * +* $Date: Thu Apr 22 17:49:47 2010 $ * +* $Author: ing04880 $ * +* $Revision: 1.90 $ * +* $Aliases: 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 <phNfcIoctlCode.h> +#include <phHciNfc.h> +#include <phHciNfc_Sequence.h> +#include <phHciNfc_RFReader.h> +#include <phHciNfc_LinkMgmt.h> +#ifdef ENABLE_P2P +#include <phHciNfc_NfcIPMgmt.h> +#endif +#include <phHciNfc_Emulation.h> +#include <phHciNfc_SWP.h> +#include <phHciNfc_DevMgmt.h> +#include <phOsalNfc.h> + +/**/ + +/* +*************************** Static Function Declaration ************************** +*/ + + +static +NFCSTATUS +phHciNfc_Config_Emulation ( + void *psHciHandle, + void *pHwRef, + phHal_sEmulationCfg_t *pEmulationConfig + + ); + + +/* +*************************** Function Definitions ************************** +*/ + + +/*! + * \brief Initialises the HCI Interface + * + * This function initialises the resources for the HCI Command and + * Response Mechanism + */ + + NFCSTATUS + phHciNfc_Initialise ( + void *psHciHandle, + void *pHwRef, + phHciNfc_Init_t init_mode, + phHal_sHwConfig_t *pHwConfig, + pphNfcIF_Notification_CB_t pHalNotify, + void *psContext, + phNfcLayer_sCfg_t *psHciLayerCfg + ) +{ + phHciNfc_sContext_t *psHciContext = NULL; + phNfcIF_sReference_t hciReference = { NULL }; + phNfcIF_sCallBack_t if_callback = { NULL, NULL, NULL, NULL }; + phNfc_sLowerIF_t *plower_if = NULL; + NFCSTATUS status = NFCSTATUS_SUCCESS; + uint8_t lower_index=0; + + if( (NULL == psHciHandle) || (NULL == pHwRef) || (NULL == pHalNotify) + || (NULL== psContext) || (NULL == psHciLayerCfg) || (NULL == pHwConfig) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else if ( NULL != *(phHciNfc_sContext_t **)psHciHandle ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_ALREADY_INITIALISED ); + } + else + { + /* Create the memory for HCI Context */ + psHciContext = (phHciNfc_sContext_t *) + phOsalNfc_GetMemory(sizeof(phHciNfc_sContext_t)); + + if(psHciContext != NULL) + { + (void)memset((void *)psHciContext,0, + sizeof(phHciNfc_sContext_t)); + + psHciContext->hci_state.cur_state = hciState_Reset; + psHciContext->hci_mode = hciMode_Reset; + psHciContext->p_hw_ref = pHwRef; + psHciContext->host_rf_type = phHal_eUnknown_DevType; + HCI_PRINT("HCI Initialisation in Progress.... \n"); + +#ifdef ESTABLISH_SESSION + /*(void)memcpy(((phHal_sHwReference_t *)pHwRef)->session_id, + DEFAULT_SESSION, (sizeof(DEFAULT_SESSION) > 0x01) ? + sizeof(DEFAULT_SESSION): + sizeof(((phHal_sHwReference_t *)pHwRef)->session_id));*/ + (void)memcpy(pHwConfig->session_id, + DEFAULT_SESSION, ((sizeof(DEFAULT_SESSION) > 0x01) + && (sizeof(DEFAULT_SESSION) <= 0x08 )) ? + sizeof(DEFAULT_SESSION): + sizeof(pHwConfig->session_id)); +#endif + HCI_DEBUG("Sizeof Default Session %u\n",sizeof(DEFAULT_SESSION)); + psHciContext->p_upper_notify = pHalNotify; + psHciContext->p_upper_context = psContext; + + if_callback.pif_ctxt = psHciContext ; + if_callback.send_complete = &phHciNfc_Send_Complete; + if_callback.receive_complete= &phHciNfc_Receive_Complete; + if_callback.notify = &phHciNfc_Notify_Event; + plower_if = hciReference.plower_if = &(psHciContext->lower_interface); + *((phHciNfc_sContext_t **)psHciHandle) = psHciContext; + psHciContext->init_mode = init_mode; + psHciContext->p_hci_layer = psHciLayerCfg ; + lower_index = psHciLayerCfg->layer_index - 1; + + if(NULL != psHciLayerCfg->layer_next->layer_registry) + { + status = psHciLayerCfg->layer_next->layer_registry( + &hciReference, if_callback, + (void *)&psHciLayerCfg[lower_index]); + HCI_DEBUG("HCI Lower Layer Register, Status = %02X\n",status); + } + if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init) ) + { + status = phHciNfc_FSM_Update ( psHciContext, + hciState_Initialise + ); + if(NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = ADMIN_INIT_SEQ; + psHciContext->target_release = FALSE; + psHciContext->config_type = POLL_LOOP_CFG; + psHciContext->p_config_params = pHwConfig ; + status = plower_if->init((void *)plower_if->pcontext, + (void *)psHciContext->p_hw_ref); + HCI_DEBUG("HCI Lower Layer Initialisation, Status = %02X\n",status); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Handle Initialisation in the Invalid State */ + } + }/* End of Lower Layer Init */ + } /* End of Status Check for Memory */ + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); + + HCI_PRINT("HCI Context Memory Allocation Failed\n"); + } + + } + return status; +} + + +/*! + * \brief Release of the HCI Interface . + * + * This function Closes all the open pipes and frees all the resources used by + * HCI Layer + */ + + NFCSTATUS + phHciNfc_Release ( + void *psHciHandle, + void *pHwRef, + pphNfcIF_Notification_CB_t pHalReleaseCB, + void *psContext + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + /* This Scenario Forces the HCI and the lower layers + * to release its Resources + */ + else if ( NULL == pHalReleaseCB ) + { + /* Release the lower layer Resources */ + phHciNfc_Release_Lower( psHciContext, pHwRef ); + /* Release the HCI layer Resources */ + phHciNfc_Release_Resources( &psHciContext ); + } + else if ( NULL == psContext ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + HCI_PRINT("HCI Release in Progress.... \n"); + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Release ); + if ((NFCSTATUS_SUCCESS == status) +#ifdef NXP_HCI_SHUTDOWN_OVERRIDE + || (NFCSTATUS_INVALID_STATE == PHNFCSTATUS(status)) +#endif + ) + { + psHciContext->p_upper_notify = pHalReleaseCB; + psHciContext->p_upper_context = psContext; + /* psHciContext->hci_seq = EMULATION_REL_SEQ;*/ + /* psHciContext->hci_seq = READER_MGMT_REL_SEQ; */ + if (HCI_SELF_TEST != psHciContext->init_mode) + { + psHciContext->hci_seq = PL_STOP_SEQ; + } + else + { + psHciContext->hci_seq = ADMIN_REL_SEQ; + } + +#ifdef NXP_HCI_SHUTDOWN_OVERRIDE + if (NFCSTATUS_SUCCESS != status) + { + psHciContext->hci_state.next_state = (uint8_t) hciState_Release; + status = NFCSTATUS_PENDING; + } + else +#endif + { + status = phHciNfc_Release_Sequence(psHciContext,pHwRef); + } + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Return appropriate Error */ + } + + } + + return status; +} + +#if 0 +/*! + * \brief Interface to Starts the RF Device Discovery. + * + * This function Starts the Discovery Wheel. + */ + + + NFCSTATUS + phHciNfc_Start_Discovery ( + void *psHciHandle, + void *pHwRef + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if ( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + status = phHciNfc_ReaderMgmt_Enable_Discovery( psHciContext, pHwRef ); + } + + return status; +} + + +/*! + * \brief Interface to Stop the RF Device Discovery. + * + * This function Stops the Discovery Wheel. + */ + + + NFCSTATUS + phHciNfc_Stop_Discovery ( + void *psHciHandle, + void *pHwRef + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if ( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + status = phHciNfc_ReaderMgmt_Disable_Discovery( psHciContext, pHwRef ); + } + + return status; +} + + +#endif + +/*! + * \brief Interface to Configure the Device With the appropriate + * Configuration Parameters . + * + * This function configures the Devices with the provided + * configuration attributes. + */ + + + NFCSTATUS + phHciNfc_Configure ( + void *psHciHandle, + void *pHwRef, + phHal_eConfigType_t config_type, + phHal_uConfig_t *pConfig + ) + { + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == pConfig) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + switch(config_type) + { + case NFC_P2P_CONFIG: + { +#ifdef ENABLE_P2P + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->config_type = NFC_GENERAL_CFG; + psHciContext->p_config_params = &(pConfig->nfcIPConfig); + psHciContext->hci_seq = INITIATOR_GENERAL_SEQ; + status = phHciNfc_NfcIP_SetATRInfo( psHciHandle, + pHwRef, NFCIP_INITIATOR, + &(pConfig->nfcIPConfig)); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + else + { + psHciContext->hci_seq = TARGET_GENERAL_SEQ; + } + } +#else + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + +#endif + break; + } + case NFC_EMULATION_CONFIG: + { + status = phHciNfc_Config_Emulation( psHciHandle, + pHwRef, &(pConfig->emuConfig)); + break; + } + case NFC_SE_PROTECTION_CONFIG: + { + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->config_type = SWP_PROTECT_CFG; + psHciContext->p_config_params = &(pConfig->protectionConfig); + psHciContext->hci_seq = HCI_END_SEQ; + status = phHciNfc_SWP_Protection( psHciHandle, + pHwRef, pConfig->protectionConfig.mode); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + break; + } + default: + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + }/* End of the Configuration Switch */ + } + + return status; + } + + +/*! + * \brief Interface to Configure the RF Device Discovery using + * HCI Polling Loop Gate . + * + * This function configures the HCI Polling Loop Gate with the provided + * configuration attributes. + */ + + NFCSTATUS + phHciNfc_Config_Discovery ( + void *psHciHandle, + void *pHwRef, + phHal_sADD_Cfg_t *pPollConfig + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == pPollConfig) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + HCI_PRINT("HCI Poll Configuration .... \n"); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + + if (NFCSTATUS_SUCCESS == status) + { +#if 0 + if(pPollConfig->PollDevInfo.PollEnabled) + { + psHciContext->hci_seq = PL_DURATION_SEQ; + } + else + { + psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; + /* psHciContext->hci_seq = (pPollConfig->NfcIP_Mode != 0 )? + PL_CONFIG_PHASE_SEQ: + READER_DISABLE_SEQ; */ + } +#endif + psHciContext->hci_seq = PL_DURATION_SEQ; + psHciContext->config_type = POLL_LOOP_CFG; + psHciContext->p_config_params = pPollConfig; + status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef ); + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Return appropriate Error */ + } + } + return status; +} + +/*! + * \brief Interface to Restart the RF Device Discovery. + * + * This function restarts the Discovery Wheel. + */ + + + NFCSTATUS + phHciNfc_Restart_Discovery ( + void *psHciHandle, + void *pHwRef, + uint8_t re_poll + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; + + if ( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + + /* To be back in the Poll State to Re-Poll the Target */ + status = phHciNfc_FSM_Update ( psHciContext, hciState_Initialise ); + if (NFCSTATUS_SUCCESS == status) + { + switch (psHciContext->host_rf_type) + { + case phHal_eISO14443_A_PCD: + { + target_type = phHal_eISO14443_A_PICC; + break; + } + case phHal_eNfcIP1_Initiator: + { + target_type = phHal_eNfcIP1_Target; + break; + } +#ifdef TYPE_B + case phHal_eISO14443_B_PCD: + { + target_type = phHal_eISO14443_B_PICC; + break; + } +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PCD: + { + target_type = phHal_eFelica_PICC; + break; + } +#endif +#ifdef TYPE_JEWEL + case phHal_eJewel_PCD: + { + target_type = phHal_eJewel_PICC; + break; + } +#endif +#ifdef TYPE_ISO15693 + case phHal_eISO15693_PCD: + { + target_type = phHal_eISO15693_PICC; + break; + } +#endif /* #ifdef TYPE_ISO15693 */ +#ifndef TYPE_B + case phHal_eISO14443_B_PCD: +#endif +#ifndef TYPE_FELICA + case phHal_eFelica_PCD: +#endif +#ifndef TYPE_JEWEL + case phHal_eJewel_PCD: +#endif +#ifndef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PCD: +#endif + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + }/* End of the Remote Target Type Switch */ + if( NFCSTATUS_SUCCESS == status ) + { + status = phHciNfc_ReaderMgmt_Deselect( + psHciContext, pHwRef, target_type, re_poll); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + else + { + psHciContext->host_rf_type = phHal_eUnknown_DevType; + } + } + } + else + { + /* TODO: Return appropriate Error */ + } + } + + return status; +} + + + +/*! + * \brief Interface to Configure the device to emulation as + * the tag, smart tag or p2p target . + * + * This function configures the HCI Polling Loop Gate with the provided + * configuration attributes. + */ + + static + NFCSTATUS + phHciNfc_Config_Emulation ( + void *psHciHandle, + void *pHwRef, + phHal_sEmulationCfg_t *pEmulationCfg + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == pEmulationCfg) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + + HCI_PRINT("HCI Configure Emulation .... \n"); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = EMULATION_CONFIG_SEQ; + psHciContext->p_config_params = pEmulationCfg; + switch( pEmulationCfg->emuType ) + { + case NFC_SMARTMX_EMULATION: + { + psHciContext->config_type = SMX_WI_CFG; + status = phHciNfc_Emulation_Cfg(psHciContext, + pHwRef, SMX_WI_CFG); + break; + } + case NFC_UICC_EMULATION: + { + psHciContext->config_type = UICC_SWP_CFG; + psHciContext->hci_seq = EMULATION_CONFIG_SEQ; + (void)phHciNfc_SWP_Update_Sequence( + psHciContext, CONFIG_SEQ ); + status = phHciNfc_EmulationCfg_Sequence( + psHciContext, pHwRef); + break; + } + case NFC_HOST_CE_A_EMULATION: + case NFC_HOST_CE_B_EMULATION: +#if defined(HOST_EMULATION) + { + if(TRUE == pEmulationCfg->config. + hostEmuCfg_A.enableEmulation) + { + psHciContext->hci_seq = ADMIN_CE_SEQ; + } + status = phHciNfc_EmulationCfg_Sequence( + psHciContext, pHwRef); + break; + } +#endif + default: + { + break; + } + + } /* End of Config Switch */ + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Return appropriate Error */ + } + } + + return status; +} + + NFCSTATUS + phHciNfc_Switch_SwpMode ( + void *psHciHandle, + void *pHwRef, + phHal_eSWP_Mode_t swp_mode /* , + void *pSwpCfg */ + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + + HCI_PRINT("HCI SWP Switch .... "); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->config_type = SWP_EVT_CFG; + status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef , + (uint8_t) swp_mode ); + + /* Send the Success Status as this is an event */ + status = ((status == NFCSTATUS_SUCCESS)? + NFCSTATUS_PENDING : status); + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + + HCI_PRINT(" Execution Error \n"); + } + else + { + HCI_PRINT(" Successful \n"); + } + } + else + { + HCI_PRINT(" Not allowed - Invalid State \n"); + /* TODO: Return appropriate Error */ + } + } + + return status; +} + + + +/*! + * \brief Interface to Switch the Mode of the SmartMx from Virtual/Wired + * to the other mode. + * + * This function switches the mode of the SmartMX connected through WI(S2C) + * Interface to virtual/wired mode. + */ + + + NFCSTATUS + phHciNfc_Switch_SmxMode ( + void *psHciHandle, + void *pHwRef, + phHal_eSmartMX_Mode_t smx_mode, + phHal_sADD_Cfg_t *pPollConfig + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == pPollConfig) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + + HCI_PRINT("HCI Smart MX Mode Switch .... \n"); + status = phHciNfc_FSM_Update ( psHciContext, hciState_Config ); + + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = READER_DISABLE_SEQ; + if ( (eSmartMx_Wired == psHciContext->smx_mode) + && ( hciState_Connect == psHciContext->hci_state.cur_state) + &&( eSmartMx_Wired != smx_mode) + ) + { + /* Workaround: For Wired Mode Disconnect + All the statemachine updates should be done only with the + Statemachine API and should not be overridden. + */ + psHciContext->hci_state.cur_state = hciState_Disconnect; + } + psHciContext->config_type = SMX_WI_MODE; + psHciContext->smx_mode = smx_mode; + psHciContext->p_config_params = pPollConfig; + status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef ); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Return appropriate Error */ + } + } + + return status; +} + + +/*! + * \brief Interface to Select the Next Remote Target Discovered during the + * discovery sequence using the particular HCI Reader Gate . + * + * + * This function Selects and Activates the next Remote Target + * Detected using the particular HCI Reader Gate. + */ + + + +NFCSTATUS +phHciNfc_Select_Next_Target ( + void *psHciHandle, + void *pHwRef + ) +{ + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Select ); + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = READER_SELECT_SEQ; + status = phHciNfc_ReaderMgmt_Activate_Next( psHciContext, pHwRef ); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + } + + return status; + +} + + +/*! + * \brief Interface to Connect the Remote Target Discovered during the + * discovery sequence using the particular HCI Reader Gate . + * + * + * This function connects the Remote Target Detected using the particular + * HCI Reader Gate with the appropriate configuration setup. + */ + + + NFCSTATUS + phHciNfc_Connect ( + void *psHciHandle, + void *pHwRef, + phHal_sRemoteDevInformation_t *p_target_info + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + /* phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; */ + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == p_target_info) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Connect ); + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = READER_SELECT_SEQ; + switch (p_target_info->RemDevType) + { + case phHal_eISO14443_A_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eMifare_PICC: + case phHal_eISO14443_3A_PICC: +#ifdef ENABLE_P2P + case phHal_eNfcIP1_Target: +#endif +#ifdef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifdef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif +#ifdef TYPE_ISO15693 + case phHal_eISO15693_PICC: +#endif /* #ifdef TYPE_ISO15693 */ + + { + psHciContext->p_target_info = p_target_info; + status = phHciNfc_ReaderMgmt_Select( + psHciContext, pHwRef, + p_target_info->RemDevType ); + break; + } +#ifndef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PICC: +#endif + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + }/* End of the Remote Target Type Switch */ + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + + } /* End of the HCI Handle Validation */ + + return status; +} + + +/*! + * \brief Interface to Reactivate the Remote Targets Discovered during the + * discovery sequence using the particular HCI Reader Gate . + * + * + * This function reactivates the Remote Target Detected using the particular + * HCI Reader Gate with the appropriate configuration setup. + */ + + + NFCSTATUS + phHciNfc_Reactivate ( + void *psHciHandle, + void *pHwRef, + phHal_sRemoteDevInformation_t *p_target_info + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + /* phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; */ + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == p_target_info) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Reactivate ); + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = READER_REACTIVATE_SEQ; + switch (p_target_info->RemDevType) + { + case phHal_eISO14443_A_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eMifare_PICC: + case phHal_eISO14443_3A_PICC: + { + psHciContext->host_rf_type = phHal_eISO14443_A_PCD; + break; + } + case phHal_eNfcIP1_Target: + { + psHciContext->host_rf_type = phHal_eNfcIP1_Initiator; + break; + } +#ifdef TYPE_B + case phHal_eISO14443_4B_PICC: + case phHal_eISO14443_B_PICC: + { + psHciContext->host_rf_type = phHal_eISO14443_B_PCD; + break; + } +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PICC: + { + psHciContext->host_rf_type = phHal_eFelica_PCD; + break; + } +#endif +#ifdef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PICC: +#endif + /* Reactivate for Jewel is not Supported */ + case phHal_eJewel_PICC: + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + }/* End of the Remote Target Type Switch */ + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + + if(NFCSTATUS_SUCCESS == status ) + { + psHciContext->p_target_info = p_target_info; + status = phHciNfc_ReaderMgmt_Reactivate( + psHciContext, pHwRef, p_target_info->RemDevType ); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } /* End of the HCI Handle Validation */ + + + return status; +} + + +/*! + * \brief Interface to Disconnect the selected target. + * + * This function disconnects the remote target selected. + */ + + + NFCSTATUS + phHciNfc_Disconnect ( + void *psHciHandle, + void *pHwRef, + uint8_t re_poll + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; + /* phHal_eSmartMX_Mode_t smx_mode = (phHal_eSmartMX_Mode_t)type; */ + static uint8_t repoll=0; + + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || ( NULL == psHciContext->p_target_info) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + repoll = re_poll; + psHciContext->p_config_params = &repoll; + /* psHciContext->hci_seq = HCI_END_SEQ; */ + + /* To be back in the Poll State to Re-Poll the Target */ + status = phHciNfc_FSM_Update ( psHciContext, hciState_Disconnect ); + if (NFCSTATUS_SUCCESS == status) + { + psHciContext->hci_seq = READER_UICC_DISPATCH_SEQ; + target_type = psHciContext->p_target_info->RemDevType; + switch (target_type) + { + case phHal_eMifare_PICC: + case phHal_eISO14443_A_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eISO14443_3A_PICC: + case phHal_eNfcIP1_Target: +#ifdef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifdef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif +#ifdef TYPE_ISO15693 + case phHal_eISO15693_PICC: +#endif /* #ifdef TYPE_ISO15693 */ + + { + status = phHciNfc_Disconnect_Sequence( + psHciContext, pHwRef ); + break; + } +#ifndef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifndef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifndef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif +#ifndef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PICC: +#endif + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + }/* End of the Remote Target Type Switch */ + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + /* TODO: Return appropriate Error */ + } + } /* End of the HCI Handle Validation */ + + return status; +} + +/*! + * \brief Interface to exchange the data to/from + * the selected target. + * + * This function sends and receives the data to/from + * the selected remote target. + */ + + NFCSTATUS + phHciNfc_Exchange_Data ( + void *psHciHandle, + void *pHwRef, + phHal_sRemoteDevInformation_t *p_target_info, + phHciNfc_XchgInfo_t *p_xchg_info + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == p_target_info) + || (NULL == p_xchg_info) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else if (p_target_info != psHciContext->p_target_info ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_REMOTE_DEVICE); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact ); + if (NFCSTATUS_SUCCESS == status) + { + switch (p_target_info->RemDevType) + { + case phHal_eMifare_PICC: + case phHal_eISO14443_A_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eISO14443_3A_PICC: +#ifdef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifdef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif +#ifdef TYPE_ISO15693 + case phHal_eISO15693_PICC: +#endif /* #ifdef TYPE_ISO15693 */ + { + psHciContext->p_xchg_info = p_xchg_info; + status = phHciNfc_ReaderMgmt_Exchange_Data( + psHciContext, pHwRef, p_xchg_info ); + break; + } +#ifndef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifndef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifndef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif + case phHal_eNfcIP1_Target: +#ifndef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PICC: +#endif + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + + }/* End of the Remote Target Type Switch */ + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + } /* End of the HCI Handle Validation */ + + return status; +} + +/*! + * \brief Interface to Send the data to/from + * the selected NfcIP. + * + * This function sends and receives the data to/from + * the selected remote target. + */ + + NFCSTATUS + phHciNfc_Send_Data ( + void *psHciHandle, + void *pHwRef, + phHal_sRemoteDevInformation_t *p_remote_dev_info, + phHciNfc_XchgInfo_t *p_send_param + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + || (NULL == p_send_param) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact ); + if (NFCSTATUS_SUCCESS == status) + { + switch (psHciContext->host_rf_type) + { + case phHal_eISO14443_A_PICC: + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eISO14443_4B_PICC: + { + break; + } +#ifdef ENABLE_P2P + case phHal_eNfcIP1_Initiator: + { + if (p_remote_dev_info != + psHciContext->p_target_info ) + { + status = PHNFCSTVAL(CID_NFC_HCI, + NFCSTATUS_INVALID_REMOTE_DEVICE); + } + else + { + psHciContext->p_xchg_info = p_send_param; + status = phHciNfc_NfcIP_Send_Data( psHciContext, + pHwRef, p_send_param ); + } + break; + } + case phHal_eNfcIP1_Target: + { + psHciContext->p_xchg_info = p_send_param; + status = phHciNfc_NfcIP_Send_Data( psHciContext, + pHwRef, p_send_param ); + break; + } +#endif +#ifdef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PCD: + case phHal_eFelica_PCD: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } +#endif + case phHal_eUnknown_DevType: + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + + }/* End of the Remote Target Type Switch */ +#if defined( ENABLE_P2P ) || defined (TYPE_B_PRIME) + if( NFCSTATUS_PENDING != status ) +#endif + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + } /* End of the HCI Handle Validation */ + + return status; + + } + +#if 0 + +/*! + * \brief Interface to Send the data from + * the selected NfcIP. + * + * This function sends and receives the data to/from + * the selected remote target. + */ + + NFCSTATUS + phHciNfc_Receive_Data ( + void *psHciHandle, + void *pHwRef, + uint8_t *p_data, + uint8_t length + ) + { + phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle); + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if( (NULL == psHciHandle) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + if (NFCSTATUS_SUCCESS == status) + { + status = phHciNfc_Receive(psHciHandle, pHwRef, p_data, length); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + return status; + + } + +#endif + + /*! + * \brief Interface to Check for the presence of + * the selected target in the field . + * + * This function checks the presence of the + * the selected remote target in the field . + */ + + + +NFCSTATUS +phHciNfc_Presence_Check ( + void *psHciHandle, + void *pHwRef + ) +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; + + if( (NULL == psHciContext) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Presence ); + if (NFCSTATUS_SUCCESS == status) + { + target_type = psHciContext->p_target_info->RemDevType; + switch (target_type) + { + case phHal_eISO14443_A_PICC: + case phHal_eMifare_PICC: + case phHal_eISO14443_4A_PICC: + case phHal_eISO14443_3A_PICC: +#ifdef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifdef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifdef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif +#ifdef TYPE_ISO15693 + case phHal_eISO15693_PICC: +#endif /* #ifdef TYPE_ISO15693 */ +#ifdef ENABLE_P2P + case phHal_eNfcIP1_Target: +#endif + { + status = phHciNfc_ReaderMgmt_Presence_Check( + psHciContext, pHwRef ); + break; + } +#ifdef TYPE_B_PRIME + case phHal_eISO14443_BPrime_PICC: +#endif +#ifndef TYPE_B + case phHal_eISO14443_B_PICC: + case phHal_eISO14443_4B_PICC: +#endif +#ifndef TYPE_FELICA + case phHal_eFelica_PICC: +#endif +#ifndef TYPE_JEWEL + case phHal_eJewel_PICC: +#endif + case phHal_eUnknown_DevType: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); + break; + } + default: + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + break; + } + + }/* End of the Remote Target Type Switch */ + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + else + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); + } + } /* End of the HCI Handle Validation */ + + return status; +} + + NFCSTATUS + phHciNfc_PRBS_Test ( + void *psHciHandle, + void *pHwRef, + uint32_t test_type, + phNfc_sData_t *test_param + ) + { + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + + if( (NULL == psHciContext) + || (NULL == pHwRef) + || (test_type != DEVMGMT_PRBS_TEST) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_IO ); + if (NFCSTATUS_SUCCESS == status) + { + status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef, + (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param); + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + return status; + } + + + NFCSTATUS + phHciNfc_System_Test ( + void *psHciHandle, + void *pHwRef, + uint32_t test_type, + phNfc_sData_t *test_param + ) +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + static phNfc_sData_t test_result; + static uint8_t gpio_status = 0; + + if( (NULL == psHciContext) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_Test ); + if (NFCSTATUS_SUCCESS == status) + { + if (test_type != NFC_GPIO_READ) + { + status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef, + (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param); + } + else + { + test_result.buffer = &gpio_status; + status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef, + (uint16_t)NFC_GPIO_READ, test_result.buffer); + + } + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + + return status; +} + + + NFCSTATUS + phHciNfc_System_Configure ( + void *psHciHandle, + void *pHwRef, + uint32_t config_type, + uint8_t config_value + ) +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + + if( (NULL == psHciContext) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_IO ); + if (NFCSTATUS_SUCCESS == status) + { + status = phHciNfc_DevMgmt_Configure(psHciContext, pHwRef, + (uint16_t)config_type, config_value); + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + return status; +} + +NFCSTATUS + phHciNfc_System_Get_Info( + void *psHciHandle, + void *pHwRef, + uint32_t config_type, + uint8_t *p_config_value + ) +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + + if( (NULL == psHciContext) + || (NULL == pHwRef) + || (NULL == p_config_value) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_IO ); + if (NFCSTATUS_SUCCESS == status) + { + status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef, + (uint16_t)config_type, p_config_value); + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + + return status; +} + + + NFCSTATUS + phHciNfc_Get_Link_Status( + void *psHciHandle, + void *pHwRef + ) +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + phHciNfc_sContext_t *psHciContext = + ((phHciNfc_sContext_t *)psHciHandle); + + if( (NULL == psHciContext) + || (NULL == pHwRef) + ) + { + status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); + } + else + { + psHciContext->p_hw_ref = pHwRef; + status = phHciNfc_FSM_Update ( psHciContext, hciState_IO ); + if (NFCSTATUS_SUCCESS == status) + { + status = phHciNfc_LinkMgmt_Open(psHciContext, pHwRef); + + if( NFCSTATUS_PENDING != status ) + { + /* Roll Back the State Machine to its Original State */ + phHciNfc_FSM_Rollback ( psHciContext ); + } + } + } + + return status; +} + + + |