| /* |
| * 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_Emulation.c * |
| * \brief HCI Emulation management routines. * |
| * * |
| * * |
| * Project: NFC-FRI-1.1 * |
| * * |
| * $Date: Tue Jun 8 09:30:37 2010 $ * |
| * $Author: ing04880 $ * |
| * $Revision: 1.52 $ * |
| * $Aliases: NFC_FRI1.1_WK1023_R35_1 $ |
| * * |
| * =========================================================================== * |
| */ |
| |
| /* |
| ***************************** Header File Inclusion **************************** |
| */ |
| #include <phNfcConfig.h> |
| #include <phNfcCompId.h> |
| #include <phNfcHalTypes.h> |
| #include <phHciNfc_Pipe.h> |
| #include <phHciNfc_Emulation.h> |
| #include <phHciNfc_WI.h> |
| #include <phHciNfc_SWP.h> |
| #ifdef ENABLE_P2P |
| #include <phHciNfc_NfcIPMgmt.h> |
| #endif |
| #ifdef HOST_EMULATION |
| #include <phHciNfc_CE_A.h> |
| #include <phHciNfc_CE_B.h> |
| #endif |
| #include <phOsalNfc.h> |
| /* |
| ****************************** Macro Definitions ******************************* |
| */ |
| |
| |
| |
| /* |
| *************************** Structure and Enumeration *************************** |
| */ |
| |
| /** \defgroup grp_hci_nfc HCI Emulation Management Component |
| * |
| * |
| */ |
| |
| typedef enum phHciNfc_EmulationMgmt_Seq{ |
| NFCIP_TARGET_PIPE_OPEN = 0x00U, |
| NFCIP_TARGET_MODE_CONFIG, |
| NFCIP_TARGET_MERGE_SAK, |
| NFCIP_TARGET_PIPE_CLOSE, |
| |
| HOST_CE_A_INIT, |
| HOST_CE_A_RELEASE, |
| |
| HOST_CE_B_INIT, |
| HOST_CE_B_RELEASE, |
| |
| WI_PIPE_OPEN, |
| WI_ENABLE_EMULATION, |
| WI_DEFAULT_EMULATION, |
| WI_DISABLE_EMULATION, |
| |
| WI_ENABLE_NOTIFICATION, |
| WI_DISABLE_NOTIFICATION, |
| |
| WI_SWITCH_WIRED_MODE, |
| WI_SWITCH_DEFAULT_MODE, |
| |
| WI_PIPE_CLOSE, |
| |
| SWP_PIPE_OPEN, |
| SWP_ENABLE_EMULATION, |
| SWP_DEFAULT_EMULATION, |
| SWP_DETECTION, |
| SWP_DISABLE_EMULATION, |
| SWP_GET_BIT_RATE, |
| SWP_PIPE_CLOSE, |
| |
| CONFIG_DEFAULT_EMULATION, |
| |
| END_EMULATION_SEQ |
| } phHciNfc_EmulationMgmt_Seq_t; |
| |
| typedef struct phHciNfc_EmulationMgmt_Info{ |
| phHal_eEmulationType_t se_default; |
| uint8_t smx_powerless; |
| uint8_t uicc_enable; |
| uint8_t uicc_powerless; |
| uint8_t uicc_id; |
| /* Application ID of the UICC Transaction performed */ |
| uint8_t uicc_aid[MAX_AID_LEN]; |
| uint8_t uicc_param[MAX_UICC_PARAM_LEN]; |
| uint8_t uicc_param_len; |
| phHciNfc_Pipe_Info_t *p_uicc_pipe_info; |
| phHciNfc_EmulationMgmt_Seq_t emulation_cur_seq; |
| phHciNfc_EmulationMgmt_Seq_t emulation_next_seq; |
| |
| |
| } phHciNfc_EmulationMgmt_Info_t; |
| |
| |
| /* |
| *************************** Static Function Declaration ************************** |
| */ |
| |
| static |
| NFCSTATUS |
| phHciNfc_Recv_Uicc_Cmd ( |
| void *psContext, |
| void *pHwRef, |
| uint8_t *pCmd, |
| #ifdef ONE_BYTE_LEN |
| uint8_t length |
| #else |
| uint16_t length |
| #endif |
| ); |
| |
| static |
| NFCSTATUS |
| phHciNfc_Recv_Uicc_Event ( |
| void *psContext, |
| void *pHwRef, |
| uint8_t *pEvent, |
| #ifdef ONE_BYTE_LEN |
| uint8_t length |
| #else |
| uint16_t length |
| #endif |
| ); |
| |
| |
| /* |
| *************************** Function Definitions *************************** |
| */ |
| |
| void |
| phHciNfc_Uicc_Connectivity( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_Pipe_Info_t *pPipeInfo = NULL; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info = NULL; |
| |
| if( NULL != psHciContext->p_emulation_mgmt_info ) |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| pPipeInfo = psHciContext->p_pipe_list[NXP_PIPE_CONNECTIVITY]; |
| if( (TRUE == ((phHal_sHwReference_t *)pHwRef)->uicc_connected) |
| && (NULL == pPipeInfo)) |
| { |
| status = phHciNfc_Allocate_Resource((void **)&pPipeInfo, |
| sizeof(phHciNfc_Pipe_Info_t)); |
| if((NULL != pPipeInfo) |
| && (NFCSTATUS_SUCCESS == status)) |
| { |
| /* The Source Host is the UICC Host */ |
| pPipeInfo->pipe.source.host_id = |
| (uint8_t) phHciNfc_UICCHostID; |
| /* The Source Gate is same as the Destination Gate */ |
| pPipeInfo->pipe.source.gate_id = |
| (uint8_t) phHciNfc_ConnectivityGate; |
| /* The Destination Host is the Terminal Host */ |
| pPipeInfo->pipe.dest.host_id = |
| (uint8_t) phHciNfc_TerminalHostID; |
| /* The Source Gate is same as the Destination Gate */ |
| pPipeInfo->pipe.dest.gate_id = |
| (uint8_t) phHciNfc_ConnectivityGate; |
| /* The Pipe ID is Hardcoded to Connectivity */ |
| pPipeInfo->pipe.pipe_id = (uint8_t) NXP_PIPE_CONNECTIVITY; |
| |
| |
| status = phHciNfc_Uicc_Update_PipeInfo(psHciContext, |
| NXP_PIPE_CONNECTIVITY, pPipeInfo); |
| if (NFCSTATUS_SUCCESS == status) |
| { |
| psHciContext->p_pipe_list[NXP_PIPE_CONNECTIVITY] = pPipeInfo; |
| p_emulation_mgmt_info->uicc_enable = TRUE; |
| } |
| else |
| { |
| (void)phOsalNfc_FreeMemory(pPipeInfo); |
| } |
| } |
| } |
| } |
| return; |
| } |
| |
| /*! |
| * \brief Get the pipe_id of Connectivity Managment Gate. |
| * |
| * This function Get the pipe_id of Connectivity Managment Gate. |
| * |
| */ |
| |
| |
| NFCSTATUS |
| phHciNfc_Uicc_Get_PipeID( |
| phHciNfc_sContext_t *psHciContext, |
| uint8_t *ppipe_id |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info = NULL; |
| if( (NULL != psHciContext) |
| && ( NULL != ppipe_id ) |
| && ( NULL != psHciContext->p_emulation_mgmt_info ) |
| ) |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| *ppipe_id = p_emulation_mgmt_info->uicc_id ; |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| return status; |
| } |
| |
| |
| /* Function to Update the Pipe Information */ |
| NFCSTATUS |
| phHciNfc_Uicc_Update_PipeInfo( |
| phHciNfc_sContext_t *psHciContext, |
| uint8_t pipe_id, |
| phHciNfc_Pipe_Info_t *pPipeInfo |
| ) |
| { |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| |
| if( NULL == psHciContext ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else if ( NULL == psHciContext->p_emulation_mgmt_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| /* Update the pipe_id of the Connectivity Gate |
| * obtained from the HCI Response */ |
| p_emulation_mgmt_info->uicc_id = pipe_id; |
| p_emulation_mgmt_info->p_uicc_pipe_info = pPipeInfo; |
| if ( NULL != pPipeInfo) |
| { |
| /* Update the Response Receive routine of the Connectivity Gate */ |
| /* pPipeInfo->recv_resp = phHciNfc_Recv_Uicc_Response; */ |
| pPipeInfo->recv_cmd = &phHciNfc_Recv_Uicc_Cmd; |
| pPipeInfo->recv_event = &phHciNfc_Recv_Uicc_Event; |
| } |
| } |
| |
| return status; |
| } |
| |
| |
| /*! |
| * \brief Updates the Sequence of Emulation Managment Gate. |
| * |
| * This function Resets/Updates the sequence of the Emulation Management |
| * gate. |
| * |
| */ |
| |
| |
| NFCSTATUS |
| phHciNfc_EmuMgmt_Update_Seq( |
| phHciNfc_sContext_t *psHciContext, |
| phHciNfc_eSeqType_t seq_type |
| ) |
| { |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| if( NULL == psHciContext ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| if( NULL == psHciContext->p_emulation_mgmt_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| switch(seq_type) |
| { |
| case RESET_SEQ: |
| case INIT_SEQ: |
| { |
| #ifdef ENABLE_P2P |
| p_emulation_mgmt_info->emulation_cur_seq = NFCIP_TARGET_PIPE_OPEN; |
| #else |
| p_emulation_mgmt_info->emulation_cur_seq = WI_PIPE_OPEN; |
| #endif |
| p_emulation_mgmt_info->emulation_next_seq = END_EMULATION_SEQ ; |
| break; |
| } |
| case UPDATE_SEQ: |
| { |
| p_emulation_mgmt_info->emulation_cur_seq = |
| p_emulation_mgmt_info->emulation_next_seq; |
| break; |
| } |
| case INFO_SEQ: |
| { |
| p_emulation_mgmt_info->emulation_cur_seq = SWP_ENABLE_EMULATION; |
| p_emulation_mgmt_info->emulation_next_seq = END_EMULATION_SEQ ; |
| break; |
| } |
| case REL_SEQ: |
| { |
| p_emulation_mgmt_info->emulation_cur_seq = WI_DISABLE_EMULATION; |
| p_emulation_mgmt_info->emulation_next_seq = END_EMULATION_SEQ ; |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| } |
| } |
| |
| return status; |
| } |
| |
| |
| /*! |
| * \brief Initialisation of RF Emulation Gates. |
| * |
| * This function initialses the RF Emulation Management and |
| * populates the Reader Management Information Structure |
| * |
| */ |
| |
| |
| NFCSTATUS |
| phHciNfc_EmuMgmt_Initialise( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_Pipe_Info_t *p_pipe_info = NULL; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| |
| if( NULL == psHciContext ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| |
| if( ( NULL == psHciContext->p_emulation_mgmt_info ) |
| && (phHciNfc_Allocate_Resource((void **)(&p_emulation_mgmt_info), |
| sizeof(phHciNfc_EmulationMgmt_Info_t))== NFCSTATUS_SUCCESS) |
| ) |
| { |
| psHciContext->p_emulation_mgmt_info = p_emulation_mgmt_info; |
| #ifdef ENABLE_P2P |
| p_emulation_mgmt_info->emulation_cur_seq = NFCIP_TARGET_PIPE_OPEN; |
| #else |
| p_emulation_mgmt_info->emulation_cur_seq = WI_PIPE_OPEN; |
| #endif |
| p_emulation_mgmt_info->emulation_next_seq = END_EMULATION_SEQ; |
| p_emulation_mgmt_info->uicc_id = (uint8_t)HCI_UNKNOWN_PIPE_ID; |
| } |
| else |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| } |
| |
| if( NULL == psHciContext->p_emulation_mgmt_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INSUFFICIENT_RESOURCES); |
| } |
| #ifdef ESTABLISH_SESSION |
| else if(( hciMode_Session == psHciContext->hci_mode ) |
| && (NFCIP_TARGET_PIPE_OPEN == p_emulation_mgmt_info->emulation_cur_seq ) |
| ) |
| { |
| status = NFCSTATUS_SUCCESS; |
| } |
| #endif |
| else |
| { |
| switch(p_emulation_mgmt_info->emulation_cur_seq ) |
| { |
| #ifdef ENABLE_P2P |
| /* NFCIP Target Open sequence */ |
| case NFCIP_TARGET_PIPE_OPEN: |
| { |
| p_pipe_info = ((phHciNfc_NfcIP_Info_t *) |
| psHciContext->p_nfcip_info)->p_tgt_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_Open_Pipe( psHciContext, |
| pHwRef, p_pipe_info ); |
| if(status == NFCSTATUS_SUCCESS) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| NFCIP_TARGET_MODE_CONFIG; |
| status = NFCSTATUS_PENDING; |
| } |
| } |
| break; |
| } |
| /* NFCIP Target Mode Config sequence */ |
| case NFCIP_TARGET_MODE_CONFIG: |
| { |
| #define NFCIP_ACTIVE_SHIFT 0x03U |
| #define NFCIP_PASSIVE_MASK 0x07U |
| uint8_t mode = ( NXP_NFCIP_ACTIVE_DEFAULT << NFCIP_ACTIVE_SHIFT ) | |
| ( DEFAULT_NFCIP_TARGET_MODE_SUPPORT & NFCIP_PASSIVE_MASK ); |
| status = phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, |
| NFCIP_TARGET, mode); |
| if(status == NFCSTATUS_PENDING ) |
| { |
| #ifdef TGT_MERGE_SAK |
| p_emulation_mgmt_info->emulation_next_seq = |
| NFCIP_TARGET_MERGE_SAK; |
| #else |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_PIPE_OPEN; |
| #endif /* #ifdef TGT_MERGE_SAK */ |
| /* status = NFCSTATUS_SUCCESS; */ |
| } |
| break; |
| } |
| #ifdef TGT_MERGE_SAK |
| /* NFCIP Target SAK Merge sequence */ |
| case NFCIP_TARGET_MERGE_SAK: |
| { |
| status = phHciNfc_NfcIP_SetMergeSak( psHciContext, pHwRef, |
| TRUE ); |
| if(status == NFCSTATUS_PENDING ) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_PIPE_OPEN; |
| /* status = NFCSTATUS_SUCCESS; */ |
| } |
| break; |
| } |
| #endif /* #ifdef TGT_MERGE_SAK */ |
| #endif /* #ifdef ENABLE_P2P */ |
| /* Secure Element WI pipe open sequence */ |
| case WI_PIPE_OPEN: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_Open_Pipe( psHciContext, |
| pHwRef, p_pipe_info ); |
| if(status == NFCSTATUS_SUCCESS) |
| { |
| #ifdef DISABLE_WI_NOTIFICATION |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_PIPE_OPEN; |
| #else |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_ENABLE_NOTIFICATION; |
| #endif |
| status = NFCSTATUS_PENDING; |
| } |
| } |
| break; |
| } |
| /* Enable the SmartMx Notifications through WI */ |
| case WI_ENABLE_NOTIFICATION: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_WI_Configure_Notifications( |
| psHciContext, pHwRef, eEnableEvents ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_PIPE_OPEN; |
| } |
| } |
| break; |
| } |
| /* Enable the SmartMx Emulation by Default through WI */ |
| case WI_ENABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_WI_Configure_Default( psHciContext, |
| pHwRef, TRUE ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_PIPE_OPEN; |
| } |
| } |
| break; |
| } |
| /* SWP pipe open sequence */ |
| case SWP_PIPE_OPEN: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_Open_Pipe( psHciContext, |
| pHwRef, p_pipe_info ); |
| if(status == NFCSTATUS_SUCCESS) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_ENABLE_EMULATION; |
| #ifndef ESTABLISH_SESSION |
| status = NFCSTATUS_PENDING; |
| #endif |
| } |
| } |
| break; |
| } |
| /* Enable the UICC Emulation through SWP */ |
| case SWP_ENABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| #ifdef SWP_EVENT_USAGE |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef, |
| UICC_SWITCH_MODE_ON ); |
| /* UICC_SWITCH_MODE_DEFAULT */ |
| #else |
| status = phHciNfc_SWP_Configure_Default( psHciContext, |
| pHwRef, TRUE ); |
| #endif |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DETECTION; |
| /* status = NFCSTATUS_SUCCESS; */ |
| } |
| } |
| break; |
| } |
| /* Disable the UICC Emulation through SWP */ |
| case SWP_DETECTION: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| break; |
| } |
| else |
| { |
| status = phHciNfc_Uicc_Connect_Status( |
| psHciContext, pHwRef ); |
| if(status == NFCSTATUS_SUCCESS) |
| { |
| uint8_t uicc_connect = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->uicc_status; |
| if(UICC_CONNECTED == uicc_connect) |
| { |
| #ifdef SWP_EVENT_USAGE |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DISABLE_EMULATION; |
| #else |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_DISABLE_EMULATION; |
| #endif |
| ((phHal_sHwReference_t *) |
| pHwRef)->uicc_connected = TRUE; |
| status = NFCSTATUS_PENDING; |
| } |
| else |
| { |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, |
| pHwRef, UICC_SWITCH_MODE_DEFAULT ); |
| (NFCSTATUS_PENDING == status)? |
| (p_emulation_mgmt_info->emulation_next_seq = |
| WI_DISABLE_EMULATION): |
| (p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DETECTION); |
| break; |
| } |
| } |
| else |
| { |
| break; |
| } |
| } |
| } |
| /* fall through */ |
| /* Disable the SmartMx Emulation through WI */ |
| case WI_DISABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_WI_Configure_Mode( psHciContext, |
| pHwRef, eSmartMx_Default ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DISABLE_EMULATION; |
| status = NFCSTATUS_SUCCESS; |
| } |
| } |
| break; |
| } |
| #ifndef SWP_EVENT_USAGE |
| /* fall through */ |
| /* Get the UICC Baud Rate Status */ |
| case SWP_GET_BIT_RATE: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_SWP_Get_Bitrate( |
| psHciContext, pHwRef ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DISABLE_EMULATION; |
| status = NFCSTATUS_SUCCESS; |
| } |
| } |
| break; |
| } |
| #endif |
| /* fall through */ |
| /* Disable the UICC Emulation through SWP */ |
| case SWP_DISABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, |
| pHwRef, UICC_SWITCH_MODE_DEFAULT ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_DISABLE_EMULATION; |
| /* Disable WI Emulation for Previous Wired |
| * Mode Set */ |
| /* status = NFCSTATUS_SUCCESS; */ |
| } |
| } |
| break; |
| } |
| default: |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); |
| break; |
| } |
| |
| }/* End of the Sequence Switch */ |
| |
| }/* End of the Reader Info Memory Check */ |
| |
| } /* End of Null Context Check */ |
| |
| return status; |
| } |
| |
| /*! |
| * \brief Connection Routine for the Uicc. |
| * |
| * This function tries to enable and initialise the UICC connected |
| * through SWP. |
| * |
| */ |
| |
| |
| NFCSTATUS |
| phHciNfc_Uicc_Connect_Status( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| /* phHciNfc_Pipe_Info_t *p_pipe_info = NULL; */ |
| /* phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; */ |
| static uint32_t uicc_connection_retry = 0; |
| |
| if( NULL == psHciContext ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| phHciNfc_SWP_Status_t uicc_status = |
| ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->uicc_status; |
| if(uicc_connection_retry == 0) |
| { |
| #ifdef UICC_STATUS_DELAY |
| for( ;uicc_connection_retry < UICC_STATUS_DELAY_COUNT; |
| uicc_connection_retry ++ ); |
| uicc_connection_retry = 0; |
| #endif |
| status = phHciNfc_SWP_Get_Status( |
| psHciContext, pHwRef ); |
| if (NFCSTATUS_PENDING == status) |
| { |
| uicc_connection_retry++; |
| } |
| } |
| else |
| { |
| switch(uicc_status) |
| { |
| case UICC_CONNECTION_ONGOING: |
| case UICC_DISCONNECTION_ONGOING: |
| case UICC_NOT_CONNECTED: |
| { |
| if(uicc_connection_retry < |
| UICC_MAX_CONNECT_RETRY) |
| { |
| status = phHciNfc_SWP_Get_Status( |
| psHciContext, pHwRef ); |
| if (NFCSTATUS_PENDING == status) |
| { |
| uicc_connection_retry++; |
| } |
| } |
| break; |
| } |
| case UICC_CONNECTED: |
| { |
| break; |
| } |
| case UICC_CONNECTION_LOST: |
| case UICC_CONNECTION_FAILED: |
| default: |
| { |
| uicc_connection_retry = 0; |
| break; |
| } |
| } /* End of the Status Switch */ |
| } |
| |
| if( NFCSTATUS_PENDING != status ) |
| { |
| uicc_connection_retry = 0; |
| /* Error Scenario due to SWP Disable Config */ |
| } |
| |
| } /* End of Null Context Check */ |
| |
| return status; |
| } |
| |
| /*! |
| * \brief Release of RF Emulation Gate Configuration. |
| * |
| * This function initialses the RF Emulation Management and |
| * populates the Reader Management Information Structure |
| * |
| */ |
| |
| |
| NFCSTATUS |
| phHciNfc_EmuMgmt_Release( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_Pipe_Info_t *p_pipe_info = NULL; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| |
| if( NULL == psHciContext ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| |
| if( NULL == psHciContext->p_emulation_mgmt_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INSUFFICIENT_RESOURCES); |
| } |
| else |
| { |
| switch(p_emulation_mgmt_info->emulation_cur_seq ) |
| { |
| /* Enable/Disable the SmartMx Emulation through WI |
| * After the power down |
| */ |
| /* Enable the SmartMx Emulation by Default through WI */ |
| case WI_DEFAULT_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_WI_Configure_Default( psHciContext, |
| pHwRef, p_emulation_mgmt_info->smx_powerless ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| WI_DISABLE_EMULATION; |
| } |
| } |
| break; |
| } |
| /* SmartMx In Default Mode */ |
| case WI_DISABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_WI_Info_t *) |
| psHciContext->p_wi_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_WI_Configure_Mode( psHciContext, |
| pHwRef, eSmartMx_Default ); |
| if(status == NFCSTATUS_SUCCESS ) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DISABLE_EMULATION; |
| status = phHciNfc_EmuMgmt_Update_Seq(psHciContext, |
| UPDATE_SEQ); |
| /* status = NFCSTATUS_PENDING; */ |
| } |
| } |
| break; |
| } |
| /* Enable/Disable the UICC Emulation through SWP |
| * After the power down |
| */ |
| /* Enable the UICC Emulation by Default through SWP */ |
| case SWP_DEFAULT_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_SWP_Configure_Default( psHciContext, |
| pHwRef, p_emulation_mgmt_info->uicc_powerless ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| SWP_DISABLE_EMULATION; |
| /* status = NFCSTATUS_SUCCESS; */ |
| } |
| } |
| break; |
| } |
| /* Disable the UICC Emulation through SWP */ |
| case SWP_DISABLE_EMULATION: |
| { |
| p_pipe_info = ((phHciNfc_SWP_Info_t *) |
| psHciContext->p_swp_info)->p_pipe_info; |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, |
| pHwRef, UICC_SWITCH_MODE_DEFAULT ); |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| CONFIG_DEFAULT_EMULATION; |
| status = phHciNfc_EmuMgmt_Update_Seq(psHciContext, |
| UPDATE_SEQ); |
| status = NFCSTATUS_SUCCESS; |
| } |
| } |
| break; |
| } |
| /* Configure the Default Secure Element Emulation */ |
| case CONFIG_DEFAULT_EMULATION: |
| { |
| #if 0 |
| if(NULL == p_pipe_info ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, |
| NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| /* status = phHciNfc_DevMgmt_Configure( psHciContext, |
| pHwRef, , ); */ |
| if(status == NFCSTATUS_PENDING) |
| { |
| p_emulation_mgmt_info->emulation_next_seq = |
| END_EMULATION_SEQ; |
| status = phHciNfc_EmuMgmt_Update_Seq(psHciContext, |
| UPDATE_SEQ); |
| status = NFCSTATUS_SUCCESS; |
| } |
| } |
| #endif |
| break; |
| } |
| default: |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); |
| break; |
| } |
| |
| }/* End of the Sequence Switch */ |
| |
| }/* End of the Reader Info Memory Check */ |
| |
| } /* End of Null Context Check */ |
| |
| return status; |
| } |
| |
| #if 0 |
| NFCSTATUS |
| phHciNfc_Emulation_Start ( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| |
| return status; |
| } |
| #endif |
| |
| NFCSTATUS |
| phHciNfc_Emulation_Cfg ( |
| phHciNfc_sContext_t *psHciContext, |
| void *pHwRef, |
| phHciNfc_eConfigType_t cfg_type |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| phHal_sEmulationCfg_t *p_emulation_cfg = NULL; |
| |
| if( (NULL == psHciContext) || (NULL == pHwRef) ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else if ( ( NULL == psHciContext->p_emulation_mgmt_info ) |
| || ( NULL == psHciContext->p_config_params ) ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); |
| } |
| else |
| { |
| p_emulation_mgmt_info = (phHciNfc_EmulationMgmt_Info_t *) |
| psHciContext->p_emulation_mgmt_info ; |
| p_emulation_cfg = psHciContext->p_config_params; |
| switch(cfg_type) |
| { |
| case SMX_WI_CFG: |
| { |
| phHal_sSmartMX_Cfg_t *smx_config = |
| &p_emulation_cfg->config.smartMxCfg; |
| p_emulation_mgmt_info->smx_powerless = |
| (uint8_t)(FALSE != smx_config->lowPowerMode ); |
| status = phHciNfc_WI_Configure_Default( psHciContext, pHwRef, |
| smx_config->enableEmulation ); |
| break; |
| } |
| case UICC_SWP_CFG: |
| { |
| #ifdef SWP_CFG_SEQ |
| phHal_sUiccEmuCfg_t *uicc_config = |
| &p_emulation_cfg->config.uiccEmuCfg; |
| p_emulation_mgmt_info->uicc_powerless = |
| (uint8_t)(FALSE != uicc_config->lowPowerMode ); |
| { |
| #ifdef SWP_EVENT_USAGE |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef, |
| ((TRUE == uicc_config->enableUicc)? /* UICC_SWITCH_MODE_DEFAULT */ |
| UICC_SWITCH_MODE_ON :UICC_SWITCH_MODE_OFF)); |
| #else |
| status = phHciNfc_SWP_Configure_Default( psHciContext, pHwRef, |
| uicc_config->enableUicc ); |
| #endif |
| } |
| #else |
| status = phHciNfc_SWP_Config_Sequence( psHciContext, |
| pHwRef, p_emulation_cfg); |
| #endif |
| break; |
| } |
| case SWP_EVT_CFG: |
| { |
| phHal_sUiccEmuCfg_t *uicc_config = |
| &p_emulation_cfg->config.uiccEmuCfg; |
| p_emulation_mgmt_info->uicc_powerless = |
| (uint8_t)(FALSE != uicc_config->lowPowerMode ); |
| { |
| status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef, |
| ((TRUE == uicc_config->enableUicc)? /* UICC_SWITCH_MODE_DEFAULT */ |
| UICC_SWITCH_MODE_ON :UICC_SWITCH_MODE_DEFAULT)); |
| } |
| break; |
| } |
| #ifdef HOST_EMULATION |
| case NFC_CE_A_CFG: |
| { |
| phHal_sHostEmuCfg_A_t *host_ce_a_cfg = |
| &p_emulation_cfg->config.hostEmuCfg_A; |
| if(host_ce_a_cfg->enableEmulation == TRUE ) |
| { |
| status = phHciNfc_CE_A_Initialise( psHciContext, pHwRef); |
| } |
| else |
| { |
| status = phHciNfc_CE_A_Release( psHciContext, pHwRef); |
| } |
| break; |
| } |
| case NFC_CE_B_CFG: |
| { |
| phHal_sHostEmuCfg_B_t *host_ce_b_cfg = |
| &p_emulation_cfg->config.hostEmuCfg_B; |
| if(host_ce_b_cfg->enableEmulation == TRUE ) |
| { |
| status = phHciNfc_CE_B_Initialise( psHciContext, pHwRef); |
| } |
| else |
| { |
| status = phHciNfc_CE_B_Release( psHciContext, pHwRef); |
| } |
| break; |
| } |
| #endif |
| /* case INVALID_CFG: |
| case POLL_LOOP_CFG: */ |
| default: |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); |
| break; |
| } |
| |
| } /* End of the Configuration Switch */ |
| } |
| |
| return status; |
| } |
| |
| |
| static |
| NFCSTATUS |
| phHciNfc_Recv_Uicc_Cmd ( |
| void *psContext, |
| void *pHwRef, |
| uint8_t *pCmd, |
| #ifdef ONE_BYTE_LEN |
| uint8_t length |
| #else |
| uint16_t length |
| #endif |
| ) |
| { |
| uint8_t pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID; |
| uint8_t cmd = (uint8_t) HCP_MSG_INSTRUCTION_INVALID; |
| uint8_t response = (uint8_t) ANY_OK; |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_sContext_t *psHciContext = |
| (phHciNfc_sContext_t *)psContext ; |
| phHciNfc_HCP_Packet_t *hcp_packet = NULL; |
| phHciNfc_HCP_Message_t *hcp_message = NULL; |
| phHciNfc_Pipe_Info_t *p_pipe_info = NULL; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info=NULL; |
| |
| if( (NULL == psHciContext) |
| || (NULL == pHwRef) |
| || (HCP_HEADER_LEN > length ) |
| ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| hcp_packet = (phHciNfc_HCP_Packet_t *)pCmd; |
| hcp_message = &hcp_packet->msg.message; |
| p_emulation_mgmt_info = psHciContext->p_emulation_mgmt_info; |
| |
| /* Get the Command instruction bits from the Message Header */ |
| cmd = (uint8_t) GET_BITS8( hcp_message->msg_header, |
| HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); |
| pipe_id = p_emulation_mgmt_info->uicc_id; |
| p_pipe_info = psHciContext->p_pipe_list[pipe_id]; |
| |
| switch( cmd ) |
| { |
| /* These are Commands are sent from the UICC Controller */ |
| case ANY_OPEN_PIPE: |
| { |
| p_emulation_mgmt_info->uicc_enable = TRUE ; |
| break; |
| } |
| case ANY_CLOSE_PIPE: |
| { |
| if(TRUE != p_emulation_mgmt_info->uicc_enable) |
| { |
| response = ANY_E_PIPE_NOT_OPENED; |
| /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FAILED); */ |
| } |
| else |
| { |
| p_emulation_mgmt_info->uicc_enable = FALSE; |
| } |
| break; |
| } |
| case ANY_SET_PARAMETER: |
| case ANY_GET_PARAMETER: |
| case PRO_HOST_REQUEST: |
| { |
| response = ANY_E_CMD_NOT_SUPPORTED; |
| /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_COMMAND_NOT_SUPPORTED);*/ |
| break; |
| } |
| default: |
| { |
| response = ANY_E_NOK; |
| /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_COMMAND); */ |
| break; |
| } |
| } |
| hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; |
| phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, |
| pipe_id, HCP_MSG_TYPE_RESPONSE, response ); |
| psHciContext->tx_total = HCP_HEADER_LEN; |
| status = phHciNfc_Send_HCP( (void *)psHciContext, (void *)pHwRef ); |
| |
| p_pipe_info->recv_msg_type = HCP_MSG_TYPE_COMMAND; |
| p_pipe_info->sent_msg_type = HCP_MSG_TYPE_RESPONSE; |
| p_pipe_info->prev_msg = response ; |
| p_pipe_info->prev_status = status; |
| status = NFCSTATUS_SUCCESS; |
| |
| } |
| return status; |
| } |
| |
| static |
| NFCSTATUS |
| phHciNfc_Recv_Uicc_Event ( |
| void *psContext, |
| void *pHwRef, |
| uint8_t *pEvent, |
| #ifdef ONE_BYTE_LEN |
| uint8_t length |
| #else |
| uint16_t length |
| #endif |
| ) |
| { |
| uint8_t event = (uint8_t) HCP_MSG_INSTRUCTION_INVALID; |
| uint32_t i = 0; |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phHciNfc_sContext_t *psHciContext = |
| (phHciNfc_sContext_t *)psContext ; |
| phHciNfc_HCP_Packet_t *hcp_packet = NULL; |
| phHciNfc_HCP_Message_t *hcp_message = NULL; |
| phHal_sEventInfo_t event_info; |
| phHciNfc_EmulationMgmt_Info_t *p_emulation_mgmt_info = |
| psHciContext->p_emulation_mgmt_info ; |
| |
| |
| if( (NULL == p_emulation_mgmt_info) |
| || ( TRUE != p_emulation_mgmt_info->uicc_enable) |
| ) |
| { |
| status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); |
| } |
| else |
| { |
| 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_eUICCHost ; |
| event_info.eventSource = phHal_ePICC_DevType ; |
| |
| switch( event ) |
| { |
| case EVT_END_OF_TRANSACTION: |
| { |
| event_info.eventType = NFC_EVT_END_OF_TRANSACTION; |
| break; |
| } |
| case EVT_TRANSACTION: |
| { |
| if(length > HCP_HEADER_LEN + TRANSACTION_MIN_LEN) |
| { |
| event_info.eventType = NFC_EVT_TRANSACTION; |
| |
| for(;i<(length-HCP_HEADER_LEN);) |
| { |
| switch (hcp_message->payload[i]) |
| { |
| case TRANSACTION_AID: |
| { |
| /* AID LENGTH INDEX */ |
| i++; |
| /* Fill the event_info.eventInfo.aid |
| * Structure with the Received Transaction AID. |
| */ |
| event_info.eventInfo.aid.length = |
| hcp_message->payload[i++]; |
| (void) memcpy((void *)p_emulation_mgmt_info->uicc_aid, |
| &(hcp_message->payload[i]), |
| event_info.eventInfo.aid.length ); |
| event_info.eventInfo.aid.buffer = (uint8_t *) |
| p_emulation_mgmt_info->uicc_aid; |
| i = i + event_info.eventInfo.aid.length; |
| break; |
| } |
| case TRANSACTION_PARAM: |
| { |
| /* Parameter Length Index */ |
| i++; |
| /* Fill the event_info.eventInfo.param |
| * Structure with the Received Parameter. |
| */ |
| p_emulation_mgmt_info->uicc_param_len = |
| hcp_message->payload[i++]; |
| (void) memcpy((void *)p_emulation_mgmt_info->uicc_param, |
| &(hcp_message->payload[i]), |
| p_emulation_mgmt_info->uicc_param_len ); |
| event_info.eventInfo.uicc_info.param.length = |
| p_emulation_mgmt_info->uicc_param_len; |
| event_info.eventInfo.uicc_info.param.buffer = (uint8_t *) |
| p_emulation_mgmt_info->uicc_param; |
| i = i + event_info.eventInfo.uicc_info.param.length; |
| break; |
| } |
| default: |
| { |
| |
| status = PHNFCSTVAL( CID_NFC_HCI, |
| NFCSTATUS_FEATURE_NOT_SUPPORTED ); |
| i = length; |
| HCI_DEBUG("%s: Statement Should Not Occur \n", |
| "phHciNfc_Recv_Uicc_Event"); |
| break; |
| } |
| } /* End of Transaction Switch */ |
| } |
| } |
| break; |
| } |
| case EVT_CONNECTIVITY: |
| { |
| event_info.eventType = NFC_EVT_CONNECTIVITY; |
| break; |
| } |
| case EVT_OPERATION_ENDED: |
| { |
| event_info.eventType = NFC_EVT_OPERATION_ENDED; |
| break; |
| } |
| default: |
| { |
| status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED ); |
| HCI_DEBUG("%s: Statement Should Not Occur \n","phHciNfc_Recv_Uicc_Event"); |
| break; |
| } |
| } |
| if ( NFCSTATUS_SUCCESS == status ) |
| { |
| phHciNfc_Notify_Event( psHciContext, pHwRef, |
| NFC_NOTIFY_EVENT, (void *)&event_info ); |
| } |
| } |
| return status; |
| } |
| |
| |
