839 lines
30 KiB
C
839 lines
30 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_Jewel.c *
|
|
* \brief HCI Jewel/Topaz Management Routines. *
|
|
* *
|
|
* *
|
|
* Project: NFC-FRI-1.1 *
|
|
* *
|
|
* $Date: Mon Mar 29 17:34:47 2010 $ *
|
|
* $Author: ing04880 $ *
|
|
* $Revision: 1.8 $ *
|
|
* $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_RFReader.h>
|
|
#include <phOsalNfc.h>
|
|
|
|
#if defined(TYPE_JEWEL)
|
|
#include <phHciNfc_Jewel.h>
|
|
|
|
/*
|
|
****************************** Macro Definitions *******************************
|
|
*/
|
|
#define JEWEL_SINGLE_TAG_FOUND 0x00U
|
|
#define JEWEL_MULTIPLE_TAGS_FOUND 0x03U
|
|
#define NXP_WRA_CONTINUE_ACTIVATION 0x12U
|
|
|
|
#define NXP_JEWEL_READID 0x78U
|
|
#define NXP_JEWEL_READID_LENGTH 0x06U
|
|
|
|
/*
|
|
*************************** Structure and Enumeration ***************************
|
|
*/
|
|
|
|
/*
|
|
*************************** Static Function Declaration **************************
|
|
*/
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_Response(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_Event(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
uint8_t *pEvent,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_InfoUpdate(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t index,
|
|
uint8_t *reg_value,
|
|
uint8_t reg_length
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_Packet(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
);
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_Get_PipeID(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t *ppipe_id
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if( (NULL != psHciContext)
|
|
&& ( NULL != ppipe_id )
|
|
&& ( NULL != psHciContext->p_jewel_info )
|
|
)
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info = NULL;
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)psHciContext->p_jewel_info;
|
|
*ppipe_id = ps_jewel_info->pipe_id;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_Init_Resources(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info = NULL;
|
|
if( NULL == psHciContext )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else
|
|
{
|
|
if(
|
|
( NULL == psHciContext->p_jewel_info ) &&
|
|
(phHciNfc_Allocate_Resource((void **)(&ps_jewel_info),
|
|
sizeof(phHciNfc_Jewel_Info_t))== NFCSTATUS_SUCCESS)
|
|
)
|
|
{
|
|
psHciContext->p_jewel_info = ps_jewel_info;
|
|
ps_jewel_info->current_seq = JEWEL_INVALID_SEQ;
|
|
ps_jewel_info->next_seq = JEWEL_INVALID_SEQ;
|
|
ps_jewel_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_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_jewel_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)psHciContext->p_jewel_info ;
|
|
|
|
/* Update the pipe_id of the Jewel Gate obtained from the HCI
|
|
Response */
|
|
ps_jewel_info->pipe_id = pipeID;
|
|
ps_jewel_info->p_pipe_info = pPipeInfo;
|
|
/* Update the Response Receive routine of the Jewel Gate */
|
|
pPipeInfo->recv_resp = phHciNfc_Recv_Jewel_Response;
|
|
/* Update the event Receive routine of the Jewel Gate */
|
|
pPipeInfo->recv_event = phHciNfc_Recv_Jewel_Event;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_Update_Info(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t infotype,
|
|
void *jewel_info
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
if (NULL == psHciContext)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_jewel_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_info ;
|
|
|
|
switch(infotype)
|
|
{
|
|
case HCI_JEWEL_ENABLE:
|
|
{
|
|
if (NULL != jewel_info)
|
|
{
|
|
ps_jewel_info->enable_jewel_gate =
|
|
*((uint8_t *)jewel_info);
|
|
}
|
|
break;
|
|
}
|
|
case HCI_JEWEL_INFO_SEQ:
|
|
{
|
|
ps_jewel_info->current_seq = JEWEL_READID_SEQUENCE;
|
|
ps_jewel_info->next_seq = JEWEL_READID_SEQUENCE;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_Info_Sequence (
|
|
void *psHciHandle,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
((phHciNfc_sContext_t *)psHciHandle);
|
|
static uint8_t paraminfo[NXP_JEWEL_READID_LENGTH + 1] = {0};
|
|
|
|
if( (NULL == psHciContext)
|
|
|| (NULL == pHwRef)
|
|
)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_jewel_info) ||
|
|
(HCI_JEWEL_ENABLE !=
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
enable_jewel_gate))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_info ;
|
|
ps_pipe_info = ps_jewel_info->p_pipe_info;
|
|
if(NULL == ps_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
else
|
|
{
|
|
switch(ps_jewel_info->current_seq)
|
|
{
|
|
case JEWEL_READID_SEQUENCE:
|
|
{
|
|
pipeid = ps_pipe_info->pipe.pipe_id;
|
|
ps_pipe_info->reg_index = NXP_JEWEL_READID;
|
|
paraminfo[0] = NXP_JEWEL_READID;
|
|
|
|
ps_pipe_info->param_info = (void *)¶minfo;
|
|
ps_pipe_info->param_length = NXP_JEWEL_READID_LENGTH + 1;
|
|
|
|
status = phHciNfc_Send_Jewel_Command(psHciContext,
|
|
pHwRef, pipeid,
|
|
NXP_JEWEL_RAW);
|
|
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
ps_jewel_info->next_seq = JEWEL_END_SEQUENCE;
|
|
}
|
|
break;
|
|
}
|
|
case JEWEL_END_SEQUENCE:
|
|
{
|
|
phNfc_sCompletionInfo_t CompInfo;
|
|
|
|
ps_pipe_info->reg_index = JEWEL_END_SEQUENCE;
|
|
if (JEWEL_MULTIPLE_TAGS_FOUND ==
|
|
ps_jewel_info->multiple_tgts_found)
|
|
{
|
|
CompInfo.status = NFCSTATUS_MULTIPLE_TAGS;
|
|
}
|
|
else
|
|
{
|
|
CompInfo.status = NFCSTATUS_SUCCESS;
|
|
}
|
|
|
|
CompInfo.info = &(ps_jewel_info->s_jewel_info);
|
|
|
|
ps_jewel_info->s_jewel_info.RemDevType = phHal_eJewel_PICC;
|
|
ps_jewel_info->current_seq = JEWEL_READID_SEQUENCE;
|
|
ps_jewel_info->next_seq = JEWEL_READID_SEQUENCE;
|
|
status = NFCSTATUS_SUCCESS;
|
|
/* Notify to the upper layer */
|
|
phHciNfc_Tag_Notify(psHciContext, pHwRef,
|
|
NFC_NOTIFY_TARGET_DISCOVERED,
|
|
&CompInfo);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_InfoUpdate(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t index,
|
|
uint8_t *reg_value,
|
|
uint8_t reg_length
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info = NULL;
|
|
phHal_sJewelInfo_t *ps_jewel_tag_info = NULL;
|
|
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info);
|
|
ps_jewel_tag_info = &(ps_jewel_info->s_jewel_info.RemoteDevInfo.Jewel_Info);
|
|
|
|
switch(index)
|
|
{
|
|
case NXP_JEWEL_READID:
|
|
{
|
|
HCI_PRINT_BUFFER("\tJewel ID", reg_value, reg_length);
|
|
if(NXP_JEWEL_READID_LENGTH == reg_length)
|
|
{
|
|
uint8_t i = 0;
|
|
ps_jewel_tag_info->HeaderRom0 = reg_value[i++];
|
|
ps_jewel_tag_info->HeaderRom1 = reg_value[i++];
|
|
(void)memcpy(ps_jewel_tag_info->Uid,
|
|
&(reg_value[i]),
|
|
(reg_length - i));
|
|
|
|
ps_jewel_tag_info->UidLength = (reg_length - i);
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_Packet(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
uint8_t *pResponse,
|
|
#ifdef ONE_BYTE_LEN
|
|
uint8_t length
|
|
#else
|
|
uint16_t length
|
|
#endif
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
(psHciContext->p_jewel_info);
|
|
|
|
if (NXP_JEWEL_READID == ps_jewel_info->p_pipe_info->reg_index)
|
|
{
|
|
status = phHciNfc_Jewel_InfoUpdate(psHciContext,
|
|
ps_jewel_info->p_pipe_info->reg_index,
|
|
pResponse, (uint8_t)length);
|
|
}
|
|
else
|
|
{
|
|
/* Send Jewel data to the upper layer */
|
|
HCI_PRINT_BUFFER("Jewel Bytes received", pResponse, length);
|
|
psHciContext->rx_index = HCP_HEADER_LEN;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_Response(
|
|
void *psContext,
|
|
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 *)psContext;
|
|
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
|
|
|| (0 == length))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if(NULL == psHciContext->p_jewel_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
uint8_t prev_cmd = ANY_GET_PARAMETER;
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_info ;
|
|
if( NULL == ps_jewel_info->p_pipe_info)
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
else
|
|
{
|
|
prev_cmd = ps_jewel_info->p_pipe_info->prev_msg ;
|
|
switch(prev_cmd)
|
|
{
|
|
case ANY_GET_PARAMETER:
|
|
{
|
|
if (length >= HCP_HEADER_LEN)
|
|
{
|
|
status = phHciNfc_Jewel_InfoUpdate(psHciContext,
|
|
ps_jewel_info->p_pipe_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("Jewel Parameter Set \n");
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
ps_jewel_info->next_seq = JEWEL_READID_SEQUENCE;
|
|
break;
|
|
}
|
|
case ANY_OPEN_PIPE:
|
|
{
|
|
HCI_PRINT("Jewel open pipe complete\n");
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
ps_jewel_info->next_seq = JEWEL_READID_SEQUENCE;
|
|
break;
|
|
}
|
|
case ANY_CLOSE_PIPE:
|
|
{
|
|
HCI_PRINT("Jewel close pipe complete\n");
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
break;
|
|
}
|
|
case NXP_JEWEL_RAW:
|
|
{
|
|
HCI_PRINT("Jewel packet received \n");
|
|
if (length >= HCP_HEADER_LEN)
|
|
{
|
|
phHciNfc_Append_HCPFrame(psHciContext->recv_buffer,
|
|
0, pResponse, length);
|
|
psHciContext->rx_total = length;
|
|
status = phHciNfc_Recv_Jewel_Packet(psHciContext,
|
|
&pResponse[HCP_HEADER_LEN],
|
|
(length - HCP_HEADER_LEN));
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_WRA_CONTINUE_ACTIVATION:
|
|
case NXP_WR_ACTIVATE_ID:
|
|
{
|
|
HCI_PRINT("Jewel continue activation or ");
|
|
HCI_PRINT("reactivation completed \n");
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
break;
|
|
}
|
|
case NXP_WR_PRESCHECK:
|
|
{
|
|
HCI_PRINT("Presence check completed \n");
|
|
break;
|
|
}
|
|
case NXP_WR_ACTIVATE_NEXT:
|
|
{
|
|
HCI_PRINT("Activate next completed \n");
|
|
if (length > HCP_HEADER_LEN)
|
|
{
|
|
if (JEWEL_MULTIPLE_TAGS_FOUND ==
|
|
pResponse[HCP_HEADER_LEN])
|
|
{
|
|
ps_jewel_info->multiple_tgts_found =
|
|
JEWEL_MULTIPLE_TAGS_FOUND;
|
|
}
|
|
else
|
|
{
|
|
ps_jewel_info->multiple_tgts_found = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
break;
|
|
}
|
|
case NXP_WR_DISPATCH_TO_UICC:
|
|
{
|
|
switch(length)
|
|
{
|
|
case HCP_HEADER_LEN:
|
|
{
|
|
/* Optional error code, if no error code field
|
|
in the response, then this command is
|
|
successfully completed */
|
|
ps_jewel_info->uicc_activation =
|
|
UICC_CARD_ACTIVATION_SUCCESS;
|
|
break;
|
|
}
|
|
case (HCP_HEADER_LEN + 1):
|
|
{
|
|
ps_jewel_info->uicc_activation =
|
|
pResponse[HCP_HEADER_LEN];
|
|
break;
|
|
} /* End of case (HCP_HEADER_LEN + index) */
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
if (NFCSTATUS_SUCCESS == status)
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
|
|
UPDATE_SEQ);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
break;
|
|
}
|
|
}
|
|
if( NFCSTATUS_SUCCESS == status )
|
|
{
|
|
ps_jewel_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
|
|
ps_jewel_info->current_seq = ps_jewel_info->next_seq;
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Recv_Jewel_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_jewel_info) ||
|
|
(HCI_JEWEL_ENABLE !=
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
enable_jewel_gate))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_HCP_Packet_t *p_packet = NULL;
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info = NULL;
|
|
phHciNfc_HCP_Message_t *message = NULL;
|
|
uint8_t instruction=0,
|
|
i = 0;
|
|
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_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 ((EVT_TARGET_DISCOVERED == instruction)
|
|
&& ((JEWEL_MULTIPLE_TAGS_FOUND == message->payload[i] )
|
|
|| (JEWEL_SINGLE_TAG_FOUND == message->payload[i]))
|
|
)
|
|
{
|
|
static phNfc_sCompletionInfo_t pCompInfo;
|
|
|
|
if (JEWEL_MULTIPLE_TAGS_FOUND == message->payload[i])
|
|
{
|
|
ps_jewel_info->multiple_tgts_found =
|
|
JEWEL_MULTIPLE_TAGS_FOUND;
|
|
pCompInfo.status = NFCSTATUS_MULTIPLE_TAGS;
|
|
}
|
|
else
|
|
{
|
|
ps_jewel_info->multiple_tgts_found = FALSE;
|
|
pCompInfo.status = NFCSTATUS_SUCCESS;
|
|
}
|
|
|
|
psHciContext->host_rf_type = phHal_eJewel_PCD;
|
|
ps_jewel_info->s_jewel_info.RemDevType = phHal_eJewel_PICC;
|
|
ps_jewel_info->current_seq = JEWEL_READID_SEQUENCE;
|
|
|
|
/* Notify to the HCI Generic layer To Update the FSM */
|
|
phHciNfc_Notify_Event(psHciContext, pHwRef,
|
|
NFC_NOTIFY_TARGET_DISCOVERED,
|
|
&pCompInfo);
|
|
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Send_Jewel_Command(
|
|
phHciNfc_sContext_t *psContext,
|
|
void *pHwRef,
|
|
uint8_t pipe_id,
|
|
uint8_t cmd
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext =
|
|
(phHciNfc_sContext_t *)psContext ;
|
|
if( (NULL == psHciContext) || (NULL == pHwRef) )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_jewel_info) ||
|
|
(HCI_JEWEL_ENABLE !=
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
enable_jewel_gate) ||
|
|
(HCI_UNKNOWN_PIPE_ID ==
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
pipe_id) ||
|
|
(pipe_id !=
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
pipe_id))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
|
|
phHciNfc_HCP_Packet_t *hcp_packet = NULL;
|
|
phHciNfc_HCP_Message_t *hcp_message = NULL;
|
|
uint8_t i = 0,
|
|
length = HCP_HEADER_LEN;
|
|
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_info ;
|
|
ps_pipe_info = ps_jewel_info->p_pipe_info;
|
|
if(NULL == ps_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
else
|
|
{
|
|
psHciContext->tx_total = 0 ;
|
|
hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
|
|
|
|
if (NXP_JEWEL_RAW == cmd)
|
|
{
|
|
/* Construct the HCP Frame */
|
|
phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
|
|
(uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
|
|
hcp_message = &(hcp_packet->msg.message);
|
|
phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
|
|
i, (uint8_t *)ps_pipe_info->param_info,
|
|
ps_pipe_info->param_length);
|
|
length =(uint8_t)(length + i + ps_pipe_info->param_length);
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_COMMAND);
|
|
}
|
|
|
|
if (NFCSTATUS_SUCCESS == status)
|
|
{
|
|
ps_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
|
|
ps_pipe_info->prev_msg = cmd;
|
|
psHciContext->tx_total = length;
|
|
psHciContext->response_pending = TRUE;
|
|
|
|
/* Send the Constructed HCP packet to the lower layer */
|
|
status = phHciNfc_Send_HCP( psHciContext, pHwRef);
|
|
ps_pipe_info->prev_status = status;
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Jewel_GetRID(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static uint8_t reader_id_info[NXP_JEWEL_READID_LENGTH] = {0};
|
|
|
|
if( (NULL == psHciContext) || (NULL == pHwRef))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
}
|
|
else if((NULL == psHciContext->p_jewel_info) ||
|
|
(HCI_JEWEL_ENABLE !=
|
|
((phHciNfc_Jewel_Info_t *)(psHciContext->p_jewel_info))->
|
|
enable_jewel_gate))
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Jewel_Info_t *ps_jewel_info=NULL;
|
|
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
|
|
uint8_t pipeid = 0;
|
|
|
|
ps_jewel_info = (phHciNfc_Jewel_Info_t *)
|
|
psHciContext->p_jewel_info ;
|
|
|
|
ps_pipe_info = ps_jewel_info->p_pipe_info;
|
|
if(NULL == ps_pipe_info )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
else
|
|
{
|
|
pipeid = ps_jewel_info->pipe_id ;
|
|
reader_id_info[0] = NXP_JEWEL_READID;
|
|
|
|
ps_pipe_info->param_info = (void *)&reader_id_info;
|
|
ps_pipe_info->param_length = NXP_JEWEL_READID_LENGTH + 1 ;
|
|
|
|
status = phHciNfc_Send_Jewel_Command(psHciContext,
|
|
pHwRef, pipeid,
|
|
NXP_JEWEL_RAW);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
#endif /* #if defined(TYPE_JEWEL) */
|
|
|
|
|