/* * 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 #include #include #include #include #include #include #ifdef ENABLE_P2P #include #endif #ifdef HOST_EMULATION #include #include #endif #include /* ****************************** 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; }