/* * 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 hHciNfc_AdminMgmt.c * * \brief HCI Admin Gate Management Routines. * * * * * * Project: NFC-FRI-1.1 * * * * $Date: Mon Apr 5 19:23:34 2010 $ * * $Author: ing04880 $ * * $Revision: 1.47 $ * * $Aliases: NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $ * * * =========================================================================== * */ /* ***************************** Header File Inclusion **************************** */ #include #include #include #include #include /* ****************************** Macro Definitions ******************************* */ #define SESSION_INDEX 0x01U #define MAX_PIPE_INDEX 0x02U #define WHITELIST_INDEX 0x03U #define HOST_LIST_INDEX 0x04U /* Max Whitelist Supported by the Device*/ #define SESSIONID_LEN 0x08U #define WHITELIST_MAX_LEN 0x03U #define HOST_LIST_MAX_LEN 0x05U /* Address Definitions for HW Configuration */ #define NFC_ADDRESS_UICC_SESSION 0x9EA2U /* *************************** Structure and Enumeration *************************** */ typedef enum phHciNfc_Admin_Seq{ ADMIN_PIPE_OPEN = 0x00U, ADMIN_GET_HOST_LIST, ADMIN_GET_WHITE_LIST, ADMIN_GET_SESSION, ADMIN_VERIFY_SESSION, ADMIN_CLEAR_UICC_PIPES, ADMIN_CLEAR_PIPES, ADMIN_PIPE_REOPEN, ADMIN_CREATE_PIPES, ADMIN_SET_SESSION, ADMIN_SET_WHITE_LIST, ADMIN_UPDATE_PIPES, ADMIN_PIPE_CLOSE, ADMIN_DELETE_PIPES, ADMIN_END_SEQUENCE } phHciNfc_Admin_Seq_t; /* Information structure for the Admin Gate */ typedef struct phHciNfc_AdminGate_Info{ /* Current running Sequence of the Admin Management */ phHciNfc_Admin_Seq_t current_seq; /* Next running Sequence of the Admin Management */ phHciNfc_Admin_Seq_t next_seq; /* Pointer to the Admin Pipe Information */ phHciNfc_Pipe_Info_t *admin_pipe_info; /* Sequence for the Pipe Initialisation */ phHciNfc_PipeMgmt_Seq_t pipe_seq; /* Session ID of the Device */ uint8_t session_id[SESSIONID_LEN]; /* Max number of pipes that can be created on the Device */ uint8_t max_pipe; /* List of Hosts that can be access the device Admin Gate. */ uint8_t whitelist[WHITELIST_MAX_LEN]; /* Host List from the Host Controller */ uint8_t host_list[HOST_LIST_MAX_LEN]; } phHciNfc_AdminGate_Info_t; /* *************************** Static Function Declaration ************************** */ /** * \ingroup grp_hci_nfc * * The phHciNfc_Recv_Admin_Response function interprets the received AdminGate * response from the Host Controller Gate. * * \param[in] psHciContext psHciContext is the pointer to HCI Layer * context Structure. * \param[in] pHwRef pHwRef is the Information of * the Device Interface Link . * \param[in,out] pResponse Response received from the Host Cotroller * Admin gate. * \param[in] length length contains the length of the * response received from the Host Controller. * * \retval NFCSTATUS_PENDING AdminGate Response to be received is pending. * \retval NFCSTATUS_SUCCESS AdminGate Response received Successfully. * \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters * could not be interpreted properly. * \retval Other errors Errors related to the other layers * */ static NFCSTATUS phHciNfc_Recv_Admin_Response( void *psHciContext, void *pHwRef, uint8_t *pResponse, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ); static NFCSTATUS phHciNfc_Admin_InfoUpdate( phHciNfc_sContext_t *psHciContext, phHal_sHwReference_t *pHwRef, uint8_t index, uint8_t *reg_value, uint8_t reg_length ); static NFCSTATUS phHciNfc_Recv_Admin_Cmd ( void *psContext, void *pHwRef, uint8_t *pCmd, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ); static NFCSTATUS phHciNfc_Recv_Admin_Event ( void *psContext, void *pHwRef, uint8_t *pEvent, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ); /* *************************** Function Definitions *************************** */ /*! * \brief Initialisation of Admin Gate and Establish the Session . * * This function initialses the Admin Gates and Establishes the Session by creating * all the required pipes and sets the Session ID * */ NFCSTATUS phHciNfc_Admin_Initialise( phHciNfc_sContext_t *psHciContext, void *pHwRef ) { NFCSTATUS status = NFCSTATUS_SUCCESS; phHciNfc_Pipe_Info_t *p_pipe_info = NULL; phHciNfc_AdminGate_Info_t *p_admin_info=NULL; uint8_t length = 0; if( (NULL == psHciContext) || (NULL == pHwRef ) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { if( ( NULL == psHciContext->p_admin_info ) && (phHciNfc_Allocate_Resource((void **)(&p_admin_info), sizeof(phHciNfc_AdminGate_Info_t))== NFCSTATUS_SUCCESS) ) { psHciContext->p_admin_info = (void *) p_admin_info; p_admin_info->current_seq = ADMIN_PIPE_OPEN; p_admin_info->next_seq = ADMIN_END_SEQUENCE; p_admin_info->admin_pipe_info = NULL; } else { p_admin_info = (phHciNfc_AdminGate_Info_t * ) psHciContext->p_admin_info ; } if( NULL == p_admin_info) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); } else { switch(p_admin_info->current_seq) { /* Admin pipe open sequence , Initially open the Admin Pipe */ case ADMIN_PIPE_OPEN: { if(phHciNfc_Allocate_Resource((void **)(&p_pipe_info), sizeof(phHciNfc_Pipe_Info_t))!= NFCSTATUS_SUCCESS) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); } else { /* Populate the pipe information in the pipe handle */ ((phHciNfc_Pipe_Info_t *)p_pipe_info)->pipe.pipe_id = PIPETYPE_STATIC_ADMIN; ((phHciNfc_Pipe_Info_t *)p_pipe_info)->recv_resp = &phHciNfc_Recv_Admin_Response; ((phHciNfc_Pipe_Info_t *)p_pipe_info)->recv_cmd = &phHciNfc_Recv_Admin_Cmd; ((phHciNfc_Pipe_Info_t *)p_pipe_info)->recv_event = &phHciNfc_Recv_Admin_Event; psHciContext->p_pipe_list[PIPETYPE_STATIC_ADMIN] = p_pipe_info ; status = phHciNfc_Open_Pipe( psHciContext, pHwRef,p_pipe_info ); if(status == NFCSTATUS_SUCCESS) { p_admin_info->admin_pipe_info = p_pipe_info ; p_admin_info->next_seq = ADMIN_GET_SESSION; status = NFCSTATUS_PENDING; } } break; } case ADMIN_GET_SESSION: { p_pipe_info = p_admin_info->admin_pipe_info; p_pipe_info->reg_index = SESSION_INDEX; p_pipe_info->prev_status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, (uint8_t)HCI_ADMIN_PIPE_ID, (uint8_t)ANY_GET_PARAMETER); if(NFCSTATUS_PENDING == p_pipe_info->prev_status ) { #ifdef UICC_SESSION_RESET p_admin_info->next_seq = ADMIN_CLEAR_UICC_PIPES; #elif defined (ESTABLISH_SESSION) p_admin_info->next_seq = ADMIN_VERIFY_SESSION; #else p_admin_info->next_seq = ADMIN_CLEAR_PIPES; #endif status = NFCSTATUS_PENDING; } break; } #ifdef UICC_SESSION_RESET case ADMIN_CLEAR_UICC_PIPES: { uint8_t config = 0x00; p_pipe_info = p_admin_info->admin_pipe_info; /* TODO: Implement the Clear UICC PIPES Using * Memory configuration. */ status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, NFC_ADDRESS_UICC_SESSION , config ); if(NFCSTATUS_PENDING == status ) { p_admin_info->next_seq = ADMIN_CLEAR_PIPES; status = NFCSTATUS_PENDING; } break; } #endif case ADMIN_VERIFY_SESSION: { phHal_sHwConfig_t *p_hw_config = (phHal_sHwConfig_t *) psHciContext->p_config_params; phHal_sHwReference_t *p_hw_ref = (phHal_sHwReference_t *) pHwRef; int cmp_val = 0; p_pipe_info = p_admin_info->admin_pipe_info; cmp_val = phOsalNfc_MemCompare(p_hw_config->session_id , p_hw_ref->session_id , sizeof(p_hw_ref->session_id)); //this ifdef can be removed when this is not a patch that is being //administered after a new release of Android. it is required that //the new pipes for A and B emu get created for the CE patch //if this patch is adminstered after the phone has been updated with //a release, it is possible that the create A/B pipe code could never //get executed, so we are forcing it every time. this can be removed //for a main build with a new OS release #ifndef FIRST_CE_PATCH if((cmp_val == 0) && ( HCI_SESSION == psHciContext->init_mode) ) { psHciContext->hci_mode = hciMode_Session; status = phHciNfc_Update_Pipe( psHciContext, pHwRef, &p_admin_info->pipe_seq ); if((status == NFCSTATUS_SUCCESS) && (NULL != p_pipe_info)) { p_pipe_info->reg_index = MAX_PIPE_INDEX; status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, (uint8_t)HCI_ADMIN_PIPE_ID, (uint8_t)ANY_GET_PARAMETER ); p_pipe_info->prev_status = status; if(NFCSTATUS_PENDING == status ) { p_admin_info->next_seq = ADMIN_PIPE_CLOSE; status = NFCSTATUS_SUCCESS; } } else { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); } break; } else #endif { /* To clear the pipe information*/ psHciContext->hci_mode = hciMode_Override; p_admin_info->current_seq = ADMIN_CLEAR_PIPES; } } /* fall through */ case ADMIN_CLEAR_PIPES: { p_pipe_info = p_admin_info->admin_pipe_info; p_pipe_info->prev_status = phHciNfc_Send_Admin_Cmd( psHciContext, pHwRef, ADM_CLEAR_ALL_PIPE, length, p_pipe_info); status = ((p_pipe_info->prev_status == NFCSTATUS_PENDING)? NFCSTATUS_SUCCESS : p_pipe_info->prev_status); if(status == NFCSTATUS_SUCCESS) { p_admin_info->next_seq = ADMIN_PIPE_REOPEN; status = NFCSTATUS_PENDING; } break; } /* Admin pipe Re-Open sequence , Re-Open the Admin Pipe */ case ADMIN_PIPE_REOPEN: { p_pipe_info = p_admin_info->admin_pipe_info; status = phHciNfc_Open_Pipe( psHciContext, pHwRef,p_pipe_info ); if(status == NFCSTATUS_SUCCESS) { p_admin_info->next_seq = ADMIN_CREATE_PIPES; status = NFCSTATUS_PENDING; } break; } case ADMIN_CREATE_PIPES: { status = phHciNfc_Create_All_Pipes( psHciContext, pHwRef, &p_admin_info->pipe_seq ); if(status == NFCSTATUS_SUCCESS) { p_admin_info->next_seq = ADMIN_GET_WHITE_LIST; status = NFCSTATUS_PENDING; } break; } case ADMIN_GET_WHITE_LIST: { p_pipe_info = p_admin_info->admin_pipe_info; if(NULL == p_pipe_info ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); } else { p_pipe_info->reg_index = WHITELIST_INDEX; status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, (uint8_t)HCI_ADMIN_PIPE_ID, (uint8_t)ANY_GET_PARAMETER ); p_pipe_info->prev_status = status; if(HCI_SELF_TEST == psHciContext->init_mode) { status = ((NFCSTATUS_PENDING == status )? NFCSTATUS_SUCCESS : status); } else { if(NFCSTATUS_PENDING == status ) { p_admin_info->next_seq = ADMIN_GET_HOST_LIST; /* status = NFCSTATUS_SUCCESS; */ } } } break; } case ADMIN_GET_HOST_LIST: { p_pipe_info = p_admin_info->admin_pipe_info; if(NULL == p_pipe_info ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); } else { p_pipe_info->reg_index = HOST_LIST_INDEX; status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, (uint8_t)HCI_ADMIN_PIPE_ID, (uint8_t)ANY_GET_PARAMETER ); p_pipe_info->prev_status = status; if(NFCSTATUS_PENDING == status ) { #if defined(HOST_WHITELIST) p_admin_info->next_seq = ADMIN_SET_WHITE_LIST; #else p_admin_info->next_seq = ADMIN_SET_SESSION; status = NFCSTATUS_SUCCESS; #endif } } break; } case ADMIN_SET_WHITE_LIST: { p_pipe_info = p_admin_info->admin_pipe_info; if(NULL == p_pipe_info ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); } else { uint8_t i = 0; for (i = 0; i < WHITELIST_MAX_LEN - 2; i++ ) { p_admin_info->whitelist[i] = i + 2; } status = phHciNfc_Set_Param(psHciContext, pHwRef, p_pipe_info, WHITELIST_INDEX, (uint8_t *)p_admin_info->whitelist, i ); if(NFCSTATUS_PENDING == status ) { p_admin_info->next_seq = ADMIN_SET_SESSION; status = NFCSTATUS_SUCCESS; } } break; } case ADMIN_SET_SESSION: { phHal_sHwConfig_t *p_hw_config = (phHal_sHwConfig_t *) psHciContext->p_config_params; p_pipe_info = p_admin_info->admin_pipe_info; status = phHciNfc_Set_Param(psHciContext, pHwRef, p_pipe_info, SESSION_INDEX, (uint8_t *)(p_hw_config->session_id), sizeof(p_hw_config->session_id)); if(NFCSTATUS_PENDING == p_pipe_info->prev_status ) { p_admin_info->next_seq = ADMIN_PIPE_CLOSE; status = NFCSTATUS_SUCCESS; } break; } default: { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); break; } }/* End of the Sequence Switch */ }/* End of the Admin Info Memory Check */ }/* End of Null context Check */ return status; } #ifdef HOST_EMULATION /*! * \brief Creates the Card Emulation Gate Pipes . * * This function Creates the Card Emulation Gate. */ NFCSTATUS phHciNfc_Admin_CE_Init( phHciNfc_sContext_t *psHciContext, void *pHwRef, phHciNfc_GateID_t ce_gate ) { NFCSTATUS status = NFCSTATUS_SUCCESS; /* phHciNfc_Pipe_Info_t *pipe_info = NULL; */ phHciNfc_AdminGate_Info_t *p_admin_info=NULL; if( (NULL == psHciContext) || (NULL == pHwRef) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { if( NULL != psHciContext->p_admin_info ) { p_admin_info = psHciContext->p_admin_info; switch(ce_gate) { /* Card Emulation A Gate Pipe Creation */ case phHciNfc_CETypeAGate: { p_admin_info->pipe_seq = PIPE_CARD_A_CREATE; break; } /* Card Emulation B Gate Pipe Creation */ case phHciNfc_CETypeBGate: { p_admin_info->pipe_seq = PIPE_CARD_B_CREATE; break; } default: { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_HCI_GATE_NOT_SUPPORTED); break; } } /* End of CE Gate Switch */ if (NFCSTATUS_SUCCESS == status) { status = phHciNfc_CE_Pipes_OP( psHciContext, pHwRef, &p_admin_info->pipe_seq ); if(status == NFCSTATUS_SUCCESS) { p_admin_info->next_seq = ADMIN_END_SEQUENCE; /* status = NFCSTATUS_PENDING; */ } } }/* End of NULL Check for the Admin_Info */ } /* End of Null Check for the Context */ return status; } #endif /*! * \brief Releases the resources allocated the Admin Management. * * This function Releases the resources allocated the Admin Management * and resets the hardware to the reset state. */ NFCSTATUS phHciNfc_Admin_Release( phHciNfc_sContext_t *psHciContext, void *pHwRef, phHciNfc_HostID_t host_type ) { NFCSTATUS status = NFCSTATUS_SUCCESS; phHciNfc_Pipe_Info_t *p_pipe_info = NULL; if( (NULL == psHciContext) || (NULL == pHwRef) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { if( NULL != psHciContext->p_admin_info ) { if(phHciNfc_UICCHostID != host_type) { p_pipe_info = psHciContext->p_pipe_list[PIPETYPE_STATIC_ADMIN]; status = phHciNfc_Close_Pipe( psHciContext, pHwRef, p_pipe_info ); } }/* End of NULL Check for the Admin_Info */ } /* End of Null Check for the Context */ return status; } /*! * \brief Sends the HCI Admin Event to the corresponding peripheral device. * * This function sends the HCI Admin Events to the connected NFC Pheripheral * device */ NFCSTATUS phHciNfc_Send_Admin_Event ( phHciNfc_sContext_t *psHciContext, void *pHwRef, uint8_t event, uint8_t length, void *params ) { phHciNfc_HCP_Packet_t *hcp_packet = NULL; phHciNfc_AdminGate_Info_t *p_admin_info=NULL; NFCSTATUS status = NFCSTATUS_SUCCESS; if( (NULL == psHciContext) || (NULL == pHwRef) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { psHciContext->tx_total = 0 ; length += HCP_HEADER_LEN ; p_admin_info = psHciContext->p_admin_info; if( EVT_HOT_PLUG == event ) { /* Use the HCP Packet Structure to Construct the send HCP * Packet data. */ hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, (uint8_t) HCI_ADMIN_PIPE_ID, HCP_MSG_TYPE_EVENT, event); } else { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INSTRUCTION); } if( NFCSTATUS_SUCCESS == status ) { p_admin_info->admin_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT; p_admin_info->admin_pipe_info->prev_msg = event ; p_admin_info->admin_pipe_info->param_info = params ; psHciContext->tx_total = length; psHciContext->response_pending = FALSE ; status = phHciNfc_Send_HCP( (void *)psHciContext, (void *)pHwRef ); p_admin_info->admin_pipe_info->prev_status = NFCSTATUS_PENDING; } } return status; } /*! * \brief Sends the HCI Admin Commands to the corresponding peripheral device. * * This function sends the HCI Admin Commands to the connected NFC Pheripheral * device */ NFCSTATUS phHciNfc_Send_Admin_Cmd ( phHciNfc_sContext_t *psHciContext, void *pHwRef, uint8_t cmd, uint8_t length, void *params ) { phHciNfc_HCP_Packet_t *hcp_packet = NULL; phHciNfc_HCP_Message_t *hcp_message = NULL; phHciNfc_AdminGate_Info_t *p_admin_info=NULL; phHciNfc_Pipe_Info_t *p_pipe_info = NULL; uint8_t i=0; NFCSTATUS status = NFCSTATUS_SUCCESS; if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == params) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { p_pipe_info = (phHciNfc_Pipe_Info_t *) params; psHciContext->tx_total = 0 ; length += HCP_HEADER_LEN ; p_admin_info = psHciContext->p_admin_info; switch( cmd ) { case ADM_CREATE_PIPE: { hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; /* Use the HCP Packet Structure to Construct the send HCP * Packet data. */ phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, (uint8_t) HCI_ADMIN_PIPE_ID, HCP_MSG_TYPE_COMMAND, cmd); hcp_message = &(hcp_packet->msg.message); /* Source HOST ID Parameter is not passed as a * parameter in the HCI SPEC */ /* hcp_message->payload[i++] = p_pipe_info->pipe.source.host_id; */ hcp_message->payload[i++] = p_pipe_info->pipe.source.gate_id; hcp_message->payload[i++] = p_pipe_info->pipe.dest.host_id; hcp_message->payload[i++] = p_pipe_info->pipe.dest.gate_id; break; } case ADM_DELETE_PIPE: { uint8_t pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID; pipe_id = p_pipe_info->pipe.pipe_id; if( pipe_id < PIPETYPE_DYNAMIC ) { /* The Static Pipes cannot be Deleted */ status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER ); HCI_DEBUG("phHciNfc_Send_Admin_Cmd: Static Pipe %u " "Cannot be Deleted \n",pipe_id); } else { /* Use the HCP Packet Structure to Construct the send HCP * Packet data. */ hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, (uint8_t) HCI_ADMIN_PIPE_ID, HCP_MSG_TYPE_COMMAND, cmd); hcp_message = &(hcp_packet->msg.message); hcp_message->payload[i++] = pipe_id ; } break; } case ADM_CLEAR_ALL_PIPE: { /* Use the HCP Packet Structure to Construct the send HCP * Packet data. */ hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, (uint8_t) HCI_ADMIN_PIPE_ID, HCP_MSG_TYPE_COMMAND, cmd); hcp_message = &(hcp_packet->msg.message); break; } /* These are notifications and can not be sent by the Host */ /* case ADM_NOTIFY_PIPE_CREATED: */ /* case ADM_NOTIFY_PIPE_DELETED: */ /* case ADM_NOTIFY_ALL_PIPE_CLEARED: */ default: status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_COMMAND); break; } if( NFCSTATUS_SUCCESS == status ) { p_admin_info->admin_pipe_info->sent_msg_type = HCP_MSG_TYPE_COMMAND; p_admin_info->admin_pipe_info->prev_msg = cmd; p_admin_info->admin_pipe_info->param_info = p_pipe_info; psHciContext->tx_total = length; psHciContext->response_pending = TRUE; status = phHciNfc_Send_HCP( (void *)psHciContext, (void *)pHwRef ); p_admin_info->admin_pipe_info->prev_status = NFCSTATUS_PENDING; } } return status; } /*! * \brief Receives the HCI Response from the corresponding peripheral device. * * This function receives the HCI Command Response from the connected NFC * Pheripheral device. */ static NFCSTATUS phHciNfc_Recv_Admin_Response( void *psContext, void *pHwRef, uint8_t *pResponse, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ) { 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_AdminGate_Info_t *p_admin_info = NULL; NFCSTATUS status = NFCSTATUS_SUCCESS; uint8_t pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID; uint8_t prev_cmd = 0; NFCSTATUS prev_status = NFCSTATUS_SUCCESS; if( (NULL == psHciContext) || (NULL == pHwRef) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else if ( NULL == psHciContext->p_admin_info ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); } else { hcp_packet = (phHciNfc_HCP_Packet_t *)pResponse; hcp_message = &hcp_packet->msg.message; p_admin_info = psHciContext->p_admin_info; prev_cmd = p_admin_info->admin_pipe_info->prev_msg ; prev_status = p_admin_info->admin_pipe_info->prev_status ; if(prev_status == NFCSTATUS_PENDING) { switch(prev_cmd) { case ANY_SET_PARAMETER: { break; } case ANY_GET_PARAMETER: { status = phHciNfc_Admin_InfoUpdate(psHciContext, (phHal_sHwReference_t *)pHwRef, p_admin_info->admin_pipe_info->reg_index, &pResponse[HCP_HEADER_LEN], (uint8_t)(length - HCP_HEADER_LEN)); break; } case ANY_OPEN_PIPE: { break; } case ANY_CLOSE_PIPE: { phOsalNfc_FreeMemory(p_admin_info->admin_pipe_info); p_admin_info->admin_pipe_info = NULL; psHciContext->p_pipe_list[PIPETYPE_STATIC_ADMIN] = NULL; break; } case ADM_CREATE_PIPE: { p_pipe_info = (phHciNfc_Pipe_Info_t *) p_admin_info->admin_pipe_info->param_info; pipe_id = hcp_message->payload[RESPONSE_PIPEID_OFFSET]; status = phHciNfc_Update_PipeInfo(psHciContext, &(p_admin_info->pipe_seq), pipe_id, p_pipe_info); if(NFCSTATUS_SUCCESS == status ) { psHciContext->p_pipe_list[pipe_id] = p_pipe_info; p_pipe_info->pipe.pipe_id = pipe_id; } break; } case ADM_DELETE_PIPE: { p_pipe_info = (phHciNfc_Pipe_Info_t *) p_admin_info->admin_pipe_info->param_info; if ( NULL != p_pipe_info ) { pipe_id = p_pipe_info->pipe.pipe_id; status = phHciNfc_Update_PipeInfo( psHciContext, &(p_admin_info->pipe_seq), (uint8_t) HCI_UNKNOWN_PIPE_ID, p_pipe_info); if(NFCSTATUS_SUCCESS == status ) { phOsalNfc_FreeMemory(p_pipe_info); psHciContext->p_pipe_list[pipe_id] = NULL; } } break; } case ADM_CLEAR_ALL_PIPE: { break; } default: { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE); HCI_DEBUG("%s: Default Statement Should Not Occur \n", "phHciNfc_Recv_Admin_Response"); break; } } } if( NFCSTATUS_SUCCESS == status ) { if( NULL != p_admin_info->admin_pipe_info) { p_admin_info->admin_pipe_info->prev_status = NFCSTATUS_SUCCESS; } p_admin_info->current_seq = p_admin_info->next_seq; } } return status; } /*! * \brief Receives the HCI Admin Commands from the corresponding peripheral device. * * This function receives the HCI Admin Commands from the connected NFC Pheripheral * device */ static NFCSTATUS phHciNfc_Recv_Admin_Cmd ( void *psContext, void *pHwRef, uint8_t *pCmd, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ) { phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext ; phHciNfc_HCP_Packet_t *hcp_packet = NULL; phHciNfc_HCP_Message_t *hcp_message = NULL; phHciNfc_AdminGate_Info_t *p_admin_info=NULL; phHciNfc_Pipe_Info_t *p_pipe_info = NULL; uint8_t index=0; 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; 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_admin_info = psHciContext->p_admin_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); switch( cmd ) { /* These are notifications sent by the Host Controller */ case ADM_NOTIFY_PIPE_CREATED: { pipe_id = hcp_message->payload[RESPONSE_PIPEID_OFFSET]; p_pipe_info = (phHciNfc_Pipe_Info_t *) phOsalNfc_GetMemory(sizeof(phHciNfc_Pipe_Info_t)); memset(p_pipe_info, 0, sizeof(phHciNfc_Pipe_Info_t)); if(NULL != p_pipe_info) { /* The Source Host is the UICC Host */ p_pipe_info->pipe.source.host_id = hcp_message->payload[index++]; /* The Source Gate is same as the Destination Gate */ p_pipe_info->pipe.source.gate_id = hcp_message->payload[index++]; /* The Source Host is the Terminal Host */ p_pipe_info->pipe.dest.host_id = hcp_message->payload[index++]; p_pipe_info->pipe.dest.gate_id = hcp_message->payload[index++]; p_pipe_info->pipe.pipe_id = hcp_message->payload[index++]; } status = phHciNfc_Update_PipeInfo(psHciContext, &(p_admin_info->pipe_seq), pipe_id, p_pipe_info); if( NFCSTATUS_SUCCESS == status ) { psHciContext->p_pipe_list[pipe_id] = p_pipe_info; if (NULL != p_pipe_info) { p_pipe_info->pipe.pipe_id = pipe_id; } } break; } case ADM_NOTIFY_PIPE_DELETED: { pipe_id = hcp_message->payload[index++]; p_pipe_info = psHciContext->p_pipe_list[pipe_id]; if ( NULL != p_pipe_info ) { status = phHciNfc_Update_PipeInfo( psHciContext, &(p_admin_info->pipe_seq), (uint8_t) HCI_UNKNOWN_PIPE_ID, p_pipe_info); if(NFCSTATUS_SUCCESS == status ) { phOsalNfc_FreeMemory(p_pipe_info); psHciContext->p_pipe_list[pipe_id] = NULL; } } break; } /* TODO: Since we receive the Host ID, we need to clear * all the pipes created with the host */ case ADM_NOTIFY_ALL_PIPE_CLEARED: { break; } /* case ADM_CREATE_PIPE: */ /* case ADM_DELETE_PIPE: */ /* case ADM_CLEAR_ALL_PIPE: */ default: { response = ANY_E_CMD_NOT_SUPPORTED; status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_COMMAND_NOT_SUPPORTED); break; } } hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, (uint8_t) HCI_ADMIN_PIPE_ID, HCP_MSG_TYPE_RESPONSE, response ); psHciContext->tx_total = HCP_HEADER_LEN; status = phHciNfc_Send_HCP( (void *)psHciContext, (void *)pHwRef ); p_admin_info->admin_pipe_info->recv_msg_type = HCP_MSG_TYPE_COMMAND; p_admin_info->admin_pipe_info->sent_msg_type = HCP_MSG_TYPE_RESPONSE; p_admin_info->admin_pipe_info->prev_msg = response; p_admin_info->admin_pipe_info->prev_status = NFCSTATUS_PENDING; } return status; } /*! * \brief Receives the HCI Admin Event from the corresponding peripheral device. * * This function receives the HCI Admin Events from the connected NFC Pheripheral * device */ static NFCSTATUS phHciNfc_Recv_Admin_Event ( void *psContext, void *pHwRef, uint8_t *pEvent, #ifdef ONE_BYTE_LEN uint8_t length #else uint16_t length #endif ) { phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext ; phHciNfc_HCP_Packet_t *hcp_packet = NULL; phHciNfc_HCP_Message_t *hcp_message = NULL; uint8_t event = (uint8_t) HCP_MSG_INSTRUCTION_INVALID; NFCSTATUS status = NFCSTATUS_SUCCESS; if( (NULL == psHciContext) || (NULL == pHwRef) || (HCP_HEADER_LEN > length ) ) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { hcp_packet = (phHciNfc_HCP_Packet_t *)pEvent; hcp_message = &hcp_packet->msg.message; /* Get the Command instruction bits from the Message Header */ event = (uint8_t) GET_BITS8( hcp_message->msg_header, HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); if( EVT_HOT_PLUG == event ) { status = phHciNfc_Send_Admin_Event ( psHciContext, pHwRef, EVT_HOT_PLUG, 0 ,NULL); } else { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INSTRUCTION); } } return status; } static NFCSTATUS phHciNfc_Admin_InfoUpdate( phHciNfc_sContext_t *psHciContext, phHal_sHwReference_t *pHwRef, uint8_t index, uint8_t *reg_value, uint8_t reg_length ) { phHciNfc_AdminGate_Info_t *p_admin_info=NULL; uint8_t i=0; NFCSTATUS status = NFCSTATUS_SUCCESS; if(NULL == reg_value) { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); } else { p_admin_info = psHciContext->p_admin_info ; HCI_PRINT_BUFFER("Admin Mgmt Info Buffer",reg_value,reg_length); switch(index) { case SESSION_INDEX : { for(i=0 ;(reg_length == SESSIONID_LEN)&&(i < reg_length); i++) { p_admin_info->session_id[i] = reg_value[i]; pHwRef->session_id[i] = reg_value[i]; } break; } case MAX_PIPE_INDEX : { p_admin_info->max_pipe = reg_value[i]; break; } case WHITELIST_INDEX : { for(i=0 ;(reg_length <= WHITELIST_MAX_LEN)&&(i < reg_length); i++) { p_admin_info->whitelist[i] = reg_value[i]; } break; } case HOST_LIST_INDEX : { for(i=0 ;(reg_length <= HOST_LIST_MAX_LEN)&&(i < reg_length); i++) { p_admin_info->host_list[i] = reg_value[i]; } break; } default: { status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE); break; } /*End of the default Switch Case */ } /*End of the Index Switch */ } /* End of Context and the Identity information validity check */ return status; }