| /* |
| * 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 <phNfcCompId.h> |
| #include <phHciNfc_Pipe.h> |
| #include <phHciNfc_AdminMgmt.h> |
| #include <phHciNfc_DevMgmt.h> |
| #include <phOsalNfc.h> |
| /* |
| ****************************** 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)); |
| 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 |
| { |
| /* 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)); |
| 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; |
| } |
| |
