uint8_t phNciNfc_ValidateBitRate(phNciNfc_BitRates_t eBitRate)
{
uint8_t bStatus = 1;
PH_LOG_NCI_FUNC_ENTRY();
switch(eBitRate)
{
case phNciNfc_e_BitRate106:
case phNciNfc_e_BitRate212:
case phNciNfc_e_BitRate424:
case phNciNfc_e_BitRate848:
case phNciNfc_e_BitRate1696:
case phNciNfc_e_BitRate3392:
case phNciNfc_e_BitRate6784:
case phNciNfc_e_BitRate26:
bStatus = 0;
break;
default:
bStatus = (eBitRate >= PH_NCINFCTYPES_BIT_RATE_PROP_MIN &&
eBitRate <= PH_NCINFCTYPES_BIT_RATE_PROP_MAX) ? 0 : 1;
break;
}
PH_LOG_NCI_FUNC_EXIT();
return bStatus;
}
static NFCSTATUS phNciNfc_SeSendCb(void* pContext, void *pInfo, NFCSTATUS wStatus)
{
NFCSTATUS wStat = wStatus;
pphNciNfc_Context_t pNciContext = pContext;
UNUSED(pInfo);
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciContext)
{
if(NULL != pNciContext->tTranscvCtxt.tSendPld.pBuff)
{
PH_LOG_NCI_INFO_STR("De-allocating Send Request Payload Buffer...");
phOsalNfc_FreeMemory(pNciContext->tTranscvCtxt.tSendPld.pBuff);
pNciContext->tTranscvCtxt.tSendPld.pBuff = NULL;
pNciContext->tTranscvCtxt.tSendPld.wLen = 0;
}
phNciNfc_Notify(pNciContext, wStatus, NULL);
}
else
{
PH_LOG_NCI_CRIT_STR("Invalid context received from RecvMgrHdlr!");
}
PH_LOG_NCI_FUNC_EXIT();
return wStat;
}
NFCSTATUS
phNciNfc_UpdateConnInfo(
uint8_t bDestId,
phNciNfc_DestType_t tDestType,
uint8_t bConnId,
uint8_t bInitialCredits,
uint8_t bMaxDpldSize
)
{
NFCSTATUS status = NFCSTATUS_FAILED;
uint8_t ConnIdx;
PH_LOG_NCI_FUNC_ENTRY();
for(ConnIdx = 1; ConnIdx < (MAX_LOGICAL_CONNS+1) ; ConnIdx++)
{
if( (bDestId == gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].bDestId) &&
(tDestType == gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].bDestType) )
{
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].tConn.bConnId = bConnId;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].tConn.bMaxDpldSize = bMaxDpldSize;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].tConn.bNumCredits = bInitialCredits;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[ConnIdx].bIfActive = TRUE;
gphNciNfc_ConnMgmtInt.tConnInfo.bOpenConns++;
status = NFCSTATUS_SUCCESS;
break;
}
}
PH_LOG_NCI_FUNC_EXIT();
return status;
}
NFCSTATUS
phNciNfc_SetConnCredentials(void *psNciContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphNciNfc_Context_t psNciCtxt = (pphNciNfc_Context_t )psNciContext;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL == psNciCtxt)
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Invalid Context Param..");
}
else
{
/* Update Static conn info with conn details & device handle */
wStatus = phNciNfc_UpdateConnDestInfo(psNciCtxt->tActvDevIf.pDevInfo->bRfDiscId,
phNciNfc_e_REMOTE_NFC_ENDPOINT,
psNciCtxt->tActvDevIf.pDevInfo);
if(NFCSTATUS_SUCCESS == wStatus)
{
PH_LOG_NCI_INFO_STR("Conn Credentials updated successfully..");
}
else
{
PH_LOG_NCI_CRIT_STR("Conn Credentials update failed!!..");
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS phNciNfc_SendCb(void* pContext, void *pInfo, NFCSTATUS wStatus)
{
NFCSTATUS wStat = wStatus;
pphNciNfc_Context_t pNciContext = pContext;
UNUSED(pInfo);
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciContext)
{
/* Opening a dummy read request inorder not to loose data sent from remote device */
(void )phNciNfc_DummyReadReq((void *)pNciContext);
if(NULL != pNciContext->IfNtf)
{
pNciContext->IfNtf(pNciContext->IfNtfCtx,wStat,NULL);
}
if(NULL != pNciContext->tTranscvCtxt.tSendPld.pBuff)
{
PH_LOG_NCI_INFO_STR("De-allocating Send Request Payload Buffer...");
phOsalNfc_FreeMemory(pNciContext->tTranscvCtxt.tSendPld.pBuff);
pNciContext->tTranscvCtxt.tSendPld.pBuff = NULL;
pNciContext->tTranscvCtxt.tSendPld.wLen = 0;
}
}
else
{
PH_LOG_NCI_CRIT_STR("Invalid context received from RecvMgrHdlr!");
}
PH_LOG_NCI_FUNC_EXIT();
return wStat;
}
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;
}
static NFCSTATUS
phNciNfc_ResetNtfCb(void* pContext,
void *pInfo,
NFCSTATUS status)
{
pphNciNfc_Context_t pNciCtx = (pphNciNfc_Context_t )pContext;
pphNciNfc_TransactInfo_t pTransInfo = pInfo;
NFCSTATUS wStatus;
wStatus = status;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pNciCtx) && (NULL != pTransInfo))
{
/* Reset notification received, take necessary action */
PH_LOG_NCI_INFO_STR("Received RESET notification from NFCC");
/* Reset Sender statemachine */
(void )phNciNfc_CoreResetSenderStateMachine(&pNciCtx->NciCoreContext);
(void )phTmlNfc_WriteAbort(pNciCtx->NciCoreContext.pHwRef);
if(NULL != pNciCtx->tRegListInfo.pResetNtfCb)
{
pNciCtx->tRegListInfo.pResetNtfCb(pNciCtx->tRegListInfo.ResetNtfCtxt,
eNciNfc_NciResetNtf,NULL,NFCSTATUS_SUCCESS);
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
void
phNciNfc_CoreRecvMgrDeRegDataCb(void *pCtx, uint8_t bConnId)
{
pphNciNfc_CoreContext_t pCoreCtx = (pphNciNfc_CoreContext_t)pCtx;
uint8_t bIndex;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pCoreCtx)
{
for(bIndex =0; bIndex < PHNCINFC_CORE_MAX_DATA_REGS; bIndex++)
{
/* Check if a valid entry is present in the list */
if(NULL != pCoreCtx->tDataCtx.aDataRegList[bIndex].pNotifyCb)
{
/* Check if connection is matching */
if(bConnId == pCoreCtx->tDataCtx.aDataRegList[bIndex].bConnId)
{
pCoreCtx->tDataCtx.aDataRegList[bIndex].bEnabled = PHNCINFC_CORE_DISABLE_REG_ENTRY;
pCoreCtx->tDataCtx.aDataRegList[bIndex].bConnId = 0;
pCoreCtx->tDataCtx.aDataRegList[bIndex].pContext = NULL;
pCoreCtx->tDataCtx.aDataRegList[bIndex].pNotifyCb = NULL;
PH_LOG_NCI_INFO_U32MSG("Deregistered data call back fun registered on logical connection",bConnId);
}
}
}
}
PH_LOG_NCI_FUNC_EXIT();
return ;
}
static NFCSTATUS
phNciNfc_CompleteReleaseSequence(void *pContext, NFCSTATUS wStatus)
{
pphNciNfc_Context_t pNciCtx = pContext;
pphNciNfc_IfNotificationCb_t pUpperLayerCb = NULL;
void *pUpperLayerCtx = NULL;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciCtx)
{
pUpperLayerCb = pNciCtx->IfNtf;
pUpperLayerCtx = pNciCtx->IfNtfCtx;
pNciCtx->IfNtf = NULL;
pNciCtx->IfNtfCtx = NULL;
wStatus = phNciNfc_ReleaseNciHandle();
if(NULL != pUpperLayerCb)
{
PH_LOG_NCI_INFO_STR("Invoking upper layer call back function");
pUpperLayerCb(pUpperLayerCtx, wStatus, NULL);
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
uint8_t phNciNfc_ValidateRfTechMode(phNciNfc_RfTechMode_t eRfTechmode)
{
uint8_t bStatus = 1;
PH_LOG_NCI_FUNC_ENTRY();
switch(eRfTechmode)
{
case phNciNfc_NFCA_Poll:
case phNciNfc_NFCA_Active_Poll:
case phNciNfc_NFCB_Poll:
case phNciNfc_NFCF_Poll:
case phNciNfc_NFCF_Active_Poll:
case phNciNfc_NFCISO15693_Poll:
case phNciNfc_NFCA_Listen:
case phNciNfc_NFCA_Active_Listen:
case phNciNfc_NFCB_Listen:
case phNciNfc_NFCF_Listen:
case phNciNfc_NFCF_Active_Listen:
case phNciNfc_NFCISO15693_Active_Listen:
bStatus = 0;
break;
default:
bStatus = (eRfTechmode >= PH_NCINFCTYPES_RF_TECH_POLL_PROP_MIN && eRfTechmode <= PH_NCINFCTYPES_RF_TECH_POLL_PROP_MAX) ||
(eRfTechmode >= PH_NCINFCTYPES_RF_TECH_LISTEN_PROP_MIN && eRfTechmode <= PH_NCINFCTYPES_RF_TECH_LISTEN_PROP_MAX) ? 0 : 1;
break;
}
PH_LOG_NCI_FUNC_EXIT();
return bStatus;
}
uint8_t
phNciNfc_ValidateRfProtocol(phNciNfc_RfProtocols_t eRfProtocol)
{
uint8_t bStatus = 1;
PH_LOG_NCI_FUNC_ENTRY();
/* Verify whether input Rf Protocol is out of the supported range */
switch(eRfProtocol)
{
case phNciNfc_e_RfProtocolsUnknownProtocol:
case phNciNfc_e_RfProtocolsT1tProtocol:
case phNciNfc_e_RfProtocolsT2tProtocol:
case phNciNfc_e_RfProtocolsT3tProtocol:
case phNciNfc_e_RfProtocolsIsoDepProtocol:
case phNciNfc_e_RfProtocolsNfcDepProtocol:
case phNciNfc_e_RfProtocols15693Protocol:
bStatus = 0;
break;
default:
bStatus = (eRfProtocol >= PH_NCINFCTYPES_RF_PROTOS_PROP_MIN &&
eRfProtocol <= PH_NCINFCTYPES_RF_PROTOS_PROP_MAX) ? 0 : 1;
break;
}
PH_LOG_NCI_FUNC_EXIT();
return bStatus;
}
NFCSTATUS
phNciNfc_CreateConn(
uint8_t bDestId,
phNciNfc_DestType_t bDestType
)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
uint8_t bConnIdx;
PH_LOG_NCI_FUNC_ENTRY();
for(bConnIdx = 1; bConnIdx < (MAX_LOGICAL_CONNS+1) ; bConnIdx++)
{
if(FALSE == gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bIfActive)
{
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bDestId = bDestId;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bDestType = bDestType;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bIfActive = FALSE;
wStatus = NFCSTATUS_SUCCESS;
break;
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_UpdateConnDestInfo(
uint8_t bDestId,
phNciNfc_DestType_t tDestType,
void *pHandle
)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t bConnIdx;
uint8_t bConnId;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL == pHandle)
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Invalid Params supplied!!");
}
else
{
if( (phNciNfc_e_NFCEE == tDestType) ||\
(phNciNfc_e_NFCC_LOOPBACK == tDestType) )
{
wStatus = phNciNfc_GetConnInfo(bDestId,tDestType,&bConnId);
if( (NFCSTATUS_SUCCESS != wStatus)
|| (NFCSTATUS_SUCCESS != phNciNfc_GetConnIndex(bConnId,&bConnIdx) )
)
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_FAILED);
}
else
{
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].pActvDevHandle = pHandle;
}
}
else if(phNciNfc_e_REMOTE_NFC_ENDPOINT == tDestType)
{
pphNciNfc_RemoteDevInformation_t pActvDev = (pphNciNfc_RemoteDevInformation_t)pHandle;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bDestId = pActvDev->bRfDiscId;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bDestType = tDestType;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].tConn.bMaxDpldSize = pActvDev->bMaxPayLoadSize;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].tConn.bNumCredits = pActvDev->bInitialCredit;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].bIfActive = TRUE;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[CONNTYPE_STATIC].pActvDevHandle = pActvDev;
}
else
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Unsupported Destination Type!!");
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS
phNciNfc_CoreRegister(void *pRegList,
pphNciNfc_CoreRegInfo_t pRegInfo,
phNciNfc_NciCoreMsgType_t eMsgType)
{
uint8_t bIndex = 0;
uint8_t bGetEmptySlot = 1;
NFCSTATUS wStatus = NFCSTATUS_FAILED;
pphNciNfc_CoreRegRspNtfInfo_t pRegRspNtfList = NULL;
pphNciNfc_CoreRegDataInfo_t pRegDataList = NULL;
PH_LOG_NCI_FUNC_ENTRY();
if(phNciNfc_e_NciCoreMsgTypeCntrlRsp == eMsgType)
{
/* Force registration (over-write resposnse/data call back entry if any exist) */
bIndex = 0;
wStatus = NFCSTATUS_SUCCESS;
}
else
{
/* Get a free slot in the list */
wStatus = phNciNfc_CoreGetIndex(bGetEmptySlot,pRegList,pRegInfo,eMsgType,&bIndex);
}
if(NFCSTATUS_SUCCESS == wStatus)
{
switch(eMsgType)
{
case phNciNfc_e_NciCoreMsgTypeCntrlRsp:
case phNciNfc_e_NciCoreMsgTypeCntrlNtf:
pRegRspNtfList = (pphNciNfc_CoreRegRspNtfInfo_t)pRegList;
pRegRspNtfList[bIndex].bEnabled = pRegInfo->bEnabled;
pRegRspNtfList[bIndex].bGid = pRegInfo->bGid;
pRegRspNtfList[bIndex].bOid = pRegInfo->bOid;
pRegRspNtfList[bIndex].pContext = pRegInfo->pContext;
pRegRspNtfList[bIndex].pNotifyCb = pRegInfo->pNotifyCb;
break;
case phNciNfc_e_NciCoreMsgTypeData:
pRegDataList = (pphNciNfc_CoreRegDataInfo_t)pRegList;
pRegDataList[bIndex].bEnabled = pRegInfo->bEnabled;
pRegDataList[bIndex].bConnId = pRegInfo->bConnId;
pRegDataList[bIndex].pContext = pRegInfo->pContext;
pRegDataList[bIndex].pNotifyCb = pRegInfo->pNotifyCb;
break;
default:
break;
}
PH_LOG_NCI_INFO_STR("Registration success");
}
else
{
PH_LOG_NCI_CRIT_STR("No free slots available, registraiton failed!");
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_NfcIsoLstnRdrInit(
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen
)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff = NULL;
uint8_t RfTechSpecParamsLen = 0;
uint8_t bUidLength = 0;
uint8_t bSelResRespLen = 0;
uint8_t bSelRespVal = 0;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL == pRemDevInf) || (NULL == pBuff) || (0 == wLen))
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Invalid Param(s)..");
}
else
{
pRemDevInf->bRfDiscId = pBuff[0];
pRemDevInf->eRfIf = (phNciNfc_RfInterfaces_t)pBuff[1];
pRemDevInf->eRFProtocol = (phNciNfc_RfProtocols_t)pBuff[2];
pRemDevInf->eRFTechMode = (phNciNfc_RfTechMode_t)pBuff[3];
pRemDevInf->bMaxPayLoadSize = pBuff[4];
pRemDevInf->bInitialCredit = pBuff[5];
/* Obtain the len of RF tech specific parameters from Resp buff */
RfTechSpecParamsLen = pBuff[6];
pRemDevInf->bTechSpecificParamLen = RfTechSpecParamsLen;
pRfNtfBuff = &(pBuff[7+RfTechSpecParamsLen]);
pRemDevInf->eDataXchgRFTechMode = (phNciNfc_RfTechMode_t)*(pRfNtfBuff+0);
pRemDevInf->bTransBitRate = *(pRfNtfBuff+1);
pRemDevInf->bRecvBitRate = *(pRfNtfBuff+2);
/* Length of NFCID1 */
bUidLength = *(pRfNtfBuff+2);
/* 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
{
bSelRespVal = 0;
}
/* Length of SEL_RES shall be '0' incase of Nfc Forum Type 1 Tag */
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
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;
}
NFCSTATUS
phNciNfc_CoreRecvMgrDeRegisterCb(void *pCtx,
pphNciNfc_CoreRegInfo_t pRegInfo,
phNciNfc_NciCoreMsgType_t eMsgType)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
pphNciNfc_CoreContext_t pCoreCtx = (pphNciNfc_CoreContext_t)pCtx;
void *pRegList = NULL;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pCoreCtx) && (NULL != pRegInfo))
{
if(NULL != pRegInfo->pNotifyCb)
{
wStatus = NFCSTATUS_SUCCESS;
switch(eMsgType)
{
case phNciNfc_e_NciCoreMsgTypeCntrlRsp:
pRegList = (void *) pCoreCtx->tRspCtx.aRspRegList;
PH_LOG_NCI_INFO_STR("De-registering response message call back...");
break;
case phNciNfc_e_NciCoreMsgTypeCntrlNtf:
pRegList = (void *) pCoreCtx->tNtfCtx.aNtfRegList;
PH_LOG_NCI_INFO_STR("De-registering notification message call back...");
break;
case phNciNfc_e_NciCoreMsgTypeData:
pRegList = (void *) pCoreCtx->tDataCtx.aDataRegList;
PH_LOG_NCI_INFO_STR("De-registering data message call back...");
break;
default:
PH_LOG_NCI_WARN_STR("Invalid message type");
wStatus = NFCSTATUS_INVALID_PARAMETER;
break;
}
if(NFCSTATUS_SUCCESS == wStatus)
{
wStatus = phNciNfc_CoreDeRegister(pRegList,pRegInfo,eMsgType);
}
}
else
{
PH_LOG_NCI_WARN_STR("Invalid call back function pointer to register");
}
}
else
{
PH_LOG_NCI_WARN_STR("Invalid input parameters");
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS
phNciNfc_CompleteNfccResetSequence(void *pContext, NFCSTATUS wStatus)
{
pphNciNfc_Context_t pNciCtx = pContext;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciCtx)
{
phNciNfc_Notify(pNciCtx, wStatus,NULL);
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS phNciNfc_ProcessResetRsp(void *pContext, NFCSTATUS Status)
{
NFCSTATUS wStatus = Status;
pphNciNfc_Context_t pNciContext = pContext;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciContext)
{
if((NFCSTATUS_RESPONSE_TIMEOUT != Status) && (pNciContext->RspBuffInfo.wLen == 3))
{
/*Check Status Byte*/
if (pNciContext->RspBuffInfo.pBuff[0] == PH_NCINFC_STATUS_OK)
{
/* Nfcc supported Nci version */
pNciContext->ResetInfo.NciVer = pNciContext->RspBuffInfo.pBuff[1];
if((pNciContext->ResetInfo.NciVer & PH_NCINFC_VERSION_MAJOR_MASK) <=
(PH_NCINFC_VERSION & PH_NCINFC_VERSION_MAJOR_MASK))
{
/* Update Reset type */
if(pNciContext->RspBuffInfo.pBuff[2] == phNciNfc_ResetType_KeepConfig)
{
PH_LOG_NCI_INFO_STR("Nfcc reseted to 'phNciNfc_ResetType_KeepConfig'");
pNciContext->ResetInfo.ResetTypeRsp = phNciNfc_ResetType_KeepConfig;
}else
{
PH_LOG_NCI_INFO_STR("Nfcc reseted to 'phNciNfc_ResetType_ResetConfig'");
pNciContext->ResetInfo.ResetTypeRsp = phNciNfc_ResetType_ResetConfig;
}
wStatus = NFCSTATUS_SUCCESS;
}else
{
PH_LOG_NCI_INFO_STR("Unsupported NCI version 0x%02x", pNciContext->ResetInfo.NciVer);
wStatus = NFCSTATUS_FAILED;
}
}else
{
wStatus = NFCSTATUS_FAILED;
}
}else
{
wStatus = NFCSTATUS_FAILED;
}
}else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS phNciNfc_CoreIfRegRspNtf(void *pCtx,
pphNciNfc_sCoreHeaderInfo_t pInfo,
pphNciNfc_CoreIfNtf_t pNotify,
void *pContext)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphNciNfc_CoreContext_t pCoreCtx = pCtx;
phNciNfc_CoreRegInfo_t tRegInfo;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pCoreCtx) && (NULL != pInfo) && (NULL != pNotify))
{
tRegInfo.pContext = pContext;
tRegInfo.pNotifyCb = pNotify;
if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeData)
{
/*Register with data manager*/
tRegInfo.bEnabled = pInfo->bEnabled;
tRegInfo.bConnId = pInfo->bConn_ID;
wStatus = phNciNfc_CoreRecvMgrRegisterCb((void *)pCoreCtx, &tRegInfo,
phNciNfc_e_NciCoreMsgTypeData);
}else if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeCntrlRsp)
{
/*Register with Response Manager*/
tRegInfo.bEnabled = (uint8_t) PHNCINFC_ENABLE_AUTO_DEREG;
tRegInfo.bGid = (uint8_t)pInfo->Group_ID;
tRegInfo.bOid = (uint8_t)pInfo->Opcode_ID.Val;
wStatus = phNciNfc_CoreRecvMgrRegisterCb((void *)pCoreCtx, &tRegInfo,
phNciNfc_e_NciCoreMsgTypeCntrlRsp);
}else if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeCntrlNtf)
{
/*Register with NTF Manager*/
tRegInfo.bEnabled = (uint8_t) PHNCINFC_DISABLE_AUTO_DEREG;
tRegInfo.bGid = (uint8_t)pInfo->Group_ID;
tRegInfo.bOid = (uint8_t)pInfo->Opcode_ID.Val;
wStatus = phNciNfc_CoreRecvMgrRegisterCb((void *)pCoreCtx, &tRegInfo,
phNciNfc_e_NciCoreMsgTypeCntrlNtf);
}else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
}else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
static NFCSTATUS phNciNfc_CompleteInitSequence(void *pContext, NFCSTATUS wStatus)
{
pphNciNfc_Context_t pNciCtx = pContext;
phNciNfc_TransactInfo_t tTranscInfo;
PH_LOG_NCI_FUNC_ENTRY();
if(NULL != pNciCtx)
{
tTranscInfo.pContext = (void*)pNciCtx;
tTranscInfo.pbuffer = (void*)&pNciCtx->ResetInfo.ResetTypeRsp;
tTranscInfo.wLength = sizeof(pNciCtx->ResetInfo.ResetTypeRsp);
phNciNfc_Notify(pNciCtx, wStatus,(void *)&tTranscInfo);
}
PH_LOG_NCI_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_UpdateNfcIRemDevInfo(pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen
)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t *pRfNtfBuff = NULL;
uint8_t RfTechSpecParamsLen = 0;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL == pRemDevInf) || (NULL == pBuff) || (0 == wLen))
{
wStatus = PHNFCSTVAL(CID_NFC_NCI, NFCSTATUS_INVALID_PARAMETER);
PH_LOG_NCI_CRIT_STR(" Invalid Param(s)..");
}
else
{
pRemDevInf->bRfDiscId = pBuff[0];
pRemDevInf->eRfIf = (phNciNfc_RfInterfaces_t)pBuff[1];
if(phNciNfc_e_RfInterfacesNfceeDirect_RF != (pRemDevInf->eRfIf))
{
pRemDevInf->eRFProtocol = (phNciNfc_RfProtocols_t)pBuff[2];
pRemDevInf->eRFTechMode = (phNciNfc_RfTechMode_t)pBuff[3];
pRemDevInf->bMaxPayLoadSize = pBuff[4];
pRemDevInf->bInitialCredit = pBuff[5];
/* Obtain the len of RF tech specific parameters from Resp buff */
RfTechSpecParamsLen = pBuff[6];
pRemDevInf->bTechSpecificParamLen = RfTechSpecParamsLen;
pRfNtfBuff = &(pBuff[7+RfTechSpecParamsLen]);
pRemDevInf->eDataXchgRFTechMode = (phNciNfc_RfTechMode_t)*(pRfNtfBuff+0);
pRemDevInf->bTransBitRate = *(pRfNtfBuff+1);
pRemDevInf->bRecvBitRate = *(pRfNtfBuff+2);
}
else
{
PH_LOG_NCI_WARN_STR("Interface is NFCEE Direct RF,subsequent payload contents ignored..");
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS phNciNfc_CoreIfUnRegRspNtf(void *pCtx,
pphNciNfc_sCoreHeaderInfo_t pInfo,
pphNciNfc_CoreIfNtf_t pNotify
)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphNciNfc_CoreContext_t pCoreCtx = pCtx;
phNciNfc_CoreRegInfo_t tRegInfo;
phNciNfc_NciCoreMsgType_t eMsgType = phNciNfc_e_NciCoreMsgTypeInvalid;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pCtx) && (NULL != pInfo))
{
tRegInfo.pNotifyCb = pNotify;
if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeData)
{
/*UnRegister From data manager*/
tRegInfo.bConnId = pInfo->bConn_ID;
eMsgType = phNciNfc_e_NciCoreMsgTypeData;
}else if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeCntrlRsp)
{
/*UnRegister From Response Manager*/
tRegInfo.bGid = (uint8_t)pInfo->Group_ID;
tRegInfo.bOid = (uint8_t)pInfo->Opcode_ID.Val;
eMsgType = phNciNfc_e_NciCoreMsgTypeCntrlRsp;
}else if (pInfo->eMsgType == phNciNfc_e_NciCoreMsgTypeCntrlNtf)
{
/*UnRegister From NTF Manager*/
tRegInfo.bGid = (uint8_t)pInfo->Group_ID;
tRegInfo.bOid = (uint8_t)pInfo->Opcode_ID.Val;
eMsgType = phNciNfc_e_NciCoreMsgTypeCntrlNtf;
}else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
if(NFCSTATUS_INVALID_PARAMETER != wStatus)
{
wStatus = phNciNfc_CoreRecvMgrDeRegisterCb((void*)pCoreCtx, &tRegInfo,
eMsgType);
}
}else
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS
phNciNfc_ListenMgmt(void *psContext,
pphNciNfc_RemoteDevInformation_t pRemDevInf,
uint8_t *pBuff,
uint16_t wLen)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
pphNciNfc_Context_t psNciCtxt = (pphNciNfc_Context_t)psContext;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL == psNciCtxt) || (0 == wLen) || (NULL == pBuff) || (NULL == pRemDevInf))
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_INFO_STR("Invalid input parameters");
}
else
{
/* Extract info into RemDevInf structure */
wStatus = phNciNfc_UpdateLstnMgmtRemDevInfo(pRemDevInf,pBuff,wLen);
if(NFCSTATUS_SUCCESS == wStatus)
{
/* Based on active Rf Technology and Rf protocol,
perform reader management init or P2P management init*/
if(phNciNfc_e_RfInterfacesNFCDEP_RF == pRemDevInf->eRfIf &&
phNciNfc_e_RfProtocolsNfcDepProtocol == pRemDevInf->eRFProtocol)
{
wStatus = phNciNfc_NfcILstnInit(psNciCtxt,pRemDevInf,pBuff,wLen);
}
else if(phNciNfc_e_RfInterfacesISODEP_RF == pRemDevInf->eRfIf &&
phNciNfc_e_RfProtocolsIsoDepProtocol == pRemDevInf->eRFProtocol)
{
wStatus = phNciNfc_NfcIsoLstnRdrInit(pRemDevInf,pBuff,wLen);
}
}
if(NFCSTATUS_SUCCESS == wStatus)
{
(psNciCtxt->tActvDevIf.pDevInfo) = pRemDevInf;
wStatus = phNciNfc_SetConnCredentials(psNciCtxt);
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS phNciNfc_CoreUtilsValidateCtrlPktOID(uint8_t bMT, uint8_t bGID, uint8_t bOID)
{
NFCSTATUS bRetNfcStat;
PH_LOG_NCI_FUNC_ENTRY();
/* If received packet is a response packet */
if(phNciNfc_e_NciCoreMsgTypeCntrlRsp == bMT)
{
bRetNfcStat = phNciNfc_CoreUtilsValidateRspPktOID(bGID, bOID);
}
/* If received packet is a notification packet (bMT == phNciNfc_e_NciCoreMsgTypeCntrlNtf) */
else
{
bRetNfcStat = phNciNfc_CoreUtilsValidateNtfPktOID(bGID, bOID);
}
PH_LOG_NCI_FUNC_EXIT();
return bRetNfcStat;
}
NFCSTATUS
phNciNfc_ValidateIntfActvdNtf(uint8_t *pNtf, uint16_t wSize)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
uint16_t wOffset = 0;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pNtf) && (0 != wSize))
{
/* Validate the size of received ntf (Min it should be 11 bytes) */
if(wSize >= PHNCINFC_RFDISC_ACTVNTFMINLEN)
{
if(pNtf[1] == phNciNfc_e_RfInterfacesNfceeDirect_RF)
{
wStatus = NFCSTATUS_SUCCESS;
}
else
{
wOffset = (PHNCINFC_RF_DISCOVERY_ID_LEN +
PHNCINFC_RF_INTFERFACE_LEN +
PHNCINFC_RF_PROTOCOL_LEN +
PHNCINFC_ACTVD_RF_TECH_MODE_LEN +
PHNCINFC_MAX_DATA_PKT_PAYLOAD_LEN +
PHNCINFC_INITIAL_NO_CREDITS_LEN +
PHNCINFC_RF_TECH_SPECIFIC_PARAMS_LEN);
wOffset += pNtf[wOffset-1];
wOffset += (PHNCINFC_DATA_XCNG_RF_TECH_MODE_LEN +
PHNCINFC_DATA_XCNG_TX_BIT_RATE_LEN +
PHNCINFC_DATA_XCNG_RX_BIT_RATE_LEN +
PHNCINFC_ACTIVATION_PARAMS_LEN);
wOffset += pNtf[wOffset-1];
if(wOffset == wSize)
{
/* Validate common parameters of Interface Actvf Ntf */
wStatus = phNciNfc_ValidateIfActParams(pNtf, wSize);
}
}
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
NFCSTATUS phNciNfc_CoreUtilsValidateGID(uint8_t bGID)
{
NFCSTATUS wStatus = NFCSTATUS_FAILED;
PH_LOG_NCI_FUNC_ENTRY();
switch(bGID)
{
case phNciNfc_e_CoreNciCoreGid:
case phNciNfc_e_CoreRfMgtGid:
case phNciNfc_e_CoreNfceeMgtGid:
case phNciNfc_e_CorePropGid:
wStatus = NFCSTATUS_SUCCESS;
break;
default:
break;
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
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 ;
}
NFCSTATUS
phNciNfc_CloseConn(
uint8_t bConnId
)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
uint8_t bConnIdx;
PH_LOG_NCI_FUNC_ENTRY();
if(gphNciNfc_ConnMgmtInt.tConnInfo.bOpenConns > 1)
{
for(bConnIdx = 1; bConnIdx < (MAX_LOGICAL_CONNS+1) ; bConnIdx++)
{
if(TRUE == gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bIfActive)
{
if(bConnId == gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].tConn.bConnId)
{
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].tConn.bConnId = INVALID_CONN_ID;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].tConn.bMaxDpldSize = 0;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].tConn.bNumCredits = FLOW_CONTROL_DISABLED;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bDestId = UNASSIGNED_DESTID;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bDestType = phNciNfc_e_UNKNOWN_DEST_TYPE;
gphNciNfc_ConnMgmtInt.tConnInfo.tConnList[bConnIdx].bIfActive = FALSE;
gphNciNfc_ConnMgmtInt.tConnInfo.bOpenConns--;
wStatus = NFCSTATUS_SUCCESS;
break;
}
}
}
}
else
{
PH_LOG_NCI_INFO_STR("No connection left to close");
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
