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; }