static void phHciNfc_CoreInitialiseContext(void *pContext)
{
phHciNfc_HciContext_t *pHciContext = (phHciNfc_HciContext_t *) pContext;
phHciNfc_HciCoreContext_t *pHciCoreContext = &(pHciContext->pHciCoreContext);
phOsalNfc_SetMemory(&pHciCoreContext->tHciCtxSendMsgParams,0,sizeof(phHciNfc_SendParams_t));
pHciCoreContext->phHciNfcCoreUpperLayerSendCb = NULL;
pHciCoreContext->pUpperLayerContext = NULL;
pHciCoreContext->tHciCtxRxMsgParams.bIns = 0;
pHciCoreContext->tHciCtxRxMsgParams.bMsgType = 0;
pHciCoreContext->tHciCtxRxMsgParams.bPipeId = 0;
pHciCoreContext->tHciCtxRxMsgParams.wLen = 0;
pHciCoreContext->tHciCtxRxMsgParams.pData = NULL;
pHciCoreContext->tHciFragInfo.dwTxdHcpPayloadNoOfDataBytes = 0;
phOsalNfc_SetMemory(pHciCoreContext->tReceiveInfo.ListHead.tMem.aBuffer,
0,
sizeof(pHciCoreContext->tReceiveInfo.ListHead.tMem.aBuffer)
);
pHciCoreContext->tReceiveInfo.ListHead.tMem.wLen = 0;
pHciCoreContext->tReceiveInfo.ListHead.pNext = NULL;
/* Node head shall not be deleted */
pHciCoreContext->tReceiveInfo.wNumOfNodes = 1;
pHciCoreContext->tReceiveInfo.wPayloadSize = 0;
pHciContext->tHciSeTxRxTimerInfo.dwRspTimerId = 0;
pHciContext->tHciSeTxRxTimerInfo.dwTimeOut = PHHCINFC_DEFAULT_HCI_TX_RX_TIME_OUT;
pHciContext->tHciSeTxRxTimerInfo.dwTimerStatus = 0;
phOsalNfc_SetMemory(pHciContext->aGetHciSessionId, 0xFF, sizeof(pHciContext->aGetHciSessionId));
phOsalNfc_SetMemory(pHciContext->aSEPipeList, 0x00, sizeof(phHciNfc_PipeGateInfo_t) * 3);
phOsalNfc_SetMemory(pHciContext->aUICCPipeList, 0x00, sizeof(phHciNfc_PipeGateInfo_t));
}
static
NFCSTATUS
phFriNfc_MfUL_ReadWriteLockBytes (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint8_t write_flag = FALSE;
if (/* Lock bytes starts from the beginning of the block */
(0 == ps_type2_info->LockByteNumber)
/* To make sure this is the first read */
&& (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
/* Lock bytes are greater than or equal to the block size, i.e., 4 bytes */
&& (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
>= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
{
/* Then directly write the lock bytes, dont waste time for read */
(void)phOsalNfc_SetMemory((void *)ps_type2_info->DynLockBytes, 0xFF,
sizeof (ps_type2_info->DynLockBytes));
write_flag = TRUE;
}
else if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
{
/* Read is mandatory, First read and then update the block,
because chances are there that lock byte may start in between
the block */
}
else if (/* check if remaining bytes exceeds or same as the block size */
(phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
>= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
{
/* Then directly write the lock bytes, dont waste time for read */
(void)phOsalNfc_SetMemory((void *)ps_type2_info->DynLockBytes, 0xFF,
sizeof (ps_type2_info->DynLockBytes));
write_flag = TRUE;
}
else
{
/* Read is mandatory, First read and then update the block */
}
if (write_flag)
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
else
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
return result;
}
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
phNciNfc_CoreRecvMgrRelease(pphNciNfc_CoreContext_t pCoreCtx)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pCoreCtx)
{
phOsalNfc_SetMemory(&pCoreCtx->tRspCtx, 0x00, sizeof(phNciNfc_CoreRspRegContext_t));
phOsalNfc_SetMemory(&pCoreCtx->tNtfCtx, 0x00, sizeof(phNciNfc_CoreNtfRegContext_t));
phOsalNfc_SetMemory(&pCoreCtx->tDataCtx, 0x00, sizeof(phNciNfc_CoreDataRegContext_t));
wStatus = NFCSTATUS_SUCCESS;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS phNciNfc_SendReset(void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNciNfc_CoreTxInfo_t TxInfo;
pphNciNfc_Context_t pNciContext = (pphNciNfc_Context_t)pContext;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciContext)
{
phOsalNfc_SetMemory(&TxInfo, 0x00, sizeof(phNciNfc_CoreTxInfo_t));
TxInfo.tHeaderInfo.eMsgType = phNciNfc_e_NciCoreMsgTypeCntrlCmd;
TxInfo.tHeaderInfo.Group_ID = phNciNfc_e_CoreNciCoreGid;
TxInfo.tHeaderInfo.Opcode_ID.OidType.NciCoreCmdOid = phNciNfc_e_NciCoreResetCmdOid;
TxInfo.Buff = (uint8_t *)&pNciContext->ResetInfo.ResetTypeReq;
TxInfo.wLen = 1;
wStatus = phNciNfc_CoreIfTxRx(&(pNciContext->NciCoreContext), &TxInfo,
&(pNciContext->RspBuffInfo), PHNCINFC_NCI_CMD_RSP_TIMEOUT,
(pphNciNfc_CoreIfNtf_t)&phNciNfc_GenericSequence, pContext);
}
else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
void phOsalNfc_Timer_Init(void)
{
if (gpphOsalNfc_Context != NULL)
{
phOsalNfc_SetMemory((void *)gpphOsalNfc_Context->TimerList,0,sizeof(gpphOsalNfc_Context->TimerList));
InitializeCriticalSection(&gpphOsalNfc_Context->TimerLock);
}
}
void
phFriNfc_ISO15693_FmtReset (
phFriNfc_sNdefSmtCrdFmt_t *psNdefSmtCrdFmt)
{
/* reset to ISO15693 data structure */
(void)phOsalNfc_SetMemory((void *)&(psNdefSmtCrdFmt->AddInfo.s_iso15693_info),
0x00, sizeof (phFriNfc_ISO15693_AddInfo_t));
psNdefSmtCrdFmt->FmtProcStatus = 0;
}
void
phNciNfc_CoreRecvMgrDeRegisterAll(void *pCtx)
{
pphNciNfc_CoreContext_t pCoreCtx = (pphNciNfc_CoreContext_t)pCtx;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pCoreCtx)
{
/* Clear all response call back function information */
phOsalNfc_SetMemory(&pCoreCtx->tRspCtx,'\0',sizeof(phNciNfc_CoreRspRegContext_t));
/* Clear all data call back function information */
phOsalNfc_SetMemory(&pCoreCtx->tDataCtx,'\0',sizeof(phNciNfc_CoreDataRegContext_t));
/* Clear all notification call back function information */
phOsalNfc_SetMemory(&pCoreCtx->tNtfCtx,'\0',sizeof(phNciNfc_CoreNtfRegContext_t));
PH_LOG_NCI_INFO_STR("All (Rsp/Data/Ntf) call back registrations information cleared!");
}
PH_LOG_NCI_FUNC_EXIT();
return ;
}
void
phNciNfc_LogConnMgmtDeInit()
{
if(gphNciNfc_ConnMgmtInt.tCWTimerIf.TimerStatus == 1)
{
PH_LOG_NCI_INFO_STR("Stopping Credit await timer..");
(void)phOsalNfc_Timer_Stop(gphNciNfc_ConnMgmtInt.tCWTimerIf.dwTimerId);
(void)phOsalNfc_Timer_Delete(gphNciNfc_ConnMgmtInt.tCWTimerIf.dwTimerId);
}
phOsalNfc_SetMemory(&gphNciNfc_ConnMgmtInt, 0x00, sizeof(phNciNfc_LogConnMgmt_Int_t));
}
NFCSTATUS
phNciNfc_CoreRecvMgrInit(pphNciNfc_CoreContext_t pCoreCtx)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pCoreCtx)
{
/* Initialize Response, Data and Notification call backs to NULL */
phOsalNfc_SetMemory(&pCoreCtx->tRspCtx, 0x00, sizeof(phNciNfc_CoreRspRegContext_t));
phOsalNfc_SetMemory(&pCoreCtx->tNtfCtx, 0x00, sizeof(phNciNfc_CoreNtfRegContext_t));
phOsalNfc_SetMemory(&pCoreCtx->tDataCtx, 0x00, sizeof(phNciNfc_CoreDataRegContext_t));
/*Initialise Receive Buffer*/
pCoreCtx->tReceiveInfo.ListHead.pNext = NULL;
pCoreCtx->tReceiveInfo.ListHead.tMem.wLen = 0;
pCoreCtx->tReceiveInfo.wPayloadSize = 0;
pCoreCtx->tReceiveInfo.wNumOfNodes = 1; /*By default Head is a one node*/
wStatus = NFCSTATUS_SUCCESS;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_LogConnMgmtInit()
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
PH_LOG_NCI_FUNC_ENTRY();
phOsalNfc_SetMemory(&gphNciNfc_ConnMgmtInt, 0x00, sizeof(phNciNfc_LogConnMgmt_Int_t));
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].tConn.bConnId = CONNTYPE_STATIC;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].tConn.bMaxDpldSize = 0;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].tConn.bNumCredits = 0;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bDestId = UNASSIGNED_DESTID;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bDestType = phNciNfc_e_UNKNOWN_DEST_TYPE;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bIfActive = FALSE;
gphNciNfc_ConnMgmtInt.tConnInfo.bOpenConns = 1;
PH_LOG_NCI_FUNC_EXIT();
return status;
}
static NFCSTATUS phNciNfc_Init(void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNciNfc_CoreTxInfo_t TxInfo;
pphNciNfc_Context_t pNciContext = (pphNciNfc_Context_t)pContext;
PH_LOG_NCI_FUNC_ENTRY();
phOsalNfc_SetMemory(&TxInfo, 0x00, sizeof(phNciNfc_CoreTxInfo_t));
TxInfo.tHeaderInfo.eMsgType = phNciNfc_e_NciCoreMsgTypeCntrlCmd;
TxInfo.tHeaderInfo.Group_ID = phNciNfc_e_CoreNciCoreGid;
TxInfo.tHeaderInfo.Opcode_ID.OidType.NciCoreCmdOid = phNciNfc_e_NciCoreInitCmdOid;
TxInfo.Buff = (uint8_t *)&pNciContext->tInitInfo.bExtension;
TxInfo.wLen = 0;
wStatus = phNciNfc_CoreIfTxRx(&(pNciContext->NciCoreContext),
&TxInfo,
&(pNciContext->RspBuffInfo),
PHNCINFC_NCI_INIT_RSP_TIMEOUT,
(pphNciNfc_CoreIfNtf_t)&phNciNfc_GenericSequence,
pContext);
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
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;
}
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;
}
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;
}
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_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_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_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;
}
