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;
}
/*******************************************************************************
**
** Function phDnldNfc_ReadLog
**
** Description Retrieves log data from EEPROM
**
** Parameters pData - response buffer which gets updated with data from EEPROM
** pNotify - notify caller after getting response
** pContext - caller context
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - Read request to NFCC is successful
** NFCSTATUS_FAILED - Read request failed due to internal error
** NFCSTATUS_NOT_ALLOWED - command not allowed
** Other command specific errors -
**
*******************************************************************************/
NFCSTATUS phDnldNfc_ReadLog(pphDnldNfc_Buff_t pData, pphDnldNfc_RspCb_t pNotify, void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
if((NULL == pNotify) || (NULL == pData) ||
(NULL == pContext)
)
{
NXPLOG_FWDNLD_E("Invalid Input Parameters!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
else
{
if(phDnldNfc_TransitionIdle != gpphDnldContext->tDnldInProgress)
{
NXPLOG_FWDNLD_E("Dnld Cmd Request in Progress..Cannot Continue!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_BUSY);
}
else
{
if((NULL != pData->pBuff) && (0 != pData->wLen))
{
(gpphDnldContext->tCmdId) = PH_DL_CMD_READ;
(gpphDnldContext->FrameInp.Type) = phDnldNfc_FTRead;
(gpphDnldContext->FrameInp.dwAddr) = PHDNLDNFC_EEPROM_LOG_START_ADDR;
(gpphDnldContext->tRspBuffInfo.pBuff) = pData->pBuff;
(gpphDnldContext->tRspBuffInfo.wLen) = pData->wLen;
(gpphDnldContext->tUserData.pBuff) = NULL;
(gpphDnldContext->tUserData.wLen) = 0;
(gpphDnldContext->UserCb) = pNotify;
(gpphDnldContext->UserCtxt) = pContext;
memset(&(gpphDnldContext->tRWInfo),0,sizeof(gpphDnldContext->tRWInfo));
wStatus = phDnldNfc_CmdHandler(gpphDnldContext,phDnldNfc_EventRead);
if(NFCSTATUS_PENDING == wStatus)
{
NXPLOG_FWDNLD_D("Read Request submitted successfully");
}
else
{
NXPLOG_FWDNLD_E("Read Request Failed!!");
}
}
else
{
NXPLOG_FWDNLD_E("Invalid Buff Parameters!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
}
}
return wStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_Write
**
** Description Asynchronously writes given data block to hardware interface/driver
** Enables writer thread if there are no write requests pending
** Returns successfully once writer thread completes write operation
** Notifies upper layer using callback mechanism
** NOTE:
** * it is important to post a message with id PH_TMLNFC_WRITE_MESSAGE
** to IntegrationThread after data has been written to PN54X
** * if CRC needs to be computed, then input buffer should be capable to store
** two more bytes apart from length of packet
**
** Parameters pBuffer - data to be sent
** wLength - length of data buffer
** pTmlWriteComplete - pointer to the function to be invoked upon completion
** pContext - context provided by upper layer
**
** Returns NFC status:
** NFCSTATUS_PENDING - command is yet to be processed
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_BUSY - write request is already in progress
**
*******************************************************************************/
NFCSTATUS phTmlNfc_Write(uint8_t *pBuffer, uint16_t wLength, pphTmlNfc_TransactCompletionCb_t pTmlWriteComplete, void *pContext)
{
NFCSTATUS wWriteStatus;
/* Check whether TML is Initialized */
if (NULL != gpphTmlNfc_Context)
{
if ((NULL != gpphTmlNfc_Context->pDevHandle) && (NULL != pBuffer) &&
(PH_TMLNFC_RESET_VALUE != wLength) && (NULL != pTmlWriteComplete))
{
if (!gpphTmlNfc_Context->tWriteInfo.bThreadBusy)
{
/* Setting the flag marks beginning of a Write Operation */
gpphTmlNfc_Context->tWriteInfo.bThreadBusy = TRUE;
/* Copy the buffer, length and Callback function,
This shall be utilized while invoking the Callback function in thread */
gpphTmlNfc_Context->tWriteInfo.pBuffer = pBuffer;
gpphTmlNfc_Context->tWriteInfo.wLength = wLength;
gpphTmlNfc_Context->tWriteInfo.pThread_Callback = pTmlWriteComplete;
gpphTmlNfc_Context->tWriteInfo.pContext = pContext;
wWriteStatus = NFCSTATUS_PENDING;
//FIXME: If retry is going on. Stop the retry thread/timer
if (phTmlNfc_e_EnableRetrans == gpphTmlNfc_Context->eConfig)
{
/* Set retry count to default value */
//FIXME: If the timer expired there, and meanwhile we have created
// a new request. The expired timer will think that retry is still
// ongoing.
bCurrentRetryCount = gpphTmlNfc_Context->bRetryCount;
gpphTmlNfc_Context->bWriteCbInvoked = FALSE;
}
/* Set event to invoke Writer Thread */
gpphTmlNfc_Context->tWriteInfo.bEnable = 1;
sem_post(&gpphTmlNfc_Context->txSemaphore);
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_BUSY);
}
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_INVALID_PARAMETER);
}
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_NOT_INITIALISED);
}
return wWriteStatus;
}
/*******************************************************************************
**
** Function phDnldNfc_RawReq
**
** Description Sends raw frame request to NFCC.
** It is currently used for sending an NCI RESET cmd after doing a production key update
**
** Parameters pFrameData - input buffer, contains raw frame packet to be sent to NFCC
** pRspData - response buffer received from NFCC
** pNotify - notify caller after getting response
** pContext - caller context
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - GetSessionState request to NFCC is successful
** NFCSTATUS_FAILED - GetSessionState request failed due to internal error
** NFCSTATUS_NOT_ALLOWED - command not allowed
** Other command specific errors -
**
*******************************************************************************/
NFCSTATUS phDnldNfc_RawReq(pphDnldNfc_Buff_t pFrameData, pphDnldNfc_Buff_t pRspData, pphDnldNfc_RspCb_t pNotify, void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
if((NULL == pFrameData) || (NULL == pNotify) || (NULL == pRspData) ||
(NULL == pContext)
)
{
NXPLOG_FWDNLD_E("Invalid Input Parameters!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
else
{
if(phDnldNfc_TransitionIdle != gpphDnldContext->tDnldInProgress)
{
NXPLOG_FWDNLD_E("Raw Cmd Request in Progress..Cannot Continue!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_BUSY);
}
else
{
if(((NULL != pFrameData->pBuff) && (0 != pFrameData->wLen)) &&
((NULL != pRspData->pBuff) && (0 != pRspData->wLen))
)
{
(gpphDnldContext->tRspBuffInfo.pBuff) = pRspData->pBuff;
(gpphDnldContext->tRspBuffInfo.wLen) = pRspData->wLen;
(gpphDnldContext->FrameInp.Type) = phDnldNfc_FTRaw;
(gpphDnldContext->tCmdId) = PH_DL_CMD_NONE;
(gpphDnldContext->tUserData.pBuff) = pFrameData->pBuff;
(gpphDnldContext->tUserData.wLen) = pFrameData->wLen;
(gpphDnldContext->UserCb) = pNotify;
(gpphDnldContext->UserCtxt) = pContext;
wStatus = phDnldNfc_CmdHandler(gpphDnldContext,phDnldNfc_EventRaw);
if(NFCSTATUS_PENDING == wStatus)
{
NXPLOG_FWDNLD_D("RawFrame Request submitted successfully");
}
else
{
NXPLOG_FWDNLD_E("RawFrame Request Failed!!");
}
}
else
{
NXPLOG_FWDNLD_E("Invalid Buff Parameters!!");
wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
}
}
return wStatus;
}
NFCSTATUS phFriNfc_LlcpMac_ChkLlcp (phFriNfc_LlcpMac_t *LlcpMac,
phHal_sRemoteDevInformation_t *psRemoteDevInfo,
phFriNfc_LlcpMac_Chk_CB_t ChkLlcpMac_Cb,
void *pContext)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if (NULL == LlcpMac || NULL == psRemoteDevInfo)
{
status = PHNFCSTVAL(CID_FRI_NFC_LLCP_MAC, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Store the Remote Device info received from Device Discovery */
LlcpMac->psRemoteDevInfo = psRemoteDevInfo;
if(LlcpMac->psRemoteDevInfo->RemDevType == phHal_eNfcIP1_Initiator)
{
/* Set the PeerRemoteDevType variable to the Target type */
LlcpMac->PeerRemoteDevType = phFriNfc_LlcpMac_ePeerTypeTarget;
}
else if(LlcpMac->psRemoteDevInfo->RemDevType == phHal_eNfcIP1_Target)
{
/* Set the PeerRemoteDevType variable to the Initiator type */
LlcpMac->PeerRemoteDevType = phFriNfc_LlcpMac_ePeerTypeInitiator;
}
switch(LlcpMac->psRemoteDevInfo->RemDevType)
{
case phHal_eNfcIP1_Initiator:
case phHal_eNfcIP1_Target:
{
/* Set the MAC mapping type detected */
LlcpMac->MacType = phFriNfc_LlcpMac_eTypeNfcip;
/* Register the lower layer to the MAC mapping component */
status = phFriNfc_LlcpMac_Nfcip_Register (LlcpMac);
if(status == NFCSTATUS_SUCCESS)
{
status = LlcpMac->LlcpMacInterface.chk(LlcpMac,ChkLlcpMac_Cb,pContext);
}
else
{
status = PHNFCSTVAL(CID_FRI_NFC_LLCP_MAC, NFCSTATUS_FAILED);
}
}break;
default:
{
status = PHNFCSTVAL(CID_FRI_NFC_LLCP_MAC, NFCSTATUS_INVALID_DEVICE);
}break;
}
}
return status;
}
NFCSTATUS
phHciNfc_ReaderB_Set_LayerData(
void *psContext,
void *pHwRef,
phNfc_sData_t *layer_data_info
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phHciNfc_sContext_t *psHciContext =
(phHciNfc_sContext_t *)psContext ;
if( (NULL == psHciContext) || (NULL == pHwRef) ||
(NULL == layer_data_info) || (NULL == layer_data_info->buffer)
|| (0 == layer_data_info->length))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if((NULL == psHciContext->p_reader_b_info) ||
(HCI_READER_B_ENABLE !=
((phHciNfc_ReaderB_Info_t *)(psHciContext->p_reader_b_info))->
enable_rdr_b_gate))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_ReaderB_Info_t *ps_rdr_b_info=NULL;
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
uint8_t pipeid = 0;
ps_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
psHciContext->p_reader_b_info ;
p_pipe_info = ps_rdr_b_info->p_pipe_info;
if(NULL == p_pipe_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
p_pipe_info->reg_index = RDR_B_HIGHER_LAYER_DATA_INDEX;
pipeid = ps_rdr_b_info->pipe_id ;
p_pipe_info->param_info = (void *)layer_data_info->buffer;
p_pipe_info->param_length = (uint8_t)
layer_data_info->length;
/* Fill the data buffer and send the command to the
device */
status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
pipeid, (uint8_t)ANY_SET_PARAMETER);
}
}
return status;
}
NFCSTATUS
phHciNfc_SWP_Configure_Mode(
void *psHciHandle,
void *pHwRef,
uint8_t uicc_mode
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
static uint8_t param = 0;
phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)
psHciHandle);
if( (NULL == psHciContext)||(NULL == pHwRef))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if ( NULL == psHciContext->p_swp_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_INFORMATION);
}
else
{
phHciNfc_SWP_Info_t *ps_swp_info=NULL;
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
ps_pipe_info = ps_swp_info->p_pipe_info;
if(NULL == ps_pipe_info)
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_INFORMATION);
}
else
{
/* Switch the Mode of the SmartMx */
param = uicc_mode;
ps_pipe_info->param_info =(void*)¶m ;
ps_pipe_info->param_length = sizeof(param) ;
status = phHciNfc_Send_SWP_Event( psHciContext, pHwRef,
ps_swp_info->pipe_id,
NXP_EVT_SWP_SWITCH_MODE );
/* Send the Success Status as this is an event */
status = ((status == NFCSTATUS_PENDING)?
NFCSTATUS_SUCCESS : status);
}/* End of else part*/
}
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;
}
NFCSTATUS
phHciNfc_Felica_Request_Mode(
phHciNfc_sContext_t *psHciContext,
void *pHwRef)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
static uint8_t pres_chk_data[6] = {0};
if( (NULL == psHciContext) || (NULL == pHwRef) )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
phHciNfc_Felica_Info_t *ps_fel_info = NULL;
phHciNfc_Pipe_Info_t *ps_pipe_info = NULL;
phHal_sFelicaInfo_t *ps_rem_fel_info = NULL;
ps_fel_info = (phHciNfc_Felica_Info_t *)
psHciContext->p_felica_info ;
ps_pipe_info = ps_fel_info->p_pipe_info;
if(NULL == ps_pipe_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
ps_rem_fel_info =
&(ps_fel_info->felica_info.RemoteDevInfo.Felica_Info);
pres_chk_data[0] = sizeof(pres_chk_data);
pres_chk_data[1] = 0x00; // Felica poll
pres_chk_data[2] = 0xFF;
pres_chk_data[3] = 0xFF;
pres_chk_data[4] = 0x00;
pres_chk_data[5] = 0x00;
ps_pipe_info->param_info = pres_chk_data;
ps_pipe_info->param_length = sizeof(pres_chk_data);
status = phHciNfc_Send_Felica_Command(
psHciContext, pHwRef,
ps_pipe_info->pipe.pipe_id,
NXP_FELICA_RAW);
}
}
return status;
}
NFCSTATUS
phHciNfc_Felica_Update_Info(
phHciNfc_sContext_t *psHciContext,
uint8_t infotype,
void *fel_info
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if (NULL == psHciContext)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if(NULL == psHciContext->p_felica_info)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_Felica_Info_t *p_fel_info=NULL;
p_fel_info = (phHciNfc_Felica_Info_t *)
psHciContext->p_felica_info ;
switch(infotype)
{
case HCI_FELICA_ENABLE:
{
if (NULL != fel_info)
{
p_fel_info->enable_felica_gate =
*((uint8_t *)fel_info);
}
break;
}
case HCI_FELICA_INFO_SEQ:
{
p_fel_info->current_seq = FELICA_SYSTEMCODE;
p_fel_info->next_seq = FELICA_SYSTEMCODE;
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
break;
}
}
}
return status;
}
NFCSTATUS
phHciNfc_ReaderB_Update_Info(
phHciNfc_sContext_t *psHciContext,
uint8_t infotype,
void *rdr_b_info
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
if (NULL == psHciContext)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if(NULL == psHciContext->p_reader_b_info)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_ReaderB_Info_t *ps_rdr_b_info=NULL;
ps_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
psHciContext->p_reader_b_info ;
switch(infotype)
{
case HCI_READER_B_ENABLE:
{
if(NULL != rdr_b_info)
{
ps_rdr_b_info->enable_rdr_b_gate =
*((uint8_t *)rdr_b_info);
}
break;
}
case HCI_READER_B_INFO_SEQ:
{
ps_rdr_b_info->current_seq = RDR_B_PUPI;
ps_rdr_b_info->next_seq = RDR_B_PUPI;
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
break;
}
}
}
return status;
}
static
NFCSTATUS
phHciNfc_LinkMgmt_InfoUpdate(
phHciNfc_sContext_t *psHciContext,
phHal_sHwReference_t *pHwRef,
uint8_t index,
uint8_t *reg_value,
uint8_t reg_length
)
{
phHciNfc_LinkMgmt_Info_t *p_link_mgmt_info=NULL;
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t i=0;
if( (NULL == psHciContext)
|| (NULL == pHwRef)
|| (NULL == reg_value)
|| (reg_length == 0)
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if ( NULL == psHciContext->p_link_mgmt_info )
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
}
else
{
p_link_mgmt_info = (phHciNfc_LinkMgmt_Info_t *)
psHciContext->p_link_mgmt_info ;
if (REC_ERROR_INDEX == index)
{
HCI_PRINT_BUFFER("\tHost Controller REC Error Count :",reg_value,reg_length);
/* p_link_mgmt_info->hc_rec_error = reg_value[i] ; */
for(i=0 ;(reg_length == REC_RETRY_LEN)&&(i < reg_length); i++)
{
p_link_mgmt_info->hc_rec_error |=
(uint16_t)(reg_value[i] << (BYTE_SIZE * i));
}
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
} /* End of the Index Check */
} /* End of Context and the Link information validity check */
return status;
}
NFCSTATUS
phFriNfc_NdefSmtCrd_ConvertToReadOnly (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_PARAMETER);
uint8_t sak = 0;
if((NdefSmtCrdFmt != NULL)
&& (NdefSmtCrdFmt->CompletionRoutine->CompletionRoutine != NULL)
&& (NdefSmtCrdFmt->CompletionRoutine->Context != NULL))
{
sak = NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak;
switch (NdefSmtCrdFmt->psRemoteDevInfo->RemDevType)
{
case phHal_eMifare_PICC:
{
if (0x00 == sak)
{
result = phFriNfc_MfUL_ConvertToReadOnly (NdefSmtCrdFmt);
}
else
{
/* MIFARE classic 1k/4k is not supported */
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_REMOTE_DEVICE);
}
break;
}
case phHal_eISO14443_A_PICC:
{
result = phFriNfc_Desfire_ConvertToReadOnly (NdefSmtCrdFmt);
break;
}
default :
{
/* Remote device is not recognised.
Probably not NDEF compliant */
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_REMOTE_DEVICE);
break;
}
}
}
return result;
}
NFCSTATUS
phHciNfc_ReaderA_Fwi_Sfgt (
void *psHciHandle,
void *pHwRef
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
if( (NULL == psHciContext)
|| (NULL == pHwRef)
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if((NULL == psHciContext->p_reader_a_info) ||
(HCI_READER_A_ENABLE !=
((phHciNfc_ReaderA_Info_t *)(psHciContext->p_reader_a_info))->
enable_rdr_a_gate))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_ReaderA_Info_t *p_rdr_a_info=NULL;
phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
uint8_t pipeid = 0;
p_rdr_a_info = (phHciNfc_ReaderA_Info_t *)
psHciContext->p_reader_a_info ;
p_pipe_info = p_rdr_a_info->p_pipe_info;
if(NULL == p_pipe_info )
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_SEQUENCE);
}
else
{
p_pipe_info->reg_index = RDR_A_FWI_SFGT_INDEX;
pipeid = p_rdr_a_info->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_Delete_Pipe(
phHciNfc_sContext_t *psHciContext,
void *pHwRef,
phHciNfc_Pipe_Info_t *pPipeHandle
)
{
NFCSTATUS status=NFCSTATUS_SUCCESS;
NFCSTATUS cmd_status = NFCSTATUS_SUCCESS;
if( (NULL == psHciContext)
|| (NULL == pHwRef)
|| (NULL == pPipeHandle)
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
cmd_status = phHciNfc_Send_Admin_Cmd( psHciContext, pHwRef,
ADM_DELETE_PIPE, PIPEID_LEN, pPipeHandle );
status = ( (cmd_status == NFCSTATUS_PENDING)?
NFCSTATUS_SUCCESS : cmd_status);
}
return status;
}
NFCSTATUS
phHciNfc_Close_Pipe(
phHciNfc_sContext_t *psHciContext,
void *pHwRef,
phHciNfc_Pipe_Info_t *pPipeHandle
)
{
uint8_t pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
NFCSTATUS status = NFCSTATUS_SUCCESS;
NFCSTATUS cmd_status = NFCSTATUS_SUCCESS;
if( (NULL == psHciContext)
|| ( NULL == pHwRef )
|| ( NULL == pPipeHandle )
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Obtain the pipe_id from the pipe_handle */
pipe_id = pPipeHandle->pipe.pipe_id;
if( (uint8_t)HCI_UNKNOWN_PIPE_ID > pipe_id)
{
cmd_status = phHciNfc_Send_Generic_Cmd(
psHciContext, pHwRef, pipe_id,
ANY_CLOSE_PIPE );
status = ((cmd_status == NFCSTATUS_PENDING)?
NFCSTATUS_SUCCESS : cmd_status);
}
}
return status;
}
static
NFCSTATUS
phHciNfc_Recv_Iso_B_Packet(
phHciNfc_sContext_t *psHciContext,
uint8_t *pResponse,
#ifdef ONE_BYTE_LEN
uint8_t length
#else
uint16_t length
#endif
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t i = 1;
psHciContext->rx_index = HCP_HEADER_LEN;
/* command WR_XCHG_DATA: so give ISO 14443-4B data to the upper layer */
HCI_PRINT_BUFFER("ISO 14443-4B Bytes received", pResponse, length);
if(FALSE != pResponse[(length - i)])
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_RF_ERROR);
}
return status;
}
static
NFCSTATUS
phFriNfc_LlcpMac_Nfcip_Activate(
_Inout_ phFriNfc_LlcpMac_t *LlcpMac
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
PH_LOG_LLCP_FUNC_ENTRY();
if(LlcpMac == NULL)
{
PH_LOG_LLCP_WARN_STR("Invalid 'LlcpMac' pointer");
status = PHNFCSTVAL(CID_FRI_NFC_LLCP_MAC, NFCSTATUS_INVALID_PARAMETER);
}
else
{
PH_LOG_LLCP_INFO_STR("Invoking LinkStatus_Cb with link state 'phFriNfc_LlcpMac_eLinkActivated'");
LlcpMac->LinkState = phFriNfc_LlcpMac_eLinkActivated;
LlcpMac->LinkStatus_Cb(LlcpMac->LinkStatus_Context,
LlcpMac->LinkState,
&LlcpMac->sConfigParam,
LlcpMac->PeerRemoteDevType);
}
PH_LOG_LLCP_INFO_X32MSG("Return:",status);
PH_LOG_LLCP_FUNC_EXIT();
return status;
}
NFCSTATUS phFriNfc_OvrHal_Connect(phFriNfc_OvrHal_t *OvrHal,
phFriNfc_CplRt_t *CompletionInfo,
phHal_sRemoteDevInformation_t *RemoteDevInfo,
phHal_sDevInputParam_t *DevInputParam)
{
NFCSTATUS status = NFCSTATUS_PENDING;
/* Check the Input Parameters */
if((NULL == OvrHal) || (NULL == CompletionInfo) || (NULL == RemoteDevInfo) ||
(NULL == DevInputParam))
{
status = PHNFCSTVAL(CID_FRI_NFC_OVR_HAL ,NFCSTATUS_INVALID_PARAMETER);
}
else
{
phFriNfc_OvrHal_SetComplInfo(OvrHal, CompletionInfo, PH_FRINFC_OVRHAL_CON);
status = phHal4Nfc_Connect(
OvrHal->psHwReference,
RemoteDevInfo,
phFriNfc_OvrHal_CB_ConnectDisconnect,
(void *)OvrHal
);
}
return status;
}
static NFCSTATUS
phFriNfc_TopazDynamicFormat_ProcessWritingTermTlvBytes(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt)
{
static const uint8_t c_expectedResponse[] =
{
PH_FRINFC_TOPAZ_TLV_TERM_T, /* Terminator TLV */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Rest of data bytes are zeros */
};
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NDEF_FUNC_ENTRY();
assert(NdefSmtCrdFmt != NULL);
if ((*NdefSmtCrdFmt->SendRecvLength != sizeof(c_expectedResponse)) ||
(0 != phOsalNfc_MemCompare(NdefSmtCrdFmt->SendRecvBuf,
(void*)c_expectedResponse,
sizeof(c_expectedResponse))))
{
PH_LOG_NDEF_WARN_STR("Unexpected response received. Formatting failed");
wStatus = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT, NFCSTATUS_FORMAT_ERROR);
}
else
{
PH_LOG_NDEF_INFO_STR("Successfully formatted dynamic Topaz card");
}
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phFriNfc_TopazFormat_Format(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NDEF_FUNC_ENTRY();
if (NdefSmtCrdFmt == NULL)
{
wStatus = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT, NFCSTATUS_INVALID_PARAMETER);
}
else
{
NdefSmtCrdFmt->State = 0;
phOsalNfc_SetMemory(&NdefSmtCrdFmt->AddInfo.Type1Info,
0,
sizeof(NdefSmtCrdFmt->AddInfo.Type1Info));
NdefSmtCrdFmt->AddInfo.Type1Info.CurrentBlock = 0x01;
NdefSmtCrdFmt->AddInfo.Type1Info.CurrentByte = 0;
wStatus = phFriNfc_TopazFormat_WriteByte(NdefSmtCrdFmt,
NdefSmtCrdFmt->AddInfo.Type1Info.CurrentBlock,
NdefSmtCrdFmt->AddInfo.Type1Info.CurrentByte,
c_staticTopazFormat[NdefSmtCrdFmt->AddInfo.Type1Info.CurrentByte]);
}
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phFriNfc_ISO15693_Format (
phFriNfc_sNdefSmtCrdFmt_t *psNdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phHal_sIso15693Info_t *ps_rem_iso_15693_info =
&(psNdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info);
if ((ISO15693_7TH_BYTE_UID_VALUE ==
ps_rem_iso_15693_info->Uid[ISO15693_BYTE_7_INDEX])
&& (ISO15693_6TH_BYTE_UID_VALUE ==
ps_rem_iso_15693_info->Uid[ISO15693_BYTE_6_INDEX]))
{
/* Check if the card is manufactured by NXP (6th byte
index of UID value = 0x04 and the
last byte of UID is 0xE0, only then the card detected
is NDEF compliant */
psNdefSmtCrdFmt->State = ISO15693_FORMAT;
/* GET system information command to get the card size */
result = phFriNfc_ISO15693_H_FmtReadWrite (psNdefSmtCrdFmt,
ISO15693_GET_SYSTEM_INFO_CMD, NULL, 0);
}
else
{
result = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
}
return result;
}
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;
}
uint32_t phOsalNfc_Timer_Create(void)
{
uint32_t i = 0;
if (NULL == gpphOsalNfc_Context) {
return PHNFCSTVAL(CID_NFC_OSAL, NFCSTATUS_INVALID_PARAMETER);
}
EnterCriticalSection(&gpphOsalNfc_Context->TimerLock);
while (i < PH_MAX_OSAL_NUM_TIMERS)
{
/* check whether the timer is free. If free then only it is created */
if(gpphOsalNfc_Context->TimerList[i].pTimer == NULL)
{
gpphOsalNfc_Context->TimerList[i].pTimer = CreateThreadpoolTimer(phOsalNfc_TimerCallback, (void*)i, NULL);
gpphOsalNfc_Context->TimerList[i].dwThreadId = GetCurrentThreadId();
break;
}
i++;
}
LeaveCriticalSection(&gpphOsalNfc_Context->TimerLock);
if ((i == PH_MAX_OSAL_NUM_TIMERS) || (gpphOsalNfc_Context->TimerList[i].pTimer == NULL))
{
return PH_OSALNFC_INVALID_TIMER_ID;
}
return (i + PH_OSAL_TIMER_BASE_ADDRESS);
}
NFCSTATUS phFriNfc_OvrHal_Send(phFriNfc_OvrHal_t *OvrHal,
phFriNfc_CplRt_t *CompletionInfo,
phHal_sRemoteDevInformation_t *RemoteDevInfo,
uint8_t *SendBuf,
uint16_t SendLength)
{
NFCSTATUS status = NFCSTATUS_PENDING;
/* Check the Input Parameters */
if( (NULL==OvrHal) || (NULL==CompletionInfo) || (NULL==RemoteDevInfo) || (NULL==SendBuf) )
{
status = PHNFCSTVAL(CID_FRI_NFC_OVR_HAL ,NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Get the remote dev type */
OvrHal->TransactInfo.remotePCDType = RemoteDevInfo->RemDevType;
/* Save the receive buffer for use in callback */
OvrHal->sSendData.buffer = SendBuf;
OvrHal->sSendData.length = SendLength;
/* Set the callback */
phFriNfc_OvrHal_SetComplInfo(OvrHal, CompletionInfo, PH_FRINFC_OVRHAL_SND);
/* Call the HAL 4.0 Receive Function */
status = phHal4Nfc_Send( OvrHal->psHwReference,
&OvrHal->TransactInfo,
OvrHal->sSendData,
phFriNfc_OvrHal_CB_Send,
(void *)OvrHal);
}
return status;
}
/* This starts the timer */
NFCSTATUS phOsalNfc_Timer_Start(uint32_t TimerId,
uint32_t dueTimeMsec,
ppCallBck_t pCallback,
void *pContext)
{
uint32_t uIndex;
LONGLONG DueTime;
uint32_t uWindow = (dueTimeMsec < 50) ? 0 : (dueTimeMsec / 4);
if (NULL == gpphOsalNfc_Context ||
PH_OSALNFC_TIMER_ID_INVALID == TimerId) {
return PHNFCSTVAL(CID_NFC_OSAL, NFCSTATUS_INVALID_PARAMETER);
}
uIndex = TimerId - PH_OSAL_TIMER_BASE_ADDRESS;
// Convert dueTimeMsec to relative filetime units (100ns)
DueTime = Int32x32To64(dueTimeMsec, -10000);
EnterCriticalSection(&gpphOsalNfc_Context->TimerLock);
SetThreadpoolTimer(gpphOsalNfc_Context->TimerList[uIndex].pTimer, (FILETIME*)&DueTime, 0, uWindow);
gpphOsalNfc_Context->TimerList[uIndex].pCallback = pCallback;
gpphOsalNfc_Context->TimerList[uIndex].pContext = pContext;
LeaveCriticalSection(&gpphOsalNfc_Context->TimerLock);
return NFCSTATUS_SUCCESS;
}
NFCSTATUS
phNciNfc_SetConnCredentials(void *psNciContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphNciNfc_Context_t psNciCtxt = (pphNciNfc_Context_t )psNciContext;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL == psNciCtxt)
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Invalid Context Param..");
}
else
{
/* Update Static conn info with conn details & device handle */
wStatus = phNciNfc_UpdateConnDestInfo(psNciCtxt->tActvDevIf.pDevInfo->bRfDiscId,
phNciNfc_e_REMOTE_NFC_ENDPOINT,
psNciCtxt->tActvDevIf.pDevInfo);
if(NFCSTATUS_SUCCESS == wStatus)
{
PH_LOG_NCI_INFO_STR("Conn Credentials updated successfully..");
}
else
{
PH_LOG_NCI_CRIT_STR("Conn Credentials update failed!!..");
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phHciNfc_SWP_Protection(
void *psHciHandle,
void *pHwRef,
uint8_t mode
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
static uint8_t param = 0 ;
phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
if((NULL == psHciContext)||(NULL == pHwRef))
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else if(NULL == psHciContext->p_swp_info)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else
{
phHciNfc_SWP_Info_t *ps_swp_info=NULL;
phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
ps_pipe_info = ps_swp_info->p_pipe_info;
if(NULL == ps_pipe_info)
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_INFORMATION);
}
else
{
ps_pipe_info->reg_index = NXP_SWP_PROTECTED_INDEX;
/* Enable/Disable SWP Protection */
param = (uint8_t)mode;
ps_pipe_info->param_info =(void*)¶m ;
ps_pipe_info->param_length = sizeof(param) ;
status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
ps_swp_info->pipe_id,
(uint8_t)ANY_SET_PARAMETER);
}
}
return status;
}
static
NFCSTATUS
phHciNfc_Recv_Mifare_Packet(
phHciNfc_sContext_t *psHciContext,
uint8_t cmd,
uint8_t *pResponse,
#ifdef ONE_BYTE_LEN
uint8_t length
#else
uint16_t length
#endif
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
/* To remove "warning (VS C4100) : unreferenced formal parameter" */
PHNFC_UNUSED_VARIABLE(pResponse);
PHNFC_UNUSED_VARIABLE(length);
if (NXP_MIFARE_RAW == cmd)
{
#ifdef ENABLE_MIFARE_RAW
uint8_t index = 0;
#ifndef HAL_SW_3A_STATUS
if(phHal_eISO14443_3A_PICC == psHciContext->p_target_info->RemDevType)
{
index++;
psHciContext->rx_index = (index + HCP_HEADER_LEN);
HCI_PRINT_BUFFER("Mifare Bytes received", &pResponse[index], (length - index));
}
else
#endif
if (RDR_A_MIFARE_STATUS == pResponse[index]) /* Status byte */
{
index++;
psHciContext->rx_index = (index + HCP_HEADER_LEN);
HCI_PRINT_BUFFER("Mifare Bytes received", &pResponse[index], (length - index));
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI,
NFCSTATUS_INVALID_HCI_RESPONSE);
}
#else
psHciContext->rx_index = HCP_HEADER_LEN;
/* Give Mifare data to the upper layer */
HCI_PRINT_BUFFER("Mifare Bytes received", pResponse, length);
#endif /* #ifdef ENABLE_MIFARE_RAW */
}
else
{
psHciContext->rx_index = HCP_HEADER_LEN;
/* command NXP_MIFARE_CMD: so give Mifare data to the upper layer */
HCI_PRINT_BUFFER("Mifare Bytes received", pResponse, length);
}
return status;
}
/*-----------------------------------------------------------------------------
FUNCTION: phDal4Nfc_Register
PURPOSE: DAL register function.
-----------------------------------------------------------------------------*/
NFCSTATUS phDal4Nfc_Register( phNfcIF_sReference_t *psRefer,
phNfcIF_sCallBack_t if_cb, void *psIFConf )
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
if ((NULL != psRefer) &&
(NULL != psRefer->plower_if) &&
(NULL != if_cb.receive_complete) &&
(NULL != if_cb.send_complete)
)
{
/* Register the LLC functions to the upper layer */
psRefer->plower_if->init = phDal4Nfc_Init;
psRefer->plower_if->release = phDal4Nfc_Shutdown;
psRefer->plower_if->send = phDal4Nfc_Write;
psRefer->plower_if->receive = phDal4Nfc_Read;
psRefer->plower_if->receive_wait = phDal4Nfc_ReadWait;
psRefer->plower_if->transact_abort = phDal4Nfc_ReadWaitCancel;
psRefer->plower_if->unregister = phDal4Nfc_Unregister;
if (NULL != pgDalContext)
{
/* Copy the DAL context to the upper layer */
psRefer->plower_if->pcontext = pgDalContext;
/* Register the callback function from the upper layer */
pgDalContext->cb_if.receive_complete = if_cb.receive_complete;
pgDalContext->cb_if.send_complete = if_cb.send_complete;
pgDalContext->cb_if.notify = if_cb.notify;
/* Get the upper layer context */
pgDalContext->cb_if.pif_ctxt = if_cb.pif_ctxt;
/* Update the error state */
result = NFCSTATUS_SUCCESS;
}
else
{
result = PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_NOT_INITIALISED);
}
}
else /*Input parameters invalid*/
{
result = PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_INVALID_PARAMETER);
}
return result;
}
