2197 lines
79 KiB
C
2197 lines
79 KiB
C
/*
|
|
* 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_NfcIPMgmt.c *
|
|
* \brief HCI NFCIP-1 management routines. *
|
|
* *
|
|
* *
|
|
* Project: NFC-FRI-1.1 *
|
|
* *
|
|
* $Date: Tue Jun 8 09:32:31 2010 $ *
|
|
* $Author: ing04880 $ *
|
|
* $Revision: 1.33 $ *
|
|
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
|
|
* *
|
|
* =========================================================================== *
|
|
*/
|
|
|
|
/*
|
|
***************************** Header File Inclusion ****************************
|
|
*/
|
|
#include <phNfcCompId.h>
|
|
#include <phNfcHalTypes.h>
|
|
#include <phHciNfc_Pipe.h>
|
|
#include <phHciNfc_RFReader.h>
|
|
#include <phHciNfc_Emulation.h>
|
|
#include <phOsalNfc.h>
|
|
|
|
#if defined (ENABLE_P2P)
|
|
#include <phHciNfc_NfcIPMgmt.h>
|
|
/*
|
|
****************************** Macro Definitions *******************************
|
|
*/
|
|
/* RF Error */
|
|
#define NFCIP_RF_NO_ERROR 0x00U
|
|
#define NFCIP_STATUS_MAX_VALUE 0x01U
|
|
|
|
/* Read and write to the below registry for initiator and target */
|
|
#define NXP_NFCIP_MODE 0x01U
|
|
#define NXP_NFCIP_ATR_REQ 0x02U
|
|
#define NXP_NFCIP_ATR_RES 0x03U
|
|
#define NXP_NFCIP_PSL1 0x04U
|
|
#define NXP_NFCIP_PSL2 0x05U
|
|
#define NXP_NFCIP_DID 0x06U
|
|
#define NXP_NFCIP_NAD 0x07U
|
|
#define NXP_NFCIP_OPTIONS 0x08U
|
|
#define NXP_NFCIP_STATUS 0x09U
|
|
#define NXP_NFCIP_NFCID3I 0x0AU
|
|
#define NXP_NFCIP_NFCID3T 0x0BU
|
|
#define NXP_NFCIP_PARAM 0x0CU
|
|
#define NXP_NFCIP_MERGE 0x0DU
|
|
|
|
/* command */
|
|
#define NXP_NFCIP_ATTREQUEST 0x12U
|
|
#define NXP_NFCI_CONTINUE_ACTIVATION 0x13U
|
|
|
|
/* Event */
|
|
#define NXP_EVT_NFC_SND_DATA 0x01U
|
|
#define NXP_EVT_NFC_ACTIVATED 0x02U
|
|
#define NXP_EVT_NFC_DEACTIVATED 0x03U
|
|
#define NXP_EVT_NFC_RCV_DATA 0x04U
|
|
#define NXP_EVT_NFC_CONTINUE_MI 0x05U
|
|
|
|
#define NFCIP_DATE_RATE_FACTOR 0x40U
|
|
#define NFCIP_DATE_RATE_SHIFT 0x06U
|
|
#define NFCIP_DATA_RATE_CALC(val) \
|
|
((((uint8_t)(val) >> NFCIP_DATE_RATE_SHIFT) + \
|
|
0x01U) * NFCIP_DATE_RATE_FACTOR)
|
|
#define NFCIP_COMM_INITIATOR_SHIFT 0x03
|
|
#define NFCIP_COMM_FACTOR 0x03
|
|
/*
|
|
*************************** Structure and Enumeration ***************************
|
|
*/
|
|
|
|
/*
|
|
*************************** Static Function Declaration **************************
|
|
*/
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_InfoUpdate(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t index,
|
|
uint8_t *reg_value,
|
|
uint8_t reg_length
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_RecvData(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_NfcIP_Response(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
phHciNfc_Pipe_Info_t *ppipe_info,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_NfcIP_Event(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Initiator_Event(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Target_Event(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Initiator_Response(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Target_Response(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
/*
|
|
*************************** Function Definitions ***************************
|
|
*/
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Initiator_Init_Resources(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_NfcIP_Info_t *p_init_info=NULL;
|
|
if( NULL == psHciContext )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else
|
|
{
|
|
if (NULL != psHciContext->p_nfcip_info)
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
else if(( NULL == psHciContext->p_nfcip_info ) &&
|
|
(phHciNfc_Allocate_Resource((void **)(&p_init_info),
|
|
sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
|
|
)
|
|
{
|
|
psHciContext->p_nfcip_info = p_init_info;
|
|
p_init_info->nfcip_type = NFCIP_INVALID;
|
|
p_init_info->current_seq = NFCIP_INVALID_SEQUENCE;
|
|
p_init_info->next_seq = NFCIP_INVALID_SEQUENCE;
|
|
p_init_info->p_init_pipe_info = NULL;
|
|
p_init_info->p_tgt_pipe_info = NULL;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Initiator_Get_PipeID(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t *ppipe_id
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
if( (NULL != psHciContext)
|
|
&& ( NULL != ppipe_id )
|
|
&& ( NULL != psHciContext->p_nfcip_info )
|
|
)
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_init_info=NULL;
|
|
p_init_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
*ppipe_id = p_init_info->p_init_pipe_info->pipe.pipe_id ;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Initiator_Update_PipeInfo(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t pipeID,
|
|
phHciNfc_Pipe_Info_t *pPipeInfo
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
if( NULL == psHciContext )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_init_info=NULL;
|
|
p_init_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
/* Update the pipe_id of the NFCIP-1 initiator Gate obtained from
|
|
the HCI Response */
|
|
p_init_info->p_init_pipe_info = pPipeInfo;
|
|
p_init_info->p_init_pipe_info->pipe.pipe_id = pipeID;
|
|
/* Update the Response Receive routine of the NFCIP-1 initiator Gate */
|
|
pPipeInfo->recv_resp = &phHciNfc_Recv_Initiator_Response;
|
|
/* Update the event Receive routine of the NFCIP-1 initiator Gate */
|
|
pPipeInfo->recv_event = &phHciNfc_Recv_Initiator_Event;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_Presence_Check(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_nfcip_info) ||
|
|
(NFCIP_INVALID ==
|
|
((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
|
|
p_nfcipinfo->p_init_pipe_info :
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *hcp_packet = NULL;
|
|
uint16_t length = HCP_HEADER_LEN;
|
|
uint8_t pipeid = 0;
|
|
|
|
pipeid = p_pipe_info->pipe.pipe_id;
|
|
psHciContext->tx_total = 0 ;
|
|
hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
|
|
/* Construct the HCP Frame */
|
|
phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
|
|
(uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND,
|
|
(uint8_t)NXP_NFCIP_ATTREQUEST);
|
|
|
|
p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
|
|
p_pipe_info->prev_msg = (uint8_t)NXP_NFCIP_ATTREQUEST;
|
|
psHciContext->tx_total = length;
|
|
psHciContext->response_pending = (uint8_t)TRUE;
|
|
|
|
/* Send the Constructed HCP packet to the lower layer */
|
|
status = phHciNfc_Send_HCP( psHciContext, pHwRef);
|
|
p_pipe_info->prev_status = status;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Initiator_Response(
|
|
void *pContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
(phHciNfc_sContext_t *)pContext ;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
|
|
|
|
p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = p_nfcip_info->p_init_pipe_info;
|
|
if( NULL == p_pipe_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
status = phHciNfc_Recv_NfcIP_Response(psHciContext,
|
|
p_pipe_info, pResponse,
|
|
length);
|
|
if (NFCSTATUS_SUCCESS == status)
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Initiator_Event(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
(phHciNfc_sContext_t *)psContext ;
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *p_packet = NULL;
|
|
phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
|
|
phHciNfc_HCP_Message_t *message = NULL;
|
|
uint8_t instruction=0;
|
|
|
|
p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
|
|
message = &p_packet->msg.message;
|
|
/* Get the instruction bits from the Message Header */
|
|
instruction = (uint8_t) GET_BITS8( message->msg_header,
|
|
HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
|
|
if (NXP_EVT_NFC_ACTIVATED == instruction)
|
|
{
|
|
p_nfcip_info->nfcip_type = NFCIP_INITIATOR;
|
|
psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
|
|
p_nfcip_info->rem_nfcip_tgt_info.RemDevType = phHal_eNfcIP1_Target;
|
|
}
|
|
|
|
status = phHciNfc_Recv_NfcIP_Event(psHciContext,
|
|
pHwRef, pEvent, length);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Target_Init_Resources(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_NfcIP_Info_t *p_target_info=NULL;
|
|
if( NULL == psHciContext )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else
|
|
{
|
|
if (NULL != psHciContext->p_nfcip_info)
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
else if(
|
|
( NULL == psHciContext->p_nfcip_info ) &&
|
|
(phHciNfc_Allocate_Resource((void **)(&p_target_info),
|
|
sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
|
|
)
|
|
{
|
|
psHciContext->p_nfcip_info = p_target_info;
|
|
p_target_info->nfcip_type = NFCIP_INVALID;
|
|
p_target_info->current_seq = NFCIP_INVALID_SEQUENCE;
|
|
p_target_info->next_seq = NFCIP_INVALID_SEQUENCE;
|
|
p_target_info->p_tgt_pipe_info = NULL;
|
|
p_target_info->p_tgt_pipe_info = NULL;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Target_Get_PipeID(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t *ppipe_id
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
if( (NULL != psHciContext)
|
|
&& ( NULL != ppipe_id )
|
|
&& ( NULL != psHciContext->p_nfcip_info )
|
|
)
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_target_info=NULL;
|
|
p_target_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
*ppipe_id = p_target_info->p_tgt_pipe_info->pipe.pipe_id;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Target_Update_PipeInfo(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t pipeID,
|
|
phHciNfc_Pipe_Info_t *pPipeInfo
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
if( NULL == psHciContext )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_target_info=NULL;
|
|
p_target_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
/* Update the pipe_id of the NFCIP-1 target Gate obtained from
|
|
the HCI Response */
|
|
p_target_info->p_tgt_pipe_info = pPipeInfo;
|
|
p_target_info->p_tgt_pipe_info->pipe.pipe_id = pipeID;
|
|
/* Update the Response Receive routine of the NFCIP-1 target Gate */
|
|
pPipeInfo->recv_resp = &phHciNfc_Recv_Target_Response;
|
|
/* Update the event Receive routine of the NFCIP-1 target Gate */
|
|
pPipeInfo->recv_event = &phHciNfc_Recv_Target_Event;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Target_Response(
|
|
void *pContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
(phHciNfc_sContext_t *)pContext ;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
|
|
|
|
p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = p_nfcip_info->p_tgt_pipe_info;
|
|
if( NULL == p_pipe_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
status = phHciNfc_Recv_NfcIP_Response(psHciContext,
|
|
p_pipe_info, pResponse,
|
|
length);
|
|
if (NFCSTATUS_SUCCESS == status)
|
|
{
|
|
status = phHciNfc_EmuMgmt_Update_Seq(psHciContext,
|
|
UPDATE_SEQ);
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Target_Event(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
(phHciNfc_sContext_t *)psContext ;
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *p_packet = NULL;
|
|
phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
|
|
phHciNfc_HCP_Message_t *message = NULL;
|
|
uint8_t instruction=0;
|
|
|
|
p_nfcip_info = (phHciNfc_NfcIP_Info_t *)psHciContext->p_nfcip_info ;
|
|
p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
|
|
message = &p_packet->msg.message;
|
|
/* Get the instruction bits from the Message Header */
|
|
instruction = (uint8_t) GET_BITS8( message->msg_header,
|
|
HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
|
|
if (NXP_EVT_NFC_ACTIVATED == instruction)
|
|
{
|
|
p_nfcip_info->nfcip_type = NFCIP_TARGET;
|
|
psHciContext->host_rf_type = phHal_eNfcIP1_Target;
|
|
p_nfcip_info->rem_nfcip_tgt_info.RemDevType =
|
|
phHal_eNfcIP1_Initiator;
|
|
}
|
|
status = phHciNfc_Recv_NfcIP_Event(psHciContext,
|
|
pHwRef, pEvent, length);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_NfcIP_Response(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
phHciNfc_Pipe_Info_t *ppipe_info,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
uint8_t prev_cmd = ANY_GET_PARAMETER;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
prev_cmd = ppipe_info->prev_msg ;
|
|
switch(prev_cmd)
|
|
{
|
|
case ANY_OPEN_PIPE:
|
|
{
|
|
HCI_PRINT("NFCIP-1 NFCIP open pipe complete\n");
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
break;
|
|
}
|
|
case ANY_CLOSE_PIPE:
|
|
{
|
|
HCI_PRINT("NFCIP-1 NFCIP close pipe complete\n");
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
break;
|
|
}
|
|
case ANY_GET_PARAMETER:
|
|
{
|
|
HCI_PRINT("NFCIP-1 NFCIP get parameter complete\n");
|
|
if (length >= HCP_HEADER_LEN)
|
|
{
|
|
status = phHciNfc_NfcIP_InfoUpdate(psHciContext,
|
|
ppipe_info->reg_index,
|
|
&pResponse[HCP_HEADER_LEN],
|
|
(uint8_t)(length - HCP_HEADER_LEN));
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case ANY_SET_PARAMETER:
|
|
{
|
|
HCI_PRINT("NFCIP-1 NFCIP Parameter Set \n");
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
break;
|
|
}
|
|
case NXP_NFCI_CONTINUE_ACTIVATION:
|
|
case NXP_NFCIP_ATTREQUEST:
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( NFCSTATUS_SUCCESS == status )
|
|
{
|
|
ppipe_info->prev_status = NFCSTATUS_SUCCESS;
|
|
p_nfcipinfo->current_seq = p_nfcipinfo->next_seq;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_NfcIP_Event(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_HCP_Packet_t *p_packet = NULL;
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_HCP_Message_t *message = NULL;
|
|
phNfc_sCompletionInfo_t pCompInfo;
|
|
uint8_t instruction=0;
|
|
uint8_t type = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
|
|
message = &p_packet->msg.message;
|
|
/* Get the instruction bits from the Message Header */
|
|
instruction = (uint8_t) GET_BITS8( message->msg_header,
|
|
HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
|
|
|
|
switch(instruction)
|
|
{
|
|
case NXP_EVT_NFC_ACTIVATED:
|
|
{
|
|
HCI_PRINT("NFCIP-1 device discovered\n");
|
|
|
|
if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
|
|
{
|
|
pCompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
|
|
type = NFC_NOTIFY_TARGET_DISCOVERED;
|
|
}
|
|
else
|
|
{
|
|
type = NFC_NOTIFY_DEVICE_ACTIVATED;
|
|
}
|
|
|
|
if(length > HCP_HEADER_LEN)
|
|
{
|
|
HCI_DEBUG("NfcIP-1 activation mode : %d\n", pEvent[HCP_HEADER_LEN]);
|
|
/* Mode indicates in which mode the current activation
|
|
as be done
|
|
- 0x00: Passive mode
|
|
- 0x01: Active */
|
|
p_nfcipinfo->activation_mode = pEvent[HCP_HEADER_LEN];
|
|
}
|
|
pCompInfo.status = NFCSTATUS_SUCCESS;
|
|
/* Notify to the HCI Generic layer To Update the FSM */
|
|
phHciNfc_Notify_Event(psHciContext, pHwRef,
|
|
type, &pCompInfo);
|
|
break;
|
|
}
|
|
case NXP_EVT_NFC_DEACTIVATED:
|
|
{
|
|
static phHal_sEventInfo_t event_info;
|
|
|
|
event_info.eventHost = phHal_eHostController;
|
|
event_info.eventType = NFC_EVT_DEACTIVATED;
|
|
p_nfcipinfo->activation_mode = FALSE;
|
|
if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
|
|
{
|
|
p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
|
|
phHal_eNfcIP1_Target;
|
|
event_info.eventSource = phHal_eNfcIP1_Initiator;
|
|
}
|
|
else
|
|
{
|
|
p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
|
|
phHal_eNfcIP1_Initiator;
|
|
event_info.eventSource = phHal_eNfcIP1_Target;
|
|
}
|
|
/* Reset the sequence */
|
|
p_nfcipinfo->current_seq = NFCIP_NFCID3I;
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
|
|
HCI_PRINT("NFCIP-1 Target Deactivated\n");
|
|
phHciNfc_Notify_Event(psHciContext, pHwRef,
|
|
NFC_NOTIFY_DEVICE_DEACTIVATED,
|
|
&event_info);
|
|
break;
|
|
}
|
|
case NXP_EVT_NFC_RCV_DATA:
|
|
{
|
|
status = phHciNfc_NfcIP_RecvData(psHciContext,
|
|
pHwRef,
|
|
&pEvent[HCP_HEADER_LEN],
|
|
(length - HCP_HEADER_LEN));
|
|
break;
|
|
}
|
|
case NXP_EVT_NFC_CONTINUE_MI:
|
|
{
|
|
/* psHciContext->response_pending = FALSE; */
|
|
psHciContext->event_pending = FALSE;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_RecvData(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
uint8_t index = 0;
|
|
|
|
if( (NULL == psHciContext)
|
|
|| (NULL == pHwRef)
|
|
|| (NULL == pResponse)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else
|
|
{
|
|
phNfc_sTransactionInfo_t transInfo;
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
|
|
uint8_t type = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info;
|
|
HCI_PRINT("NFCIP-1 received bytes :");
|
|
if (NFCIP_RF_NO_ERROR == pResponse[index])
|
|
{
|
|
HCI_PRINT_BUFFER("device ", &pResponse[index], (length - index));
|
|
transInfo.status = NFCSTATUS_SUCCESS;
|
|
index++;
|
|
if (TRUE == pResponse[index])
|
|
{
|
|
/* Update the more information bit to the upper layer */
|
|
transInfo.status = NFCSTATUS_MORE_INFORMATION;
|
|
}
|
|
index++;
|
|
|
|
|
|
transInfo.buffer = &pResponse[index];
|
|
transInfo.length = (length - index);
|
|
type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
|
|
}
|
|
else
|
|
{
|
|
HCI_PRINT("NFCIP-1 receive RF ERROR ");
|
|
p_nfcipinfo->activation_mode = FALSE;
|
|
type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
|
|
transInfo.status = NFCSTATUS_RF_TIMEOUT;
|
|
transInfo.buffer = NULL;
|
|
transInfo.length = 0;
|
|
}
|
|
status = NFCSTATUS_PENDING;
|
|
/* Event NXP_EVT_NFC_RCV_DATA: so give received data to
|
|
the upper layer */
|
|
phHciNfc_Notify_Event(psHciContext, pHwRef,
|
|
type,
|
|
&transInfo );
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_Send_Data (
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_XchgInfo_t *sData
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == sData) ||
|
|
(NULL == sData->tx_buffer) || (0 == sData->tx_length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_nfcip_info) ||
|
|
(NFCIP_INVALID ==
|
|
((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
|
|
p_nfcipinfo->p_init_pipe_info :
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *hcp_packet = NULL;
|
|
phHciNfc_HCP_Message_t *hcp_message = NULL;
|
|
uint16_t length = HCP_HEADER_LEN;
|
|
uint8_t pipeid = 0,
|
|
i = 0;
|
|
|
|
HCI_PRINT_BUFFER("HCI NFCIP-1 Send Data: ", sData->tx_buffer, sData->tx_length);
|
|
|
|
psHciContext->tx_total = 0 ;
|
|
pipeid = p_pipe_info->pipe.pipe_id;
|
|
hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
|
|
hcp_message = &(hcp_packet->msg.message);
|
|
hcp_message->payload[i] = sData->params.nfc_info.more_info;
|
|
i++;
|
|
|
|
/* Construct the HCP Frame */
|
|
phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
|
|
(uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_EVENT,
|
|
(uint8_t)NXP_EVT_NFC_SND_DATA);
|
|
|
|
phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
|
|
i, (uint8_t *)sData->tx_buffer,
|
|
(uint8_t)sData->tx_length);
|
|
|
|
length =(uint16_t)(length + i + sData->tx_length);
|
|
|
|
p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_EVENT;
|
|
p_pipe_info->prev_msg = NXP_EVT_NFC_SND_DATA;
|
|
psHciContext->tx_total = length;
|
|
/* Send the Constructed HCP packet to the lower layer */
|
|
status = phHciNfc_Send_HCP( psHciContext, pHwRef);
|
|
#if !defined (ENABLE_CONTINUE_MI)
|
|
if ((TRUE == sData->params.nfc_info.more_info) &&
|
|
(NFCSTATUS_PENDING == status))
|
|
{
|
|
/* If more information bit is set, then wait for the event
|
|
NXP_EVT_NFC_CONTINUE_MI */
|
|
/* psHciContext->response_pending = TRUE; */
|
|
psHciContext->event_pending = TRUE;
|
|
}
|
|
#endif /* #if defined (ENABLE_CONTINUE_MI) */
|
|
p_pipe_info->prev_status = status;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_Info_Sequence (
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
#ifdef NOTIFY_REQD
|
|
,
|
|
uint8_t notify_reqd
|
|
#endif /* #ifdef NOTIFY_REQD */
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext)
|
|
|| (NULL == pHwRef)
|
|
)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_nfcip_info) ||
|
|
(NFCIP_INVALID ==
|
|
((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->
|
|
nfcip_type))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
|
|
p_nfcipinfo->p_init_pipe_info:
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
switch(p_nfcipinfo->current_seq)
|
|
{
|
|
case NFCIP_NFCID3I:
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3I;
|
|
/* Fill the data buffer and send the command to the
|
|
device */
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
p_pipe_info->pipe.pipe_id,
|
|
ANY_GET_PARAMETER);
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3T;
|
|
}
|
|
break;
|
|
}
|
|
case NFCIP_NFCID3T:
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3T;
|
|
/* Fill the data buffer and send the command to the
|
|
device */
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
p_pipe_info->pipe.pipe_id,
|
|
ANY_GET_PARAMETER);
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_PARAM;
|
|
}
|
|
break;
|
|
}
|
|
case NFCIP_PARAM:
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
|
|
/* Fill the data buffer and send the command to the
|
|
device */
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
p_pipe_info->pipe.pipe_id,
|
|
ANY_GET_PARAMETER);
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_ATR_INFO;
|
|
}
|
|
break;
|
|
}
|
|
case NFCIP_ATR_INFO:
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR ==
|
|
p_nfcipinfo->nfcip_type)?
|
|
NXP_NFCIP_ATR_RES :
|
|
NXP_NFCIP_ATR_REQ);
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
p_pipe_info->pipe.pipe_id,
|
|
ANY_GET_PARAMETER);
|
|
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_STATUS;
|
|
}
|
|
break;
|
|
}
|
|
case NFCIP_STATUS:
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
|
|
/* Fill the data buffer and send the command to the
|
|
device */
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
p_pipe_info->pipe.pipe_id,
|
|
ANY_GET_PARAMETER);
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
#ifdef NOTIFY_REQD
|
|
if(FALSE == notify_reqd)
|
|
#else /* #ifdef NOTIFY_REQD */
|
|
if (NULL != psHciContext->p_target_info)
|
|
#endif /* #ifdef NOTIFY_REQD */
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
p_nfcipinfo->next_seq = NFCIP_END_SEQUENCE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case NFCIP_END_SEQUENCE:
|
|
{
|
|
phHal_uRemoteDevInfo_t *rem_nfcipinfo = NULL;
|
|
|
|
if (NULL != psHciContext->p_target_info)
|
|
{
|
|
/* This is given to user */
|
|
rem_nfcipinfo =
|
|
&(psHciContext->p_target_info->RemoteDevInfo);
|
|
}
|
|
else
|
|
{
|
|
rem_nfcipinfo =
|
|
&(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo);
|
|
}
|
|
|
|
/* Update maximum frame length */
|
|
rem_nfcipinfo->NfcIP_Info.MaxFrameLength =
|
|
p_nfcipinfo->max_frame_len;
|
|
|
|
p_nfcipinfo->current_seq = NFCIP_NFCID3I;
|
|
p_nfcipinfo->next_seq = NFCIP_NFCID3I;
|
|
|
|
rem_nfcipinfo->NfcIP_Info.Nfcip_Active =
|
|
p_nfcipinfo->activation_mode;
|
|
|
|
if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
|
|
{
|
|
phNfc_sCompletionInfo_t CompInfo;
|
|
|
|
p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
|
|
phHal_eNfcIP1_Target;
|
|
|
|
/* Update initiator speed */
|
|
rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate =
|
|
(phHalNfc_eDataRate_t)
|
|
(p_nfcipinfo->initiator_speed);
|
|
|
|
|
|
/* Update ATR info */
|
|
rem_nfcipinfo->NfcIP_Info.ATRInfo_Length =
|
|
p_nfcipinfo->atr_res_length;
|
|
(void)memcpy(
|
|
(void *)rem_nfcipinfo->NfcIP_Info.ATRInfo,
|
|
(void *)p_nfcipinfo->atr_res_info,
|
|
rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);
|
|
|
|
/* Update NFCID */
|
|
rem_nfcipinfo->NfcIP_Info.NFCID_Length =
|
|
p_nfcipinfo->nfcid3i_length;
|
|
(void)memcpy(
|
|
(void *)rem_nfcipinfo->NfcIP_Info.NFCID,
|
|
(void *)p_nfcipinfo->nfcid3i,
|
|
rem_nfcipinfo->NfcIP_Info.NFCID_Length);
|
|
|
|
CompInfo.status = status = NFCSTATUS_SUCCESS;
|
|
if (NULL != psHciContext->p_target_info)
|
|
{
|
|
CompInfo.info = &(psHciContext->p_target_info);
|
|
}
|
|
else
|
|
{
|
|
CompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
|
|
}
|
|
/* Notify to the upper layer */
|
|
phHciNfc_Tag_Notify(psHciContext, pHwRef,
|
|
NFC_NOTIFY_TARGET_DISCOVERED,
|
|
&CompInfo);
|
|
}
|
|
else
|
|
{
|
|
static phHal_sEventInfo_t event_info;
|
|
|
|
p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
|
|
phHal_eNfcIP1_Initiator;
|
|
|
|
/* Update target speed */
|
|
rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate =
|
|
(phHalNfc_eDataRate_t)
|
|
(p_nfcipinfo->target_speed);
|
|
/* Update ATR info */
|
|
rem_nfcipinfo->NfcIP_Info.ATRInfo_Length =
|
|
p_nfcipinfo->atr_req_length;
|
|
(void)memcpy(
|
|
(void *)rem_nfcipinfo->NfcIP_Info.ATRInfo,
|
|
(void *)p_nfcipinfo->atr_req_info,
|
|
rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);
|
|
|
|
/* Update NFCID */
|
|
rem_nfcipinfo->NfcIP_Info.NFCID_Length =
|
|
p_nfcipinfo->nfcid3t_length;
|
|
(void)memcpy(
|
|
(void *)rem_nfcipinfo->NfcIP_Info.NFCID,
|
|
(void *)p_nfcipinfo->nfcid3t,
|
|
rem_nfcipinfo->NfcIP_Info.NFCID_Length);
|
|
|
|
event_info.eventHost = phHal_eHostController;
|
|
event_info.eventType = NFC_EVT_ACTIVATED;
|
|
event_info.eventSource = phHal_eNfcIP1_Target;
|
|
event_info.eventInfo.pRemoteDevInfo =
|
|
&(p_nfcipinfo->rem_nfcip_tgt_info);
|
|
|
|
phHciNfc_Target_Select_Notify((void *)psHciContext,
|
|
pHwRef,
|
|
NFC_NOTIFY_EVENT,
|
|
&(event_info));
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_InfoUpdate(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t index,
|
|
uint8_t *reg_value,
|
|
uint8_t reg_length
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
|
|
phHal_sNfcIPInfo_t *p_rem_nfcipinfo = NULL;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info );
|
|
p_rem_nfcipinfo = &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo.NfcIP_Info);
|
|
|
|
|
|
switch(index)
|
|
{
|
|
case NXP_NFCIP_ATR_RES:
|
|
{
|
|
if (reg_length <= NFCIP_ATR_MAX_LENGTH)
|
|
{
|
|
/* Remote device info provided by the user */
|
|
|
|
HCI_PRINT_BUFFER("\tNFCIP ATR_RES", reg_value, reg_length);
|
|
|
|
p_rem_nfcipinfo->ATRInfo_Length =
|
|
p_nfcipinfo->atr_res_length = reg_length;
|
|
|
|
(void)memcpy((void *)p_rem_nfcipinfo->ATRInfo,
|
|
(void *)reg_value,
|
|
p_rem_nfcipinfo->ATRInfo_Length);
|
|
|
|
(void)memcpy((void *)p_nfcipinfo->atr_res_info,
|
|
(void *)reg_value,
|
|
p_nfcipinfo->atr_res_length);
|
|
if (NULL != psHciContext->p_target_info)
|
|
{
|
|
phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
|
|
/* This is given to user */
|
|
p_remtgt_info =
|
|
&(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
|
|
p_remtgt_info->ATRInfo_Length = reg_length;
|
|
(void)memcpy((void *)p_remtgt_info->ATRInfo,
|
|
(void *)reg_value,
|
|
p_remtgt_info->ATRInfo_Length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_STATUS:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
#ifdef STATUS_BUFFER_CHECK
|
|
&& (*reg_value <= NFCIP_STATUS_MAX_VALUE))
|
|
#endif /* #ifdef STATUS_ERROR */
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP STATUS", reg_value, reg_length);
|
|
p_nfcipinfo->linkstatus = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_NFCID3I:
|
|
{
|
|
if (reg_length <= NFCIP_NFCID_LENGTH)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP NFCID3I", reg_value, reg_length);
|
|
p_nfcipinfo->nfcid3i_length =
|
|
p_rem_nfcipinfo->NFCID_Length = reg_length;
|
|
(void)memcpy((void *)p_rem_nfcipinfo->NFCID,
|
|
(void *)reg_value,
|
|
p_rem_nfcipinfo->NFCID_Length);
|
|
(void)memcpy((void *)p_nfcipinfo->nfcid3i,
|
|
(void *)reg_value,
|
|
reg_length);
|
|
if ((NULL != psHciContext->p_target_info) &&
|
|
(NFCIP_INITIATOR == p_nfcipinfo->nfcip_type))
|
|
{
|
|
phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
|
|
/* This is given to user */
|
|
p_remtgt_info =
|
|
&(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
|
|
p_remtgt_info->NFCID_Length = reg_length;
|
|
(void)memcpy((void *)p_remtgt_info->NFCID,
|
|
(void *)reg_value,
|
|
p_remtgt_info->NFCID_Length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_NFCID3T:
|
|
{
|
|
if (reg_length <= NFCIP_NFCID_LENGTH)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP NFCID3T", reg_value, reg_length);
|
|
p_nfcipinfo->nfcid3t_length =
|
|
p_rem_nfcipinfo->NFCID_Length = reg_length;
|
|
(void)memcpy((void *)p_rem_nfcipinfo->NFCID,
|
|
(void *)reg_value,
|
|
p_rem_nfcipinfo->NFCID_Length);
|
|
(void)memcpy((void *)p_nfcipinfo->nfcid3t,
|
|
(void *)reg_value,
|
|
reg_length);
|
|
if ((NULL != psHciContext->p_target_info) &&
|
|
(NFCIP_TARGET == p_nfcipinfo->nfcip_type))
|
|
{
|
|
phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
|
|
/* This is given to user */
|
|
p_remtgt_info =
|
|
&(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
|
|
p_remtgt_info->NFCID_Length = reg_length;
|
|
(void)memcpy((void *)p_remtgt_info->NFCID,
|
|
(void *)reg_value,
|
|
p_remtgt_info->NFCID_Length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_PARAM:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP PARAMS", reg_value, reg_length);
|
|
p_nfcipinfo->initiator_speed = (phHciNfc_eP2PSpeed_t)
|
|
((*reg_value >> NFCIP_COMM_INITIATOR_SHIFT)
|
|
& NFCIP_COMM_FACTOR);
|
|
if (p_nfcipinfo->nfcip_type == NFCIP_INITIATOR) {
|
|
switch(p_nfcipinfo->initiator_speed) {
|
|
case phNfc_eDataRate_106:
|
|
ALOGI("I'm P2P %s Initiator @ 106 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
case phNfc_eDataRate_212:
|
|
ALOGI("I'm P2P %s Initiator @ 212 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
case phNfc_eDataRate_424:
|
|
ALOGI("I'm P2P %s Initiator @ 424 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
}
|
|
}
|
|
p_nfcipinfo->target_speed = (phHciNfc_eP2PSpeed_t)
|
|
(*reg_value & NFCIP_COMM_FACTOR);
|
|
if (p_nfcipinfo->nfcip_type == NFCIP_TARGET) {
|
|
switch(p_nfcipinfo->target_speed) {
|
|
case phNfc_eDataRate_106:
|
|
ALOGI("I'm P2P %s Target @ 106 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
case phNfc_eDataRate_212:
|
|
ALOGI("I'm P2P %s Target @ 212 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
case phNfc_eDataRate_424:
|
|
ALOGI("I'm P2P %s Target @ 424 kb/s", p_nfcipinfo->activation_mode ? "Active" : "Passive");
|
|
break;
|
|
}
|
|
}
|
|
p_nfcipinfo->max_frame_len = NFCIP_DATA_RATE_CALC(*reg_value);
|
|
|
|
if (p_nfcipinfo->max_frame_len > NFCIP_MAX_DEP_REQ_HDR_LEN)
|
|
{
|
|
p_nfcipinfo->max_frame_len -= NFCIP_MAX_DEP_REQ_HDR_LEN;
|
|
|
|
if (NULL != psHciContext->p_target_info)
|
|
{
|
|
phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
|
|
/* This is given to user */
|
|
p_remtgt_info =
|
|
&(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
|
|
p_remtgt_info->MaxFrameLength = p_nfcipinfo->max_frame_len;
|
|
p_remtgt_info->Nfcip_Datarate = (phHalNfc_eDataRate_t)
|
|
p_nfcipinfo->initiator_speed;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_MODE:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP MODE", reg_value, reg_length);
|
|
p_nfcipinfo->nfcip_mode = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_ATR_REQ:
|
|
{
|
|
if (reg_length <= NFCIP_ATR_MAX_LENGTH)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP ATR_REQ", reg_value, reg_length);
|
|
p_rem_nfcipinfo->ATRInfo_Length =
|
|
p_nfcipinfo->atr_req_length = reg_length;
|
|
(void)memcpy((void *)p_rem_nfcipinfo->ATRInfo,
|
|
(void *)reg_value,
|
|
p_rem_nfcipinfo->ATRInfo_Length);
|
|
(void)memcpy((void *)p_nfcipinfo->atr_req_info,
|
|
(void *)reg_value,
|
|
p_nfcipinfo->atr_req_length);
|
|
if (NULL != psHciContext->p_target_info)
|
|
{
|
|
phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
|
|
/* This is given to user */
|
|
p_remtgt_info =
|
|
&(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
|
|
p_remtgt_info->NFCID_Length = reg_length;
|
|
(void)memcpy((void *)p_remtgt_info->ATRInfo,
|
|
(void *)reg_value,
|
|
p_remtgt_info->ATRInfo_Length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_PSL1:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP PSL1", reg_value, reg_length);
|
|
p_nfcipinfo->psl1 = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_PSL2:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP PSL2", reg_value, reg_length);
|
|
p_nfcipinfo->psl2 = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_DID:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP DID", reg_value, reg_length);
|
|
p_nfcipinfo->did = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_NAD:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP NAD", reg_value, reg_length);
|
|
p_nfcipinfo->nad = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_NFCIP_OPTIONS:
|
|
{
|
|
if (sizeof(*reg_value) == reg_length)
|
|
{
|
|
HCI_PRINT_BUFFER("\tNFCIP OPTIONS", reg_value, reg_length);
|
|
p_nfcipinfo->options = *reg_value;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetMode(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype,
|
|
uint8_t nfcip_mode
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) ||
|
|
(nfcip_mode > (uint8_t)NFCIP_MODE_ALL))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info:
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MODE;
|
|
|
|
p_pipe_info->param_info = &nfcip_mode;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetNAD(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype,
|
|
uint8_t nad
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info:
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NAD;
|
|
|
|
p_pipe_info->param_info = &nad;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetDID(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t did
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = p_nfcipinfo->p_init_pipe_info;
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_DID;
|
|
|
|
p_pipe_info->param_info = &did;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetOptions(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype,
|
|
uint8_t nfcip_options
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
|
|
p_nfcipinfo->p_init_pipe_info:
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_OPTIONS;
|
|
|
|
p_pipe_info->param_info = &nfcip_options;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetATRInfo(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype,
|
|
phHal_sNfcIPCfg_t *atr_info
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == atr_info) ||
|
|
(atr_info->generalBytesLength > NFCIP_ATR_MAX_LENGTH))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info:
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
|
|
NXP_NFCIP_ATR_REQ :
|
|
NXP_NFCIP_ATR_RES);
|
|
|
|
p_pipe_info->param_info = atr_info->generalBytes;
|
|
p_pipe_info->param_length = (uint8_t)
|
|
atr_info->generalBytesLength;
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetPSL1(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t psl1
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = p_nfcipinfo->p_init_pipe_info;
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL1;
|
|
|
|
p_pipe_info->param_info = &psl1;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetPSL2(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t psl2
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = p_nfcipinfo->p_init_pipe_info;
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL2;
|
|
|
|
p_pipe_info->param_info = &psl2;
|
|
p_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_GetStatus(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info :
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
|
|
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_GET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_GetParam(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info :
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
|
|
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_GET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Initiator_Cont_Activate (
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
p_nfcipinfo->nfcip_type = NFCIP_INITIATOR;
|
|
psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
|
|
p_pipe_info = p_nfcipinfo->p_init_pipe_info;
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *hcp_packet = NULL;
|
|
uint16_t length = HCP_HEADER_LEN;
|
|
uint8_t pipeid = 0;
|
|
|
|
pipeid = p_pipe_info->pipe.pipe_id;
|
|
psHciContext->tx_total = 0 ;
|
|
hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
|
|
/* Construct the HCP Frame */
|
|
phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
|
|
(uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND,
|
|
(uint8_t)NXP_NFCI_CONTINUE_ACTIVATION);
|
|
|
|
p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
|
|
p_pipe_info->prev_msg = (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION;
|
|
psHciContext->tx_total = length;
|
|
psHciContext->response_pending = (uint8_t)TRUE;
|
|
|
|
/* Send the Constructed HCP packet to the lower layer */
|
|
status = phHciNfc_Send_HCP( psHciContext, pHwRef);
|
|
p_pipe_info->prev_status = status;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_GetATRInfo (
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
phHciNfc_eNfcIPType_t nfciptype
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext)
|
|
|| (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if (NFCIP_INVALID == nfciptype)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
|
|
p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
|
|
p_nfcipinfo->p_init_pipe_info :
|
|
p_nfcipinfo->p_tgt_pipe_info);
|
|
|
|
if(NULL == p_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
|
|
NXP_NFCIP_ATR_RES :
|
|
NXP_NFCIP_ATR_REQ);
|
|
pipeid = p_pipe_info->pipe.pipe_id ;
|
|
/* Fill the data buffer and send the command to the
|
|
device */
|
|
status =
|
|
phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_GET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_NfcIP_SetMergeSak(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
uint8_t sak_value
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) ||
|
|
(sak_value > (uint8_t)TRUE))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_nfcip_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_NfcIP_Info_t *ps_nfcipinfo=NULL;
|
|
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
ps_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
|
|
psHciContext->p_nfcip_info ;
|
|
ps_pipe_info = ps_nfcipinfo->p_tgt_pipe_info;
|
|
|
|
if(NULL == ps_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_INFORMATION);
|
|
}
|
|
else
|
|
{
|
|
pipeid = ps_pipe_info->pipe.pipe_id ;
|
|
ps_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MERGE;
|
|
|
|
ps_pipe_info->param_info = &sak_value;
|
|
ps_pipe_info->param_length = sizeof(uint8_t);
|
|
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
|
|
pipeid, (uint8_t)ANY_SET_PARAMETER);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
#endif /* #if defined (ENABLE_P2P) */
|
|
|