NFCSTATUS phFriNfc_MfUL_Format(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
uint8_t OTPBytes[] = PH_FRINFC_MFUL_FMT_OTP_BYTES_TEMPLATE;
PH_LOG_NDEF_FUNC_ENTRY();
if (NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.ULType == phNfc_eMifareULType_UltralightC)
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
OTPBytes[PH_FRINFC_MFUL_FMT_OTP_DATA_AREA_SIZE_BYTE] = PH_FRINFC_MFULC_FMT_DATA_AREA_SIZE;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPBytes,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
else if (NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.ULType == phNfc_eMifareULType_UltralightEV1)
{
/* The NDEF TLV for Ultralight and Ultralight EV1 cards are the same, so just label
the CardType as Ultralight */
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
OTPBytes[PH_FRINFC_MFUL_FMT_OTP_DATA_AREA_SIZE_BYTE] = NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.DataAreaSize >> 3; // Divide by 8
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPBytes,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
static NFCSTATUS
phFriNfc_TopazFormat_WriteByte(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt,
uint8_t BlockNo,
uint8_t ByteNo,
uint8_t ByteToWrite)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t writeCmd[7] = { 0 };
PH_LOG_NDEF_FUNC_ENTRY();
assert(NdefSmtCrdFmt != NULL);
writeCmd[0] = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
/* Block and byte numbers need to be in the following format:
7 | 6 5 4 3 | 2 1 0 |
0 | Block | Byte |
*/
writeCmd[1] = ((BlockNo & 0x0F) << 3) | (ByteNo & 0x07);
writeCmd[2] = ByteToWrite;
/* Copy the UID to the end of command buffer */
phOsalNfc_MemCopy(&writeCmd[3],
NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
TOPAZ_UID_LENGTH);
wStatus = phFriNfc_TopazFormat_Transceive(NdefSmtCrdFmt,
writeCmd,
sizeof(writeCmd));
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
void phOsalNfc_PostMsg(_In_ uint32_t Message, _In_ UINT_PTR Param1, _In_ UINT_PTR Param2, _In_ UINT_PTR Param3, _In_ UINT_PTR Param4)
{
phOsalNfc_MsgQueue_t msgEntry = {0};
msgEntry.Message = Message;
msgEntry.Param1 = Param1;
msgEntry.Param2 = Param2;
msgEntry.Param3 = Param3;
msgEntry.Param4 = Param4;
EnterCriticalSection(&gpphOsalNfc_Context->MsgQueueLock);
if(gpphOsalNfc_Context->bMsgQueueUsed < PH_OSAL_MSG_QUEUE_MAX_SIZE)
{
phOsalNfc_MemCopy(&gpphOsalNfc_Context->MsgQueue[gpphOsalNfc_Context->bMsgQueueTail], &msgEntry, sizeof(phOsalNfc_MsgQueue_t));
gpphOsalNfc_Context->bMsgQueueTail = ((gpphOsalNfc_Context->bMsgQueueTail+1) < PH_OSAL_MSG_QUEUE_MAX_SIZE) ? gpphOsalNfc_Context->bMsgQueueTail+1 : 0;
gpphOsalNfc_Context->bMsgQueueUsed++;
SetEvent(gpphOsalNfc_Context->hMsgQueueEvent);
}
else
{
//
// This condition is only hit when the messaging thread is unresponsive and is not draining the message
// queue and hence this is a fatal condition
//
phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
}
LeaveCriticalSection(&gpphOsalNfc_Context->MsgQueueLock);
}
NFCSTATUS phNciNfc_CoreIfTxRx(pphNciNfc_CoreContext_t pCtx,
pphNciNfc_CoreTxInfo_t pTxInfo,
pphNciNfc_Buff_t pRxBuffInfo,
uint32_t dwTimeOutMs,
pphNciNfc_CoreIfNtf_t NciCb,
void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NCI_FUNC_ENTRY();
if ((NULL != pCtx) &&
(NULL != pTxInfo) &&
(NULL != pRxBuffInfo) &&
(NULL != NciCb))
{
if(pCtx->SendStateContext.CurrState == phNciNfc_StateSendIdle)
{
/* Either command or data message can be sent */
if(phNciNfc_e_NciCoreMsgTypeCntrlCmd == pTxInfo->tHeaderInfo.eMsgType)
{
pTxInfo->tHeaderInfo.bConn_ID = 0;
}
else /* Sending a data message */
{
pTxInfo->tHeaderInfo.Group_ID = (phNciNfc_CoreGid_t)0;
pTxInfo->tHeaderInfo.Opcode_ID.Val = 0;
}
/* All calling function which use 'phNciNfc_CoreIfTxRx' to send and receive cmd-Rsp or Data
shall go for Auto deregistration */
pTxInfo->tHeaderInfo.bEnabled = PHNCINFC_ENABLE_AUTO_DEREG;
pCtx->tTemp.pTxInfo = pTxInfo;
pCtx->tTemp.dwTimeOutMs = dwTimeOutMs;
pCtx->tTemp.NciCb = NciCb;
pCtx->tTemp.pContext = pContext;
pCtx->bCoreTxOnly = 0; /* Notify upper layer after response is received for the command sent or
sending command fails*/
phOsalNfc_MemCopy(&(pCtx->TxInfo), pTxInfo, sizeof(phNciNfc_CoreTxInfo_t));
/* Print the NCI packet details */
phNciNfc_PrintPacketDescription(&pTxInfo->tHeaderInfo, pTxInfo->Buff, pTxInfo->wLen);
wStatus = phNciNfc_StateHandler(pCtx, phNciNfc_EvtSendPacket);
}
else
{
wStatus = NFCSTATUS_BUSY;
}
}
else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
void phFriNfc_MfUL_Reset(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
uint8_t OTPBytes[] = PH_FRINFC_MFUL_FMT_OTP_BYTES_TEMPLATE;
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
OTPBytes[PH_FRINFC_MFUL_FMT_OTP_DATA_AREA_SIZE_BYTE] = PH_FRINFC_MFUL_FMT_DATA_AREA_SIZE;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPBytes,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[0] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[1] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = 0;
}
void phFriNfc_MfUL_Reset(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
uint8_t OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
PH_LOG_NDEF_FUNC_ENTRY();
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByte,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[0] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[1] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = 0;
PH_LOG_NDEF_FUNC_EXIT();
}
static NFCSTATUS
phFriNfc_TopazDynamicFormat_ProcessWritingMemCtrlBytes(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt)
{
static const uint8_t c_expectedResponse[] =
{
PH_FRINFC_TOPAZ_TLV_LOCK_CTRL_V2, /* Lock control bytes */
PH_FRINFC_TOPAZ_TLV_MEM_CTRL_T, PH_FRINFC_TOPAZ_TLV_MEM_CTRL_L, PH_FRINFC_TOPAZ_TLV_MEM_CTRL_V0, PH_FRINFC_TOPAZ_TLV_MEM_CTRL_V1, PH_FRINFC_TOPAZ_TLV_MEM_CTRL_V2, /* Memory control bytes */
PH_FRINFC_TOPAZ_TLV_NDEF_T, PH_FRINFC_TOPAZ_TLV_NDEF_L, /* NDEF TLV */
};
uint8_t write8Cmd[] =
{
PH_FRINFC_TOPAZ_CMD_WRITE_E8, /* WRITE-E8 */
0x03, /* Block 0x3 */
PH_FRINFC_TOPAZ_TLV_TERM_T, /* Terminator TLV */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Rest of data bytes are zeros */
0x00, 0x00, 0x00, 0x00 /* UID bytes (need to be copied over) */
};
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
{
/* Copy the UID to the end of command buffer */
phOsalNfc_MemCopy(&write8Cmd[10],
NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
TOPAZ_UID_LENGTH);
NdefSmtCrdFmt->State = PH_FRINFC_TOPAZ_STATE_WRITE_TERM_TLV_BYTES;
wStatus = phFriNfc_TopazFormat_Transceive(NdefSmtCrdFmt,
write8Cmd,
sizeof(write8Cmd));
}
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS
phFriNfc_TopazFormat_Transceive(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt,
const uint8_t* SendBuffer,
uint16_t SendBufferLength)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NDEF_FUNC_ENTRY();
assert(NdefSmtCrdFmt != NULL);
assert(SendBuffer != NULL);
assert(SendBufferLength != 0 && SendBufferLength <= PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE);
/* Fill the send buffer */
NdefSmtCrdFmt->Cmd.JewelCmd = phNfc_eJewel_Raw;
phOsalNfc_MemCopy(NdefSmtCrdFmt->SendRecvBuf, SendBuffer, SendBufferLength);
NdefSmtCrdFmt->SendLength = SendBufferLength;
/* Set the data for additional data exchange */
NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.NADPresent = 0;
NdefSmtCrdFmt->psDepAdditionalInfo.NodeAddress = 0;
/* Set the completion routines for the card operations */
NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine = phFriNfc_NdefSmtCrd_Process;
NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = NdefSmtCrdFmt;
*NdefSmtCrdFmt->SendRecvLength = PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE;
wStatus = phFriNfc_OvrHal_Transceive(NdefSmtCrdFmt->LowerDevice,
&NdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
NdefSmtCrdFmt->psRemoteDevInfo,
NdefSmtCrdFmt->Cmd,
&NdefSmtCrdFmt->psDepAdditionalInfo,
NdefSmtCrdFmt->SendRecvBuf,
NdefSmtCrdFmt->SendLength,
NdefSmtCrdFmt->SendRecvBuf,
NdefSmtCrdFmt->SendRecvLength);
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
NFCSTATUS phFriNfc_MfUL_Format(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
uint8_t OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
PH_LOG_NDEF_FUNC_ENTRY();
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByte,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
/* Set the state */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RD_16BYTES;
/* Initialise current block to the lock bits block */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_2;
/* Start authentication */
Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
PH_LOG_NDEF_FUNC_EXIT();
return Result;
}
NFCSTATUS phNciNfc_CoreIfTxOnly(pphNciNfc_CoreContext_t pCtx,
pphNciNfc_CoreTxInfo_t pTxInfo,
pphNciNfc_CoreIfNtf_t NciCb,
void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NCI_FUNC_ENTRY();
if ((NULL != pCtx) &&
(NULL != pTxInfo) &&
(NULL != NciCb))
{
if(pCtx->SendStateContext.CurrState == phNciNfc_StateSendIdle)
{
pCtx->tTemp.pTxInfo = pTxInfo;
/* No timer is used */
pCtx->tTemp.dwTimeOutMs = 0;
pCtx->tTemp.NciCb = NciCb;
pCtx->tTemp.pContext = pContext;
pCtx->bCoreTxOnly = 1; /* Send and receive operation is in progress */
phOsalNfc_MemCopy(&(pCtx->TxInfo), pTxInfo, sizeof(phNciNfc_CoreTxInfo_t));
/* Print the NCI packet details */
phNciNfc_PrintPacketDescription(&pTxInfo->tHeaderInfo, pTxInfo->Buff, pTxInfo->wLen);
wStatus = phNciNfc_StateHandler(pCtx, phNciNfc_EvtSendPacket);
}
else
{
wStatus = NFCSTATUS_BUSY;
}
}
else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phFriNfc_TopazDynamicFormat_Format(phFriNfc_sNdefSmtCrdFmt_t* NdefSmtCrdFmt)
{
uint8_t write8Cmd[] =
{
PH_FRINFC_TOPAZ_CMD_WRITE_E8, /* WRITE-E8 */
0x01, /* Block 0x1 */
PH_FRINFC_TOPAZ_CC_BYTE0, PH_FRINFC_TOPAZ_CC_BYTE1, PH_FRINFC_TOPAZ_DYNAMIC_CC_BYTE2_MMSIZE, PH_FRINFC_TOPAZ_CC_BYTE3_RW, /* CC bytes */
PH_FRINFC_TOPAZ_TLV_LOCK_CTRL_T, PH_FRINFC_TOPAZ_TLV_LOCK_CTRL_L, PH_FRINFC_TOPAZ_TLV_LOCK_CTRL_V0, PH_FRINFC_TOPAZ_TLV_LOCK_CTRL_V1, /* Lock control bytes */
0x00, 0x00, 0x00, 0x00 /* UID bytes (need to be copied over) */
};
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
PH_LOG_NDEF_FUNC_ENTRY();
if (NdefSmtCrdFmt == NULL)
{
wStatus = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Copy the UID to the end of command buffer */
phOsalNfc_MemCopy(&write8Cmd[10],
NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
TOPAZ_UID_LENGTH);
NdefSmtCrdFmt->State = PH_FRINFC_TOPAZ_STATE_WRITE_CC_BYTES;
wStatus = phFriNfc_TopazFormat_Transceive(NdefSmtCrdFmt,
write8Cmd,
sizeof(write8Cmd));
}
PH_LOG_NDEF_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phHciNfc_CoreRecvCB(void *pContext,
void *pInfo,
NFCSTATUS wStatus
)
{
uint8_t bChainBit = 0;
pphHciNfc_sCoreRecvBuff_List_t pNode = NULL;
phHciNfc_ReceiveParams_t tHciNfcRxdParams;
phNciNfc_TransactInfo_t *pHciCoreReceiveInfo;
NFCSTATUS wStat;
if(pContext != NULL)
{
if(pInfo != NULL)
{
phHciNfc_HciContext_t *pHciContext = (phHciNfc_HciContext_t *) pContext;
phHciNfc_HciCoreContext_t *pHciCoreContext = &(pHciContext->pHciCoreContext);
pHciCoreReceiveInfo = (phNciNfc_TransactInfo_t*)pInfo;
if(wStatus == NFCSTATUS_SUCCESS)
{
bChainBit = (uint8_t) GET_BITS8(*(pHciCoreReceiveInfo->pbuffer),
PHHCINFC_HCP_CHAINBIT_OFFSET,
PHHCINFC_HCP_CHAINBIT_LEN);
/* Store/Buffer HCP Header along with Data irrespective of whether chained or Unchained */
if(pHciCoreReceiveInfo->wLength <= PHHCI_HCP_MAX_RECEIVE_PACKET_SIZE)
{
/* Create the Data Node and copy the Data */
pNode = phHciNfc_CoreGetNewNode(pHciCoreContext,pHciCoreReceiveInfo->wLength);
if(pNode != NULL)
{
phOsalNfc_MemCopy((uint8_t*)&(pNode->tMem.aBuffer[0]),
(uint8_t*)(pHciCoreReceiveInfo->pbuffer),
pHciCoreReceiveInfo->wLength);
pNode->tMem.wLen = pHciCoreReceiveInfo->wLength;
}else
{
PH_LOG_LIBNFC_CRIT_STR(" HCI Core Receive- Failed To Allocate Memory for Node");
}
}else
{
/* HCP Packet should not be bigger than PHHCI_HCP_MAX_PACKET_SIZE */
}
/* Check Chaining Bit to asceratain whether complete Message is received or Not*/
if(bChainBit == HCP_CHAINBIT_UN_CHAINED)
{
/* HCI message is complete extract the Data from linked list*/
tHciNfcRxdParams.pData = phOsalNfc_GetMemory(pHciCoreContext->tReceiveInfo.wPayloadSize);
wStat = phHciNfc_HciCoreExtractData(pHciCoreContext,&tHciNfcRxdParams);
if(wStat == NFCSTATUS_SUCCESS)
{
/*Once the HCI Packets are Extracted ,HCI packet info is captured so delete the linked list */
phHciNfc_CoreDeleteList(pHciCoreContext);
/* Send the Received Data To upper layer*/
/* TO DO Registration mechanism to be implemented*/
phHciNfc_ReceiveHandler(pHciContext,
&tHciNfcRxdParams,
wStatus
);
phOsalNfc_FreeMemory(tHciNfcRxdParams.pData);
}else
{
PH_LOG_LIBNFC_CRIT_STR(" HCI Core - HCI Packet Extraction Failed");
}
}
else
{
/* Chained HCI packets which are already buffered
** No Action here waits for complete HCI Msg to be Rxd
*/
}
}else
{
/* Failed Status from lower layer- Call the upper layer call back with the returned status */
/* Send the Received Data To upper layer*/
phHciNfc_ReceiveHandler(pHciContext->pHciCoreContext.pUpperLayerContext,
NULL,
wStatus
);
}
}
else
{
/* Do Nothing if no information is received from lower layer */
PH_LOG_LIBNFC_CRIT_STR(" Invalid Receive Info Pointer received from lower layer ");
}
}else
{
PH_LOG_LIBNFC_CRIT_STR(" Invalid HCI Context received from Lower Layer ");
}
return wStatus;
}
NFCSTATUS phLibNfc_Mgt_SetLlcp_ConfigParams( phLibNfc_Llcp_sLinkParameters_t* pConfigInfo,
pphLibNfc_RspCb_t pConfigRspCb,
void* pContext
)
{
NFCSTATUS result;
phNfc_sData_t sGeneralBytesBuffer;
phLibNfc_sNfcIPCfg_t sNfcIPCfg;
const uint8_t pMagicBuffer[] = { 0x46, 0x66, 0x6D };
PH_LOG_LLCP_FUNC_ENTRY();
result = static_CheckState();
if (result != NFCSTATUS_SUCCESS)
{
PH_LOG_LLCP_FUNC_EXIT();
return result;
}
if ((pConfigInfo == NULL) || (pConfigRspCb == NULL))
{
PH_LOG_LLCP_FUNC_EXIT();
return NFCSTATUS_INVALID_PARAMETER;
}
/* Save the config for later use */
phOsalNfc_MemCopy( &gpphLibNfc_Context->llcp_cntx.sLocalParams,
pConfigInfo,
sizeof(phLibNfc_Llcp_sLinkParameters_t) );
/* Copy magic number in NFCIP General Bytes */
phOsalNfc_MemCopy(sNfcIPCfg.generalBytes, pMagicBuffer, sizeof(pMagicBuffer));
sNfcIPCfg.generalBytesLength = sizeof(pMagicBuffer);
/* Encode link parameters in TLV to configure P2P General Bytes */
sGeneralBytesBuffer.buffer = sNfcIPCfg.generalBytes + sizeof(pMagicBuffer);
sGeneralBytesBuffer.length = sizeof(sNfcIPCfg.generalBytes) - sizeof(pMagicBuffer);
result = phFriNfc_Llcp_EncodeLinkParams( &sGeneralBytesBuffer,
pConfigInfo,
PHFRINFC_LLCP_VERSION);
if (result != NFCSTATUS_SUCCESS)
{
PH_LOG_LLCP_FUNC_EXIT();
return PHNFCSTATUS(result);
}
sNfcIPCfg.generalBytesLength += (uint8_t)sGeneralBytesBuffer.length;
/* Set the P2P general bytes */
result = phLibNfc_Mgt_SetP2P_ConfigParams(&sNfcIPCfg, pConfigRspCb, pContext);
if (result != NFCSTATUS_PENDING)
{
PH_LOG_LLCP_FUNC_EXIT();
return PHNFCSTATUS(result);
}
/* Resets the LLCP LLC component */
result = phFriNfc_Llcp_Reset( &gpphLibNfc_Context->llcp_cntx.sLlcpContext,
gpphLibNfc_Context->psOverHalCtxt,
pConfigInfo,
gpphLibNfc_Context->llcp_cntx.pRxBuffer,
sizeof(gpphLibNfc_Context->llcp_cntx.pRxBuffer),
gpphLibNfc_Context->llcp_cntx.pTxBuffer,
sizeof(gpphLibNfc_Context->llcp_cntx.pTxBuffer),
gpphLibNfc_Context->bDtaFlag,
phLibNfc_Llcp_Link_Cb,
gpphLibNfc_Context);
if (result != NFCSTATUS_SUCCESS)
{
PH_LOG_LLCP_FUNC_EXIT();
return PHNFCSTATUS(result);
}
/* Resets the LLCP Transport component */
result = phFriNfc_LlcpTransport_Reset( &gpphLibNfc_Context->llcp_cntx.sLlcpTransportContext,
&gpphLibNfc_Context->llcp_cntx.sLlcpContext );
if (result != NFCSTATUS_SUCCESS)
{
PH_LOG_LLCP_FUNC_EXIT();
return PHNFCSTATUS(result);
}
PH_LOG_LLCP_FUNC_EXIT();
return NFCSTATUS_PENDING;
}
NFCSTATUS
phLibNfc_Mgt_SetP2P_ConfigParams(phLibNfc_sNfcIPCfg_t *pConfigInfo,
pphLibNfc_RspCb_t pConfigRspCb,
void * pContext)
{
NFCSTATUS wStatus = NFCSTATUS_FAILED;
pphLibNfc_LibContext_t pLibContext = gpphLibNfc_Context;
pphNciNfc_RfDiscConfigParams_t pRfDiscConfParam = NULL;
uint8_t bGeneralBytesLength = 0;
phLibNfc_DummyInfo_t Info;
phLibNfc_Event_t TrigEvent = phLibNfc_EventDummy;
PH_LOG_LIBNFC_FUNC_ENTRY();
Info.Evt = phLibNfc_DummyEventInvalid;
if(NULL == pLibContext)
{
wStatus = NFCSTATUS_NOT_INITIALISED;
}
else if((NULL == pConfigInfo) ||(NULL == pConfigRspCb))
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
else
{
bGeneralBytesLength = pConfigInfo->generalBytesLength;
if((pLibContext->bDtaFlag || (0 != bGeneralBytesLength)) &&
(PH_LIBNFC_INTERNAL_MAX_ATR_LENGTH >= bGeneralBytesLength))
{
/* Allocate memory for the input parameter that needs to be sent to
'phNciNfc_SetConfigRfParameters' API */
pRfDiscConfParam = (pphNciNfc_RfDiscConfigParams_t)phOsalNfc_GetMemory(
sizeof(phNciNfc_RfDiscConfigParams_t));
if(NULL != pRfDiscConfParam)
{
phOsalNfc_SetMemory(pRfDiscConfParam,0,sizeof(phNciNfc_RfDiscConfigParams_t));
pLibContext->CBInfo.pClientNfcIpCfgCb = pConfigRspCb;
pLibContext->CBInfo.pClientNfcIpCfgCntx = pContext;
/* Set general bytes for Poll Nfc-Dep parameters */
switch(pConfigInfo->p2pMode)
{
case NFC_DEP_POLL:
pRfDiscConfParam->tConfigInfo.PollNfcDepConfig = 1;
/* Configuring general bytes for ATR_REQ */
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.EnableConfig = 0;
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetGenBytes = 1;
pRfDiscConfParam->tPollNfcDepDiscParams.bAtrReqGeneBytesSize = bGeneralBytesLength;
phOsalNfc_MemCopy(pRfDiscConfParam->tPollNfcDepDiscParams.aAtrReqGenBytes,
pConfigInfo->generalBytes,bGeneralBytesLength);
/*Enable General Bytes to default values*/
/*Configure to default value = 0x30*/
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetAtrConfig = 1;
pRfDiscConfParam->tPollNfcDepDiscParams.AtrReqConfig.bDid = 0; /*0 For LLCP*/
pRfDiscConfParam->tPollNfcDepDiscParams.AtrReqConfig.bLr = 0x03;/*0x03 for LLCP*/
break;
case NFC_DEP_LISTEN:
/* Set general bytes for Listen Nfc-Dep parameters */
pRfDiscConfParam->tConfigInfo.LstnNfcDepConfig = 1;
/* Configuring general bytes for ATR_RES */
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.EnableConfig = 0;
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.Config.bSetGenBytes = 1;
pRfDiscConfParam->tLstnNfcDepDiscParams.bAtrResGenBytesSize = bGeneralBytesLength;
phOsalNfc_MemCopy(pRfDiscConfParam->tLstnNfcDepDiscParams.aAtrResGenBytes,
pConfigInfo->generalBytes,bGeneralBytesLength);
/*Enable General Bytes in response*/
/*Configure to defaule value*/
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.Config.bSetAtrRespConfig = 1;
pRfDiscConfParam->tLstnNfcDepDiscParams.AtrRespConfig.bLengthReduction = 0x03; /*For LLCP*/
break;
case NFC_DEP_DEFAULT:
default:
pRfDiscConfParam->tConfigInfo.PollNfcDepConfig = 1;
/* Configuring general bytes for ATR_REQ */
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.EnableConfig = 0;
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetGenBytes = 1;
pRfDiscConfParam->tPollNfcDepDiscParams.bAtrReqGeneBytesSize = bGeneralBytesLength;
phOsalNfc_MemCopy(pRfDiscConfParam->tPollNfcDepDiscParams.aAtrReqGenBytes,
pConfigInfo->generalBytes,bGeneralBytesLength);
/*Enable General Bytes to default values*/
/*Configure to default value = 0x30*/
pRfDiscConfParam->tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetAtrConfig = 1;
pRfDiscConfParam->tPollNfcDepDiscParams.AtrReqConfig.bDid = 0; /*0 For LLCP*/
pRfDiscConfParam->tPollNfcDepDiscParams.AtrReqConfig.bLr = 0x03;/*0x03 for LLCP*/
pRfDiscConfParam->tConfigInfo.LstnNfcDepConfig = 1;
/* Configuring general bytes for ATR_RES */
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.EnableConfig = 0;
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.Config.bSetGenBytes = 1;
pRfDiscConfParam->tLstnNfcDepDiscParams.bAtrResGenBytesSize = bGeneralBytesLength;
phOsalNfc_MemCopy(pRfDiscConfParam->tLstnNfcDepDiscParams.aAtrResGenBytes,
pConfigInfo->generalBytes,bGeneralBytesLength);
/*Enable General Bytes in response*/
/*Configure to defaule value*/
pRfDiscConfParam->tLstnNfcDepDiscParams.LstnNfcDepConfig.Config.bSetAtrRespConfig = 1;
pRfDiscConfParam->tLstnNfcDepDiscParams.AtrRespConfig.bLengthReduction = 0x03; /*For LLCP*/
break;
}
Info.Evt = phLibNfc_DummyEventSetP2PConfigs;
Info.Params = (void *)pRfDiscConfParam;
wStatus = phLibNfc_StateHandler(pLibContext,
TrigEvent,
NULL,
&Info,
NULL);
if(NFCSTATUS_PENDING != wStatus)
{
phOsalNfc_FreeMemory(pRfDiscConfParam);
pLibContext->CBInfo.pClientNfcIpCfgCb = NULL;
pLibContext->CBInfo.pClientNfcIpCfgCntx = NULL;
}
}
else
{
wStatus = NFCSTATUS_INSUFFICIENT_RESOURCES;
}
}
else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
}
PH_LOG_LIBNFC_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS phFriNfc_MfUL_H_ProRd16Bytes( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_FORMAT_ERROR);
uint32_t memcompare = PH_FRINFC_MFUL_FMT_VAL_0;
uint8_t ZeroBuf[] = {0x00, 0x00, 0x00, 0x00};
uint8_t OTPByteUL[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
uint8_t OTPByteULC[] = PH_FRINFC_MFULC_FMT_OTP_BYTES;
PH_LOG_NDEF_FUNC_ENTRY();
/* Check the lock bits (byte number 2 and 3 of block number 2) */
if ((NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_2] ==
PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL) &&
(NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_3] ==
PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL))
{
if (NdefSmtCrdFmt->SendRecvBuf[8] == 0x02 &&
NdefSmtCrdFmt->SendRecvBuf[9] == 0x00)
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByteULC,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
else if (NdefSmtCrdFmt->SendRecvBuf[8] == 0xFF &&
NdefSmtCrdFmt->SendRecvBuf[9] == 0xFF)
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
phOsalNfc_MemCopy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByteUL,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
else
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
}
memcompare = (uint32_t)
MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
{
/* Write NDEF TLV in block number 4 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_4;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV;
}
else
{
/* IS the card new, OTP bytes = {0x00, 0x00, 0x00, 0x00} */
memcompare = (uint32_t)MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
ZeroBuf,
PH_FRINFC_MFUL_FMT_VAL_4);
/* If OTP bytes are Zero then the card is Zero */
if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
{
/* Write OTP bytes in block number 3 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_3;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_OTPBYTES;
}
}
}
if(
((NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_TLV) ||
(NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_OTPBYTES)) &&
((NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD) ||
(NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD))
)
{
Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
}
PH_LOG_NDEF_FUNC_EXIT();
return Result;
}
static
NFCSTATUS
phFriNfc_MfUL_UpdateAndWriteLockBits (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint8_t byte_index = 0;
uint8_t no_of_bits_left_in_block = 0;
uint8_t remaining_lock_bits = 0;
uint8_t remaining_lock_bytes = 0;
/* Array of 3 is used because the lock bits with 4 bytes in a block
is handled in the function phFriNfc_MfUL_ReadWriteLockBytes
So use this function only if lock bytes doesnt use the entire block */
uint8_t lock_bytes_value[MFUL_BLOCK_SIZE_IN_BYTES] = {0};
uint8_t lock_byte_index = 0;
(void)phOsalNfc_MemCopy ((void *)lock_bytes_value,
(void*)(ps_type2_info->ReadData + ps_type2_info->ReadDataIndex),
sizeof (ps_type2_info->DynLockBytes));
remaining_lock_bits = phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt);
if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
{
/* 1st write to lock bits, so byte_index is updated */
byte_index = ps_type2_info->LockByteNumber;
}
no_of_bits_left_in_block = (uint8_t)((MFUL_BLOCK_SIZE_IN_BYTES - byte_index) *
MFUL_BYTE_SIZE_IN_BITS);
if (no_of_bits_left_in_block >= remaining_lock_bits)
{
/* Entire lock bits can be written
if block size is more than number of lock bits.
so allocate the lock bits with value 1b and
dont change the remaining bits */
if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS)
{
/* mod operation has resulted in a value, means lock bits ends in between a byte */
uint8_t mod_value = 0;
remaining_lock_bytes = ((remaining_lock_bits /
MFUL_BYTE_SIZE_IN_BITS) + 1);
/* mod_value is used to fill the only partial bits and
remaining bits shall be untouched */
mod_value = (uint8_t)(remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS);
if (remaining_lock_bits > MFUL_BYTE_SIZE_IN_BITS)
{
/* lock bits to write is greater than 8 bits */
while (lock_byte_index < (remaining_lock_bytes - 1))
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
/* Last byte of the lock bits shall be filled partially,
Set only the remaining lock bits and dont change
the other bit value */
lock_bytes_value[byte_index] = 0;
lock_bytes_value[byte_index] = (uint8_t)
SET_BITS8 (lock_bytes_value[byte_index], 0,
mod_value, 1);
}
else
{
/* lock bits to write is less than 8 bits, so
there is only one byte to write.
Set only the remaining lock bits and dont change
the other bit value */
lock_bytes_value[0] = (uint8_t)SET_BITS8 (lock_bytes_value[0], 0,
mod_value, 1);
}
} /* if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS) */
else
{
/* MOD operation is 00, that means entire byte value shall be 0xFF, means
every bit shall be to 1 */
remaining_lock_bytes = (remaining_lock_bits /
MFUL_BYTE_SIZE_IN_BITS);
while (lock_byte_index < remaining_lock_bytes)
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
} /* else of if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS) */
ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten +
remaining_lock_bits);
} /* if (no_of_bits_left_in_block >= remaining_lock_bits) */
else
{
/* Update till the left bits in the block and then carry
out next operation after this write */
while (lock_byte_index < (no_of_bits_left_in_block / MFUL_BYTE_SIZE_IN_BITS))
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten +
no_of_bits_left_in_block);
} /* else of if (no_of_bits_left_in_block >= remaining_lock_bits) */
/* Copy the values back to the DynLockBytes structure member */
(void)phOsalNfc_MemCopy ((void*)ps_type2_info->DynLockBytes,
(void *)lock_bytes_value,
sizeof (ps_type2_info->DynLockBytes));
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
return result;
}
static NFCSTATUS phNciNfc_ProcessInitRsp(void *pContext, NFCSTATUS Status)
{
NFCSTATUS wStatus = Status;
phNciNfc_sInitRspParams_t *pInitRsp = NULL;
pphNciNfc_Context_t pNciContext = pContext;
uint8_t Offset = 0;
uint16_t wTemp = 0;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciContext)
{
pInitRsp = &(pNciContext->InitRspParams);
if (pNciContext->RspBuffInfo.wLen >= 19)
{
if (pNciContext->RspBuffInfo.pBuff[Offset++] == PH_NCINFC_STATUS_OK)
{
wStatus = NFCSTATUS_SUCCESS;
/*NFCC Features*/
pInitRsp->NfccFeatures.DiscConfSuprt = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->NfccFeatures.RoutingType = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->NfccFeatures.PwrOffState = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->NfccFeatures.Byte3 = pNciContext->RspBuffInfo.pBuff[Offset++];
/*number of supported RF interfaces*/
pInitRsp->NoOfRfIfSuprt = pNciContext->RspBuffInfo.pBuff[Offset++];
if(pInitRsp->NoOfRfIfSuprt <= PH_NCINFC_CORE_MAX_SUP_RF_INTFS)
{
/*Supported RF Interfaces */
phOsalNfc_MemCopy(pInitRsp->RfInterfaces, &(pNciContext->RspBuffInfo.pBuff[Offset]),
pInitRsp->NoOfRfIfSuprt);
Offset += pInitRsp->NoOfRfIfSuprt;
/*Max No of Logical Connection supported*/
pInitRsp->MaxLogicalCon = pNciContext->RspBuffInfo.pBuff[Offset++];
/*Routing Table Size*/
pInitRsp->RoutingTableSize = pNciContext->RspBuffInfo.pBuff[Offset++]; /*LSB*/
wTemp = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->RoutingTableSize = (pInitRsp->RoutingTableSize) | (wTemp << 8);
/*Control Packet Payload Length*/
pInitRsp->CntrlPktPayloadLen = pNciContext->RspBuffInfo.pBuff[Offset++];
/*Max Size For Large parameter*/
pInitRsp->MaxSizeLarge = pNciContext->RspBuffInfo.pBuff[Offset++]; /*LSB*/
wTemp = (uint16_t)pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->MaxSizeLarge = (pInitRsp->MaxSizeLarge) | (wTemp << 8);
/*Manufacturer ID*/
pInitRsp->ManufacturerId = pNciContext->RspBuffInfo.pBuff[Offset++];
if(pInitRsp->ManufacturerId != 0x00)
{
/*Decided by Manufacturer*/
pInitRsp->ManufacturerInfo.Byte0 = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->ManufacturerInfo.Byte1 = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->ManufacturerInfo.Byte2 = pNciContext->RspBuffInfo.pBuff[Offset++];
pInitRsp->ManufacturerInfo.Byte3 = pNciContext->RspBuffInfo.pBuff[Offset++];
}
wStatus = phNciNfc_CoreIfSetMaxCtrlPacketSize(&(pNciContext->NciCoreContext),
pInitRsp->CntrlPktPayloadLen);
}
else
{
PH_LOG_NCI_CRIT_STR("Invalid number of supported Rf interfaces");
wStatus = NFCSTATUS_FAILED;
}
}
else
{
wStatus = NFCSTATUS_FAILED;
}
}
else
{
wStatus = NFCSTATUS_FAILED;
}
if((NFCSTATUS_SUCCESS == wStatus) &&
(0 == pNciContext->tInitInfo.bSkipRegisterAllNtfs))
{
wStatus = phNciNfc_RegAllNtfs(pNciContext);
if(NFCSTATUS_SUCCESS == wStatus)
{
pNciContext->dwNtfTimerId = phOsalNfc_Timer_Create();
if(PH_OSALNFC_TIMER_ID_INVALID == pNciContext->dwNtfTimerId)
{
PH_LOG_NCI_CRIT_STR("Notification Timer Create failed!!");
wStatus = NFCSTATUS_INSUFFICIENT_RESOURCES;
}
else
{
PH_LOG_NCI_INFO_STR("Notification Timer Created Successfully");
}
}
}
}
else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_Send4BData(
void *psContext
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phNciNfc_CoreTxInfo_t TxInfo;
uint16_t wPldDataSize = 0;
phNciNfc_Context_t *psNciContext = (phNciNfc_Context_t *)psContext;
PH_LOG_NCI_FUNC_ENTRY();
if( (NULL == psNciContext) )
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Context Param..");
}
else if(NULL == (psNciContext->tActvDevIf.pDevInfo))
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_DEVICE);
PH_LOG_NCI_INFO_STR(" Invalid Device..");
}
else
{
pphNciNfc_RemoteDevInformation_t pActivDev = NULL;
pActivDev = (psNciContext->tActvDevIf.pDevInfo);
if(0 != (psNciContext->tTranscvCtxt.tTranscvInfo.tSendData.wLen))
{
/* Fill the data packet details into TxInfo */
TxInfo.tHeaderInfo.eMsgType = phNciNfc_e_NciCoreMsgTypeData;
status = phNciNfc_GetConnId(pActivDev, &(TxInfo.tHeaderInfo.bConn_ID));
if(NFCSTATUS_SUCCESS == status)
{
wPldDataSize = (psNciContext->tTranscvCtxt.tTranscvInfo.tSendData.wLen);
(psNciContext->tTranscvCtxt.tSendPld.wLen) = 0;
(psNciContext->tTranscvCtxt.tSendPld.pBuff) = (uint8_t *)phOsalNfc_GetMemory(wPldDataSize);
if(NULL != (psNciContext->tTranscvCtxt.tSendPld.pBuff))
{
(psNciContext->tTranscvCtxt.tSendPld.wLen) = (wPldDataSize);
phOsalNfc_SetMemory((psNciContext->tTranscvCtxt.tSendPld.pBuff),0,
(psNciContext->tTranscvCtxt.tSendPld.wLen));
if(0 != wPldDataSize)
{
phOsalNfc_MemCopy((psNciContext->tTranscvCtxt.tSendPld.pBuff),
(psNciContext->tTranscvCtxt.tTranscvInfo.tSendData.pBuff),wPldDataSize);
}
PH_LOG_NCI_INFO_STR(" 4B Payload created successfully..");
TxInfo.Buff = (psNciContext->tTranscvCtxt.tSendPld.pBuff);
TxInfo.wLen = (psNciContext->tTranscvCtxt.tSendPld.wLen);
status = phNciNfc_CoreIfTxRx(&(psNciContext->NciCoreContext), &TxInfo,
&(psNciContext->RspBuffInfo), psNciContext->tTranscvCtxt.tTranscvInfo.wTimeout,
(pphNciNfc_CoreIfNtf_t)&phNciNfc_RdrDataXchgSequence, psContext);
/* Clear the timeout value so that it wont be used mistakenly in subsequent transceive */
psNciContext->tTranscvCtxt.tTranscvInfo.wTimeout = 0;
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
PH_LOG_NCI_INFO_STR(" Payload MemAlloc for Send request Failed..");
}
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_FAILED);
PH_LOG_NCI_INFO_STR(" Couldn't Get ConnId..");
}
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_FAILED);
PH_LOG_NCI_INFO_STR(" Send Data Buff not valid..");
}
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
NFCSTATUS
phNciNfc_Recv4BResp(
void *psContext,
NFCSTATUS wStatus
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phNciNfc_Context_t *psNciContext = (phNciNfc_Context_t *)psContext;
uint16_t wRecvDataSz = 0;
uint16_t CopyLen = 0;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL == psNciContext)
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Context Param..");
}
else
{
if((0 == (psNciContext->RspBuffInfo.wLen))
|| (PH_NCINFC_STATUS_OK != wStatus)
|| (NULL == (psNciContext->RspBuffInfo.pBuff))
)
{
/* NOTE:- ( TODO) In this fail scenario,map the status code from response handler
to the status code in Nci Context and use the same in the status below */
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_FAILED);
PH_LOG_NCI_INFO_STR(" Data Receive Failed..");
}
else
{
wRecvDataSz = (psNciContext->tTranscvCtxt.tTranscvInfo.tRecvData.wLen);
if((psNciContext->RspBuffInfo.wLen) > wRecvDataSz)
{
CopyLen = wRecvDataSz;
status = NFCSTATUS_SUCCESS; // Change to this if handling is added NFCSTATUS_MORE_INFORMATION;
}else
{
CopyLen = psNciContext->RspBuffInfo.wLen;
status = NFCSTATUS_SUCCESS;
}
/* Extract the data part from pBuff[3] & fill it to be sent to upper layer */
phOsalNfc_MemCopy((psNciContext->tTranscvCtxt.tTranscvInfo.tRecvData.pBuff),
(psNciContext->RspBuffInfo.pBuff),CopyLen);
psNciContext->tTranscvCtxt.tTranscvInfo.tRecvData.wLen = CopyLen;
}
(psNciContext->tTranscvCtxt.wPrevStatus) = status;
}
if((NULL != psNciContext) && (NULL != (psNciContext->tTranscvCtxt.tSendPld.pBuff)))
{
(psNciContext->tTranscvCtxt.tSendPld.wLen) = 0;
PH_LOG_NCI_INFO_STR(" Freeing Send Request Payload Buffer..");
phOsalNfc_FreeMemory((psNciContext->tTranscvCtxt.tSendPld.pBuff));
psNciContext->tTranscvCtxt.tSendPld.pBuff = NULL;
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
static
NFCSTATUS
phFriNfc_ISO15693_H_FmtReadWrite (
phFriNfc_sNdefSmtCrdFmt_t *psNdefSmtCrdFmt,
uint8_t command,
uint8_t *p_data,
uint8_t data_length)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
uint8_t send_index = 0;
/* set the data for additional data exchange*/
psNdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
psNdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.NADPresent = 0;
psNdefSmtCrdFmt->psDepAdditionalInfo.NodeAddress = 0;
psNdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine =
phFriNfc_ISO15693_FmtProcess;
psNdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = psNdefSmtCrdFmt;
*psNdefSmtCrdFmt->SendRecvLength = PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE;
psNdefSmtCrdFmt->Cmd.Iso15693Cmd = phHal_eIso15693_Cmd;
*(psNdefSmtCrdFmt->SendRecvBuf + send_index) = (uint8_t)ISO15693_FMT_FLAGS;
send_index = (uint8_t)(send_index + 1);
*(psNdefSmtCrdFmt->SendRecvBuf + send_index) = (uint8_t)command;
send_index = (uint8_t)(send_index + 1);
(void)phOsalNfc_MemCopy ((void *)(psNdefSmtCrdFmt->SendRecvBuf + send_index),
(void *)psNdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.Uid,
psNdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength);
send_index = (uint8_t)(send_index +
psNdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso15693_Info.UidLength);
switch (command)
{
case ISO15693_WR_SINGLE_BLK_CMD:
case ISO15693_RD_MULTIPLE_BLKS_CMD:
{
*(psNdefSmtCrdFmt->SendRecvBuf + send_index) = (uint8_t)
psNdefSmtCrdFmt->AddInfo.s_iso15693_info.current_block;
send_index = (uint8_t)(send_index + 1);
if (data_length)
{
(void)phOsalNfc_MemCopy ((void *)(psNdefSmtCrdFmt->SendRecvBuf + send_index),
(void *)p_data, data_length);
send_index = (uint8_t)(send_index + data_length);
}
else
{
result = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
}
break;
}
case ISO15693_RD_SINGLE_BLK_CMD:
{
*(psNdefSmtCrdFmt->SendRecvBuf + send_index) = (uint8_t)
psNdefSmtCrdFmt->AddInfo.s_iso15693_info.current_block;
send_index = (uint8_t)(send_index + 1);
break;
}
case ISO15693_GET_SYSTEM_INFO_CMD:
{
/* Dont do anything */
break;
}
default:
{
result = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
psNdefSmtCrdFmt->SendLength = send_index;
if (!result)
{
result = phFriNfc_OvrHal_Transceive(psNdefSmtCrdFmt->LowerDevice,
&psNdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
psNdefSmtCrdFmt->psRemoteDevInfo,
psNdefSmtCrdFmt->Cmd,
&psNdefSmtCrdFmt->psDepAdditionalInfo,
psNdefSmtCrdFmt->SendRecvBuf,
psNdefSmtCrdFmt->SendLength,
psNdefSmtCrdFmt->SendRecvBuf,
psNdefSmtCrdFmt->SendRecvLength);
}
return result;
}
NFCSTATUS
phHciNfc_CoreSend(void *pHciContextHandle,
phHciNfc_SendParams_t *pSendMsgParams,
pphHciNfc_UpperLayerSendCb_t phHciNfcUpperLayerSendCb,
void *pContext
)
{
NFCSTATUS wStatus;
phHciNfc_HciContext_t *pHciContext = (phHciNfc_HciContext_t *) pHciContextHandle;
uint8_t *pBuiltHciPkt;
uint32_t dwTotalLenOfBuiltPkt=0;
phNfc_sData_t tSendData;
if( (pHciContext == NULL) || (pSendMsgParams == NULL) )
{
PH_LOG_LIBNFC_CRIT_STR("Invalid parameter");
wStatus = NFCSTATUS_INVALID_PARAMETER;
}else
{
pBuiltHciPkt = phOsalNfc_GetMemory(PHHCI_HCP_MAX_PACKET_SIZE);
if( pBuiltHciPkt == NULL )
{
/* Failed to allocate memory for HCI packet */
wStatus = NFCSTATUS_FAILED;
}else
{
/* Store Send Call back, Uppler Layer Context and received msg params in Hci context */
phOsalNfc_MemCopy(&(pHciContext->pHciCoreContext.tHciCtxSendMsgParams),pSendMsgParams,sizeof(phHciNfc_SendParams_t));
/* Check whether Fragmenation is required
* If fragmentation is required fragmentation is performed in phHciNfcLowerLayerSendCb callback
* which is invoked by NCI after transmission of first packet here
*/
if( pSendMsgParams->dwLen <= ( PHHCI_HCI_MAX_PACKET_PAYLOAD_SIZE ) )
{
wStatus = phHciNfc_HciCoreBuildHcipacket(pSendMsgParams,
HCP_CHAINBIT_UN_CHAINED,
pSendMsgParams->dwLen,
&dwTotalLenOfBuiltPkt,
pBuiltHciPkt);
pHciContext->pHciCoreContext.tHciFragInfo.dwTxdHcpPayloadNoOfDataBytes = pSendMsgParams->dwLen;
}else
{
/* The HCI packets needs to be fragmented, send the First HCI packet and start
* HCI Fragmenation in the Send Call Back(after sucessfull transmission by lower layer)
*/
wStatus = phHciNfc_HciCoreBuildHcipacket(pSendMsgParams,
HCP_CHAINBIT_CHAINED,
PHHCI_HCI_MAX_PACKET_PAYLOAD_SIZE,
&dwTotalLenOfBuiltPkt,
pBuiltHciPkt);
pHciContext->pHciCoreContext.tHciFragInfo.dwTxdHcpPayloadNoOfDataBytes =
PHHCI_HCI_MAX_PACKET_PAYLOAD_SIZE;
}
/* Send the HCI packet to lower layer */
if( wStatus == NFCSTATUS_SUCCESS )
{
tSendData.length = dwTotalLenOfBuiltPkt;
tSendData.buffer = pBuiltHciPkt;
wStatus = phNciNfc_SeSendData(pHciContext->pNciContext,
pHciContext->pSeHandle,
(pphNciNfc_IfNotificationCb_t)&phHciNfc_HciCoreLowerLayerSendCb,
pHciContext,
&tSendData);
if(wStatus == NFCSTATUS_PENDING)
{
/* Store Send Call back, Uppler Layer Context in Hci context */
pHciContext->pHciCoreContext.phHciNfcCoreUpperLayerSendCb = phHciNfcUpperLayerSendCb;
pHciContext->pHciCoreContext.pUpperLayerContext = pContext;
PH_LOG_LIBNFC_CRIT_STR(" HCP Packet Sent to NCI ");
}
else
{
PH_LOG_LIBNFC_CRIT_STR(" Failed to send HCP to Lower ");
}
}
else
{
PH_LOG_LIBNFC_CRIT_STR(" HCI packet Formation Failed ");
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
phOsalNfc_FreeMemory(pBuiltHciPkt);
}
}
return wStatus;
}
static void phFriNfc_MfUL_H_fillSendBuf( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t BlockNo)
{
uint8_t NDEFTLV1[4] = {0x01, 0x03, 0xA0, 0x10};
uint8_t NDEFTLV2[4] = {0x44, 0x03, 0x00, 0xFE};
uint8_t NDEFTLV[4] = {0x03, 0x00, 0xFE, 0x00};
PH_LOG_NDEF_FUNC_ENTRY();
/* First byte for send buffer is always the block number */
NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_0] = (uint8_t)BlockNo;
switch(NdefSmtCrdFmt->State)
{
case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
*NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
*NdefSmtCrdFmt->SendRecvBuf =
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
*NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
(void)phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
(void)phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
{
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = OTP_BLOCK_NUMBER;
phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
case PH_FRINFC_MFUL_FMT_RD_16BYTES:
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
/* Send length for read command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
/* Copy the OTP bytes */
phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
case PH_FRINFC_MFUL_FMT_WR_TLV:
/* Send length for read command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
/* Copy the NDEF TLV */
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV1,
PH_FRINFC_MFUL_FMT_VAL_4);
}
else if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD)
{
phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV,
PH_FRINFC_MFUL_FMT_VAL_4);
}
else
{
}
break;
case PH_FRINFC_MFUL_FMT_WR_TLV1:
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
/* Send length for write command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
phOsalNfc_MemCopy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV2,
PH_FRINFC_MFUL_FMT_VAL_4);
}
break;
default:
break;
}
PH_LOG_NDEF_FUNC_EXIT();
}
static NFCSTATUS phLibNfc_InitSetConfig(void* pContext, NFCSTATUS status, void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphLibNfc_Context_t pCtx = (pphLibNfc_Context_t) pContext;
#ifdef NFC_LA_NFCID1
uint8_t aNfcId1[NFC_LA_NFCID1_LEN] = NFC_LA_NFCID1_VALUE;
#endif
#ifdef NFC_PB_H_INFO
uint8_t aInfo[NFC_PB_H_INFO_LEN] = NFC_PB_H_INFO_VALUE;
#endif
#ifdef NFC_PN_ATR_REQ_GEN_BYTES
uint8_t aGenBytes[NFC_NFC_PN_ATR_REQ_GEN_BYTES_LEN] = NFC_NFC_PN_ATR_REQ_GEN_BYTES_VALUE;
#endif
#ifdef NFC_LB_NFCID0
uint8_t aNfcId0[NFC_LB_NFCID0_LEN] = NFC_LB_NFCID0_VALUE;
#endif
#ifdef NFC_LB_APPLICATION_DATA
uint8_t aAppData[NFC_LB_APPLICATION_DATA_LEN] = NFC_LB_APPLICATION_DATA_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_1
uint8_t aT3TId1[NFC_LF_T3T_IDENTIFIERS_1_LEN] = NFC_LF_T3T_IDENTIFIERS_1_VALUE;
uint8_t bT3tId1Len = (uint8_t) NFC_LF_T3T_IDENTIFIERS_1_LEN;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_2
uint8_t aT3TId2[NFC_LF_T3T_IDENTIFIERS_2_LEN] = NFC_LF_T3T_IDENTIFIERS_2_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_3
uint8_t aT3TId3[NFC_LF_T3T_IDENTIFIERS_3_LEN] = NFC_LF_T3T_IDENTIFIERS_3_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_4
uint8_t aT3TId4[NFC_LF_T3T_IDENTIFIERS_4_LEN] = NFC_LF_T3T_IDENTIFIERS_4_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_5
uint8_t aT3TId5[NFC_LF_T3T_IDENTIFIERS_15_LEN] = NFC_LF_T3T_IDENTIFIERS_5_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_6
uint8_t aT3TId6[NFC_LF_T3T_IDENTIFIERS_6_LEN] = NFC_LF_T3T_IDENTIFIERS_6_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_7
uint8_t aT3TId7[NFC_LF_T3T_IDENTIFIERS_7_LEN] = NFC_LF_T3T_IDENTIFIERS_7_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_8
uint8_t aT3TId8[NFC_LF_T3T_IDENTIFIERS_8_LEN] = NFC_LF_T3T_IDENTIFIERS_8_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_9
uint8_t aT3TId9[NFC_LF_T3T_IDENTIFIERS_9_LEN] = NFC_LF_T3T_IDENTIFIERS_9_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_10
uint8_t aT3TId10[NFC_LF_T3T_IDENTIFIERS_10_LEN] = NFC_LF_T3T_IDENTIFIERS_10_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_11
uint8_t aT3TId11[NFC_LF_T3T_IDENTIFIERS_11_LEN] = NFC_LF_T3T_IDENTIFIERS_11_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_12
uint8_t aT3TId12[NFC_LF_T3T_IDENTIFIERS_12_LEN] = NFC_LF_T3T_IDENTIFIERS_12_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_13
uint8_t aT3TId13[NFC_LF_T3T_IDENTIFIERS_13_LEN] = NFC_LF_T3T_IDENTIFIERS_13_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_14
uint8_t aT3TId14[NFC_LF_T3T_IDENTIFIERS_14_LEN] = NFC_LF_T3T_IDENTIFIERS_14_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_15
uint8_t aT3TId15[NFC_LF_T3T_IDENTIFIERS_15_LEN] = NFC_LF_T3T_IDENTIFIERS_15_VALUE;
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_16
uint8_t aT3TId16[NFC_LF_T3T_IDENTIFIERS_16_LEN] = NFC_LF_T3T_IDENTIFIERS_16_VALUE;
#endif
#ifdef NFC_LF_T3T_PMM
uint8_t aT3TPmm[NFC_LF_T3T_PMM_LEN] = NFC_LF_T3T_PMM_VALUE;
#endif
phNciNfc_RfDiscConfigParams_t ConfigParams = {0};
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
PH_LOG_LIBNFC_FUNC_ENTRY();
ConfigParams.tConfigInfo.CommonConfig = 1;
ConfigParams.tCommonDiscParams.ComnParamsConfig.Config.SetRfFieldInfo = 1;
#if PH_LIBNFC_ENABLE_RFFIELD_INFO_NTF
ConfigParams.tCommonDiscParams.bRfFieldInfo = 1;
#else
ConfigParams.tCommonDiscParams.bRfFieldInfo = 0;
#endif
#if PH_LIBNFC_ENABLE_RF_NFCEE_ACTION_NTF
ConfigParams.tConfigInfo.CommonConfig = 1;
ConfigParams.tCommonDiscParams.ComnParamsConfig.Config.SetRfNfceeAction = 1;
ConfigParams.tCommonDiscParams.bRfNfceeAction = (uint8_t)pCtx->Config.bNfceeActionNtf;
#endif
#if PH_LIBNFC_ENABLE_NFCDEP_RTOX
ConfigParams.tConfigInfo.CommonConfig = 1;
ConfigParams.tCommonDiscParams.ComnParamsConfig.Config.SetNfcDepOperationParam = 1;
ConfigParams.tCommonDiscParams.NfcDepOperationParam.bRtoxReq = 0;
ConfigParams.tCommonDiscParams.NfcDepOperationParam.bAttentionCommand = 1;
ConfigParams.tCommonDiscParams.NfcDepOperationParam.bInformationPdu = 1;
ConfigParams.tCommonDiscParams.NfcDepOperationParam.bUseMaxTxLen = 1;
#endif
#ifdef NFC_LA_NFCID1
ConfigParams.tConfigInfo.LstnNfcAConfig = 1;
ConfigParams.tLstnNfcADiscParams.LstnNfcAConfig.Config.SetNfcID1 = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcADiscParams.aNfcID1,\
aNfcId1,(uint32_t)NFC_LA_NFCID1_LEN);
ConfigParams.tLstnNfcADiscParams.bNfcID1Size = (uint8_t)NFC_LA_NFCID1_LEN;
#endif
#ifdef NFC_PB_H_INFO
if(NFC_PB_H_INFO_LEN <= PH_NCINFC_MAX_HIGHER_LAYER_INF_LEN)
{
ConfigParams.tConfigInfo.PollIsoDepConfig = 1;
ConfigParams.tPollIsoDepDiscParams.PollIsoDepConfig.Config.SetHigherLayerInfo = 1;
phOsalNfc_MemCopy(ConfigParams.tPollIsoDepDiscParams.aHigherLayerInfo,\
aInfo,(uint32_t)NFC_PB_H_INFO_LEN);
ConfigParams.tPollIsoDepDiscParams.bHigherLayerInfoSize = (uint8_t)NFC_PB_H_INFO_LEN;
}
#endif
#ifdef NFC_PN_ATR_REQ_GEN_BYTES
if(NFC_NFC_PN_ATR_REQ_GEN_BYTES_LEN <= PH_NCINFC_MAX_ATR_REQ_GEN_BYTES_LEN)
{
ConfigParams.tConfigInfo.PollNfcDepConfig = 1;
ConfigParams.tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetGenBytes = 1;
phOsalNfc_MemCopy(ConfigParams.tPollNfcDepDiscParams.aAtrReqGenBytes,\
aGenBytes,(uint32_t)NFC_NFC_PN_ATR_REQ_GEN_BYTES_LEN);
ConfigParams.tPollNfcDepDiscParams.bAtrReqGeneBytesSize = (uint8_t)NFC_NFC_PN_ATR_REQ_GEN_BYTES_LEN;
}
#endif
#ifdef NFC_LB_NFCID0
if(NFC_LB_NFCID0_LEN <= PH_NCINFC_MAX_NFCID0_LEN)
{
ConfigParams.tConfigInfo.LstnNfcBConfig = 1;
ConfigParams.tLstnNfcBDiscParams.LstnNfcBConfig.Config.SetNfcID0 = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcBDiscParams.aNfcID0,\
aNfcId0,(uint32_t)NFC_LB_NFCID0_LEN);
ConfigParams.tLstnNfcBDiscParams.bNfcID0Size = (uint8_t)NFC_LB_NFCID0_LEN;
}
#endif
#ifdef NFC_LB_APPLICATION_DATA
if(NFC_LB_APPLICATION_DATA_LEN <= PH_NCINFC_APP_DATA_LEN)
{
ConfigParams.tConfigInfo.LstnNfcBConfig = 1;
ConfigParams.tLstnNfcBDiscParams.LstnNfcBConfig.Config.SetAppData = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcBDiscParams.aAppData,\
aAppData,(uint32_t)NFC_LB_APPLICATION_DATA_LEN);
}
#endif
#ifdef NFC_LF_T3T_IDENTIFIERS_1
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 1)
{
if(bT3tId1Len == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[0],\
aT3TId1,(uint32_t)NFC_LF_T3T_IDENTIFIERS_1_LEN);
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tFlags = 1;
ConfigParams.tLstnNfcFDiscParams.wT3tFlags |= 1;
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_1 */
#ifdef NFC_LF_T3T_IDENTIFIERS_2
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 2)
{
if(NFC_LF_T3T_IDENTIFIERS_2_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[1],\
aT3TId2,(uint32_t)NFC_LF_T3T_IDENTIFIERS_2_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_2 */
#ifdef NFC_LF_T3T_IDENTIFIERS_3
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 3)
{
if(NFC_LF_T3T_IDENTIFIERS_3_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[2],\
aT3TId3,(uint32_t)NFC_LF_T3T_IDENTIFIERS_3_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_3 */
#ifdef NFC_LF_T3T_IDENTIFIERS_4
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 4)
{
if(NFC_LF_T3T_IDENTIFIERS_4_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[3],\
aT3TId4,(uint32_t)NFC_LF_T3T_IDENTIFIERS_4_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_4 */
#ifdef NFC_LF_T3T_IDENTIFIERS_5
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 5)
{
if(NFC_LF_T3T_IDENTIFIERS_5_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[4],\
aT3TId5,(uint32_t)NFC_LF_T3T_IDENTIFIERS_5_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_5 */
#ifdef NFC_LF_T3T_IDENTIFIERS_6
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 6)
{
if(NFC_LF_T3T_IDENTIFIERS_6_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[5],\
aT3TId6,(uint32_t)NFC_LF_T3T_IDENTIFIERS_6_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_6 */
#ifdef NFC_LF_T3T_IDENTIFIERS_7
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 7)
{
if(NFC_LF_T3T_IDENTIFIERS_7_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[6],\
aT3TId7,(uint32_t)NFC_LF_T3T_IDENTIFIERS_7_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_7 */
#ifdef NFC_LF_T3T_IDENTIFIERS_8
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 8)
{
if(NFC_LF_T3T_IDENTIFIERS_8_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[7],\
aT3TId8,(uint32_t)NFC_LF_T3T_IDENTIFIERS_8_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_8 */
#ifdef NFC_LF_T3T_IDENTIFIERS_9
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 9)
{
if(NFC_LF_T3T_IDENTIFIERS_9_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[8],\
aT3TId9,(uint32_t)NFC_LF_T3T_IDENTIFIERS_9_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_9 */
#ifdef NFC_LF_T3T_IDENTIFIERS_10
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 10)
{
if(NFC_LF_T3T_IDENTIFIERS_10_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[9],\
aT3TId10,(uint32_t)NFC_LF_T3T_IDENTIFIERS_10_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_10 */
#ifdef NFC_LF_T3T_IDENTIFIERS_11
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 11)
{
if(NFC_LF_T3T_IDENTIFIERS_11_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[10],\
aT3TId11,(uint32_t)NFC_LF_T3T_IDENTIFIERS_11_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_11 */
#ifdef NFC_LF_T3T_IDENTIFIERS_12
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 12)
{
if(NFC_LF_T3T_IDENTIFIERS_12_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[11],\
aT3TId12,(uint32_t)NFC_LF_T3T_IDENTIFIERS_12_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_12 */
#ifdef NFC_LF_T3T_IDENTIFIERS_13
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 13)
{
if(NFC_LF_T3T_IDENTIFIERS_13_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[12],\
aT3TId13,(uint32_t)NFC_LF_T3T_IDENTIFIERS_13_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_13 */
#ifdef NFC_LF_T3T_IDENTIFIERS_14
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 14)
{
if(NFC_LF_T3T_IDENTIFIERS_14_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[13],\
aT3TId14,(uint32_t)NFC_LF_T3T_IDENTIFIERS_14_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_14 */
#ifdef NFC_LF_T3T_IDENTIFIERS_15
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 15)
{
if(NFC_LF_T3T_IDENTIFIERS_15_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[14],\
aT3TId15,(uint32_t)NFC_LF_T3T_IDENTIFIERS_15_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_15 */
#ifdef NFC_LF_T3T_IDENTIFIERS_16
if(pCtx->bT3tMax <= PH_NCINFC_MAX_NUM_T3T_IDS)
{
if(pCtx->bT3tMax >= 16)
{
if(NFC_LF_T3T_IDENTIFIERS_16_LEN == PH_NCINFC_T3TID_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tId = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tId[15],\
aT3TId16,(uint32_t)NFC_LF_T3T_IDENTIFIERS_16_LEN);
}
}
}
#endif /* NFC_LF_T3T_IDENTIFIERS_16 */
#ifdef NFC_LF_T3T_PMM
if(NFC_LF_T3T_PMM_LEN == PH_NCINFC_T3TPMM_LEN)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tPmm = 1;
phOsalNfc_MemCopy(ConfigParams.tLstnNfcFDiscParams.aT3tPmm,\
aT3TPmm,(uint32_t)NFC_LF_T3T_PMM_LEN);
}
#endif
#ifdef NFC_LF_T3T_FLAGS
if(NFC_LF_T3T_FLAGS_LEN == 0x02)
{
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetT3tFlags = 1;
ConfigParams.tLstnNfcFDiscParams.wT3tFlags = NFC_LF_T3T_FLAGS_VALUE;
}
#endif
#ifdef NFC_PB_AFI
ConfigParams.tConfigInfo.PollNfcBConfig = 1;
ConfigParams.tPollNfcBDiscParams.PollNfcBConfig.Config.SetAfi = 1;
ConfigParams.tPollNfcBDiscParams.bAfi = (uint8_t)NFC_PB_AFI;
#endif
/* Poll Iso-Dep bit rate configuration */
#ifdef NFC_PI_BIT_RATE
ConfigParams.tConfigInfo.PollIsoDepConfig = 1;
ConfigParams.tPollIsoDepDiscParams.PollIsoDepConfig.Config.SetBitRate = 1;
ConfigParams.tPollIsoDepDiscParams.bBitRate = (uint8_t)NFC_PI_BIT_RATE_SPEED;
#endif
/* Poll Nfc-Dep Data exchange bit rate configuration
(0-Use max bit rate supported during data exchange
1-use the same bit rate used during activation) */
#ifdef NFC_PN_NFC_DEP_SPEED
ConfigParams.tConfigInfo.PollNfcDepConfig = 1;
ConfigParams.tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetSpeed = 1;
ConfigParams.tPollNfcDepDiscParams.bNfcDepSpeed = (uint8_t)NFC_PN_NFC_DEP_SPEED_VALUE;
#endif
#ifdef NFC_PN_ATR_REQ_CONFIG
ConfigParams.tConfigInfo.PollNfcDepConfig = 1;
ConfigParams.tPollNfcDepDiscParams.PollNfcDepConfig.Config.bSetAtrConfig = 1;
ConfigParams.tPollNfcDepDiscParams.AtrReqConfig.bDid = NFC_PN_ATR_REQ_DID;
ConfigParams.tPollNfcDepDiscParams.AtrReqConfig.bLr = NFC_PN_ATR_REQ_LR;
#endif
#ifdef NFC_LA_BIT_FRAME_SDD
ConfigParams.tConfigInfo.LstnNfcAConfig = 1;
ConfigParams.tLstnNfcADiscParams.LstnNfcAConfig.Config.SetBitFrameSdd = 1;
ConfigParams.tLstnNfcADiscParams.bBitFrameSDD = (uint8_t)NFC_LA_BIT_FRAME_SDD;
#endif
#ifdef NFC_LA_PLATFORM_CONFIG
ConfigParams.tConfigInfo.LstnNfcAConfig = 1;
ConfigParams.tLstnNfcADiscParams.LstnNfcAConfig.Config.SetPlatformConfig = 1;
ConfigParams.tLstnNfcADiscParams.bPlatformConfig = (uint8_t)NFC_LA_PLATFORM_CONFIG;
#endif
#ifdef NFC_LB_SENSB_INFO
ConfigParams.tConfigInfo.LstnNfcBConfig = 1;
ConfigParams.tLstnNfcBDiscParams.LstnNfcBConfig.Config.SetSensBInfo = 1;
ConfigParams.tLstnNfcBDiscParams.SensBInfo = (uint8_t)NFC_LB_SENSB_INFO;
#endif
#ifdef NFC_LB_SFGI
ConfigParams.tConfigInfo.LstnNfcBConfig = 1;
ConfigParams.tLstnNfcBDiscParams.LstnNfcBConfig.Config.SetSfgi = 1;
ConfigParams.tLstnNfcBDiscParams.bSfgi = (uint8_t)NFC_LB_SFGI;
#endif
#ifdef NFC_LB_ADC_FO
ConfigParams.tConfigInfo.LstnNfcBConfig = 1;
ConfigParams.tLstnNfcBDiscParams.LstnNfcBConfig.Config.SetAdcFo = 1;
ConfigParams.tLstnNfcBDiscParams.AdcFo.bDid = 1;
ConfigParams.tLstnNfcBDiscParams.AdcFo.bAdcCodingField = 0x01;
#endif
#ifdef NFC_LF_CON_BITR_F
ConfigParams.tConfigInfo.LstnNfcFConfig = 1;
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetConfigBitRate = 1;
switch(NFC_LISTEN_F_BITRATE_SEL)
{
case BITRATE_LISTEN_F_212:
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn212kbps = 1;
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn424kbps = 0;
break;
case BITRATE_LISTEN_F_424:
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn212kbps = 0;
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn424kbps = 1;
break;
case BITRATE_LISTEN_F_212_424:
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn212kbps = 1;
ConfigParams.tLstnNfcFDiscParams.ConfigBitRate.bLstn424kbps = 1;
break;
default:
/* Invalid bitrate selected */
ConfigParams.tLstnNfcFDiscParams.LstnNfcFConfig.Config.SetConfigBitRate = 0;
break;
}
#endif
#ifdef NFC_LI_FWI
ConfigParams.tConfigInfo.LstnIsoDepConfig = 1;
ConfigParams.tLstnIsoDepDiscParams.LstnIsoDepConfig.Config.SetFwt = 1;
ConfigParams.tLstnIsoDepDiscParams.bFrameWaitingTime = (uint8_t)NFC_LI_FWI;
#endif
#ifdef NFC_LI_BIT_RATE
ConfigParams.tConfigInfo.LstnIsoDepConfig = 1;
ConfigParams.tLstnIsoDepDiscParams.LstnIsoDepConfig.Config.SetbBitRate = 1;
ConfigParams.tLstnIsoDepDiscParams.bBitRate = (uint8_t)NFC_LI_BIT_RATE_SPEED;
#endif
#ifdef NFC_LN_WT
ConfigParams.tConfigInfo.LstnNfcDepConfig = 1;
ConfigParams.tLstnNfcDepDiscParams.LstnNfcDepConfig.Config.bSetWT = 1;
ConfigParams.tLstnNfcDepDiscParams.bWaitingTime = (uint8_t)NFC_LN_WT;
#endif
wStatus = phNciNfc_SetConfigRfParameters(pCtx->sHwReference.pNciHandle,
&ConfigParams,
(pphNciNfc_IfNotificationCb_t)&phLibNfc_InternalSequence,
pContext);
PH_LOG_LIBNFC_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_NfcDepLstnRdrAInit(
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff = NULL;
uint8_t RfTechSpecParamsLen = 0;
uint8_t ActvnParamsLen = 0;
PH_LOG_NCI_FUNC_ENTRY();
if((0 != (wLen)) && (NULL != pBuff) && (NULL != pRemDevInf))
{
/* No Technology specific parameters incase of Listen A as per NCI Spec */
RfTechSpecParamsLen = pBuff[6];
/* Shift the buffer pointer points to first parameter of technology specific parameters */
pRfNtfBuff = &pBuff[7];
/* The activated remote device is a P2P Initiator */
(pRemDevInf->RemDevType) = phNciNfc_eNfcIP1_Initiator;
/* NOTE: NO TECHNOLOGY SPECIFIC PARAMETERS ARE DEFINED FOR LISTEN NFC-A TECHN (as per Nci Spec Rev.21) */
/* Initiator speed (Initiator to target speed) */
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Datarate = (phNciNfc_BitRates_t)pRemDevInf->bTransBitRate;
switch(pRemDevInf->eRFTechMode)
{
case phNciNfc_NFCA_Active_Listen:
case phNciNfc_NFCF_Active_Listen:
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Active = 1; /* Active communciation */
break;
default:
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Active = 0; /* Passive communciation */
break;
}
/* Obtain the length of Activation parameters from pBuff */
ActvnParamsLen = pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN];
/* Holds ATR_RES if remote device is a P2P target and ATR_REQ if remote device is a
P2P initiator */
if(0 != ActvnParamsLen)
{
pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length = (ActvnParamsLen-1);
pRfNtfBuff = &(pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN+2]);
phOsalNfc_SetMemory(pRemDevInf->tRemoteDevInfo.NfcIP_Info.aAtrInfo,0,
PH_NCINFCTYPES_ATR_MAX_LEN);
if(pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length <= PH_NCINFCTYPES_ATR_MAX_LEN)
{
phOsalNfc_MemCopy(pRemDevInf->tRemoteDevInfo.NfcIP_Info.aAtrInfo,
pRfNtfBuff,pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length);
}
else
{
pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length = 0;
PH_LOG_NCI_CRIT_STR("Invalid ATR_INFO length");
status = NFCSTATUS_FAILED;
}
}
/* The Activated device is a P2P Initiator. The P2P 'Send' and 'Receive' functions shall be active.
The P2P Target (i.e., us) is expected to receive data from remote P2P initiator and expected
to send data to Remote P2P target in response */
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Params..");
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
NFCSTATUS
phNciNfc_RdrBInit(
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff;
uint8_t RfTechSpecParamsLen;
uint8_t ActvnParamsLen = 0;
uint8_t bSensBRespLen = 0;
uint8_t bSensBRespVal;
phNciNfc_RFDevType_t DevType = phNciNfc_eInvalid_DevType;
PH_LOG_NCI_FUNC_ENTRY();
if((0 != (wLen)) && (NULL != pBuff) && (NULL != pRemDevInf))
{
/* Capture Poll mode specific params info */
if(phNciNfc_NFCB_Poll == pBuff[3])
{
PH_LOG_NCI_INFO_STR(" NFC-B Passive Poll Mode Info being captured..");
bSensBRespLen = pBuff[7];
(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.bSensBRespLen) = bSensBRespLen;
if((0 != bSensBRespLen) && ((11 == bSensBRespLen) || (12 == bSensBRespLen)))
{
phOsalNfc_SetMemory((pRemDevInf->tRemoteDevInfo.Iso14443B_Info.aSensBResp),0,bSensBRespLen);
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.aSensBResp)
,&pBuff[8],bSensBRespLen);
/* Update the actual type of target device */
bSensBRespVal = (pRemDevInf->tRemoteDevInfo.Iso14443B_Info.aSensBResp[9]);
phNciNfc_GetRfDevType(bSensBRespVal,bSensBRespLen,pRemDevInf,&DevType);
(pRemDevInf->RemDevType) = DevType;
switch((pRemDevInf->RemDevType))
{
case phNciNfc_eISO14443_4B_PICC:
{
if(phNciNfc_e_RfInterfacesISODEP_RF == (pRemDevInf->eRfIf))
{
/* Obtain the length of Activation parameters from pBuff */
RfTechSpecParamsLen = pBuff[6];
ActvnParamsLen = pBuff[7+RfTechSpecParamsLen+DATA_XCHG_PARAMS_LEN];
if(0 != ActvnParamsLen)
{
pRfNtfBuff = &(pBuff[ActvnParamsLen+1]);
(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.bAttribRespLen) = *pRfNtfBuff;
if(0 != (pRemDevInf->tRemoteDevInfo.Iso14443B_Info.bAttribRespLen))
{
phOsalNfc_SetMemory(&(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.tAttribResp),0,
sizeof(phNciNfc_ATTRIBResp_t));
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.tAttribResp),
(pRfNtfBuff+1),(pRemDevInf->tRemoteDevInfo.Iso14443B_Info.bAttribRespLen));
}
}
}
else
{
/* TODO:- RF Frame interface case,no activation parameters available for 4B Tag */
}
gpphNciNfc_RdrDataXchgSequence[0].SequnceInitiate = &phNciNfc_Send4BData;
gpphNciNfc_RdrDataXchgSequence[0].SequenceProcess = &phNciNfc_Recv4BResp;
break;
}
case phNciNfc_eISO14443_BPrime_PICC:
{
break;
}
default:
{
break;
}
}
/* Update gpphNciNfc_RdrDataXchgSequence with the appropriate functions to be called
by sequence handler on invocation during data exchange */
gpphNciNfc_RdrDataXchgSequence[1].SequnceInitiate = NULL;
gpphNciNfc_RdrDataXchgSequence[1].SequenceProcess = &phNciNfc_CompleteDataXchgSequence;
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_FAILED);
PH_LOG_NCI_INFO_STR(" Invalid SENSB_RES Length received..");
}
}
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Params..");
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
void phFriNfc_MfUL_Process(void *Context,
NFCSTATUS Status)
{
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt = (phFriNfc_sNdefSmtCrdFmt_t *)Context;
PH_LOG_NDEF_FUNC_ENTRY();
if(Status == NFCSTATUS_SUCCESS)
{
switch(NdefSmtCrdFmt->State)
{
case PH_FRINFC_MFUL_FMT_RD_16BYTES:
Status = phFriNfc_MfUL_H_ProRd16Bytes(NdefSmtCrdFmt);
break;
case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
Status = phFriNfc_MfUL_H_ProWrOTPBytes(NdefSmtCrdFmt);
break;
case PH_FRINFC_MFUL_FMT_WR_TLV:
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
/* Write NDEF TLV in block number 5 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_5;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV1;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
break;
case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
uint8_t otp_lock_page_size = 0;
uint8_t i = 0;
otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes);
(void)phOsalNfc_MemCopy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
(void *)NdefSmtCrdFmt->SendRecvBuf,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2]
| MIFARE_UL_LOCK_BYTE1_VALUE);
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = MIFARE_UL_LOCK_BYTE2_VALUE;
i = (uint8_t)(i + otp_lock_page_size);
otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes);
phOsalNfc_MemCopy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
(void *)(NdefSmtCrdFmt->SendRecvBuf + i),
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[(otp_lock_page_size - 1)] =
READ_ONLY_VALUE_IN_OTP;
switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
{
case TYPE_2_STATIC_MEM_SIZE_VALUE:
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
{
NdefSmtCrdFmt->State =
PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES;
/* Start reading from block 4 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 4;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
default:
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
{
switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
{
case TYPE_2_STATIC_MEM_SIZE_VALUE:
case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
default:
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
Status = phFriNfc_MfUL_ParseTLVs (NdefSmtCrdFmt,
NdefSmtCrdFmt->SendRecvBuf,
(uint8_t)*NdefSmtCrdFmt->SendRecvLength);
if (!Status)
{
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
NdefSmtCrdFmt->AddInfo.Type2Info.LockBlockNumber;
Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
}
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
(void)phOsalNfc_MemCopy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.ReadData,
(void *)NdefSmtCrdFmt->SendRecvBuf,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.ReadData));
NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = 0;
Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
{
NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex +
MFUL_BLOCK_SIZE_IN_BYTES);
if (!phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt))
{
/* There is no lock bits to write, then write OTP bytes */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
else if ((NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex <
MIFARE_UL_READ_MAX_SIZE)
&& (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)))
{
/* If remaining lock bits has to be written and the data is already read */
Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
}
else
{
/* Increment current block by 4 because if a data is read then 16
bytes will be given which is 4 blocks */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock + 4);
Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
{
/* Do nothing */
break;
}
case PH_FRINFC_MFUL_FMT_WR_TLV1:
break;
default:
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
/* Status is not success then call completion routine */
if(Status != NFCSTATUS_PENDING)
{
phFriNfc_SmtCrdFmt_HCrHandler(NdefSmtCrdFmt, Status);
}
PH_LOG_NDEF_FUNC_EXIT();
}
NFCSTATUS
phNciNfc_NfcDepLstnRdrFInit(
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff;
uint8_t RfTechSpecParamsLen;
uint8_t bNfcId2Len;
uint8_t ActvnParamsLen = 0;
PH_LOG_NCI_FUNC_ENTRY();
if( (0 != (wLen)) && (NULL != pBuff) && (NULL != pRemDevInf))
{
/* Remote devuce is a P2P Initiator */
pRemDevInf->RemDevType = phNciNfc_eNfcIP1_Initiator;
/* Obtain the len of RF tech specific parameters from Resp buff */
RfTechSpecParamsLen = pBuff[6]; /*TODO: Check should added for this*/
pRfNtfBuff = &pBuff[7];
bNfcId2Len = *(pRfNtfBuff);
pRemDevInf->tRemoteDevInfo.NfcIP_Info.NFCID_Length = 0;
if(0 != RfTechSpecParamsLen)
{
pRemDevInf->tRemoteDevInfo.NfcIP_Info.NFCID_Length = bNfcId2Len;
phOsalNfc_SetMemory(pRemDevInf->tRemoteDevInfo.NfcIP_Info.NFCID,0,PH_NCINFCTYPES_MAX_NFCID3_SIZE);
if(0 == bNfcId2Len)
{
PH_LOG_NCI_CRIT_STR("No NFCID2 received");
}
else if(PH_NCINFCTYPES_NFCID2_LEN == bNfcId2Len)
{
phOsalNfc_SetMemory(pRemDevInf->tRemoteDevInfo.NfcIP_Info.NFCID,0,PH_NCINFCTYPES_MAX_NFCID3_SIZE);
phOsalNfc_MemCopy(pRemDevInf->tRemoteDevInfo.NfcIP_Info.NFCID,(pRfNtfBuff+1),bNfcId2Len);
}
else
{
status = NFCSTATUS_FAILED;
PH_LOG_NCI_CRIT_STR("Invalid NFCID2 received");
}
}
if(NFCSTATUS_SUCCESS == status)
{
/* Initiator speed (Initiator to target speed) */
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Datarate = (phNciNfc_BitRates_t)pRemDevInf->bTransBitRate;
switch(pRemDevInf->eRFTechMode)
{
case phNciNfc_NFCA_Active_Listen:
case phNciNfc_NFCF_Active_Listen:
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Active = 1; /* Active communciation */
break;
default:
pRemDevInf->tRemoteDevInfo.NfcIP_Info.Nfcip_Active = 0; /* Passive communciation */
break;
}
/* Obtain the length of Activation parameters from pBuff */
ActvnParamsLen = pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN];
if(0 != ActvnParamsLen)
{
pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length = (ActvnParamsLen-1);
pRfNtfBuff = &(pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN+2]);
phOsalNfc_SetMemory(pRemDevInf->tRemoteDevInfo.NfcIP_Info.aAtrInfo,0,
PH_NCINFCTYPES_ATR_MAX_LEN);
if(pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length <= PH_NCINFCTYPES_ATR_MAX_LEN)
{
phOsalNfc_MemCopy(pRemDevInf->tRemoteDevInfo.NfcIP_Info.aAtrInfo,
pRfNtfBuff,pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length);
}
else
{
pRemDevInf->tRemoteDevInfo.NfcIP_Info.bATRInfo_Length = 0;
PH_LOG_NCI_CRIT_STR("Invalid ATR_INFO length");
status = NFCSTATUS_FAILED;
}
}
/* The Activated device is a P2P Initiator. The P2P 'Send' and 'Receive' functions shall be active.
The P2P Target (i.e., us) is expected to receive data from remote P2P initiator and expected
to send data to Remote P2P target in response */
}
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Params..");
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
NFCSTATUS
phNciNfc_RdrAInit(
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff = NULL;
uint8_t RfTechSpecParamsLen = 0;
uint8_t ActvnParamsLen = 0;
uint8_t bSelResRespLen = 0;
uint8_t bUidLength = 0;
uint8_t bSelRespVal = 0;
phNciNfc_RFDevType_t eDevType = phNciNfc_eInvalid_DevType;
PH_LOG_NCI_FUNC_ENTRY();
if((0 != (wLen)) && (NULL != pBuff) && (NULL != pRemDevInf))
{
PH_LOG_NCI_INFO_STR(" NFC-A Passive Poll Mode Info being captured..");
/* Length of technology specific parameters */
RfTechSpecParamsLen = pBuff[6];
/* Shift the buffer pointer points to first parameter of technology specific parameters */
pRfNtfBuff = &pBuff[7];
/* Get technology specific parameters incase of Nfc-A poll mode */
if (phNciNfc_NFCA_Kovio_Poll == pRemDevInf->eRFTechMode)
{
if (RfTechSpecParamsLen > PH_NCINFCTYPES_KOVIO_TAG_ID_LENGTH)
{
status = NFCSTATUS_FAILED;
}
}
else if(phNciNfc_NFCA_Listen != pRemDevInf->eRFTechMode)
{
/* Length of NFCID1 */
bUidLength = *(pRfNtfBuff+2);
if((0 != bUidLength) &&
(NFCID1_LEN4 != bUidLength) &&
(NFCID1_LEN7 != bUidLength) &&
(NFCID1_LEN10 != bUidLength))
{
PH_LOG_NCI_CRIT_STR("Invalid Nfc-A UID length");
status = NFCSTATUS_FAILED;
}
if(NFCSTATUS_SUCCESS == status)
{
/* Length of SEL_RES response */
bSelResRespLen = *(pRfNtfBuff + 3 + bUidLength);
if(1 == bSelResRespLen)
{
/* Length of SEL_RES shall be '0' incase of Nfc Forum Type 1 Tag */
bSelRespVal = *(pRfNtfBuff + 3 + bUidLength + 1);
}
else if(0 == bSelResRespLen)
{
bSelRespVal = 0;
}
else
{
PH_LOG_NCI_CRIT_STR("Invalid Nfc-A SEL_RES length");
status = NFCSTATUS_FAILED;
}
}
}
if(NFCSTATUS_SUCCESS == status)
{
phNciNfc_GetRfDevType(bSelRespVal,bSelResRespLen,pRemDevInf,&eDevType);
(pRemDevInf->RemDevType) = eDevType;
}
else
{
pRemDevInf->RemDevType = phNciNfc_eInvalid_DevType;
}
/*Update technology specific parameters (these parameters are specific to the remote device type detected)*/
switch((pRemDevInf->RemDevType))
{
case phNciNfc_eISO14443_4A_PICC:
case phNciNfc_eMifareUL_PICC:
case phNciNfc_eMifare1k_PICC:
case phNciNfc_eMifare4k_PICC:
case phNciNfc_eMifareMini_PICC:
{
if(0 != bUidLength)
{
(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.UidLength) = bUidLength;
(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bSelResRespLen) = bSelResRespLen;
(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.Sak) = bSelRespVal;
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bSensResResp),pRfNtfBuff,2);
phOsalNfc_SetMemory((pRemDevInf->tRemoteDevInfo.Iso14443A_Info.Uid),0,PH_NCINFCTYPES_MAX_UID_LENGTH);
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.Uid),
(pRfNtfBuff+3),(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.UidLength));
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid UID Length received");
}
}
break;
case phNciNfc_eJewel_PICC:
{
if((0 == bUidLength) || (NFCID1_LEN4 == bUidLength))
{
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Jewel_Info.bSensResResp),pRfNtfBuff,2);
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid UID Length received");
}
}
break;
case phNciNfc_eKovio_PICC:
{
// The tag ID is all we get
if(RfTechSpecParamsLen > 0)
{
pRemDevInf->tRemoteDevInfo.Kovio_Info.TagIdLength = RfTechSpecParamsLen;
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Kovio_Info.TagId), pRfNtfBuff, RfTechSpecParamsLen);
}
}
break;
default:
{
break;
}
}
/* Update gpphNciNfc_RdrDataXchgSequence with the appropriate functions to be called
by sequence handler on invocation during data exchange */
switch(pRemDevInf->RemDevType)
{
case phNciNfc_eISO14443_A_PICC:
{
break;
}
case phNciNfc_eKovio_PICC:
{
break;
}
case phNciNfc_eISO14443_4A_PICC:
{
if(NFCSTATUS_SUCCESS == status)
{
if(phNciNfc_e_RfInterfacesISODEP_RF == (pRemDevInf->eRfIf))
{
/* Obtain the length of Activation parameters from pBuff */
ActvnParamsLen = pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN];
if(0 != ActvnParamsLen)
{
pRfNtfBuff = &(pBuff[7+RfTechSpecParamsLen+PH_NCINFCTYPES_DATA_XCHG_PARAMS_LEN+1]);
pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bRatsRespLen = *pRfNtfBuff;
if(0 != pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bRatsRespLen)
{
if(((ActvnParamsLen - 1) >= pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bRatsRespLen) &&
(sizeof(phNciNfc_RATSResp_t) >= pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bRatsRespLen))
{
phOsalNfc_MemCopy(&(pRemDevInf->tRemoteDevInfo.Iso14443A_Info.
tRatsResp),(pRfNtfBuff+1),(pRemDevInf->tRemoteDevInfo.
Iso14443A_Info.bRatsRespLen));
}
else
{
PH_LOG_NCI_CRIT_STR("Invalid RATS Resp Recvd!!, ActvnParamsLen %d, RatsRespLen %d",
ActvnParamsLen, pRemDevInf->tRemoteDevInfo.Iso14443A_Info.bRatsRespLen);
status = NFCSTATUS_FAILED;
}
}
}
}
else
{
/* TODO:- RF Frame interface case,no activation parameters available for 4A Tag */
}
gpphNciNfc_RdrDataXchgSequence[0].SequnceInitiate = &phNciNfc_Send4AData;
gpphNciNfc_RdrDataXchgSequence[0].SequenceProcess = &phNciNfc_Recv4AResp;
}
break;
}
case phNciNfc_eMifareUL_PICC:
case phNciNfc_eMifare1k_PICC:
case phNciNfc_eMifare4k_PICC:
case phNciNfc_eMifareMini_PICC:
{
if(NFCSTATUS_SUCCESS == status)
{
gpphNciNfc_RdrDataXchgSequence[0].SequnceInitiate = &phNciNfc_SendMfReq;
gpphNciNfc_RdrDataXchgSequence[0].SequenceProcess = &phNciNfc_RecvMfResp;
}
break;
}
case phNciNfc_eJewel_PICC:
{
if(NFCSTATUS_SUCCESS == status)
{
/* Validate Technology specific parameters */
status = phNciNfc_JewelInit(pRemDevInf->tRemoteDevInfo.Jewel_Info.bSensResResp);
gpphNciNfc_RdrDataXchgSequence[0].SequnceInitiate = &phNciNfc_SendJewelReq;
gpphNciNfc_RdrDataXchgSequence[0].SequenceProcess = &phNciNfc_RecvJewelResp;
}
break;
}
default:
{
break;
}
}
gpphNciNfc_RdrDataXchgSequence[1].SequnceInitiate = NULL;
gpphNciNfc_RdrDataXchgSequence[1].SequenceProcess = &phNciNfc_CompleteDataXchgSequence;
}
else
{
status = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_INFO_STR(" Invalid Params..");
}
PH_LOG_NCI_FUNC_EXIT();
#pragma prefast(suppress: __WARNING_POTENTIAL_RANGE_POSTCONDITION_VIOLATION, "ESP:1220 PreFast Bug")
return status;
}
NFCSTATUS
phNciNfc_SeSendData(void* pNciCtx,
void* pSeHandle,
pphNciNfc_IfNotificationCb_t pSendCb,
void* pContext,
phNfc_sData_t *pSendData)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNciNfc_CoreTxInfo_t TxInfo;
uint16_t wPldDataSize;
phNciNfc_Context_t* pNciContext = (phNciNfc_Context_t *)pNciCtx;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL == pNciContext) || (pNciContext != phNciNfc_GetContext()))
{
PH_LOG_NCI_CRIT_STR("Stack not initialized");
wStatus = NFCSTATUS_NOT_INITIALISED;
}
else if((NULL == pSendData) || (NULL == pSendCb))
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_CRIT_STR("Invalid input parameter!");
}
else
{
if((0 == pSendData->length) || (NULL == pSendData->buffer))
{
PH_LOG_NCI_CRIT_STR("Invalid Send buffer!");
wStatus = NFCSTATUS_FAILED;
}
else
{
/* Fill the data packet details into TxInfo */
TxInfo.tHeaderInfo.eMsgType = phNciNfc_e_NciCoreMsgTypeData;
if (!phNciNfc_IsVersion1x(pNciContext))
{
TxInfo.tHeaderInfo.bConn_ID = CONNHCITYPE_STATIC;
}
else
{
wStatus = phNciNfc_GetConnId(pSeHandle, &(TxInfo.tHeaderInfo.bConn_ID));
}
if(NFCSTATUS_SUCCESS == wStatus)
{
wPldDataSize = (uint16_t)pSendData->length;
(pNciContext->tTranscvCtxt.tSendPld.wLen) = 0;
(pNciContext->tTranscvCtxt.tSendPld.pBuff) = (uint8_t *)phOsalNfc_GetMemory(wPldDataSize);
if(NULL != (pNciContext->tTranscvCtxt.tSendPld.pBuff))
{
(pNciContext->tTranscvCtxt.tSendPld.wLen) = (wPldDataSize);
phOsalNfc_SetMemory((pNciContext->tTranscvCtxt.tSendPld.pBuff),0,
(pNciContext->tTranscvCtxt.tSendPld.wLen));
/* Copy data to be sent to the local buffer */
phOsalNfc_MemCopy((pNciContext->tTranscvCtxt.tSendPld.pBuff),
(pSendData->buffer),wPldDataSize);
TxInfo.Buff = (pNciContext->tTranscvCtxt.tSendPld.pBuff);
TxInfo.wLen = (pNciContext->tTranscvCtxt.tSendPld.wLen);
/* Send data */
wStatus = phNciNfc_CoreIfTxOnly(&(pNciContext->NciCoreContext), &TxInfo,
(pphNciNfc_CoreIfNtf_t)&phNciNfc_SeSendCb, pNciContext);
if(NFCSTATUS_PENDING == wStatus)
{
/* Store upper layer call back function and upper layer context */
phNciNfc_SetUpperLayerCallback(pNciContext, pSendCb, pContext);
}
else
{
/* Deallocate memory allcoated for send buffer */
phOsalNfc_FreeMemory(pNciContext->tTranscvCtxt.tSendPld.pBuff);
pNciContext->tTranscvCtxt.tSendPld.pBuff = NULL;
pNciContext->tTranscvCtxt.tSendPld.wLen = 0;
}
}
else
{
wStatus = NFCSTATUS_INSUFFICIENT_RESOURCES;
PH_LOG_NCI_CRIT_STR("Payload MemAlloc for Send request Failed!");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
PH_LOG_NCI_CRIT_STR(" Couldn't Get ConnId!");
}
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
