/*!
* \brief System timer callback.
* This callback is called by Linux whenever one the timers expires. It
* calls the corresponding registered callback.
*
* \param sv structure storing the expired timer ID.
*/
static void phOsalNfc_Timer_Expired(union sigval sv)
{
uint32_t timerid = (uint32_t)(sv.sival_int);
if((timerid < MAX_NO_TIMERS)&&(timers[timerid].nIsStopped == 1))
{
//printf("phOsalNfc_Timer_Expired : Expired but already stopped TimerId=%d\n", timerid);
return;
}
if(timerid < MAX_NO_TIMERS)
{
#ifndef CYCLIC_TIMER
phOsalNfc_Timer_Stop(timerid);
#else
#endif
#ifdef NXP_MESSAGING
phOsalNfc_Timer_Msg_t *timer_msg;
phOsalNfc_DeferedCalldInfo_t *osal_defer_msg;
phDal4Nfc_Message_Wrapper_t wrapper;
timer_msg = phOsalNfc_GetMemory(sizeof(phOsalNfc_Timer_Msg_t));
if(timer_msg == NULL)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory, 0);
return;
}
osal_defer_msg = phOsalNfc_GetMemory(sizeof(phOsalNfc_DeferedCalldInfo_t));
if(osal_defer_msg == NULL)
{
phOsalNfc_FreeMemory(timer_msg);
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory, 0);
return;
}
timer_msg->TimerId = timerid;
timer_msg->pCallBck = timers[timerid].callback;
timer_msg->pContext = timers[timerid].pContext;
osal_defer_msg->pCallback = phOsalNfc_Timer_DeferredCall;
osal_defer_msg->pParameter = timer_msg;
wrapper.mtype = 1;
wrapper.msg.eMsgType = PH_OSALNFC_TIMER_MSG;
wrapper.msg.pMsgData = osal_defer_msg;
wrapper.msg.Size = sizeof(phOsalNfc_DeferedCalldInfo_t);
timers[timerid].ptr = osal_defer_msg;
#ifndef G_IDLE_ADD_MSGQ
phDal4Nfc_msgsnd(nDeferedCallMessageQueueId, (void *)&wrapper, sizeof(phOsalNfc_Message_t), 0);
#else
PostMessage((void *)&wrapper, sizeof(phOsalNfc_Message_t), 0);
#endif
//(timers[timerid].callback)(timerid, timers[timerid].pContext);
#endif
}
}
/**
* \ingroup grp_nfc_dal
*
* \brief DAL message send function
* Use this function to send a message to the queue. The message will be added at the end of
* the queue with respect to FIFO policy. The msgflg parameter is ignored.
*
* \param[in] msqid The handle of the message queue.
* \param[in] msgp The message to send.
* \param[in] msgsz The message size.
*
* \retval 0 If success.
* \retval -1 Bad passed parameter, or can not allocate memory
*/
int phDal4Nfc_msgsnd (int msqid, void * msgp, size_t msgsz, int msgflg)
{
phDal4Nfc_message_queue_t * pQueue;
phDal4Nfc_message_queue_item_t * p;
phDal4Nfc_message_queue_item_t * pNew;
if ((msqid == 0) || (msgp == NULL) || (msgsz == 0))
return -1;
if (msgsz != sizeof(phLibNfc_Message_t))
return -1;
pQueue = (phDal4Nfc_message_queue_t *)msqid;
pNew = (phDal4Nfc_message_queue_item_t *)phOsalNfc_GetMemory(sizeof(phDal4Nfc_message_queue_item_t));
if (pNew == NULL)
return -1;
memset(pNew, 0, sizeof(phDal4Nfc_message_queue_item_t));
memcpy(&pNew->nMsg, &((phDal4Nfc_Message_Wrapper_t*)msgp)->msg, sizeof(phLibNfc_Message_t));
pthread_mutex_lock(&pQueue->nCriticalSectionMutex);
if (pQueue->pItems != NULL)
{
p = pQueue->pItems;
while(p->pNext != NULL) { p = p->pNext; }
p->pNext = pNew;
pNew->pPrev = p;
}
else
{
pQueue->pItems = pNew;
}
pthread_mutex_unlock(&pQueue->nCriticalSectionMutex);
sem_post(&pQueue->nProcessSemaphore);
return 0;
}
/**
* \ingroup grp_nfc_dal
*
* \brief DAL message get function
* This function allocates the message queue. The parameters are ignored, this is
* just to keep the same api as Linux queue.
*
* \retval -1 Can not allocate memory or can not init mutex.
* \retval handle The handle on the message queue.
*/
int phDal4Nfc_msgget ( key_t key, int msgflg )
{
phDal4Nfc_message_queue_t * pQueue;
pQueue = (phDal4Nfc_message_queue_t *) phOsalNfc_GetMemory(sizeof(phDal4Nfc_message_queue_t));
if (pQueue == NULL)
return -1;
memset(pQueue, 0, sizeof(phDal4Nfc_message_queue_t));
if (pthread_mutex_init (&pQueue->nCriticalSectionMutex, NULL) == -1)
return -1;
if (sem_init (&pQueue->nProcessSemaphore, 0, 0) == -1)
return -1;
return ((int)pQueue);
}
static
NFCSTATUS
phHciNfc_Create_Pipe(
phHciNfc_sContext_t *psHciContext,
void *pHwRef,
phHciNfc_Gate_Info_t *destination,
phHciNfc_Pipe_Info_t **ppPipeHandle
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
*ppPipeHandle = (phHciNfc_Pipe_Info_t *)
phOsalNfc_GetMemory( sizeof(phHciNfc_Pipe_Info_t) );
if(NULL != *ppPipeHandle)
{
/* The Source Host is the Terminal Host */
(*ppPipeHandle)->pipe.source.host_id = (uint8_t) phHciNfc_TerminalHostID;
/* The Source Gate is same as the Destination Gate */
(*ppPipeHandle)->pipe.source.gate_id =
((phHciNfc_Gate_Info_t *)destination)->gate_id;
(*ppPipeHandle)->pipe.dest.host_id =
((phHciNfc_Gate_Info_t *)destination)->host_id;
(*ppPipeHandle)->pipe.dest.gate_id =
((phHciNfc_Gate_Info_t *)destination)->gate_id;
/* if( hciMode_Override == psHciContext->hci_mode ) */
{
/* The Pipe ID is unknown until it is assigned */
(*ppPipeHandle)->pipe.pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
status = phHciNfc_Send_Admin_Cmd( psHciContext, pHwRef,
ADM_CREATE_PIPE, (PIPEINFO_SIZE-1)
,*ppPipeHandle );
}
}
else
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
}
return status;
}
NFCSTATUS phOsalNfc_PostMsg(uint32_t SourceID, uint32_t DestID, phOsalNfc_Message_t * pMsg)
{
phOsalNfc_Message_t* pMsg_i = NULL;
uint16_t retvalue=0;
NFCSTATUS Status = NFCSTATUS_SUCCESS;
if(NULL == pMsg)
{
Status =PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_INVALID_PARAMETER);
}
else
{
pMsg_i = (void*) phOsalNfc_GetMemory(sizeof(phOsalNfc_Message_t));
if(NULL == pMsg_i)
{
Status=PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
*pMsg_i = *pMsg;
retvalue = (uint16_t)PostThreadMessage((DWORD)DestID,
(UINT)(PH_OSALNFC_MESSAGE_BASE),
(WPARAM)pMsg_i,
(LPARAM)SourceID);
if(0 == retvalue)
{
Status= PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
Status= NFCSTATUS_SUCCESS;
}
phOsalNfc_FreeMemory(pMsg_i);
}
}
return Status;
}
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
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;
}
/**
* The I/O Control function allows the caller to configure specific
* functionality provided by the lower layer.Each feature is accessible
* via a specific IOCTL Code.
*/
NFCSTATUS phLibNfc_Mgt_IoCtl (void* pDalHandle,
uint16_t IoctlCode,
phNfc_sData_t* pInParam,
phNfc_sData_t* pOutParam,
pphLibNfc_IoctlCallback_t pIoCtl_Rsp_cb,
void* pContext
)
{
NFCSTATUS StatusCode=NFCSTATUS_INVALID_PARAMETER;
if((IoctlCode==0)||(NULL==pIoCtl_Rsp_cb) ||
(NULL==pContext) ||(NULL==pInParam) ||
(NULL==pDalHandle))
{
StatusCode=NFCSTATUS_INVALID_PARAMETER;
return StatusCode;
}
if(IoctlCode!= NFC_FW_DOWNLOAD)
{
if(pOutParam == NULL)
{
StatusCode = NFCSTATUS_INVALID_PARAMETER;
return StatusCode;
}
if(( gpphLibContext == NULL) ||
(gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown))
{
StatusCode = NFCSTATUS_NOT_INITIALISED;
return StatusCode;
}
else
{
if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown)
{
StatusCode = NFCSTATUS_SHUTDOWN;
return StatusCode;
}
}
}
phLibNfc_Ioctl_Cntx.CliRspCb =pIoCtl_Rsp_cb;
phLibNfc_Ioctl_Cntx.pCliCntx = pContext;
phLibNfc_Ioctl_Cntx.pOutParam = pOutParam;
phLibNfc_Ioctl_Cntx.IoctlCode = IoctlCode;
/* Process the IOCTL requests */
switch(IoctlCode)
{
case NFC_FW_DOWNLOAD:
{/* Set power status */
phLibNfc_Ioctl_Cntx.psHwReference = phOsalNfc_GetMemory((uint32_t)sizeof(phHal_sHwReference_t));
if(phLibNfc_Ioctl_Cntx.psHwReference == NULL)
return NFCSTATUS_FAILED;
(void)memset(phLibNfc_Ioctl_Cntx.psHwReference,0,sizeof(phHal_sHwReference_t));
phLibNfc_Ioctl_Cntx.psHwReference->p_board_driver = pDalHandle;
StatusCode = phHal4Nfc_Ioctl( phLibNfc_Ioctl_Cntx.psHwReference,
NFC_FW_DOWNLOAD,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case NFC_MEM_READ:
{
StatusCode = phHal4Nfc_Ioctl(gpphLibContext->psHwReference,
NFC_MEM_READ,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case NFC_MEM_WRITE:
{
StatusCode = phHal4Nfc_Ioctl( gpphLibContext->psHwReference,
NFC_MEM_WRITE,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case PHLIBNFC_ANTENNA_TEST:
{
StatusCode = phHal4Nfc_Ioctl( gpphLibContext->psHwReference,
PHLIBNFC_ANTENNA_TEST,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case PHLIBNFC_SWP_TEST:
{
StatusCode = phHal4Nfc_Ioctl( gpphLibContext->psHwReference,
PHLIBNFC_SWP_TEST,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case PHLIBNFC_PRBS_TEST:
{
StatusCode = phHal4Nfc_Ioctl( gpphLibContext->psHwReference,
PHLIBNFC_PRBS_TEST,
pInParam,
pOutParam,
phLibNfc_Ioctl_Mgmt_CB,
&phLibNfc_Ioctl_Cntx );
}break;
case PHLIBNFC_SWITCH_SWP_MODE:
{
StatusCode = phHal4Nfc_Switch_Swp_Mode( gpphLibContext->psHwReference,
(phHal_eSWP_Mode_t)pInParam->buffer[0],
phLibNfc_Switch_Swp_Mode_CB,
&phLibNfc_Ioctl_Cntx
);
}break;
default :
{
/* don't do any thing*/
}break;
} /* End of IOCTL switch */
if(StatusCode!=NFCSTATUS_PENDING)
{
StatusCode = NFCSTATUS_FAILED;
}
else
{
if(IoctlCode!= NFC_FW_DOWNLOAD)
{
gpphLibContext->status.GenCb_pending_status=TRUE;
}
}
return StatusCode;
} /* End of IOCTL handler function */
NFCSTATUS
phNciNfc_NfcIPollInit(
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) || (NULL == pBuff) || (NULL == pRemDevInf))
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_INFO_STR(" Invalid Param(s)..");
}
else
{
gpphNciNfc_RdrDataXchgSequence = (phNciNfc_SequenceP_t *)phOsalNfc_GetMemory(
(2 * sizeof(phNciNfc_SequenceP_t)));
if(NULL != gpphNciNfc_RdrDataXchgSequence)
{
/* Extract info into RemDevInf structure */
wStatus = phNciNfc_UpdateNfcIRemDevInfo(pRemDevInf,pBuff,wLen);
if(NFCSTATUS_SUCCESS == wStatus)
{
/* Update Target specific info */
switch(pRemDevInf->eRFTechMode)
{
case phNciNfc_NFCA_Poll:
case phNciNfc_NFCA_Active_Poll:
wStatus = phNciNfc_NfcDepPollRdrAInit(pRemDevInf,pBuff,wLen);
break;
case phNciNfc_NFCF_Poll:
case phNciNfc_NFCF_Active_Poll:
wStatus = phNciNfc_NfcDepPollRdrFInit(pRemDevInf,pBuff,wLen);
break;
default:
PH_LOG_NCI_INFO_STR("Rf Technology and mode not supported");
wStatus = NFCSTATUS_FAILED;
break;
}
}
if(NFCSTATUS_SUCCESS == wStatus)
{
(psNciCtxt->tActvDevIf.pDevInfo) = pRemDevInf;
wStatus = phNciNfc_SetConnCredentials(psNciCtxt);
}
}
else
{
wStatus = NFCSTATUS_INSUFFICIENT_RESOURCES;
PH_LOG_NCI_INFO_STR(" DataXchg SequenceHandler pointer MemAlloc Failed..");
}
}
if(NFCSTATUS_SUCCESS != wStatus)
{
if(NULL != gpphNciNfc_RdrDataXchgSequence)
{
PH_LOG_NCI_INFO_STR(" Freeing RdrDataXchgSeq Mem..");
phOsalNfc_FreeMemory(gpphNciNfc_RdrDataXchgSequence);
gpphNciNfc_RdrDataXchgSequence = NULL;
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStatus;
}
/* Transfer the user data to another NfcIP device from the host.
* pTransferCallback is called, when all steps in the transfer sequence are
* completed.*/
NFCSTATUS
phHal4Nfc_Send(
phHal_sHwReference_t *psHwReference,
phHal4Nfc_TransactInfo_t *psTransferInfo,
phNfc_sData_t sTransferData,
pphHal4Nfc_SendCallback_t pSendCallback,
void *pContext
)
{
NFCSTATUS RetStatus = NFCSTATUS_PENDING;
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
/*NULL checks*/
if((NULL == psHwReference)
||( NULL == pSendCallback )
|| (NULL == psTransferInfo)
)
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
}
/*Check initialised state*/
else if((NULL == psHwReference->hal_context)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4CurrentState
< eHal4StateOpenAndReady)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4NextState
== eHal4StateClosed))
{
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
}
/*Only NfcIp1 Target can call this API*/
else if(phHal_eNfcIP1_Initiator != psTransferInfo->remotePCDType)
{
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_DEVICE);
}
else
{
Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
RetStatus= PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_FAILED);
}
/*Check Activated*/
else if(NFC_EVT_ACTIVATED == Hal4Ctxt->sTgtConnectInfo.EmulationState)
{
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
/*Register upper layer callback*/
Hal4Ctxt->psTrcvCtxtInfo->pP2PSendCb = pSendCallback;
PHDBG_INFO("NfcIP1 Send");
/*allocate buffer to store senddata received from upper layer*/
if (NULL == Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData)
{
Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData = (phNfc_sData_t *)
phOsalNfc_GetMemory(sizeof(phNfc_sData_t));
if(NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData)
{
(void)memset(Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData, 0,
sizeof(phNfc_sData_t));
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= PH_OSALNFC_INVALID_TIMER_ID;
}
}
Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->buffer
= sTransferData.buffer;
Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->length
= sTransferData.length;
/*If data size is less than MAX_SEND_LEN ,no chaining is required*/
if(PH_HAL4NFC_MAX_SEND_LEN >= sTransferData.length)
{
Hal4Ctxt->psTrcvCtxtInfo->
XchangeInfo.params.nfc_info.more_info = FALSE;
Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length
= (uint8_t)sTransferData.length;
Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_buffer
= sTransferData.buffer;
}
else/*set more_info to true,to indicate more data pending to be sent*/
{
Hal4Ctxt->psTrcvCtxtInfo->
XchangeInfo.params.nfc_info.more_info = TRUE;
Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length
= PH_HAL4NFC_MAX_SEND_LEN;
Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_buffer
= sTransferData.buffer;
Hal4Ctxt->psTrcvCtxtInfo->NumberOfBytesSent
+= PH_HAL4NFC_MAX_SEND_LEN;
}
PHDBG_INFO("HAL4:Calling Hci_Send_data()");
RetStatus = phHciNfc_Send_Data (
Hal4Ctxt->psHciHandle,
psHwReference,
NULL,
&(Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo)
);
/*check return status*/
if (NFCSTATUS_PENDING == RetStatus)
{
/*Set P2P_Send_In_Progress to defer any disconnect call until
Send complete occurs*/
Hal4Ctxt->psTrcvCtxtInfo->P2P_Send_In_Progress = TRUE;
Hal4Ctxt->Hal4NextState = eHal4StateTransaction;
/*No of bytes remaining for next send*/
Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->length
-= Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length;
}
}
else/*Deactivated*/
{
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_DESELECTED);
}
}
return RetStatus;
}
/*!
* \brief Receives the HCI Admin Commands from the corresponding peripheral device.
*
* This function receives the HCI Admin Commands from the connected NFC Pheripheral
* device
*/
static
NFCSTATUS
phHciNfc_Recv_Admin_Cmd (
void *psContext,
void *pHwRef,
uint8_t *pCmd,
#ifdef ONE_BYTE_LEN
uint8_t length
#else
uint16_t length
#endif
)
{
phHciNfc_sContext_t *psHciContext =
(phHciNfc_sContext_t *)psContext ;
phHciNfc_HCP_Packet_t *hcp_packet = NULL;
phHciNfc_HCP_Message_t *hcp_message = NULL;
phHciNfc_AdminGate_Info_t *p_admin_info=NULL;
phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
uint8_t index=0;
uint8_t pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
uint8_t cmd = (uint8_t) HCP_MSG_INSTRUCTION_INVALID;
uint8_t response = (uint8_t) ANY_OK;
NFCSTATUS status = NFCSTATUS_SUCCESS;
if( (NULL == psHciContext)
|| (NULL == pHwRef)
|| (HCP_HEADER_LEN > length )
)
{
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
}
else
{
hcp_packet = (phHciNfc_HCP_Packet_t *)pCmd;
hcp_message = &hcp_packet->msg.message;
p_admin_info = psHciContext->p_admin_info;
/* Get the Command instruction bits from the Message Header */
cmd = (uint8_t) GET_BITS8( hcp_message->msg_header,
HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
switch( cmd )
{
/* These are notifications sent by the Host Controller */
case ADM_NOTIFY_PIPE_CREATED:
{
pipe_id = hcp_message->payload[RESPONSE_PIPEID_OFFSET];
p_pipe_info = (phHciNfc_Pipe_Info_t *)
phOsalNfc_GetMemory(sizeof(phHciNfc_Pipe_Info_t));
if(NULL != p_pipe_info)
{
/* The Source Host is the UICC Host */
p_pipe_info->pipe.source.host_id =
hcp_message->payload[index++];
/* The Source Gate is same as the Destination Gate */
p_pipe_info->pipe.source.gate_id =
hcp_message->payload[index++];
/* The Source Host is the Terminal Host */
p_pipe_info->pipe.dest.host_id =
hcp_message->payload[index++];
p_pipe_info->pipe.dest.gate_id =
hcp_message->payload[index++];
p_pipe_info->pipe.pipe_id =
hcp_message->payload[index++];
}
status = phHciNfc_Update_PipeInfo(psHciContext,
&(p_admin_info->pipe_seq), pipe_id, p_pipe_info);
if( NFCSTATUS_SUCCESS == status )
{
psHciContext->p_pipe_list[pipe_id] = p_pipe_info;
if (NULL != p_pipe_info)
{
p_pipe_info->pipe.pipe_id = pipe_id;
}
}
break;
}
case ADM_NOTIFY_PIPE_DELETED:
{
pipe_id = hcp_message->payload[index++];
p_pipe_info = psHciContext->p_pipe_list[pipe_id];
if ( NULL != p_pipe_info )
{
status = phHciNfc_Update_PipeInfo(
psHciContext, &(p_admin_info->pipe_seq),
(uint8_t) HCI_UNKNOWN_PIPE_ID, p_pipe_info);
if(NFCSTATUS_SUCCESS == status )
{
phOsalNfc_FreeMemory(p_pipe_info);
psHciContext->p_pipe_list[pipe_id] = NULL;
}
}
break;
}
/* TODO: Since we receive the Host ID, we need to clear
* all the pipes created with the host
*/
case ADM_NOTIFY_ALL_PIPE_CLEARED:
{
break;
}
/* case ADM_CREATE_PIPE: */
/* case ADM_DELETE_PIPE: */
/* case ADM_CLEAR_ALL_PIPE: */
default:
{
response = ANY_E_CMD_NOT_SUPPORTED;
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_COMMAND_NOT_SUPPORTED);
break;
}
}
hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
(uint8_t) HCI_ADMIN_PIPE_ID,
HCP_MSG_TYPE_RESPONSE, response );
psHciContext->tx_total = HCP_HEADER_LEN;
status = phHciNfc_Send_HCP( (void *)psHciContext, (void *)pHwRef );
p_admin_info->admin_pipe_info->recv_msg_type = HCP_MSG_TYPE_COMMAND;
p_admin_info->admin_pipe_info->sent_msg_type = HCP_MSG_TYPE_RESPONSE;
p_admin_info->admin_pipe_info->prev_msg = response;
p_admin_info->admin_pipe_info->prev_status = NFCSTATUS_PENDING;
}
return status;
}
NFCSTATUS
phNciNfc_CoreRecvManager(void *pCtx,
NFCSTATUS wStatus,
pphNciNfc_sCoreHeaderInfo_t pHdrInfo,
phNciNfc_NciCoreMsgType_t eMsgType)
{
NFCSTATUS wStat = NFCSTATUS_INVALID_PARAMETER;
phNciNfc_TransactInfo_t tTransInfo;
void *pRegList = NULL;
phNciNfc_CoreRegInfo_t tRegInfo;
uint16_t wDataLen = 0;
uint16_t wNumOfNode = 0;
pphNciNfc_CoreContext_t pCoreCtx = (pphNciNfc_CoreContext_t) pCtx;
PH_LOG_NCI_FUNC_ENTRY();
if((NULL != pCoreCtx) && (NULL != pHdrInfo))
{
wStat = NFCSTATUS_SUCCESS;
if((phNciNfc_e_NciCoreMsgTypeCntrlRsp == eMsgType) ||
(phNciNfc_e_NciCoreMsgTypeCntrlNtf == eMsgType))
{
tRegInfo.bGid = (uint8_t)pHdrInfo->Group_ID;
tRegInfo.bOid = (uint8_t)pHdrInfo->Opcode_ID.Val;
if((phNciNfc_e_NciCoreMsgTypeCntrlRsp == eMsgType))
{
PH_LOG_NCI_INFO_STR("Invoke response call back func if registered");
pRegList = (void *)pCoreCtx->tRspCtx.aRspRegList;
}
else
{
PH_LOG_NCI_INFO_STR("Invoke notification call back func if registered");
pRegList = (void *)pCoreCtx->tNtfCtx.aNtfRegList;
}
}
else if(phNciNfc_e_NciCoreMsgTypeData == eMsgType)
{
PH_LOG_NCI_INFO_STR("Invoke data call back func if registered");
pRegList = (void *)pCoreCtx->tDataCtx.aDataRegList;
tRegInfo.bConnId = pHdrInfo->bConn_ID;
}
else
{
wStat = NFCSTATUS_INVALID_PARAMETER;
PH_LOG_NCI_CRIT_STR("Invalid message type!");
}
if(NFCSTATUS_SUCCESS == wStat)
{
/* NOTE: For time being the following operations are being done at this location
1. Allocation of buffer for storing the extracted data from linked list
2. Extraction of received payload from linked list
3. Copy of extracted data to the allocated buffer
#These operation shall be performed at the Nci module level call back in later point of time
*/
if(NFCSTATUS_SUCCESS != wStatus)
{
/* Response time out has happened */
tTransInfo.pbuffer = NULL;
tTransInfo.wLength = 0;
wStat = NFCSTATUS_SUCCESS;
}
else
{
tTransInfo.pbuffer = NULL;
tTransInfo.wLength = 0;
/* Get size of payload present in linked list */
wStat = phNciNfc_CoreGetDataLength(pCoreCtx,&wDataLen, &wNumOfNode);
if(NFCSTATUS_SUCCESS == wStat)
{
PH_LOG_NCI_INFO_U32MSG("Message size received: ",wDataLen);
if(wNumOfNode == 1)
{
/*May need seperate function for getting the pointer value*/
tTransInfo.pbuffer = &(pCoreCtx->tReceiveInfo.ListHead.tMem.aBuffer[PHNCINFC_CORE_PKT_HEADER_LEN]);
tTransInfo.wLength = wDataLen;
}else
{
/* Allocate memory for storing the payload */
tTransInfo.pbuffer = phOsalNfc_GetMemory(wDataLen);
}
if(NULL != tTransInfo.pbuffer)
{
tTransInfo.wLength = wDataLen;
/* Extract the data from linked list and copy it to the allocated buffer */
wStat = phNciNfc_CoreGetData(pCoreCtx,tTransInfo.pbuffer,wDataLen);
}
}
}
if(NFCSTATUS_SUCCESS == wStat)
{
phNciNfc_PrintPacketDescription(pHdrInfo, tTransInfo.pbuffer, tTransInfo.wLength, pCoreCtx->bLogDataMessages);
wStat = phNciNfc_CoreInvokeCb(pRegList,wStatus,&tRegInfo,eMsgType,&tTransInfo);
}
/* Free memory that had been allocated */
if((NULL != tTransInfo.pbuffer) && (wNumOfNode > 1))
{
phOsalNfc_FreeMemory(tTransInfo.pbuffer);
tTransInfo.pbuffer = NULL;
tTransInfo.wLength = 0;
}
/* Delete linked list */
phNciNfc_CoreDeleteList(pCoreCtx);
}
}
PH_LOG_NCI_FUNC_EXIT();
return wStat;
}
/**Handler for Target discovery completion for all remote device types*/
void phHal4Nfc_TargetDiscoveryComplete(
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
void *pInfo
)
{
static phHal4Nfc_DiscoveryInfo_t sDiscoveryInfo;
NFCSTATUS status = NFCSTATUS_SUCCESS;
/**SAK byte*/
uint8_t Sak = 0;
/*Union type to encapsulate and return the discovery info*/
phHal4Nfc_NotificationInfo_t uNotificationInfo;
/*All the following types will be discovered as type A ,and differentiation
will have to be done within this module based on SAK byte and UID info*/
phHal_eRemDevType_t aRemoteDevTypes[3] = {
phHal_eISO14443_A_PICC,
phHal_eNfcIP1_Target,
phHal_eMifare_PICC
};
/*Count is used to add multiple info into remote dvice list for devices that
support multiple protocols*/
uint8_t Count = 0,
NfcIpDeviceCount = 0;/**<Number of NfcIp devices discovered*/
uint16_t nfc_id = 0;
/*remote device info*/
phHal_sRemoteDevInformation_t *psRemoteDevInfo = NULL;
status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
/*Update Hal4 state*/
Hal4Ctxt->Hal4CurrentState = eHal4StateTargetDiscovered;
Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
PHDBG_INFO("Hal4:Remotedevice Discovered");
if(NULL != ((phNfc_sCompletionInfo_t *)pInfo)->info)
{
/*Extract Remote device Info*/
psRemoteDevInfo = (phHal_sRemoteDevInformation_t *)
((phNfc_sCompletionInfo_t *)pInfo)->info;
switch(psRemoteDevInfo->RemDevType)
{
case phHal_eISO14443_A_PICC:/*for TYPE A*/
{
Sak = psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak;
if((Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso14443A)
|| (TRUE == Hal4Ctxt->psADDCtxtInfo->smx_discovery))
{
/*Check if Iso is Supported*/
if(Sak & ISO_14443_BITMASK)
{
Count++;
}
/*Check for Mifare Supported*/
switch( Sak )
{
case 0x01: // 1K Classic
case 0x09: // Mini
case 0x08: // 1K
case 0x18: // 4K
case 0x88: // Infineon 1K
case 0x98: // Pro 4K
case 0xB8: // Pro 4K
case 0x28: // 1K emulation
case 0x38: // 4K emulation
aRemoteDevTypes[Count] = phHal_eMifare_PICC;
Count++;
break;
}
if((0 == Sak)&& (0 == Count))
{
/*Mifare check*/
if((NXP_UID ==
psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Uid[0])
&&(NXP_MIN_UID_LEN <=
psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.UidLength))
{
aRemoteDevTypes[Count] = phHal_eMifare_PICC;
Count++;
}
}
if ( !(Sak & NFCIP_BITMASK) )
{
// Always add a separate 3A target on a separate
// handle, so the upper layers can connect to it.
aRemoteDevTypes[Count] = phHal_eISO14443_3A_PICC;
Count++;
}
}
/*Check for P2P target passive*/
if((Sak & NFCIP_BITMASK) &&
(NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)&&
(Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
& phHal_ePassive106))
{
if( Sak == 0x53 // Fudan card incompatible to ISO18092
&& psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0] == 0x04
&& psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[1] == 0x00
)
{
aRemoteDevTypes[Count] = phHal_eISO14443_3A_PICC;
Count++;
}
else
{
aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
Count++;
}
}
}/*case phHal_eISO14443_A_PICC:*/
break;
case phHal_eNfcIP1_Target:/*P2P target detected*/
aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
Count++;
break;
case phHal_eISO14443_B_PICC: /*TYPE_B*/
#ifdef TYPE_B
aRemoteDevTypes[Count] = phHal_eISO14443_B_PICC;
Count++;
break;
#endif
case phHal_eFelica_PICC: /*Felica*/
#ifdef TYPE_FELICA
{
/*nfc_id is used to differentiate between Felica and NfcIp target
discovered in Type F*/
nfc_id = (((uint16_t)psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm[0])
<< BYTE_SIZE) |
psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm[1];
/*check for NfcIp target*/
if(NXP_NFCIP_NFCID2_ID == nfc_id)
{
if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)
&&((Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
& phHal_ePassive212) ||
(Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
& phHal_ePassive424)))
{
aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
Count++;
}
}
else/*Felica*/
{
if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableFelica212
|| Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableFelica424)
{
aRemoteDevTypes[Count] = phHal_eFelica_PICC;
Count++;
}
}
break;
}
#endif
case phHal_eJewel_PICC: /*Jewel*/
#ifdef TYPE_JEWEL
{
/*Report Jewel tags only if TYPE A is enabled*/
if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso14443A)
{
aRemoteDevTypes[Count] = phHal_eJewel_PICC;
Count++;
}
break;
}
#endif
#ifdef TYPE_ISO15693
case phHal_eISO15693_PICC: /*ISO15693*/
{
if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso15693)
{
aRemoteDevTypes[Count] = phHal_eISO15693_PICC;
Count++;
}
break;
}
#endif /* #ifdef TYPE_ISO15693 */
/*Types currently not supported*/
case phHal_eISO14443_BPrime_PICC:
default:
PHDBG_WARNING("Hal4:Notification for Not supported types");
break;
}/*End of switch*/
/*Update status code to success if atleast one device info is available*/
status = (((NFCSTATUS_SUCCESS != status)
&& (NFCSTATUS_MULTIPLE_TAGS != status))
&&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices != 0))?
NFCSTATUS_SUCCESS:status;
/*Update status to NFCSTATUS_MULTIPLE_PROTOCOLS if count > 1 ,and this
is first discovery notification from Hci*/
status = ((NFCSTATUS_SUCCESS == status)
&&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 0)
&&(Count > 1)?NFCSTATUS_MULTIPLE_PROTOCOLS:status);
/*If multiple protocols are supported ,allocate separate remote device
information for each protocol supported*/
/*Allocate and copy Remote device info into Hal4 Context*/
while(Count)
{
PHDBG_INFO("Hal4:Count is not zero");
--Count;
/*Allocate memory for each of Count number of
devices*/
if(NULL == Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices])
{
Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]
= (phHal_sRemoteDevInformation_t *)
phOsalNfc_GetMemory(
(uint32_t)(
sizeof(phHal_sRemoteDevInformation_t))
);
}
if(NULL == Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices])
{
status = PHNFCSTVAL(CID_NFC_HAL,
NFCSTATUS_INSUFFICIENT_RESOURCES);
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
break;
}
else
{
(void)memcpy(
(void *)Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices],
(void *)psRemoteDevInfo,
sizeof(phHal_sRemoteDevInformation_t)
);
/*Now copy appropriate device type from aRemoteDevTypes array*/
Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]->RemDevType
= aRemoteDevTypes[Count];
/*Increment number of devices*/
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices++;
}/*End of else*/
}/*End of while*/
/*If Upper layer is interested only in P2P notifications*/
if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)
&&(((Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 1)
&&(phHal_eNfcIP1_Target == Hal4Ctxt->rem_dev_list[0]->RemDevType))
||(NULL == Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification))
)
{
PHDBG_INFO("Hal4:Trying to notify P2P Listener");
/*NFCSTATUS_SUCCESS or NFCSTATUS_MULTIPLE_PROTOCOLS*/
if((NFCSTATUS_SUCCESS == status)
||(NFCSTATUS_MULTIPLE_PROTOCOLS == status))
{
/*Pick only the P2P target device info from the list*/
for(Count = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
Count > 0;--Count)
{
/*Only one P2P target can be detected in one discovery*/
if(phHal_eNfcIP1_Target ==
Hal4Ctxt->rem_dev_list[Count-1]->RemDevType)
{
if (Count != 1)
{
(void)memcpy(
(void *)Hal4Ctxt->rem_dev_list[0],
(void *)Hal4Ctxt->rem_dev_list[Count-1],
sizeof(phHal_sRemoteDevInformation_t)
);
}
NfcIpDeviceCount = 1;
break;
}
}
/*If any P2p devices are discovered free other device info*/
while(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > NfcIpDeviceCount)
{
phOsalNfc_FreeMemory(Hal4Ctxt->rem_dev_list[
--Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]);
Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices] = NULL;
}
/*Issue P2P notification*/
if(NfcIpDeviceCount == 1)
{
sDiscoveryInfo.NumberOfDevices
= Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
sDiscoveryInfo.ppRemoteDevInfo = Hal4Ctxt->rem_dev_list;
uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
PHDBG_INFO("Hal4:Calling P2P listener");
(*Hal4Ctxt->sUpperLayerInfo.pP2PNotification)(
(void *)(Hal4Ctxt->sUpperLayerInfo.P2PDiscoveryCtxt),
NFC_DISCOVERY_NOTIFICATION,
uNotificationInfo,
NFCSTATUS_SUCCESS
);
}
else/*Restart Discovery wheel*/
{
PHDBG_INFO("Hal4:No P2P device in list");
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
PHDBG_INFO("Hal4:Restart discovery1");
status = phHciNfc_Restart_Discovery (
(void *)Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref,
FALSE
);
Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
eHal4StateConfiguring:
Hal4Ctxt->Hal4NextState);
}
}
/*More discovery info available ,get next info from HCI*/
else if((NFCSTATUS_MULTIPLE_TAGS == status)
&&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices
< MAX_REMOTE_DEVICES))
{
status = phHciNfc_Select_Next_Target (
Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref
);
}
else/*Failed discovery ,restart discovery*/
{
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
PHDBG_INFO("Hal4:Restart discovery2");
status = phHciNfc_Restart_Discovery (
(void *)Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref,
FALSE
);/*Restart Discovery wheel*/
Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
eHal4StateConfiguring:
Hal4Ctxt->Hal4NextState);
}
}/*if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)...*/
/*Notify if Upper layer is interested in tag notifications,also notify
P2p if its in the list with other tags*/
else if(NULL != Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)
{
PHDBG_INFO("Hal4:Trying to notify Tag notification");
/*Multiple tags in field, get discovery info a second time for the
other devices*/
if((NFCSTATUS_MULTIPLE_TAGS == status)
&&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices < MAX_REMOTE_DEVICES))
{
PHDBG_INFO("Hal4:select next target1");
status = phHciNfc_Select_Next_Target (
Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref
);
}
/*Single tag multiple protocols scenario,Notify Multiple Protocols
status to upper layer*/
else if(status == NFCSTATUS_MULTIPLE_PROTOCOLS)
{
PHDBG_INFO("Hal4:Multiple Tags or protocols");
sDiscoveryInfo.NumberOfDevices
= Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
sDiscoveryInfo.ppRemoteDevInfo = Hal4Ctxt->rem_dev_list;
uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
(*Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)(
(void *)(Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt),
NFC_DISCOVERY_NOTIFICATION,
uNotificationInfo,
status
);
}
else /*NFCSTATUS_SUCCESS*/
{
if(((Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 1)
&&(phHal_eNfcIP1_Target
== Hal4Ctxt->rem_dev_list[0]->RemDevType))
||(NFCSTATUS_SUCCESS != status)
|| (Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 0)
)/*device detected but upper layer is not interested
in the type(P2P) or activate next failed*/
{
while(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > 0)
{
phOsalNfc_FreeMemory(Hal4Ctxt->rem_dev_list[
--Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]);
Hal4Ctxt->rem_dev_list[
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices] = NULL;
}
PHDBG_INFO("Hal4:Restart discovery3");
status = phHciNfc_Restart_Discovery (
(void *)Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref,
FALSE
);/*Restart Discovery wheel*/
Hal4Ctxt->Hal4NextState = (
NFCSTATUS_PENDING == status?eHal4StateConfiguring
:Hal4Ctxt->Hal4NextState
);
}
else/*All remote device info available.Notify to upper layer*/
{
/*Update status for MULTIPLE_TAGS here*/
status = (Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > 1?
NFCSTATUS_MULTIPLE_TAGS:status);
/*If listener is registered ,call it*/
sDiscoveryInfo.NumberOfDevices
= Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
sDiscoveryInfo.ppRemoteDevInfo
= Hal4Ctxt->rem_dev_list;
uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
PHDBG_INFO("Hal4:Calling Discovery Handler1");
(*Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)(
(void *)(Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt),
NFC_DISCOVERY_NOTIFICATION,
uNotificationInfo,
status
);
}
}
} /*else if(NULL != Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)*/
else/*listener not registered ,Restart Discovery wheel*/
{
PHDBG_INFO("Hal4:No listener registered.Ignoring Discovery \
Notification");
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
PHDBG_INFO("Hal4:Restart discovery4");
status = phHciNfc_Restart_Discovery (
(void *)Hal4Ctxt->psHciHandle,
(void *)gpphHal4Nfc_Hwref,
FALSE
);
Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
eHal4StateConfiguring:
Hal4Ctxt->Hal4NextState);
}
}/*if(NULL != ((phNfc_sCompletionInfo_t *)pInfo)->info)*/
NFCSTATUS phLibNfc_Mgt_Initialize(void *pDriverHandle,
pphLibNfc_RspCb_t pInitCb,
void *pContext)
{
NFCSTATUS Status = NFCSTATUS_SUCCESS;
if((NULL == pDriverHandle)||(NULL == pInitCb))
{
Status = NFCSTATUS_INVALID_PARAMETER;
}
else if(NULL == gpphLibContext)
{
/* Initialize the Lib context */
gpphLibContext=(pphLibNfc_LibContext_t)phOsalNfc_GetMemory(
(uint32_t)sizeof(phLibNfc_LibContext_t));
if(NULL == gpphLibContext)
{
Status=NFCSTATUS_INSUFFICIENT_RESOURCES;
}
else
{
(void)memset((void *)gpphLibContext,0,(
(uint32_t)sizeof(phLibNfc_LibContext_t)));
/* Store the Callback and context in LibContext structure*/
gpphLibContext->CBInfo.pClientInitCb=pInitCb;
gpphLibContext->CBInfo.pClientInitCntx=pContext;
/* Initialize the HwReferece structure */
gpphLibContext->psHwReference=(phHal_sHwReference_t *)
phOsalNfc_GetMemory((uint32_t)sizeof(phHal_sHwReference_t));
(void)memset((void *)gpphLibContext->psHwReference,0,
((uint32_t)sizeof(phHal_sHwReference_t)));
/* Allocate the Memory for the Transceive info */
if( gpphLibContext->psHwReference!=NULL)
{
gpphLibContext->psHwReference->p_board_driver = pDriverHandle;
Status = phLibNfc_UpdateNextState(gpphLibContext,
eLibNfcHalStateInitandIdle);
if(Status==NFCSTATUS_SUCCESS)
{
Status=phHal4Nfc_Open(
gpphLibContext->psHwReference,
eInitDefault,
phLibNfc_InitCb,
(void *)gpphLibContext);
}
}
else
{
Status = NFCSTATUS_INSUFFICIENT_RESOURCES;
}
phLibNfc_Ndef_Init();
}
}
else if(gpphLibContext->LibNfcState.next_state==eLibNfcHalStateShutdown)
{
Status = NFCSTATUS_SHUTDOWN;
}
else
{
Status=NFCSTATUS_ALREADY_INITIALISED;
}
return Status;
}
NFCSTATUS phLibNfc_Mgt_ConfigureTestMode(void *pDriverHandle,
pphLibNfc_RspCb_t pTestModeCb,
phLibNfc_Cfg_Testmode_t eTstmode,
void *pContext)
{
NFCSTATUS Status = NFCSTATUS_SUCCESS;
phHal4Nfc_InitType_t eInitType=eInitDefault;
if((NULL == pDriverHandle)||(NULL == pTestModeCb))
{
Status = NFCSTATUS_INVALID_PARAMETER;
}
else if((NULL != gpphLibContext) && \
(gpphLibContext->LibNfcState.next_state==eLibNfcHalStateShutdown))
{
Status = NFCSTATUS_SHUTDOWN;
}
else if( (eTstmode == phLibNfc_TstMode_On) && (NULL != gpphLibContext))
{
Status=NFCSTATUS_ALREADY_INITIALISED;
}
else if( (eTstmode == phLibNfc_TstMode_Off) && (NULL == gpphLibContext))
{
Status = NFCSTATUS_NOT_INITIALISED;
}
else if( (eTstmode == phLibNfc_TstMode_Off) && (NULL != gpphLibContext))
{
if (NULL!= gpphLibContext->CBInfo.pClientShutdownCb)
{ /* Previous callback pending */
Status = NFCSTATUS_BUSY;
}
else
{
Status = NFCSTATUS_PENDING;
if(TRUE != gpphLibContext->status.GenCb_pending_status)
{
Status = phHal4Nfc_Close(gpphLibContext->psHwReference,
phLibNfc_ShutdownCb,
(void *)gpphLibContext);
}
if(Status== NFCSTATUS_PENDING)
{
gpphLibContext->CBInfo.pClientShutdownCb = pTestModeCb;
gpphLibContext->CBInfo.pClientShtdwnCntx = pContext;
gpphLibContext->status.GenCb_pending_status=TRUE;
gpphLibContext->LibNfcState.next_state= eLibNfcHalStateShutdown;
}
else
{
Status =NFCSTATUS_FAILED;
}
}
}
else
{
/* Initialize the Lib context */
gpphLibContext=(pphLibNfc_LibContext_t)phOsalNfc_GetMemory(
(uint32_t)sizeof(phLibNfc_LibContext_t));
if(NULL == gpphLibContext)
{
Status=NFCSTATUS_INSUFFICIENT_RESOURCES;
}
else
{
(void)memset((void *)gpphLibContext,0,(
(uint32_t)sizeof(phLibNfc_LibContext_t)));
/* Store the Callback and context in LibContext structure*/
gpphLibContext->CBInfo.pClientInitCb=pTestModeCb;
gpphLibContext->CBInfo.pClientInitCntx=pContext;
/* Initialize the HwReferece structure */
gpphLibContext->psHwReference=(phHal_sHwReference_t *)
phOsalNfc_GetMemory((uint32_t)sizeof(phHal_sHwReference_t));
(void)memset((void *)gpphLibContext->psHwReference,0,
((uint32_t)sizeof(phHal_sHwReference_t)));
/* Allocate the Memory for the Transceive info */
if( gpphLibContext->psHwReference!=NULL)
{
gpphLibContext->psHwReference->p_board_driver = pDriverHandle;
Status = phLibNfc_UpdateNextState(gpphLibContext,
eLibNfcHalStateInitandIdle);
if(Status==NFCSTATUS_SUCCESS)
{
if(eTstmode == phLibNfc_TstMode_On)
eInitType = eInitTestModeOn;
if(eTstmode == phLibNfc_TstMode_Off)
eInitType = eInitDefault;
Status=phHal4Nfc_Open(
gpphLibContext->psHwReference,
eInitType,
phLibNfc_InitCb,
(void *)gpphLibContext);
}
}
else
{
Status = NFCSTATUS_INSUFFICIENT_RESOURCES;
}
phLibNfc_Ndef_Init();
}
}
return Status;
}
/*Activation complete handler*/
void phHal4Nfc_CEActivateComplete(
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
void *pInfo
)
{
phHal_sEventInfo_t *psEventInfo = (phHal_sEventInfo_t *)pInfo;
pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)Hal4Ctxt->sUpperLayerInfo.HCEEventNotificationCtxt;
NFCSTATUS Status = NFCSTATUS_SUCCESS;
Hal4Ctxt->sTgtConnectInfo.EmulationState = NFC_EVT_ACTIVATED;
/*if P2p notification is registered*/
if( NULL != pLibContext->sCeContext.pCeListenerNtfCb)
{
/*Allocate remote device Info for CE target*/
Hal4Ctxt->rem_dev_list[0]
= (phHal_sRemoteDevInformation_t *)
phOsalNfc_GetMemory(
sizeof(phHal_sRemoteDevInformation_t)
);
if(NULL == Hal4Ctxt->rem_dev_list[0])
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
Status = PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
(void)memset((void *)Hal4Ctxt->rem_dev_list[0],
0,sizeof(phHal_sRemoteDevInformation_t));
/*Copy device info*/
(void)memcpy(Hal4Ctxt->rem_dev_list[0],
psEventInfo->eventInfo.pRemoteDevInfo,
sizeof(phHal_sRemoteDevInformation_t)
);
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 1;
/*Allocate Trcv context info*/
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
Hal4Ctxt->psTrcvCtxtInfo= (pphHal4Nfc_TrcvCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_TrcvCtxtInfo_t)));
if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
{
(void)memset(Hal4Ctxt->psTrcvCtxtInfo,0,
sizeof(phHal4Nfc_TrcvCtxtInfo_t));
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus
= NFCSTATUS_PENDING;
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= PH_OSALNFC_INVALID_TIMER_ID;
}
}
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
Status= PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
/*Update state*/
Hal4Ctxt->Hal4CurrentState = eHal4StateEmulation;
Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
/*set session Opened ,this will keep track of whether the session
is alive.will be reset if a Event DEACTIVATED is received*/
Hal4Ctxt->rem_dev_list[0]->SessionOpened = TRUE;
Hal4Ctxt->sTgtConnectInfo.psConnectedDevice = Hal4Ctxt->rem_dev_list[0];
gpphLibContext->Connected_handle = Hal4Ctxt->sTgtConnectInfo.psConnectedDevice;
if(psEventInfo->eventSource==phHal_eISO14443_A_PICC)
{
(*pLibContext->sCeContext.pCeListenerNtfCb)(
pLibContext->sCeContext.pCeListenerCtxt,
phLibNfc_eCE_A_EvtActivated,
(uint32_t)Hal4Ctxt->rem_dev_list[0],
Status);
}
else
{
(*pLibContext->sCeContext.pCeListenerNtfCb)(
pLibContext->sCeContext.pCeListenerCtxt,
phLibNfc_eCE_B_EvtActivated,
(uint32_t)Hal4Ctxt->rem_dev_list[0],
Status);
}
}
}
}
return;
}
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;
}
/*Activation complete handler*/
void phHal4Nfc_P2PActivateComplete(
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
void *pInfo
)
{
phHal_sEventInfo_t *psEventInfo = (phHal_sEventInfo_t *)pInfo;
NFCSTATUS Status = NFCSTATUS_SUCCESS;
static phHal4Nfc_DiscoveryInfo_t sDiscoveryInfo;
/*Copy notification info to provide to upper layer*/
phHal4Nfc_NotificationInfo_t uNotificationInfo = {&sDiscoveryInfo};
Hal4Ctxt->sTgtConnectInfo.EmulationState = NFC_EVT_ACTIVATED;
/*if P2p notification is registered*/
if( NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)
{
/*Allocate remote device Info for P2P target*/
uNotificationInfo.psDiscoveryInfo->NumberOfDevices = 1;
if(NULL == Hal4Ctxt->rem_dev_list[0])
{
Hal4Ctxt->rem_dev_list[0]
= (phHal_sRemoteDevInformation_t *)
phOsalNfc_GetMemory(
sizeof(phHal_sRemoteDevInformation_t)
);
}
if(NULL == Hal4Ctxt->rem_dev_list[0])
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
Status = PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
(void)memset((void *)Hal4Ctxt->rem_dev_list[0],
0,sizeof(phHal_sRemoteDevInformation_t));
/*Copy device info*/
(void)memcpy(Hal4Ctxt->rem_dev_list[0],
psEventInfo->eventInfo.pRemoteDevInfo,
sizeof(phHal_sRemoteDevInformation_t)
);
/*Allocate Trcv context info*/
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
Hal4Ctxt->psTrcvCtxtInfo= (pphHal4Nfc_TrcvCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_TrcvCtxtInfo_t)));
if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
{
(void)memset(Hal4Ctxt->psTrcvCtxtInfo,0,
sizeof(phHal4Nfc_TrcvCtxtInfo_t));
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus
= NFCSTATUS_PENDING;
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= PH_OSALNFC_INVALID_TIMER_ID;
}
}
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
Status= PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
/*Update state*/
Hal4Ctxt->Hal4CurrentState = eHal4StateEmulation;
Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
uNotificationInfo.psDiscoveryInfo->ppRemoteDevInfo
= Hal4Ctxt->rem_dev_list;
/*set session Opened ,this will keep track of whether the session
is alive.will be reset if a Event DEACTIVATED is received*/
Hal4Ctxt->rem_dev_list[0]->SessionOpened = TRUE;
(*Hal4Ctxt->sUpperLayerInfo.pP2PNotification)(
Hal4Ctxt->sUpperLayerInfo.P2PDiscoveryCtxt,
NFC_DISCOVERY_NOTIFICATION,
uNotificationInfo,
Status
);
}
}
}
return;
}
/**Configure the discovery*/
NFCSTATUS phHal4Nfc_ConfigureDiscovery(
phHal_sHwReference_t *psHwReference,
phHal_eDiscoveryConfigMode_t discoveryMode,
phHal_sADD_Cfg_t *discoveryCfg,
pphHal4Nfc_GenCallback_t pConfigCallback,
void *pContext
)
{
NFCSTATUS CfgStatus = NFCSTATUS_SUCCESS;
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
if(NULL == psHwReference
|| NULL == pConfigCallback
|| NULL == discoveryCfg
)
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
}
else if((NULL == psHwReference->hal_context)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4CurrentState
< eHal4StateOpenAndReady)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4NextState
== eHal4StateClosed))
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
}
else
{
Hal4Ctxt = psHwReference->hal_context;
/*If previous Configuration request has not completed ,do not allow
new configuration*/
if(Hal4Ctxt->Hal4NextState == eHal4StateConfiguring)
{
PHDBG_INFO("Hal4:PollCfg in progress.Returning status Busy");
CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_BUSY);
}
else if(Hal4Ctxt->Hal4CurrentState >= eHal4StateOpenAndReady)
{
if (NULL == Hal4Ctxt->psADDCtxtInfo)
{
Hal4Ctxt->psADDCtxtInfo= (pphHal4Nfc_ADDCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_ADDCtxtInfo_t)));
if(NULL != Hal4Ctxt->psADDCtxtInfo)
{
(void)memset(Hal4Ctxt->psADDCtxtInfo,0,
sizeof(phHal4Nfc_ADDCtxtInfo_t)
);
}
}
if(NULL == Hal4Ctxt->psADDCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
CfgStatus= PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
/*Register Upper layer context*/
#ifdef LLCP_DISCON_CHANGES
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCfgDiscCtxt = pContext;
#else /* #ifdef LLCP_DISCON_CHANGES */
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
#endif /* #ifdef LLCP_DISCON_CHANGES */
switch(discoveryMode)
{
case NFC_DISCOVERY_START:
PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_START");
break;
case NFC_DISCOVERY_CONFIG:
PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_CONFIG");
/*Since sADDCfg is allocated in stack ,copy the ADD
configuration structure to HAL4 context*/
(void)memcpy((void *)
&(Hal4Ctxt->psADDCtxtInfo->sADDCfg),
(void *)discoveryCfg,
sizeof(phHal_sADD_Cfg_t)
);
PHDBG_INFO("Hal4:Finished copying sADDCfg");
Hal4Ctxt->psADDCtxtInfo->smx_discovery = FALSE;
#ifdef UPDATE_NFC_ACTIVE
Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollCfgInfo.EnableNfcActive
= ( 0 == Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode?
Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode:
NXP_NFCIP_ACTIVE_DEFAULT);
Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode = ((
Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode <<
(NXP_NFCIP_ACTIVE_DEFAULT * NFCIP_ACTIVE_SHIFT))
| Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode);
#endif/*#ifdef UPDATE_NFC_ACTIVE*/
/* information system_code(Felica) and
AFI(ReaderB) to be populated later */
CfgStatus = phHciNfc_Config_Discovery(
(void *)Hal4Ctxt->psHciHandle,
(void *)psHwReference,
&(Hal4Ctxt->psADDCtxtInfo->sADDCfg)
);/*Configure HCI Discovery*/
break;
case NFC_DISCOVERY_STOP:
break;
/*Restart Discovery wheel*/
case NFC_DISCOVERY_RESUME:
PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_RESUME");
Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
CfgStatus = phHciNfc_Restart_Discovery (
(void *)Hal4Ctxt->psHciHandle,
(void *)psHwReference,
FALSE
);
break;
default:
break;
}
/* Change the State of the HAL only if HCI Configure
Returns status as Pending */
if ( NFCSTATUS_PENDING == CfgStatus )
{
(void)memcpy((void *)
&(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig),
(void *)&(discoveryCfg->PollDevInfo.PollCfgInfo),
sizeof(phHal_sPollDevInfo_t)
);
PHDBG_INFO("Hal4:Finished copying PollCfgInfo");
PHDBG_INFO("Hal4:Configure returned NFCSTATUS_PENDING");
Hal4Ctxt->Hal4NextState = eHal4StateConfiguring;
Hal4Ctxt->sUpperLayerInfo.pConfigCallback
= pConfigCallback;
}
else/*Configure failed.Restore old poll dev info*/
{
(void)memcpy((void *)
&(Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollCfgInfo),
(void *)&(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig),
sizeof(phHal_sPollDevInfo_t)
);
}
}
}
else
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
}
}
return CfgStatus;
}
NFCSTATUS
phHal4Nfc_Receive(
phHal_sHwReference_t *psHwReference,
phHal4Nfc_TransactInfo_t *psRecvInfo,
pphHal4Nfc_ReceiveCallback_t pReceiveCallback,
void *pContext
)
{
NFCSTATUS RetStatus = NFCSTATUS_PENDING;
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
/*NULL checks*/
if((NULL == psHwReference)
||( NULL == pReceiveCallback)
||( NULL == psRecvInfo))
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
}
/*Check initialised state*/
else if((NULL == psHwReference->hal_context)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4CurrentState
< eHal4StateOpenAndReady)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4NextState
== eHal4StateClosed))
{
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
}
else
{
Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
if(NFC_EVT_ACTIVATED == Hal4Ctxt->sTgtConnectInfo.EmulationState)
{
/*Following condition gets satisfied only on target side,if receive
is not already called*/
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
Hal4Ctxt->psTrcvCtxtInfo= (pphHal4Nfc_TrcvCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_TrcvCtxtInfo_t)));
if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
{
(void)memset(Hal4Ctxt->psTrcvCtxtInfo,0,
sizeof(phHal4Nfc_TrcvCtxtInfo_t));
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= PH_OSALNFC_INVALID_TIMER_ID;
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus = NFCSTATUS_PENDING;
}
}
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
RetStatus= PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else /*Store callback & Return status pending*/
{
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
/*Register upper layer callback*/
Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb = NULL;
Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb = pReceiveCallback;
if(NFCSTATUS_PENDING !=
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus)
{
/**Create a timer to send received data in the callback*/
if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
== PH_OSALNFC_INVALID_TIMER_ID)
{
PHDBG_INFO("HAL4: Transaction Timer Create for Receive");
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= phOsalNfc_Timer_Create();
}
if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
== PH_OSALNFC_INVALID_TIMER_ID)
{
RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else/*start the timer*/
{
phOsalNfc_Timer_Start(
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId,
PH_HAL4NFC_RECV_CB_TIMEOUT,
phHal4Nfc_P2PRecvTimerCb,
NULL
);
}
}
}
}
else/*deactivated*/
{
RetStatus= PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_DESELECTED);
}
}
return RetStatus;
}
NFCSTATUS phHal4Nfc_ConfigParameters(
phHal_sHwReference_t *psHwReference,
phHal_eConfigType_t CfgType,
phHal_uConfig_t *puConfig,
pphHal4Nfc_GenCallback_t pConfigCallback,
void *pContext
)
{
NFCSTATUS CfgStatus = NFCSTATUS_SUCCESS;
phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
/*NULL checks*/
if(NULL == psHwReference
|| NULL == pConfigCallback
|| NULL == puConfig
)
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
}
/*Check if initialised*/
else if((NULL == psHwReference->hal_context)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4CurrentState
< eHal4StateOpenAndReady)
|| (((phHal4Nfc_Hal4Ctxt_t *)
psHwReference->hal_context)->Hal4NextState
== eHal4StateClosed))
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
}
else
{
Hal4Ctxt = psHwReference->hal_context;
/*If previous Configuration request has not completed,do not allow new
configuration*/
if(Hal4Ctxt->Hal4NextState == eHal4StateConfiguring)
{
PHDBG_INFO("Hal4:PollCfg in progress.Returning status Busy");
CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_BUSY);
}
else if(Hal4Ctxt->Hal4CurrentState >= eHal4StateOpenAndReady)
{
/*Allocate ADD context*/
if (NULL == Hal4Ctxt->psADDCtxtInfo)
{
Hal4Ctxt->psADDCtxtInfo= (pphHal4Nfc_ADDCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_ADDCtxtInfo_t)));
if(NULL != Hal4Ctxt->psADDCtxtInfo)
{
(void)memset(Hal4Ctxt->psADDCtxtInfo,0,
sizeof(phHal4Nfc_ADDCtxtInfo_t)
);
}
}
if(NULL == Hal4Ctxt->psADDCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
CfgStatus= PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
/*Register Upper layer context*/
#ifdef LLCP_DISCON_CHANGES
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCfgDiscCtxt = pContext;
#else /* #ifdef LLCP_DISCON_CHANGES */
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
#endif /* #ifdef LLCP_DISCON_CHANGES */
switch(CfgType)
{
/*NFC_EMULATION_CONFIG*/
case NFC_EMULATION_CONFIG:
{
(void)memcpy((void *)&Hal4Ctxt->uConfig,
(void *)puConfig,
sizeof(phHal_uConfig_t)
);
break;
}
/*P2P Configuration*/
case NFC_P2P_CONFIG:
{
/*If general bytes are not provided by above layer copy zeros
in general bytes*/
if(puConfig->nfcIPConfig.generalBytesLength == 0)
{
Hal4Ctxt->uConfig.nfcIPConfig.generalBytesLength = 0x00;
(void)memset(Hal4Ctxt->uConfig.nfcIPConfig.generalBytes,
0,Hal4Ctxt->uConfig.nfcIPConfig.generalBytesLength
);
}
else
{
(void)memcpy((void *)&Hal4Ctxt->uConfig,
(void *)puConfig,
sizeof(phHal_uConfig_t)
);
}
break;
}
/*Protection config*/
case NFC_SE_PROTECTION_CONFIG:
{
#ifdef IGNORE_EVT_PROTECTED
Hal4Ctxt->Ignore_Event_Protected = FALSE;
#endif/*#ifdef IGNORE_EVT_PROTECTED*/
(void)memcpy((void *)&Hal4Ctxt->uConfig,
(void *)puConfig,
sizeof(phHal_uConfig_t)
);
break;
}
default:
CfgStatus = NFCSTATUS_FAILED;
break;
}
if ( NFCSTATUS_SUCCESS == CfgStatus )
{
/*Issue configure with given configuration*/
CfgStatus = phHciNfc_Configure(
(void *)Hal4Ctxt->psHciHandle,
(void *)psHwReference,
CfgType,
&Hal4Ctxt->uConfig
);
/* Change the State of the HAL only if status is Pending */
if ( NFCSTATUS_PENDING == CfgStatus )
{
Hal4Ctxt->Hal4NextState = eHal4StateConfiguring;
Hal4Ctxt->sUpperLayerInfo.pConfigCallback
= pConfigCallback;
}
}
}
}
else
{
phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
}
}
return CfgStatus;
}
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_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;
}
/**Receive complete handler*/
void phHal4Nfc_RecvCompleteHandler(phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,void *pInfo)
{
pphHal4Nfc_ReceiveCallback_t pUpperRecvCb = NULL;
pphHal4Nfc_TransceiveCallback_t pUpperTrcvCb = NULL;
NFCSTATUS RecvStatus = ((phNfc_sTransactionInfo_t *)pInfo)->status;
/*allocate TrcvContext if not already allocated.Required since
Receive complete can occur before any other send /receive calls.*/
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
Hal4Ctxt->psTrcvCtxtInfo= (pphHal4Nfc_TrcvCtxtInfo_t)
phOsalNfc_GetMemory((uint32_t)
(sizeof(phHal4Nfc_TrcvCtxtInfo_t)));
if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
{
(void)memset(Hal4Ctxt->psTrcvCtxtInfo,0,
sizeof(phHal4Nfc_TrcvCtxtInfo_t));
Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
= PH_OSALNFC_INVALID_TIMER_ID;
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus
= NFCSTATUS_MORE_INFORMATION;
}
}
if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
RecvStatus = PHNFCSTVAL(CID_NFC_HAL ,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
else
{
/*Allocate 4K buffer to copy the received data into*/
if(NULL == Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
{
Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
= (uint8_t *)phOsalNfc_GetMemory(
PH_HAL4NFC_MAX_RECEIVE_BUFFER
);
if(NULL == Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
{
phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,
0);
RecvStatus = NFCSTATUS_INSUFFICIENT_RESOURCES;
}
else/*memset*/
{
(void)memset(
Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer,
0,
PH_HAL4NFC_MAX_RECEIVE_BUFFER
);
}
}
if(RecvStatus != NFCSTATUS_INSUFFICIENT_RESOURCES)
{
/*Copy the data*/
(void)memcpy(
(Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
+ Hal4Ctxt->psTrcvCtxtInfo->P2PRecvLength),
((phNfc_sTransactionInfo_t *)pInfo)->buffer,
((phNfc_sTransactionInfo_t *)pInfo)->length
);
/*Update P2PRecvLength,this also acts as the offset to append more
received bytes*/
Hal4Ctxt->psTrcvCtxtInfo->P2PRecvLength
+= ((phNfc_sTransactionInfo_t *)pInfo)->length;
Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length
= Hal4Ctxt->psTrcvCtxtInfo->P2PRecvLength;
}
if(RecvStatus != NFCSTATUS_MORE_INFORMATION)
{
Hal4Ctxt->psTrcvCtxtInfo->P2PRecvLength = 0;
Hal4Ctxt->Hal4NextState = (eHal4StateTransaction
== Hal4Ctxt->Hal4NextState?eHal4StateInvalid:Hal4Ctxt->Hal4NextState);
if(NFCSTATUS_PENDING == Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus)
{
/*Initiator case*/
if(NULL != Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb)
{
RecvStatus =(NFCSTATUS_RF_TIMEOUT == RecvStatus?
NFCSTATUS_DESELECTED:RecvStatus);
pUpperTrcvCb = Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb;
Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb = NULL;
Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData
= &(Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData);
(*pUpperTrcvCb)(
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData,
RecvStatus
);
}
/*P2P target*/
else if(NULL != Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb)
{
pUpperRecvCb = Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb;
Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb = NULL;
Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData
= &(Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData);
(*pUpperRecvCb)(
Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData,
RecvStatus
);
}
else
{
/*Receive data buffer is complete with data & P2P receive has
not yet been called*/
Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus
= NFCSTATUS_SUCCESS;
}
}
}
}
return;
}
