| /* |
| * Copyright (C) 2010 NXP Semiconductors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /*! |
| * \file phHal4Nfc.c |
| * \brief Hal4Nfc source. |
| * |
| * Project: NFC-FRI 1.1 |
| * |
| * $Date: Fri Jun 11 09:32:23 2010 $ |
| * $Author: ing07385 $ |
| * $Revision: 1.192 $ |
| * $Aliases: NFC_FRI1.1_WK1023_R35_1 $ |
| * |
| */ |
| |
| /* ---------------------------Include files ---------------------------------*/ |
| |
| #include <phHal4Nfc.h> |
| #include <phHal4Nfc_Internal.h> |
| #include <phOsalNfc.h> |
| #include <phHciNfc.h> |
| #include <phLlcNfc.h> |
| #include <phDal4Nfc.h> |
| #include <phDnldNfc.h> |
| #include <phOsalNfc_Timer.h> |
| |
| /* ------------------------------- Macros -----------------------------------*/ |
| #ifndef HAL_UNIT_TEST |
| #define STATIC static |
| #else |
| #define STATIC |
| #endif/*#ifndef UNIT_TEST*/ |
| #define HAL4_LAYERS 3 |
| #define LAYER_HCI 2 |
| #define LAYER_LLC 1 |
| #define LAYER_DAL 0 |
| |
| /* --------------------Structures and enumerations --------------------------*/ |
| |
| phHal_sHwReference_t *gpphHal4Nfc_Hwref; |
| |
| static void phHal4Nfc_IoctlComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ); |
| |
| static void phHal4Nfc_LowerNotificationHandler( |
| void *pContext, |
| void *pHwRef, |
| uint8_t type, |
| void *pInfo |
| ); |
| static void phHal4Nfc_HandleEvent( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ); |
| |
| static void phHal4Nfc_OpenComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ); |
| |
| static void phHal4Nfc_CloseComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ); |
| |
| static void phHal4Nfc_DownloadComplete( |
| void *pContext, |
| void *pHwRef, |
| uint8_t type, |
| void *pInfo |
| ); |
| |
| static NFCSTATUS phHal4Nfc_Configure_Layers( |
| phNfcLayer_sCfg_t **pphLayer |
| ); |
| |
| |
| /*Callback for Self tests*/ |
| static void phHal4Nfc_SelfTestComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ); |
| |
| /** |
| * The open callback function to be called by the HCI when open (initializaion) |
| * sequence is completed or if there is an error in initialization. |
| * It is passed as a parameter to HCI when calling HCI Init. |
| */ |
| |
| static void phHal4Nfc_OpenComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ) |
| { |
| NFCSTATUS status = ((phNfc_sCompletionInfo_t *)pInfo)->status; |
| pphHal4Nfc_GenCallback_t pUpper_OpenCb |
| = Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb; |
| void *pUpper_Context |
| = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| if(status == NFCSTATUS_SUCCESS) |
| { |
| PHDBG_INFO("Hal4:Open Successful"); |
| #ifdef MERGE_SAK_SW1 /*Software Workaround*/ |
| if(eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState) |
| { |
| status = phHciNfc_System_Configure ( |
| Hal4Ctxt->psHciHandle, |
| (void *)gpphHal4Nfc_Hwref, |
| PH_HAL4NFC_TGT_MERGE_ADDRESS, |
| PH_HAL4NFC_TGT_MERGE_SAK /*config value*/ |
| ); |
| } |
| if(NFCSTATUS_PENDING != status) |
| #endif/*#ifdef MERGE_SAK_SW1*/ |
| { |
| /*Update State*/ |
| Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb = NULL; |
| if(NULL != pUpper_OpenCb) |
| { |
| /*Upper layer's Open Cb*/ |
| (*pUpper_OpenCb)(Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt, |
| NFCSTATUS_SUCCESS |
| ); |
| } |
| } |
| } |
| else/*Open did not succeed.Go back to reset state*/ |
| { |
| Hal4Ctxt->Hal4CurrentState = eHal4StateClosed; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| Hal4Ctxt->psHciHandle = NULL; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg); |
| Hal4Ctxt->pHal4Nfc_LayerCfg = NULL; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt); |
| gpphHal4Nfc_Hwref->hal_context = NULL; |
| gpphHal4Nfc_Hwref = NULL; |
| PHDBG_INFO("Hal4:Open Failed"); |
| /*Call upper layer's Open Cb with error status*/ |
| if(NULL != pUpper_OpenCb) |
| { |
| /*Upper layer's Open Cb*/ |
| (*pUpper_OpenCb)(pUpper_Context,status); |
| } |
| } |
| return; |
| } |
| |
| /** |
| * The close callback function called by the HCI when close sequence is |
| * completed or if there is an error in closing. |
| * It is passed as a parameter to HCI when calling HCI Release. |
| */ |
| static void phHal4Nfc_CloseComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ) |
| { |
| NFCSTATUS status= ((phNfc_sCompletionInfo_t *)pInfo)->status; |
| pphHal4Nfc_GenCallback_t pUpper_CloseCb; |
| void *pUpper_Context; |
| uint8_t RemoteDevNumber = 0; |
| pUpper_CloseCb = Hal4Ctxt->sUpperLayerInfo.pUpperCloseCb; |
| pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| /*Update state*/ |
| Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| /*If Closed successfully*/ |
| if(NFCSTATUS_SUCCESS == status) |
| { |
| Hal4Ctxt->psHciHandle = NULL; |
| /*Free all heap allocations*/ |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg); |
| Hal4Ctxt->pHal4Nfc_LayerCfg = NULL; |
| /*Free ADD context info*/ |
| if(NULL != Hal4Ctxt->psADDCtxtInfo) |
| { |
| while(RemoteDevNumber < MAX_REMOTE_DEVICES) |
| { |
| if(NULL != Hal4Ctxt->rem_dev_list[RemoteDevNumber]) |
| { |
| phOsalNfc_FreeMemory((void *) |
| (Hal4Ctxt->rem_dev_list[RemoteDevNumber])); |
| Hal4Ctxt->rem_dev_list[RemoteDevNumber] = NULL; |
| } |
| RemoteDevNumber++; |
| } |
| Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0; |
| phOsalNfc_FreeMemory(Hal4Ctxt->psADDCtxtInfo); |
| }/*if(NULL != Hal4Ctxt->psADDCtxtInfo)*/ |
| /*Free Trcv context info*/ |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo) |
| { |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer) |
| { |
| phOsalNfc_FreeMemory( |
| Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer |
| ); |
| } |
| if((NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice) |
| && (NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData)) |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData); |
| } |
| phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo); |
| }/*if(NULL != Hal4Ctxt->psTrcvCtxtInfo)*/ |
| /*Free Hal context and Hardware reference*/ |
| gpphHal4Nfc_Hwref->hal_context = NULL; |
| gpphHal4Nfc_Hwref = NULL; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt); |
| }/* if(NFCSTATUS_SUCCESS == status)*/ |
| /*Call Upper layer's Close Cb with status*/ |
| (*pUpper_CloseCb)(pUpper_Context,status); |
| return; |
| } |
| |
| |
| /* |
| * For configuring the various layers during the Initialization call |
| * |
| * |
| */ |
| static |
| NFCSTATUS |
| phHal4Nfc_Configure_Layers( |
| phNfcLayer_sCfg_t **pphLayer |
| ) |
| { |
| uint8_t index = HAL4_LAYERS - 1; |
| uint8_t i = 0; |
| NFCSTATUS status = NFCSTATUS_SUCCESS ; |
| PHDBG_INFO("Hal4:Configuring layers"); |
| *pphLayer = (phNfcLayer_sCfg_t *) phOsalNfc_GetMemory( |
| sizeof(phNfcLayer_sCfg_t) * HAL4_LAYERS); |
| |
| if( NULL == *pphLayer) |
| { |
| status = PHNFCSTVAL(CID_NFC_HAL, |
| NFCSTATUS_INSUFFICIENT_RESOURCES);/*Memory allocation error*/ |
| } |
| else |
| { |
| |
| (void)memset((void *)*pphLayer,0,( |
| sizeof(phNfcLayer_sCfg_t) * HAL4_LAYERS)); |
| |
| for(i=0 ; i < HAL4_LAYERS ;i++, index-- ) |
| { |
| (*pphLayer + i)->layer_index = index; |
| switch(index) |
| { |
| case LAYER_HCI: /*Configure Hci*/ |
| { |
| (*pphLayer+i)->layer_name =(uint8_t *) "Hci"; |
| (*pphLayer+i)->layer_registry = NULL; |
| (*pphLayer+i)->layer_next = |
| (((phNfcLayer_sCfg_t *)*pphLayer) + i + 1); |
| break; |
| } |
| case LAYER_LLC:/*Configure LLC*/ |
| { |
| (*pphLayer+i)->layer_registry = phLlcNfc_Register; |
| (*pphLayer+i)->layer_name = (uint8_t *)"Llc"; |
| (*pphLayer+i)->layer_next = |
| (((phNfcLayer_sCfg_t *)*pphLayer) + i + 1); |
| break; |
| } |
| case LAYER_DAL: /*Configure the DAL*/ |
| { |
| (*pphLayer+i)->layer_registry = phDal4Nfc_Register; |
| (*pphLayer+i)->layer_name = (uint8_t *)"Dal"; |
| (*pphLayer+i)->layer_next = NULL ; |
| break; |
| } |
| default: |
| break; |
| } /* End of Switch */ |
| } /* End of For Loop */ |
| } /* End of NULL Check */ |
| |
| return status ; |
| } |
| |
| |
| |
| #ifdef ANDROID |
| |
| #define LOG_TAG "NFC-HCI" |
| |
| #include <utils/Log.h> |
| #include <dlfcn.h> |
| |
| #define FW_PATH "/system/vendor/firmware/libpn544_fw.so" |
| |
| const unsigned char *nxp_nfc_full_version = NULL; |
| const unsigned char *nxp_nfc_fw = NULL; |
| |
| int dlopen_firmware() { |
| void *p; |
| |
| void *handle = dlopen(FW_PATH, RTLD_NOW); |
| if (handle == NULL) { |
| ALOGE("Could not open %s", FW_PATH); |
| return -1; |
| } |
| |
| p = dlsym(handle, "nxp_nfc_full_version"); |
| if (p == NULL) { |
| ALOGE("Could not link nxp_nfc_full_version"); |
| return -1; |
| } |
| nxp_nfc_full_version = (unsigned char *)p; |
| |
| p = dlsym(handle, "nxp_nfc_fw"); |
| if (p == NULL) { |
| ALOGE("Could not link nxp_nfc_fw"); |
| return -1; |
| } |
| nxp_nfc_fw = (unsigned char *)p; |
| |
| return 0; |
| } |
| #endif |
| |
| /** |
| * The open function called by the upper HAL when HAL4 is to be opened |
| * (initialized). |
| * |
| */ |
| NFCSTATUS phHal4Nfc_Open( |
| phHal_sHwReference_t *psHwReference, |
| phHal4Nfc_InitType_t InitType, |
| pphHal4Nfc_GenCallback_t pOpenCallback, |
| void *pContext |
| ) |
| { |
| NFCSTATUS openRetVal = NFCSTATUS_SUCCESS; |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| phHciNfc_Init_t eHciInitType = (phHciNfc_Init_t)InitType; |
| /*Set Default Clock settings once*/ |
| static phHal_sHwConfig_t sHwConfig = { |
| {0}, |
| NXP_DEFAULT_CLK_REQUEST, |
| NXP_DEFAULT_INPUT_CLK |
| }; |
| /*NULL checks*/ |
| if(NULL == psHwReference || NULL == pOpenCallback) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| openRetVal = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER); |
| } |
| else if(NULL != gpphHal4Nfc_Hwref) |
| { |
| /*Hal4 context is open or open in progress ,return Ctxt already open*/ |
| openRetVal = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_ALREADY_INITIALISED); |
| } |
| else/*Do an initialization*/ |
| { |
| #ifdef ANDROID |
| dlopen_firmware(); |
| #endif |
| |
| /*If hal4 ctxt in Hwreference is NULL create a new context*/ |
| if(NULL == ((phHal_sHwReference_t *)psHwReference)->hal_context) |
| { |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *) |
| phOsalNfc_GetMemory((uint32_t)sizeof( |
| phHal4Nfc_Hal4Ctxt_t) |
| ); |
| ((phHal_sHwReference_t *)psHwReference)->hal_context = Hal4Ctxt; |
| } |
| else/*Take context from Hw reference*/ |
| { |
| Hal4Ctxt = ((phHal_sHwReference_t *)psHwReference)->hal_context; |
| } |
| if(NULL == Hal4Ctxt) |
| { |
| openRetVal = PHNFCSTVAL(CID_NFC_HAL, |
| NFCSTATUS_INSUFFICIENT_RESOURCES); |
| } |
| else |
| { |
| (void)memset((void *)Hal4Ctxt, |
| 0, |
| ((uint32_t)sizeof(phHal4Nfc_Hal4Ctxt_t))); |
| /* Configure layers if not configured */ |
| if( NULL == Hal4Ctxt->pHal4Nfc_LayerCfg ) |
| { |
| openRetVal = phHal4Nfc_Configure_Layers( |
| &(Hal4Ctxt->pHal4Nfc_LayerCfg) |
| ); |
| } |
| |
| if( openRetVal == NFCSTATUS_SUCCESS ) |
| { |
| /*update Next state*/ |
| Hal4Ctxt->Hal4NextState = (HCI_NFC_DEVICE_TEST == eHciInitType? |
| eHal4StateSelfTestMode:eHal4StateOpenAndReady); |
| /*Store callback and context ,and set Default settings in Context*/ |
| Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb = pOpenCallback; |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext; |
| Hal4Ctxt->sTgtConnectInfo.EmulationState = NFC_EVT_DEACTIVATED; |
| gpphHal4Nfc_Hwref = psHwReference; |
| PHDBG_INFO("Hal4:Calling Hci-Init"); |
| openRetVal = phHciNfc_Initialise ( |
| (void *)&Hal4Ctxt->psHciHandle, |
| psHwReference, |
| eHciInitType, |
| &sHwConfig, |
| (pphNfcIF_Notification_CB_t) |
| phHal4Nfc_LowerNotificationHandler, |
| (void *)Hal4Ctxt, |
| Hal4Ctxt->pHal4Nfc_LayerCfg |
| ); |
| /*Hci Init did not succeed.free Resources and return*/ |
| if( (openRetVal != NFCSTATUS_SUCCESS) |
| && (PHNFCSTATUS (openRetVal) != NFCSTATUS_PENDING) ) |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt->pHal4Nfc_LayerCfg); |
| phOsalNfc_FreeMemory(Hal4Ctxt); |
| Hal4Ctxt = NULL; |
| } |
| }/*if( openRetVal == NFCSTATUS_SUCCESS )*/ |
| else/*Free the context*/ |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt); |
| }/*else*/ |
| } |
| } |
| return openRetVal; |
| } |
| |
| /** The I/O Control function allows the caller to use (vendor-) specific |
| * functionality provided by the lower layer or by the hardware. */ |
| NFCSTATUS phHal4Nfc_Ioctl( |
| phHal_sHwReference_t *psHwReference, |
| uint32_t IoctlCode, |
| phNfc_sData_t *pInParam, |
| phNfc_sData_t *pOutParam, |
| pphHal4Nfc_IoctlCallback_t pIoctlCallback, |
| void *pContext |
| ) |
| { |
| NFCSTATUS RetStatus = NFCSTATUS_FAILED; |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| uint32_t config_type = 0; |
| uint8_t ind = 0; |
| /*NULL checks*/ |
| if((NULL == psHwReference) |
| || (NULL == pIoctlCallback) |
| ) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER); |
| } |
| /*Only the Ioctls NFC_FW_DOWNLOAD_CHECK and NFC_FW_DOWNLOAD are allowed in |
| the uninitialized state of HAL*/ |
| else if(NULL == psHwReference->hal_context) |
| { |
| #ifdef FW_DOWNLOAD |
| |
| #if !defined (NXP_FW_INTEGRITY_VERIFY) |
| if(NFC_FW_DOWNLOAD_CHECK == IoctlCode) |
| { |
| RetStatus = phDnldNfc_Run_Check( |
| psHwReference |
| ); |
| } |
| else |
| #endif /* !defined (NXP_FW_INTEGRITY_VERIFY) */ |
| if((NFC_FW_DOWNLOAD == IoctlCode) |
| &&(NULL == gpphHal4Nfc_Hwref))/*Indicates current state is shutdown*/ |
| { |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *) |
| phOsalNfc_GetMemory((uint32_t)sizeof( |
| phHal4Nfc_Hal4Ctxt_t) |
| ); |
| if(NULL == Hal4Ctxt) |
| { |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL, |
| NFCSTATUS_INSUFFICIENT_RESOURCES); |
| } |
| else |
| { |
| ((phHal_sHwReference_t *)psHwReference)->hal_context |
| = Hal4Ctxt; |
| (void)memset((void *)Hal4Ctxt, |
| 0, |
| ((uint32_t)sizeof(phHal4Nfc_Hal4Ctxt_t))); |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext; |
| Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb |
| = pIoctlCallback;/*Register upper layer callback*/ |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam = pOutParam; |
| /*Upgrade the firmware*/ |
| RetStatus = phDnldNfc_Upgrade ( |
| psHwReference, |
| phHal4Nfc_DownloadComplete, |
| Hal4Ctxt |
| ); |
| if((NFCSTATUS_SUCCESS == RetStatus) |
| || (NFCSTATUS_PENDING != PHNFCSTATUS(RetStatus)) |
| ) |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt); |
| ((phHal_sHwReference_t *)psHwReference)->hal_context = NULL; |
| } |
| } |
| } |
| else |
| #endif/*NFC_FW_DOWNLOAD*/ |
| { |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED); |
| } |
| } |
| else/*Status is Initialised*/ |
| { |
| /*Register upper layer context*/ |
| Hal4Ctxt = psHwReference->hal_context; |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam = pOutParam; |
| switch(IoctlCode) |
| { |
| /*Self test Ioctls*/ |
| case DEVMGMT_ANTENNA_TEST: |
| case DEVMGMT_SWP_TEST: |
| case DEVMGMT_NFCWI_TEST: |
| if(eHal4StateSelfTestMode ==Hal4Ctxt->Hal4CurrentState) |
| { |
| RetStatus = phHciNfc_System_Test( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| IoctlCode , |
| pInParam |
| ); |
| } |
| break; |
| /*PRBS Test*/ |
| case DEVMGMT_PRBS_TEST: |
| RetStatus = phHciNfc_PRBS_Test( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| IoctlCode , |
| pInParam |
| ); |
| break; |
| /*To Set Antenna Power Level*/ |
| case NFC_ANTENNA_CWG: |
| if(eHal4StateSelfTestMode ==Hal4Ctxt->Hal4CurrentState) |
| { |
| RetStatus = phHciNfc_System_Configure ( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| NFC_ANTENNA_CWG, |
| pInParam->buffer[0] /**Set Power Level*/ |
| ); |
| |
| } |
| break; |
| /*Not allowed when Init is complete*/ |
| case NFC_FW_DOWNLOAD_CHECK: |
| case NFC_FW_DOWNLOAD: |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL, |
| NFCSTATUS_BUSY); |
| break; |
| /*Gpio read*/ |
| case NFC_GPIO_READ: |
| /* if(eHal4StateSelfTestMode == Hal4Ctxt->Hal4CurrentState) */ |
| { |
| RetStatus = phHciNfc_System_Get_Info( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| IoctlCode , |
| pOutParam->buffer |
| ); |
| } |
| break; |
| /*Used to Read Memory/Registers .3 bytes of Array passed form the |
| address to read from in MSB first format.*/ |
| case NFC_MEM_READ: |
| { |
| if((NULL != pInParam) |
| && (pInParam->length == 3)) |
| { |
| for( ind = 0; ind < 3; ind++ ) |
| { |
| config_type = ((config_type << BYTE_SIZE ) |
| | (pInParam->buffer[ind] )); |
| } |
| RetStatus = phHciNfc_System_Get_Info( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| config_type , |
| pOutParam->buffer |
| ); |
| } |
| else |
| { |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL, |
| NFCSTATUS_INVALID_PARAMETER); |
| } |
| } |
| break; |
| /*Used to Write Memory/Registers .First 3 bytes of Array passed in MSB |
| first format form the address to write to.The 4th Byte is the 8 bit |
| value to be written to the address*/ |
| case NFC_MEM_WRITE: |
| { |
| if((NULL != pInParam) |
| && (pInParam->length == 4)) |
| { |
| for( ind = 0; ind < 3; ind++ ) |
| { |
| config_type = ((config_type << BYTE_SIZE ) |
| | (pInParam->buffer[ind] )); |
| } |
| RetStatus = phHciNfc_System_Configure ( |
| Hal4Ctxt->psHciHandle, |
| (void *)psHwReference, |
| config_type, |
| pInParam->buffer[3] /*config value*/ |
| ); |
| } |
| else |
| { |
| RetStatus = PHNFCSTVAL(CID_NFC_HAL , |
| NFCSTATUS_INVALID_PARAMETER); |
| } |
| } |
| break; |
| default: |
| break; |
| } |
| if(NFCSTATUS_PENDING == RetStatus)/*Callback Pending*/ |
| { |
| /*Register upper layer callback and context*/ |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext; |
| Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb= pIoctlCallback; |
| /*Store the Ioctl code*/ |
| Hal4Ctxt->Ioctl_Type = IoctlCode; |
| } |
| } |
| return RetStatus; |
| } |
| |
| |
| /** |
| * The close function called by the upper layer when HAL4 is to be closed |
| * (shutdown). |
| */ |
| NFCSTATUS phHal4Nfc_Close( |
| phHal_sHwReference_t *psHwReference, |
| pphHal4Nfc_GenCallback_t pCloseCallback, |
| void *pContext |
| ) |
| { |
| NFCSTATUS closeRetVal = NFCSTATUS_SUCCESS; |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| /*NULL checks*/ |
| if(NULL == psHwReference || NULL == pCloseCallback) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| closeRetVal = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER); |
| } |
| else if((NULL == psHwReference->hal_context) |
| || (((phHal4Nfc_Hal4Ctxt_t *) |
| psHwReference->hal_context)->Hal4CurrentState |
| < eHal4StateSelfTestMode) |
| || (((phHal4Nfc_Hal4Ctxt_t *) |
| psHwReference->hal_context)->Hal4NextState |
| == eHal4StateClosed)) |
| { |
| /*return already closed*/ |
| closeRetVal= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED); |
| } |
| else /*Close the HAL*/ |
| { |
| /*Get Hal4 context from Hw reference*/ |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)((phHal_sHwReference_t *) |
| psHwReference)->hal_context; |
| /*Unregister Tag Listener*/ |
| if(NULL != Hal4Ctxt->psADDCtxtInfo) |
| { |
| Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL; |
| } |
| /*store Callback and Context*/ |
| Hal4Ctxt->sUpperLayerInfo.pUpperCloseCb = pCloseCallback; |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext; |
| /*Call Hci Release*/ |
| PHDBG_INFO("Hal4:Calling Hci Release"); |
| closeRetVal =(NFCSTATUS)phHciNfc_Release( |
| (void *)Hal4Ctxt->psHciHandle, |
| psHwReference, |
| (pphNfcIF_Notification_CB_t) |
| phHal4Nfc_LowerNotificationHandler, |
| (void *)Hal4Ctxt |
| ); |
| /*Update Next state and exit*/ |
| if( PHNFCSTATUS (closeRetVal) == NFCSTATUS_PENDING ) |
| { |
| Hal4Ctxt->Hal4NextState = eHal4StateClosed; |
| Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL; |
| } |
| else |
| { |
| |
| } |
| } |
| return closeRetVal; |
| } |
| |
| /*Forcibly shutdown the HAl4.Frees all Resources in use by Hal4 before shutting |
| down*/ |
| void phHal4Nfc_Hal4Reset( |
| phHal_sHwReference_t *pHwRef, |
| void *pContext |
| ) |
| { |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| NFCSTATUS closeRetVal = NFCSTATUS_SUCCESS; |
| uint8_t RemoteDevNumber = 0; |
| if(pHwRef ==NULL) |
| { |
| closeRetVal = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER); |
| } |
| else if(pHwRef->hal_context != NULL) |
| { |
| /*Get the Hal context*/ |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pHwRef->hal_context; |
| /*store the upper layer context*/ |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext; |
| Hal4Ctxt->Hal4NextState = eHal4StateClosed; |
| Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL; |
| /*Call Hci Release*/ |
| PHDBG_INFO("Hal4:Calling Hci Release"); |
| closeRetVal =(NFCSTATUS)phHciNfc_Release( |
| (void *)Hal4Ctxt->psHciHandle, |
| pHwRef, |
| (pphNfcIF_Notification_CB_t)NULL, |
| (void *)Hal4Ctxt |
| );/*Clean up Hci*/ |
| Hal4Ctxt->Hal4CurrentState = eHal4StateClosed; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg); |
| Hal4Ctxt->pHal4Nfc_LayerCfg = NULL; |
| /*Free ADD context*/ |
| if(NULL != Hal4Ctxt->psADDCtxtInfo) |
| { |
| Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL; |
| while(RemoteDevNumber < MAX_REMOTE_DEVICES) |
| { |
| if(NULL != Hal4Ctxt->rem_dev_list[RemoteDevNumber]) |
| { |
| phOsalNfc_FreeMemory((void *) |
| (Hal4Ctxt->rem_dev_list[RemoteDevNumber])); |
| Hal4Ctxt->rem_dev_list[RemoteDevNumber] = NULL; |
| } |
| RemoteDevNumber++; |
| } |
| Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0; |
| phOsalNfc_FreeMemory(Hal4Ctxt->psADDCtxtInfo); |
| } |
| /*Free Trcv context*/ |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo) |
| { |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer) |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo |
| ->sLowerRecvData.buffer); |
| } |
| if((NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice) |
| && (NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData)) |
| { |
| phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData); |
| } |
| phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo); |
| } |
| phOsalNfc_FreeMemory(Hal4Ctxt);/*Free the context*/ |
| pHwRef->hal_context = NULL; |
| gpphHal4Nfc_Hwref = NULL; |
| } |
| else |
| { |
| /*Hal4 Context is already closed.Return Success*/ |
| } |
| /*Reset Should always return Success*/ |
| if(closeRetVal != NFCSTATUS_SUCCESS) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| } |
| return; |
| } |
| |
| /** |
| * \if hal |
| * \ingroup grp_hal_common |
| * \else |
| * \ingroup grp_mw_external_hal_funcs |
| * \endif |
| * |
| * Retrieves the capabilities of the device represented by the Hardware |
| * Reference parameter. |
| * The HW, SW versions, the MTU and other mandatory information are located |
| * inside the pDevCapabilities parameter. |
| */ |
| NFCSTATUS phHal4Nfc_GetDeviceCapabilities( |
| phHal_sHwReference_t *psHwReference, |
| phHal_sDeviceCapabilities_t *psDevCapabilities, |
| void *pContext |
| ) |
| { |
| NFCSTATUS retstatus = NFCSTATUS_SUCCESS; |
| /*NULL checks*/ |
| if(psDevCapabilities == NULL || psHwReference == NULL || pContext == NULL) |
| { |
| retstatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER); |
| } |
| /*Check for Initialized 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/*Provide Device capabilities and Version Info to the caller*/ |
| { |
| (void)memcpy((void *)psDevCapabilities, |
| (void *)&(psHwReference->device_info), |
| sizeof(phHal_sDeviceCapabilities_t)); |
| psDevCapabilities->ReaderSupProtocol.Felica = TRUE; |
| psDevCapabilities->ReaderSupProtocol.ISO14443_4A = TRUE; |
| psDevCapabilities->ReaderSupProtocol.ISO14443_4B = TRUE; |
| psDevCapabilities->ReaderSupProtocol.ISO15693 = TRUE; |
| psDevCapabilities->ReaderSupProtocol.Jewel = TRUE; |
| psDevCapabilities->ReaderSupProtocol.MifareStd = TRUE; |
| psDevCapabilities->ReaderSupProtocol.MifareUL = TRUE; |
| psDevCapabilities->ReaderSupProtocol.NFC = TRUE; |
| psDevCapabilities->EmulationSupProtocol.Felica = FALSE; |
| psDevCapabilities->EmulationSupProtocol.ISO14443_4A = FALSE; |
| psDevCapabilities->EmulationSupProtocol.ISO14443_4B = FALSE; |
| psDevCapabilities->EmulationSupProtocol.ISO15693 = FALSE; |
| psDevCapabilities->EmulationSupProtocol.Jewel = FALSE; |
| psDevCapabilities->EmulationSupProtocol.MifareStd = FALSE; |
| psDevCapabilities->EmulationSupProtocol.MifareUL = FALSE; |
| psDevCapabilities->EmulationSupProtocol.NFC = TRUE; |
| psDevCapabilities->hal_version = ( |
| (((PH_HAL4NFC_INTERFACE_VERSION << BYTE_SIZE) |
| |(PH_HAL4NFC_INTERFACE_REVISION)<<BYTE_SIZE) |
| |(PH_HAL4NFC_INTERFACE_PATCH)<<BYTE_SIZE) |
| |PH_HAL4NFC_INTERAFECE_BUILD |
| ); |
| } |
| return retstatus; |
| } |
| |
| /* |
| * Handles all notifications received from HCI layer. |
| * |
| */ |
| static void phHal4Nfc_LowerNotificationHandler( |
| void *pContext, |
| void *pHwRef, |
| uint8_t type, |
| void *pInfo |
| ) |
| { |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| if((NULL == pInfo) || (NULL == pHwRef) |
| || (NULL == pContext)) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| } |
| else |
| { |
| /*A copy of hardware reference is maintained in HAL for comparing passed |
| and returned context.Set to NULL after a Shutdown*/ |
| if(NULL != gpphHal4Nfc_Hwref)/*Get context from Hw ref*/ |
| { |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)gpphHal4Nfc_Hwref->hal_context; |
| if(NFC_INVALID_RELEASE_TYPE == Hal4Ctxt->sTgtConnectInfo.ReleaseType) |
| { |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext; |
| gpphHal4Nfc_Hwref = (phHal_sHwReference_t *)pHwRef; |
| } |
| } |
| else/*No Copy of Hw ref in HAL.Copy both Hwref and Hal context passed |
| by Hci*/ |
| { |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext; |
| gpphHal4Nfc_Hwref = (phHal_sHwReference_t *)pHwRef; |
| } |
| /*Check the type of notification received from Hci and handle it |
| accordingly*/ |
| switch(type) |
| { |
| case NFC_NOTIFY_INIT_COMPLETED: |
| case NFC_NOTIFY_INIT_FAILED: |
| phHal4Nfc_OpenComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_IO_SUCCESS: |
| case NFC_IO_ERROR: |
| phHal4Nfc_IoctlComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_RESULT: |
| phHal4Nfc_SelfTestComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_DEINIT_COMPLETED: |
| case NFC_NOTIFY_DEINIT_FAILED: |
| phHal4Nfc_CloseComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_POLL_ENABLED: |
| case NFC_NOTIFY_POLL_DISABLED: |
| case NFC_NOTIFY_POLL_RESTARTED: |
| case NFC_NOTIFY_CONFIG_ERROR: |
| case NFC_NOTIFY_CONFIG_SUCCESS: |
| phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type); |
| break; |
| case NFC_NOTIFY_TARGET_DISCOVERED: |
| case NFC_NOTIFY_DISCOVERY_ERROR: |
| phHal4Nfc_TargetDiscoveryComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_TARGET_REACTIVATED: |
| phHal4Nfc_ReactivationComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_EVENT: |
| PHDBG_INFO("Hal4:Calling Event callback"); |
| phHal4Nfc_HandleEvent(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_TARGET_CONNECTED: |
| PHDBG_INFO("Hal4:Calling Hal4 Connect complete"); |
| phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo); |
| break; |
| |
| case NFC_NOTIFY_TARGET_DISCONNECTED: |
| { |
| PHDBG_INFO("Hal4:Target Disconnected"); |
| if(Hal4Ctxt->Hal4NextState == eHal4StatePresenceCheck) |
| { |
| phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo); |
| } |
| else |
| { |
| phHal4Nfc_DisconnectComplete(Hal4Ctxt,pInfo); |
| } |
| break; |
| } |
| case NFC_NOTIFY_TRANSCEIVE_COMPLETED: |
| case NFC_NOTIFY_TRANSCEIVE_ERROR : |
| PHDBG_INFO("Hal4:Transceive Callback"); |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo) |
| { |
| #ifdef TRANSACTION_TIMER |
| if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| != PH_OSALNFC_INVALID_TIMER_ID) |
| { |
| phOsalNfc_Timer_Stop( |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| ); |
| phOsalNfc_Timer_Delete( |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| ); |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| = PH_OSALNFC_INVALID_TIMER_ID; |
| } |
| #endif /*TRANSACTION_TIMER*/ |
| phHal4Nfc_TransceiveComplete(Hal4Ctxt,pInfo); |
| } |
| break; |
| case NFC_NOTIFY_SEND_COMPLETED : |
| PHDBG_INFO("Hal4:NfcIp1 Send Callback"); |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo) |
| { |
| phHal4Nfc_SendCompleteHandler(Hal4Ctxt,pInfo); |
| } |
| break; |
| case NFC_NOTIFY_TRANSACTION : |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_RECV_ERROR : |
| case NFC_NOTIFY_RECV_EVENT : |
| PHDBG_INFO("Hal4:Receive Event"); |
| if(NULL != Hal4Ctxt->psTrcvCtxtInfo) |
| { |
| if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| != PH_OSALNFC_INVALID_TIMER_ID) |
| { |
| phOsalNfc_Timer_Stop( |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| ); |
| phOsalNfc_Timer_Delete( |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| ); |
| Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId |
| = PH_OSALNFC_INVALID_TIMER_ID; |
| } |
| } |
| phHal4Nfc_RecvCompleteHandler(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_TARGET_PRESENT: |
| phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo); |
| break; |
| case NFC_NOTIFY_DEVICE_ERROR: |
| { |
| NFCSTATUS status = NFCSTATUS_BOARD_COMMUNICATION_ERROR; |
| pphHal4Nfc_GenCallback_t pUpper_OpenCb |
| = Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb; |
| void *pUpper_Context |
| = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| static phHal4Nfc_NotificationInfo_t uNotificationInfo; |
| if(NULL != Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler) |
| { |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler( |
| Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt, |
| NFC_EVENT_NOTIFICATION, |
| uNotificationInfo, |
| NFCSTATUS_BOARD_COMMUNICATION_ERROR |
| ); |
| } |
| else if (( eHal4StateSelfTestMode == Hal4Ctxt->Hal4NextState ) |
| || ( eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState ) ) |
| { |
| Hal4Ctxt->Hal4CurrentState = eHal4StateClosed; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| (void)phHciNfc_Release((void *)Hal4Ctxt->psHciHandle, |
| pHwRef, (pphNfcIF_Notification_CB_t)NULL, |
| (void *)Hal4Ctxt);/*Clean up Hci*/ |
| Hal4Ctxt->psHciHandle = NULL; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg); |
| Hal4Ctxt->pHal4Nfc_LayerCfg = NULL; |
| phOsalNfc_FreeMemory((void *)Hal4Ctxt); |
| gpphHal4Nfc_Hwref->hal_context = NULL; |
| gpphHal4Nfc_Hwref = NULL; |
| PHDBG_INFO("Hal4:Open Failed"); |
| /*Call upper layer's Open Cb with error status*/ |
| if(NULL != pUpper_OpenCb) |
| { |
| /*Upper layer's Open Cb*/ |
| (*pUpper_OpenCb)(pUpper_Context,status); |
| } |
| } |
| else |
| { |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| phOsalNfc_RaiseException(phOsalNfc_e_UnrecovFirmwareErr,1); |
| } |
| break; |
| } |
| case NFC_NOTIFY_CONNECT_FAILED: |
| case NFC_NOTIFY_DISCONNECT_FAILED: |
| /*Generic Error type received from Hci.Handle the error based on |
| Hal4 next state and which past callback was Pending*/ |
| case NFC_NOTIFY_ERROR: |
| { |
| PHDBG_WARNING("Hal4:Error Notification from HCI"); |
| switch(Hal4Ctxt->Hal4NextState) |
| { |
| case eHal4StateClosed: |
| phHal4Nfc_CloseComplete(Hal4Ctxt,pInfo); |
| break; |
| case eHal4StateSelfTestMode: |
| phHal4Nfc_SelfTestComplete(Hal4Ctxt,pInfo); |
| break; |
| case eHal4StateConfiguring: |
| phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type); |
| break; |
| case eHal4StateTargetDiscovered: |
| case eHal4StateTargetActivate: |
| { |
| if(NULL != Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb) |
| { |
| if(NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice) |
| { |
| phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type); |
| } |
| else |
| { |
| phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo); |
| } |
| } |
| else |
| { |
| phHal4Nfc_TargetDiscoveryComplete(Hal4Ctxt,pInfo); |
| } |
| break; |
| } |
| case eHal4StateTargetConnected: |
| phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo); |
| break; |
| case eHal4StateOpenAndReady: |
| phHal4Nfc_DisconnectComplete(Hal4Ctxt,pInfo); |
| break; |
| case eHal4StatePresenceCheck: |
| phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo); |
| break; |
| default: |
| PHDBG_WARNING("Unknown Error notification"); |
| break; |
| } |
| break; |
| }/*End of switch(Hal4Ctxt->Hal4State)*/ |
| default: |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| break; |
| }/*End of switch(type)*/ |
| } |
| return; |
| } |
| |
| |
| /*Event handler for HAL-HCI interface*/ |
| static void phHal4Nfc_HandleEvent( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ) |
| { |
| phHal_sEventInfo_t *psEventInfo = (phHal_sEventInfo_t *)pInfo; |
| static phNfc_sNotificationInfo_t sNotificationInfo; |
| phHal4Nfc_NotificationInfo_t uNotificationInfo = {NULL}; |
| NFCSTATUS RetStatus = NFCSTATUS_FAILED; |
| /*Check if Hal4 Close has already been called*/ |
| if(eHal4StateClosed != Hal4Ctxt->Hal4NextState) |
| { |
| switch(psEventInfo->eventType) |
| { |
| case NFC_EVT_ACTIVATED:/*Target Activated*/ |
| { |
| if(psEventInfo->eventHost == phHal_eHostController) |
| { |
| switch(psEventInfo->eventSource) |
| { |
| case phHal_eNfcIP1_Target: |
| phHal4Nfc_P2PActivateComplete(Hal4Ctxt,pInfo); |
| break; |
| case phHal_eISO14443_A_PICC: |
| case phHal_eISO14443_B_PICC: |
| sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| break; |
| case NFC_EVT_DEACTIVATED:/*Target Deactivated*/ |
| { |
| if(psEventInfo->eventHost == phHal_eHostController) |
| { |
| switch(psEventInfo->eventSource) |
| { |
| case phHal_eNfcIP1_Target: |
| phHal4Nfc_HandleP2PDeActivate(Hal4Ctxt,pInfo); |
| break; |
| case phHal_eISO14443_A_PICC: |
| case phHal_eISO14443_B_PICC: |
| sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| break; |
| /*Set Protection Event*/ |
| case NFC_EVT_PROTECTED: |
| { |
| #ifdef IGNORE_EVT_PROTECTED |
| /*Ignore_Event_Protected is set to false during Field Off event and |
| Set protection Configuration.After a NFC_EVT_PROTECTED is received |
| once all subsequent NFC_EVT_PROTECTED events are ignored*/ |
| if(FALSE == Hal4Ctxt->Ignore_Event_Protected) |
| { |
| Hal4Ctxt->Ignore_Event_Protected = TRUE; |
| #endif/*#ifdef IGNORE_EVT_PROTECTED*/ |
| sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| #ifdef IGNORE_EVT_PROTECTED |
| } |
| #endif/*#ifdef IGNORE_EVT_PROTECTED*/ |
| break; |
| } |
| /*NFC_UICC_RDPHASES_DEACTIVATE_REQ*/ |
| case NFC_UICC_RDPHASES_DEACTIVATE_REQ: |
| { |
| if(NULL != gpphHal4Nfc_Hwref) |
| { |
| gpphHal4Nfc_Hwref->uicc_rdr_active = FALSE; |
| } |
| break; |
| } |
| case NFC_UICC_RDPHASES_ACTIVATE_REQ: |
| { |
| if(NULL != gpphHal4Nfc_Hwref) |
| { |
| gpphHal4Nfc_Hwref->uicc_rdr_active = TRUE; |
| } |
| /*If a NFC_UICC_RDPHASES_ACTIVATE_REQ is received before a configure |
| discovery,then create a ADD context info*/ |
| 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) |
| { |
| Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollEnabled |
| |= psEventInfo->eventInfo.rd_phases; |
| /*Configure HCI Discovery*/ |
| RetStatus = phHciNfc_Config_Discovery( |
| (void *)Hal4Ctxt->psHciHandle, |
| gpphHal4Nfc_Hwref, |
| &(Hal4Ctxt->psADDCtxtInfo->sADDCfg) |
| ); |
| Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == RetStatus? |
| eHal4StateConfiguring: |
| Hal4Ctxt->Hal4NextState); |
| } |
| break; |
| } |
| /*Call Default Event handler for these Events*/ |
| case NFC_INFO_TXLDO_OVERCUR: |
| case NFC_INFO_MEM_VIOLATION: |
| case NFC_INFO_TEMP_OVERHEAT: |
| case NFC_INFO_LLC_ERROR: |
| { |
| sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| PHDBG_INFO("Hal4:Exception events"); |
| if(NULL != Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler) |
| { |
| /*Pass on Event notification info from Hci to Upper layer*/ |
| uNotificationInfo.psEventInfo = psEventInfo; |
| Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler( |
| Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt, |
| sNotificationInfo.type, |
| uNotificationInfo, |
| NFCSTATUS_SUCCESS |
| ); |
| } |
| break; |
| } |
| /*Call emulation Event handler fto handle these Events*/ |
| case NFC_EVT_TRANSACTION: |
| case NFC_EVT_START_OF_TRANSACTION: |
| case NFC_EVT_END_OF_TRANSACTION: |
| case NFC_EVT_CONNECTIVITY: |
| case NFC_EVT_OPERATION_ENDED: |
| case NFC_EVT_MIFARE_ACCESS: |
| case NFC_EVT_APDU_RECEIVED: |
| case NFC_EVT_EMV_CARD_REMOVAL: |
| sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| PHDBG_INFO("Hal4:Event transaction\n"); |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| case NFC_EVT_FIELD_ON: |
| Hal4Ctxt->psEventInfo = sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| PHDBG_INFO("Hal4:Event Field ON\n"); |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| case NFC_EVT_FIELD_OFF: |
| #ifdef IGNORE_EVT_PROTECTED |
| Hal4Ctxt->Ignore_Event_Protected = FALSE; |
| #endif/*#ifdef IGNORE_EVT_PROTECTED*/ |
| Hal4Ctxt->psEventInfo = sNotificationInfo.info = psEventInfo; |
| sNotificationInfo.status = NFCSTATUS_SUCCESS; |
| sNotificationInfo.type = NFC_EVENT_NOTIFICATION; |
| pInfo = &sNotificationInfo; |
| PHDBG_INFO("Hal4:Event Field OFF\n"); |
| phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo); |
| break; |
| default: |
| PHDBG_WARNING("Hal4:Unhandled Event type received"); |
| break; |
| }/*End of switch*/ |
| }/*if(eHal4StateClosed != Hal4Ctxt->Hal4NextState)*/ |
| return; |
| } |
| |
| |
| /*Callback handler for Self Test Ioctl completion*/ |
| static void phHal4Nfc_SelfTestComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ) |
| { |
| NFCSTATUS status = NFCSTATUS_FAILED; |
| phNfc_sData_t *SelfTestResults |
| = (phNfc_sData_t *)(((phNfc_sCompletionInfo_t *)pInfo)->info); |
| pphHal4Nfc_IoctlCallback_t pUpper_IoctlCb |
| = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb; |
| void *pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| /*check for Success*/ |
| if(( DEVMGMT_SWP_TEST == Hal4Ctxt->Ioctl_Type ) |
| || ( DEVMGMT_ANTENNA_TEST == Hal4Ctxt->Ioctl_Type )) |
| { |
| status = NFCSTATUS_SUCCESS; |
| } |
| else if((SelfTestResults->length > 0) && (0 == SelfTestResults->buffer[0])) |
| { |
| status = NFCSTATUS_SUCCESS; |
| } |
| else |
| { |
| if (NULL != pInfo) |
| { |
| status = ((phNfc_sCompletionInfo_t *)pInfo)->status; |
| } |
| } |
| |
| /*Copy response buffer and length*/ |
| (void)memcpy(Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->buffer, |
| SelfTestResults->buffer, |
| SelfTestResults->length); |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->length |
| = SelfTestResults->length; |
| /*Call registered Ioctl callback*/ |
| (*pUpper_IoctlCb)( |
| pUpper_Context, |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam, |
| status |
| ); |
| return; |
| } |
| |
| |
| static void phHal4Nfc_IoctlComplete( |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt, |
| void *pInfo |
| ) |
| { |
| /*Copy status*/ |
| NFCSTATUS status = (((phNfc_sCompletionInfo_t *)pInfo)->status); |
| pphHal4Nfc_IoctlCallback_t pUpper_IoctlCb |
| = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb; |
| #ifdef MERGE_SAK_SW2 |
| pphHal4Nfc_GenCallback_t pConfigCallback = |
| Hal4Ctxt->sUpperLayerInfo.pConfigCallback; |
| #endif/*#ifdef MERGE_SAK_SW2*/ |
| void *pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb = NULL; |
| #ifdef MERGE_SAK_SW1 /*Software workaround 1*/ |
| if(eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState) |
| { |
| Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| /*Upper layer's Open Cb*/ |
| (*Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb)( |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt, |
| NFCSTATUS_SUCCESS |
| ); |
| } |
| #endif/*#ifdef MERGE_SAK_SW1*/ |
| #ifdef MERGE_SAK_SW2 /*Software workaround 2*/ |
| else if((eHal4StateConfiguring == Hal4Ctxt->Hal4NextState) |
| &&(NULL != pConfigCallback)) |
| { |
| Hal4Ctxt->sUpperLayerInfo.pConfigCallback = NULL; |
| Hal4Ctxt->Hal4NextState = eHal4StateInvalid; |
| (*pConfigCallback)( |
| Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,status |
| ); |
| } |
| else |
| #endif/*#ifdef MERGE_SAK_SW2*/ |
| { |
| /*for NFC_MEM_READ and NFC_GPIO_READ ,provide one Byte Response*/ |
| if ((NFC_MEM_READ == Hal4Ctxt->Ioctl_Type) |
| || (NFC_GPIO_READ == Hal4Ctxt->Ioctl_Type) |
| ) |
| { |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->length |
| = sizeof (uint8_t); |
| } |
| /*Call registered Ioctl callback*/ |
| if(NULL != pUpper_IoctlCb) |
| { |
| (*pUpper_IoctlCb)( |
| pUpper_Context, |
| Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam, |
| status |
| ); |
| } |
| } |
| return; |
| } |
| |
| #ifdef FW_DOWNLOAD |
| /**Callback handler for Download completion*/ |
| STATIC void phHal4Nfc_DownloadComplete( |
| void *pContext, |
| void *pHwRef, |
| uint8_t type, |
| void *pInfo |
| ) |
| { |
| phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL; |
| NFCSTATUS status = NFCSTATUS_FAILED; |
| pphHal4Nfc_IoctlCallback_t pUpper_DnldCb = NULL; |
| phNfc_sData_t *pIoctlOutParam = NULL; |
| phHal_sHwReference_t *psHwRef = NULL; |
| void *pUpper_Context = NULL; |
| /*NULL checks*/ |
| if((NULL == pInfo) || (NULL == pHwRef) || (NULL == pContext)) |
| { |
| phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1); |
| } |
| else |
| { |
| type = type; |
| Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext; |
| /*Copy back stored context/callback for the upper layer*/ |
| pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt; |
| pIoctlOutParam = Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam; |
| pUpper_DnldCb = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb; |
| Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb = NULL; |
| /*Copy download status*/ |
| status = (((phNfc_sCompletionInfo_t *)pInfo)->status); |
| /*copy hw reference*/ |
| psHwRef = (phHal_sHwReference_t *)pHwRef; |
| /*Free the temporary hal context used only for the sake of download*/ |
| phOsalNfc_FreeMemory(psHwRef->hal_context); |
| psHwRef->hal_context = NULL; |
| /*Call upper layer callback*/ |
| if(NULL != pUpper_DnldCb) |
| { |
| (*pUpper_DnldCb)( |
| pUpper_Context, |
| pIoctlOutParam, |
| status |
| ); |
| } |
| } |
| return; |
| } |
| #endif /*FW_DOWNLOAD*/ |
| |
