Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2010 NXP Semiconductors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 /*!
     17 * \file  phHal4Nfc_Reader.c
     18 * \brief Hal4Nfc Reader source.
     19 *
     20 * Project: NFC-FRI 1.1
     21 *
     22 * $Date: Mon May 31 11:43:43 2010 $
     23 * $Author: ing07385 $
     24 * $Revision: 1.120 $
     25 * $Aliases: NFC_FRI1.1_WK1023_R35_1 $
     26 *
     27 */
     28 
     29 /* ---------------------------Include files ------------------------------------*/
     30 #include <phHal4Nfc.h>
     31 #include <phHal4Nfc_Internal.h>
     32 #include <phOsalNfc.h>
     33 #include <phHciNfc.h>
     34 #include <phOsalNfc_Timer.h>
     35 #include <phNfcConfig.h>
     36 
     37 
     38 /* ------------------------------- Macros ------------------------------------*/
     39 #define PH_HAL4NFC_CMD_LENGTH      PHHAL_MAX_DATASIZE+12/**< Cmd length used
     40                                                               for Transceive*/
     41 #define PH_HAL4NFC_MAX_TRCV_LEN                     4096 /**<Only a max of 1KB
     42                                                               can be sent at
     43                                                               a time*/
     44 #define PH_HAL4NFC_FLAG_0                              0
     45 
     46 #define PH_HAL4NFC_FLAG_1                              1
     47 
     48 #define PH_HAL4NFC_SEL_SECTOR1_BYTE0                0xC2
     49 #define PH_HAL4NFC_SEL_SECTOR1_BYTE1                0xFF
     50 
     51 #define PH_HAL4NFC_SEL_SECTOR2_BYTE0                0x02
     52 #define PH_HAL4NFC_SEL_SECTOR2_BYTE_RESERVED        0x00
     53 
     54 phHal4Nfc_Hal4Ctxt_t *gpHal4Ctxt;
     55 
     56 /* --------------------Structures and enumerations --------------------------*/
     57 
     58 static void phHal4Nfc_Iso_3A_Transceive(
     59                         phHal_sTransceiveInfo_t   *psTransceiveInfo,
     60                         phHal4Nfc_Hal4Ctxt_t      *Hal4Ctxt
     61                         );
     62 
     63 static void phHal4Nfc_MifareTransceive(
     64                         phHal_sTransceiveInfo_t   *psTransceiveInfo,
     65                         phHal_sRemoteDevInformation_t  *psRemoteDevInfo,
     66                         phHal4Nfc_Hal4Ctxt_t      *Hal4Ctxt
     67                         );
     68 
     69 /*Allows to connect to a single, specific, already known Remote Device.*/
     70 NFCSTATUS phHal4Nfc_Connect(
     71                             phHal_sHwReference_t          *psHwReference,
     72                             phHal_sRemoteDevInformation_t *psRemoteDevInfo,
     73                             pphHal4Nfc_ConnectCallback_t   pNotifyConnectCb,
     74                             void                          *pContext
     75                             )
     76 {
     77     NFCSTATUS RetStatus = NFCSTATUS_SUCCESS;
     78     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
     79     uint8_t RemoteDevCount = 0;
     80     int32_t MemCmpRet = 0;
     81     /*NULL chks*/
     82     if(NULL == psHwReference
     83         || NULL == pNotifyConnectCb
     84         || NULL == psRemoteDevInfo)
     85     {
     86         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
     87         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
     88     }
     89     /*Check initialised state*/
     90     else if((NULL == psHwReference->hal_context)
     91                         || (((phHal4Nfc_Hal4Ctxt_t *)
     92                                 psHwReference->hal_context)->Hal4CurrentState
     93                                                < eHal4StateOpenAndReady)
     94                         || (((phHal4Nfc_Hal4Ctxt_t *)
     95                                 psHwReference->hal_context)->Hal4NextState
     96                                                == eHal4StateClosed))
     97     {
     98         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
     99     }
    100     else if ((psRemoteDevInfo ==
    101              ((phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context)->
    102                 sTgtConnectInfo.psConnectedDevice)
    103              &&((phHal_eNfcIP1_Target == psRemoteDevInfo->RemDevType)
    104                 ||(phHal_eJewel_PICC == psRemoteDevInfo->RemDevType)))
    105     {
    106         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_FEATURE_NOT_SUPPORTED);
    107     }
    108     else
    109     {
    110         /*Get Hal ctxt from hardware reference*/
    111         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
    112         /*Register upper layer context*/
    113         Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
    114         /*Register upper layer callback*/
    115         Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = pNotifyConnectCb;
    116         /*Allow Connect only if no other remote device is connected*/
    117         if((eHal4StateTargetDiscovered == Hal4Ctxt->Hal4CurrentState)
    118             && (NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice))
    119         {
    120             RemoteDevCount = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
    121             while(0 != RemoteDevCount)
    122             {
    123                 RemoteDevCount--;
    124                 /*Check if handle provided by upper layer matches with any
    125                   remote device in the list*/
    126                 if(psRemoteDevInfo
    127                     == (Hal4Ctxt->rem_dev_list[RemoteDevCount]))
    128                 {
    129 
    130                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice
    131                                   = Hal4Ctxt->rem_dev_list[RemoteDevCount];
    132                     break;
    133                 }
    134             }/*End of while*/
    135 
    136             if(NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    137             {
    138                 /*No matching device handle in list*/
    139                 RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
    140                                         NFCSTATUS_INVALID_REMOTE_DEVICE);
    141             }
    142             else
    143             {
    144                 MemCmpRet = phOsalNfc_MemCompare(
    145                     (void *)&(psRemoteDevInfo->RemoteDevInfo),
    146                     (void *)&(Hal4Ctxt->rem_dev_list[Hal4Ctxt
    147                     ->psADDCtxtInfo->nbr_of_devices - 1]->RemoteDevInfo),
    148                     sizeof(phHal_uRemoteDevInfo_t));
    149 
    150                 /*If device is already selected issue connect from here*/
    151                 if(0 == MemCmpRet)
    152                 {
    153                     RetStatus = phHciNfc_Connect(Hal4Ctxt->psHciHandle,
    154                         (void *)psHwReference,
    155                         Hal4Ctxt->rem_dev_list[RemoteDevCount]);
    156                     if(NFCSTATUS_PENDING == RetStatus)
    157                     {
    158                         Hal4Ctxt->Hal4NextState = eHal4StateTargetConnected;
    159                     }
    160 
    161                 }
    162                 else/*Select the matching device to connect to*/
    163                 {
    164                     RetStatus = phHciNfc_Reactivate (
    165                         Hal4Ctxt->psHciHandle,
    166                         (void *)psHwReference,
    167                         Hal4Ctxt->rem_dev_list[RemoteDevCount]
    168                         );
    169                     Hal4Ctxt->Hal4NextState = eHal4StateTargetActivate;
    170                 }
    171                 if(NFCSTATUS_PENDING != RetStatus)
    172                 {
    173                     /*Rollback state*/
    174                     Hal4Ctxt->Hal4CurrentState = eHal4StateOpenAndReady;
    175                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice =  NULL;
    176                     Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = NULL;
    177                     Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = NULL;
    178                 }
    179             }
    180         }
    181         /*Issue Reconnect*/
    182         else if(psRemoteDevInfo ==
    183                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    184         {
    185             RetStatus = phHciNfc_Reactivate (
    186                 Hal4Ctxt->psHciHandle,
    187                 (void *)psHwReference,
    188                 psRemoteDevInfo
    189                 );
    190                 Hal4Ctxt->Hal4NextState = eHal4StateTargetActivate;
    191         }
    192 #ifdef RECONNECT_SUPPORT
    193         else if (psRemoteDevInfo !=
    194                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    195         {
    196             phHal_sRemoteDevInformation_t           *ps_store_connected_device =
    197                                                 Hal4Ctxt->sTgtConnectInfo.psConnectedDevice;
    198 
    199             RemoteDevCount = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
    200 
    201             while (0 != RemoteDevCount)
    202             {
    203                 RemoteDevCount--;
    204                 /*Check if handle provided by upper layer matches with any
    205                   remote device in the list*/
    206                 if(psRemoteDevInfo == (Hal4Ctxt->rem_dev_list[RemoteDevCount]))
    207                 {
    208                     break;
    209                 }
    210             }/*End of while*/
    211 
    212             if (ps_store_connected_device ==
    213                 Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    214             {
    215                 RetStatus = phHciNfc_Reactivate (Hal4Ctxt->psHciHandle,
    216                                                 (void *)psHwReference,
    217                                                 psRemoteDevInfo);
    218 
    219                 if (NFCSTATUS_PENDING == RetStatus)
    220                 {
    221                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice =
    222                                     Hal4Ctxt->rem_dev_list[RemoteDevCount];
    223                     Hal4Ctxt->Hal4NextState = eHal4StateTargetActivate;
    224                 }
    225             }
    226         }
    227 #endif /* #ifdef RECONNECT_SUPPORT */
    228         else if(NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    229         {
    230             /*Wrong state to issue connect*/
    231             RetStatus = PHNFCSTVAL(CID_NFC_HAL,
    232                                     NFCSTATUS_INVALID_REMOTE_DEVICE);
    233         }
    234         else/*No Target or already connected to device*/
    235         {
    236             RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_FAILED);
    237         }
    238 
    239     }
    240     return RetStatus;
    241 }
    242 
    243 /*For Ordering Transceive Info for ISO_3A type tags*/
    244 static void phHal4Nfc_Iso_3A_Transceive(
    245                         phHal_sTransceiveInfo_t   *psTransceiveInfo,
    246                         phHal4Nfc_Hal4Ctxt_t      *Hal4Ctxt
    247                         )
    248 {
    249     uint16_t i;
    250     uint16_t counter= 0;
    251     /* Mifare UL, Keep MIFARE RAW command as it is */
    252     Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type
    253                     = (uint8_t)psTransceiveInfo->cmd.MfCmd;
    254     /* Set flags for Select Sector */
    255     if (psTransceiveInfo->sSendData.buffer[0] != phHal_eMifareWrite4)
    256     {
    257         if (Hal4Ctxt->SelectSectorFlag == PH_HAL4NFC_FLAG_0)
    258         {
    259             /* First Select Sector command */
    260             if ((psTransceiveInfo->sSendData.buffer[1] == PH_HAL4NFC_SEL_SECTOR1_BYTE0) &&
    261                 (psTransceiveInfo->sSendData.buffer[2] == PH_HAL4NFC_SEL_SECTOR1_BYTE1))
    262             {
    263                 Hal4Ctxt->SelectSectorFlag++;
    264                 PHDBG_INFO("Inside 3ATrancv,first cmd, SelectSectorFlag is 1");
    265                 for (i = 1; i < psTransceiveInfo->sSendData.length; i++)
    266                 {
    267                     psTransceiveInfo->sSendData.buffer[i - 1] =
    268                         psTransceiveInfo->sSendData.buffer[i];
    269                 }
    270 
    271                 psTransceiveInfo->sSendData.length--;
    272             }
    273             else
    274             {
    275                 PHDBG_INFO("Inside 3ATrancv,first cmd,setting SelectSectorFlag 0");
    276                 Hal4Ctxt->SelectSectorFlag = 0;
    277             }
    278         }
    279         else if (Hal4Ctxt->SelectSectorFlag == PH_HAL4NFC_FLAG_1)
    280         {
    281             if ((psTransceiveInfo->sSendData.buffer[1] < PH_HAL4NFC_SEL_SECTOR2_BYTE0) &&
    282                 (psTransceiveInfo->sSendData.buffer[2] == PH_HAL4NFC_SEL_SECTOR2_BYTE_RESERVED) &&
    283                 (psTransceiveInfo->sSendData.buffer[3] == PH_HAL4NFC_SEL_SECTOR2_BYTE_RESERVED) &&
    284                 (psTransceiveInfo->sSendData.buffer[4] == PH_HAL4NFC_SEL_SECTOR2_BYTE_RESERVED))
    285             {
    286                 Hal4Ctxt->SelectSectorFlag++;
    287                 PHDBG_INFO("Inside 3ATrancv,2nd cmd, SelectSectorFlag set to 2");
    288                 for (i = 1; i < psTransceiveInfo->sSendData.length; i++)
    289                 {
    290                     psTransceiveInfo->sSendData.buffer[i - 1] =
    291                         psTransceiveInfo->sSendData.buffer[i];
    292                 }
    293 
    294                 psTransceiveInfo->sSendData.length--;
    295             }
    296             else
    297             {
    298                 PHDBG_INFO("Inside 3ATrancv,2nd cmd, SelectSectorFlag set to 0");
    299                 Hal4Ctxt->SelectSectorFlag = 0;
    300             }
    301         }
    302         else
    303         {
    304             Hal4Ctxt->SelectSectorFlag = 0;
    305         }
    306     }
    307     else
    308     {
    309         PHDBG_INFO("Inside 3ATrancv,Mifarewrite4");
    310         /* Convert MIFARE RAW to MIFARE CMD */
    311         if (psTransceiveInfo->cmd.MfCmd == phHal_eMifareRaw)
    312         {
    313             psTransceiveInfo->cmd.MfCmd =
    314                 (phHal_eMifareCmdList_t)psTransceiveInfo->sSendData.buffer[0];
    315 
    316             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type =
    317                 (uint8_t)psTransceiveInfo->cmd.MfCmd;
    318 
    319             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.addr =
    320                 psTransceiveInfo->addr =
    321                 psTransceiveInfo->sSendData.buffer[1];
    322 
    323             for (counter = 2; counter < psTransceiveInfo->sSendData.length;
    324                  counter++)
    325             {
    326                 psTransceiveInfo->sSendData.buffer[counter - 2] =
    327                     psTransceiveInfo->sSendData.buffer[counter];
    328             }
    329             PHDBG_INFO("Hal4:Inside 3A_Trcv() ,minus length by 4");
    330             psTransceiveInfo->sSendData.length =
    331                 psTransceiveInfo->sSendData.length - 4;
    332         }
    333         else
    334         {
    335             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type
    336                         = (uint8_t)psTransceiveInfo->cmd.MfCmd;
    337         }
    338     }
    339     return;
    340 }
    341 
    342 /*For Ordering Transceive Info for Mifare tags*/
    343 static void phHal4Nfc_MifareTransceive(
    344                         phHal_sTransceiveInfo_t   *psTransceiveInfo,
    345                         phHal_sRemoteDevInformation_t  *psRemoteDevInfo,
    346                         phHal4Nfc_Hal4Ctxt_t      *Hal4Ctxt
    347                         )
    348 {
    349     uint16_t counter;
    350     if (
    351 #ifndef DISABLE_MIFARE_UL_WRITE_WORKAROUND
    352         phHal_eMifareWrite4 != psTransceiveInfo->sSendData.buffer[0]
    353 #else
    354         1
    355 #endif/*#ifndef DISABLE_MIFARE_UL_WRITE_WORKAROUND*/
    356         )
    357 
    358     {
    359         /* Mifare UL, Keep MIFARE RAW command as it is */
    360         Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type
    361                         = (uint8_t)psTransceiveInfo->cmd.MfCmd;
    362 
    363     }
    364     else
    365     {
    366         /* Convert MIFARE RAW to MIFARE CMD */
    367         if (psTransceiveInfo->cmd.MfCmd == phHal_eMifareRaw)
    368         {
    369             psTransceiveInfo->cmd.MfCmd =
    370                 (phHal_eMifareCmdList_t)psTransceiveInfo->sSendData.buffer[0];
    371 
    372             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type =
    373                 (uint8_t)psTransceiveInfo->cmd.MfCmd;
    374 
    375             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.addr =
    376                 psTransceiveInfo->addr =
    377                 psTransceiveInfo->sSendData.buffer[1];
    378 
    379             for (counter = 2; counter < psTransceiveInfo->sSendData.length;
    380                  counter++)
    381             {
    382                 psTransceiveInfo->sSendData.buffer[counter - 2] =
    383                     psTransceiveInfo->sSendData.buffer[counter];
    384             }
    385             PHDBG_INFO("Hal4:Inside MifareTrcv() ,minus length by 4");
    386             psTransceiveInfo->sSendData.length =
    387                 psTransceiveInfo->sSendData.length - 4;
    388 
    389         }
    390         else
    391         {
    392             Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.cmd_type
    393                         = (uint8_t)psTransceiveInfo->cmd.MfCmd;
    394         }
    395     }
    396     return;
    397 }
    398 
    399 /*  The phHal4Nfc_Transceive function allows the Initiator to send and receive
    400  *  data to and from the Remote Device selected by the caller.*/
    401 NFCSTATUS phHal4Nfc_Transceive(
    402                                phHal_sHwReference_t          *psHwReference,
    403                                phHal_sTransceiveInfo_t       *psTransceiveInfo,
    404                                phHal_sRemoteDevInformation_t  *psRemoteDevInfo,
    405                                pphHal4Nfc_TransceiveCallback_t pTrcvCallback,
    406                                void                           *pContext
    407                                )
    408 {
    409     NFCSTATUS RetStatus = NFCSTATUS_PENDING;
    410     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext;
    411 
    412     /*NULL checks*/
    413     if((NULL == psHwReference)
    414         ||( NULL == pTrcvCallback )
    415         || (NULL == psRemoteDevInfo)
    416         || (NULL == psTransceiveInfo)
    417         || (NULL == psTransceiveInfo->sRecvData.buffer)
    418         || (NULL == psTransceiveInfo->sSendData.buffer)
    419         )
    420     {
    421         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
    422         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
    423     }
    424 #ifdef HAL_TRCV_LIMIT
    425     else if(PH_HAL4NFC_MAX_TRCV_LEN < psTransceiveInfo->sSendData.length)
    426     {
    427         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_ALLOWED);
    428     }
    429 #endif/*#ifdef HAL_TRCV_LIMIT*/
    430     /*Check initialised state*/
    431     else if((NULL == psHwReference->hal_context)
    432                         || (((phHal4Nfc_Hal4Ctxt_t *)
    433                                 psHwReference->hal_context)->Hal4CurrentState
    434                                                < eHal4StateOpenAndReady)
    435                         || (((phHal4Nfc_Hal4Ctxt_t *)
    436                                 psHwReference->hal_context)->Hal4NextState
    437                                                == eHal4StateClosed))
    438     {
    439         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
    440     }
    441     else
    442     {
    443         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
    444         gpphHal4Nfc_Hwref = (phHal_sHwReference_t *)psHwReference;
    445         if((eHal4StateTargetConnected != Hal4Ctxt->Hal4CurrentState)
    446             ||(eHal4StateInvalid != Hal4Ctxt->Hal4NextState))
    447         {
    448             /*Hal4 state Busy*/
    449             RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_BUSY);
    450             PHDBG_INFO("HAL4:Trcv Failed.Returning Busy");
    451         }
    452         else if(psRemoteDevInfo != Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
    453         {
    454             /*No such Target connected*/
    455             RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_INVALID_REMOTE_DEVICE);
    456         }
    457         else
    458         {
    459             /*allocate Trcv context*/
    460             if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
    461             {
    462                 Hal4Ctxt->psTrcvCtxtInfo= (pphHal4Nfc_TrcvCtxtInfo_t)
    463                 phOsalNfc_GetMemory((uint32_t)(sizeof(phHal4Nfc_TrcvCtxtInfo_t)));
    464                 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
    465                 {
    466                     (void)memset(Hal4Ctxt->psTrcvCtxtInfo,0,
    467                                         sizeof(phHal4Nfc_TrcvCtxtInfo_t));
    468                     Hal4Ctxt->psTrcvCtxtInfo->RecvDataBufferStatus
    469                         = NFCSTATUS_PENDING;
    470                     Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    471                                                 = PH_OSALNFC_INVALID_TIMER_ID;
    472                 }
    473             }
    474             if(NULL == Hal4Ctxt->psTrcvCtxtInfo)
    475             {
    476                 phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
    477                 RetStatus= PHNFCSTVAL(CID_NFC_HAL ,
    478                                             NFCSTATUS_INSUFFICIENT_RESOURCES);
    479             }
    480             else
    481             {
    482                 /*Process transceive based on Remote device type*/
    483                 switch(Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemDevType)
    484                 {
    485                 case phHal_eISO14443_3A_PICC:
    486                     phHal4Nfc_Iso_3A_Transceive(
    487                                         psTransceiveInfo,
    488                                         Hal4Ctxt
    489                                         );
    490                     break;
    491                 case phHal_eMifare_PICC:
    492                     PHDBG_INFO("Mifare Cmd received");
    493                     phHal4Nfc_MifareTransceive(
    494                                         psTransceiveInfo,
    495                                         psRemoteDevInfo,
    496                                         Hal4Ctxt
    497                                         );
    498 
    499 #if 0
    500                     Hal4Ctxt->psTrcvCtxtInfo->
    501                         XchangeInfo.params.tag_info.cmd_type
    502                                         = (uint8_t)psTransceiveInfo->cmd.MfCmd;
    503 #endif
    504                     break;
    505                 case phHal_eISO14443_A_PICC:
    506                 case phHal_eISO14443_B_PICC:
    507                     PHDBG_INFO("ISO14443 Cmd received");
    508                     Hal4Ctxt->psTrcvCtxtInfo->
    509                         XchangeInfo.params.tag_info.cmd_type
    510                             = (uint8_t)psTransceiveInfo->cmd.Iso144434Cmd;
    511                     break;
    512                 case phHal_eISO15693_PICC:
    513                     PHDBG_INFO("ISO15693 Cmd received");
    514                     Hal4Ctxt->psTrcvCtxtInfo->
    515                         XchangeInfo.params.tag_info.cmd_type
    516                             = (uint8_t)psTransceiveInfo->cmd.Iso15693Cmd;
    517                     break;
    518                 case phHal_eNfcIP1_Target:
    519                     {
    520                         PHDBG_INFO("NfcIP1 Transceive");
    521                         Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData
    522                             = &(psTransceiveInfo->sSendData);
    523                         Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData =
    524                             &(psTransceiveInfo->sRecvData);
    525                     }
    526                     break;
    527                 case phHal_eFelica_PICC:
    528                     PHDBG_INFO("Felica Cmd received");
    529                     Hal4Ctxt->psTrcvCtxtInfo->
    530                         XchangeInfo.params.tag_info.cmd_type
    531                         = (uint8_t)psTransceiveInfo->cmd.FelCmd;
    532                     break;
    533                 case phHal_eJewel_PICC:
    534                     PHDBG_INFO("Jewel Cmd received");
    535                     Hal4Ctxt->psTrcvCtxtInfo->
    536                         XchangeInfo.params.tag_info.cmd_type
    537                         = (uint8_t)psTransceiveInfo->cmd.JewelCmd;
    538                     break;
    539                 case phHal_eISO14443_BPrime_PICC:
    540                     RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
    541                                               NFCSTATUS_FEATURE_NOT_SUPPORTED);
    542                     break;
    543                 default:
    544                     PHDBG_WARNING("Invalid Device type received");
    545                     RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_FAILED);
    546                     break;
    547 
    548                 }
    549             }
    550         }
    551         /*If status is anything other than NFCSTATUS_PENDING ,an error has
    552           already occured, so dont process any further and return*/
    553         if(RetStatus == NFCSTATUS_PENDING)
    554         {
    555             if(phHal_eNfcIP1_Target ==
    556                   Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemDevType)
    557             {
    558                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
    559                 /*Register upper layer callback*/
    560                 Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb  = pTrcvCallback;
    561                 if(psRemoteDevInfo->RemoteDevInfo.NfcIP_Info.MaxFrameLength
    562                     >= psTransceiveInfo->sSendData.length)
    563                 {
    564                     Hal4Ctxt->psTrcvCtxtInfo->
    565                         XchangeInfo.params.nfc_info.more_info = FALSE;
    566                     Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length
    567                                 = (uint8_t)psTransceiveInfo->sSendData.length;
    568                     Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_buffer
    569                         = psTransceiveInfo->sSendData.buffer;
    570                     /*Number of bytes remaining for next send*/
    571                     Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->length = 0;
    572                 }
    573                 else
    574                 {
    575                     Hal4Ctxt->psTrcvCtxtInfo->
    576                         XchangeInfo.params.nfc_info.more_info = TRUE;
    577                     Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_buffer
    578                         = Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->buffer;
    579                     Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length
    580                                                 = psRemoteDevInfo->RemoteDevInfo.NfcIP_Info.MaxFrameLength;
    581 #if 0
    582                     Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->buffer
    583                                                 += psRemoteDevInfo->RemoteDevInfo.NfcIP_Info.MaxFrameLength;
    584 #else
    585                     Hal4Ctxt->psTrcvCtxtInfo->NumberOfBytesSent
    586                         += psRemoteDevInfo->RemoteDevInfo.NfcIP_Info.MaxFrameLength;
    587 #endif
    588                     /*Number of bytes remaining for next send*/
    589                     Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData->length
    590                                                -= psRemoteDevInfo->RemoteDevInfo.NfcIP_Info.MaxFrameLength;
    591                 }
    592                 Hal4Ctxt->Hal4NextState = eHal4StateTransaction;
    593 #ifdef TRANSACTION_TIMER
    594                 /**Create a timer to keep track of transceive timeout*/
    595                 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    596                     == PH_OSALNFC_INVALID_TIMER_ID)
    597                 {
    598                     PHDBG_INFO("HAL4: Transaction Timer Create for transceive");
    599                     Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    600                         = phOsalNfc_Timer_Create();
    601                 }
    602                 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    603                     == PH_OSALNFC_INVALID_TIMER_ID)
    604                 {
    605                     RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
    606                         NFCSTATUS_INSUFFICIENT_RESOURCES);
    607                 }
    608                 else
    609 #endif/*TRANSACTION_TIMER*/
    610                 {
    611                     PHDBG_INFO("Hal4:Calling phHciNfc_Send_Data from Hal4_Transceive()");
    612                     RetStatus = phHciNfc_Send_Data (
    613                                     Hal4Ctxt->psHciHandle,
    614                                     psHwReference,
    615                                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
    616                                     &(Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo)
    617                                     );
    618                     if(NFCSTATUS_PENDING == RetStatus)
    619                     {
    620                         Hal4Ctxt->psTrcvCtxtInfo->P2P_Send_In_Progress = TRUE;
    621                     }
    622                 }
    623             }
    624             else if(psTransceiveInfo->sSendData.length > PH_HAL4NFC_CMD_LENGTH)
    625             {
    626                 RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_INVALID_PARAMETER);
    627             }
    628             else if((psTransceiveInfo->sSendData.length == 0)
    629                     && (Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length != 0))
    630             {
    631                 PHDBG_INFO("Hal4:Read remaining bytes");
    632                 Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData
    633                                             = &(psTransceiveInfo->sRecvData);
    634                 /*Number of read bytes left is greater than bytes requested
    635                     by upper layer*/
    636                 if(Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length
    637                     < Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length)
    638                 {
    639                     (void)memcpy(Hal4Ctxt->psTrcvCtxtInfo
    640                                                 ->psUpperRecvData->buffer,
    641                         (Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
    642                         + Hal4Ctxt->psTrcvCtxtInfo->LowerRecvBufferOffset)
    643                         ,Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length);
    644                     Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length -=
    645                         Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length;
    646                     Hal4Ctxt->psTrcvCtxtInfo->LowerRecvBufferOffset
    647                         += Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length;
    648                     RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
    649                                                 NFCSTATUS_MORE_INFORMATION);
    650                 }
    651                 else/*Number of read bytes left is smaller.Copy all bytes
    652                       and free Hal's buffer*/
    653                 {
    654                     Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length
    655                         = Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length;
    656                     (void)memcpy(Hal4Ctxt->psTrcvCtxtInfo
    657                                                         ->psUpperRecvData
    658                                                                     ->buffer,
    659                         (Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
    660                             + Hal4Ctxt->psTrcvCtxtInfo->LowerRecvBufferOffset)
    661                         ,Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length);
    662                     phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo
    663                                                     ->sLowerRecvData.buffer);
    664                     Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer = NULL;
    665                     Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length = 0;
    666                     Hal4Ctxt->psTrcvCtxtInfo->LowerRecvBufferOffset   = 0;
    667                     RetStatus = NFCSTATUS_SUCCESS;
    668                 }
    669             }
    670             else/*No more bytes remaining in Hal.Read from device*/
    671             {
    672                  /*Register upper layer context*/
    673                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
    674                 /*Register upper layer callback*/
    675                 Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb  = pTrcvCallback;
    676                 Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params.tag_info.addr
    677                                                     = psTransceiveInfo->addr;
    678                 Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_length
    679                                 = (uint16_t)psTransceiveInfo->sSendData.length;
    680                 Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.tx_buffer
    681                                         = psTransceiveInfo->sSendData.buffer;
    682                 Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData
    683                                             = &(psTransceiveInfo->sRecvData);
    684 #ifdef TRANSACTION_TIMER
    685                 /**Create a timer to keep track of transceive timeout*/
    686                 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    687                                     == PH_OSALNFC_INVALID_TIMER_ID)
    688                 {
    689                     PHDBG_INFO("HAL4: Transaction Timer Create for transceive");
    690                     Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    691                                             = phOsalNfc_Timer_Create();
    692                 }
    693                 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
    694                     == PH_OSALNFC_INVALID_TIMER_ID)
    695                 {
    696                     RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
    697                                            NFCSTATUS_INSUFFICIENT_RESOURCES);
    698                 }
    699                 else
    700 #endif /*TRANSACTION_TIMER*/
    701                 {
    702                     PHDBG_INFO("Calling phHciNfc_Exchange_Data");
    703                     RetStatus = phHciNfc_Exchange_Data(
    704                         Hal4Ctxt->psHciHandle,
    705                         psHwReference,
    706                         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
    707                         &(Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo)
    708                         );
    709 
    710                     if(NFCSTATUS_PENDING == RetStatus)
    711                     {
    712                         Hal4Ctxt->Hal4NextState = eHal4StateTransaction;
    713 #ifdef TRANSACTION_TIMER
    714                         /**Start timer to keep track of transceive timeout*/
    715                         phOsalNfc_Timer_Start(
    716                             Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId,
    717                             PH_HAL4NFC_TRANSCEIVE_TIMEOUT,
    718                             phHal4Nfc_TrcvTimeoutHandler
    719                             );
    720 #endif/*#ifdef TRANSACTION_TIMER*/
    721                     }
    722                     else
    723                     {
    724                         Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
    725                     }
    726                 }
    727             }
    728         }
    729     }
    730     return RetStatus;
    731 }
    732 
    733 #ifdef TRANSACTION_TIMER
    734 /**Handle transceive timeout*/
    735 void phHal4Nfc_TrcvTimeoutHandler(uint32_t TrcvTimerId)
    736 {
    737     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = gpphHal4Nfc_Hwref->hal_context;
    738     pphHal4Nfc_ReceiveCallback_t pUpperRecvCb = NULL;
    739     pphHal4Nfc_TransceiveCallback_t pUpperTrcvCb = NULL;
    740     phOsalNfc_Timer_Stop(TrcvTimerId);
    741     phOsalNfc_Timer_Delete(TrcvTimerId);
    742     Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId = PH_OSALNFC_INVALID_TIMER_ID;
    743     Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
    744     /*For a P2P target*/
    745     if(Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb != NULL)
    746     {
    747         pUpperRecvCb = Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb;
    748         Hal4Ctxt->psTrcvCtxtInfo->pP2PRecvCb = NULL;
    749         (*pUpperRecvCb)(
    750             Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
    751             NULL,
    752             NFCSTATUS_RF_TIMEOUT
    753             );
    754     }
    755     else
    756     {
    757         /*For a P2P Initiator and tags*/
    758         if(Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb != NULL)
    759         {
    760             pUpperTrcvCb = Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb;
    761             Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb = NULL;
    762             (*pUpperTrcvCb)(
    763                         Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
    764                         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
    765                         NULL,
    766                         NFCSTATUS_RF_TIMEOUT
    767                         );
    768         }
    769     }
    770 }
    771 #endif /*TRANSACTION_TIMER*/
    772 
    773 
    774 /**The function allows to disconnect from a specific Remote Device.*/
    775 NFCSTATUS phHal4Nfc_Disconnect(
    776                         phHal_sHwReference_t          *psHwReference,
    777                         phHal_sRemoteDevInformation_t *psRemoteDevInfo,
    778                         phHal_eReleaseType_t           ReleaseType,
    779                         pphHal4Nfc_DiscntCallback_t    pDscntCallback,
    780                         void                             *pContext
    781                         )
    782 {
    783     NFCSTATUS RetStatus = NFCSTATUS_PENDING;
    784     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
    785     PHDBG_INFO("Hal4:Inside Hal4 disconnect");
    786     /*NULL checks*/
    787     if(NULL == psHwReference || NULL == pDscntCallback
    788         || NULL == psRemoteDevInfo)
    789     {
    790         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
    791         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
    792     }
    793     /*Check Initialised state*/
    794     else if((NULL == psHwReference->hal_context)
    795                         || (((phHal4Nfc_Hal4Ctxt_t *)
    796                                 psHwReference->hal_context)->Hal4CurrentState
    797                                                < eHal4StateOpenAndReady)
    798                         || (((phHal4Nfc_Hal4Ctxt_t *)
    799                                 psHwReference->hal_context)->Hal4NextState
    800                                                == eHal4StateClosed))
    801     {
    802         RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
    803     }
    804     else if(((phHal4Nfc_Hal4Ctxt_t *)
    805                     psHwReference->hal_context)->Hal4CurrentState
    806                     != eHal4StateTargetConnected)
    807     {
    808         PHDBG_INFO("Hal4:Current sate is not connect.Release returning failed");
    809         RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_FAILED);
    810     }
    811     else
    812     {
    813         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
    814         if((Hal4Ctxt->sTgtConnectInfo.psConnectedDevice == NULL)
    815             || (psRemoteDevInfo != Hal4Ctxt->sTgtConnectInfo.psConnectedDevice))
    816         {
    817             PHDBG_INFO("Hal4:disconnect returning INVALID_REMOTE_DEVICE");
    818             RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_INVALID_REMOTE_DEVICE);
    819         }
    820         else
    821         {
    822             /*Register upper layer context*/
    823             Hal4Ctxt->sUpperLayerInfo.psUpperLayerDisconnectCtxt = pContext;
    824             /*Register upper layer callback*/
    825             Hal4Ctxt->sTgtConnectInfo.pUpperDisconnectCb  = pDscntCallback;
    826             /*Register Release Type*/
    827             Hal4Ctxt->sTgtConnectInfo.ReleaseType = ReleaseType;
    828             if((eHal4StateTransaction == Hal4Ctxt->Hal4NextState)
    829                 &&((phHal_eNfcIP1_Target != psRemoteDevInfo->RemDevType)
    830                 ||((NFC_DISCOVERY_CONTINUE != ReleaseType)
    831                    &&(NFC_DISCOVERY_RESTART != ReleaseType))))
    832             {
    833                 Hal4Ctxt->sTgtConnectInfo.ReleaseType
    834                                                   = NFC_INVALID_RELEASE_TYPE;
    835                 PHDBG_INFO("Hal4:disconnect returning NFCSTATUS_NOT_ALLOWED");
    836                 RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_NOT_ALLOWED);
    837             }
    838             else if((eHal4StateTransaction == Hal4Ctxt->Hal4NextState)
    839                     &&(NULL != Hal4Ctxt->psTrcvCtxtInfo)
    840                     &&(TRUE == Hal4Ctxt->psTrcvCtxtInfo->P2P_Send_In_Progress))
    841             {
    842                 /*store the hardware reference for executing disconnect later*/
    843                 gpphHal4Nfc_Hwref = psHwReference;
    844                 PHDBG_INFO("Hal4:disconnect deferred");
    845             }
    846             else/*execute disconnect*/
    847             {
    848                 RetStatus = phHal4Nfc_Disconnect_Execute(psHwReference);
    849             }
    850         }
    851     }
    852     return RetStatus;
    853 }
    854 
    855 /**Execute Hal4 Disconnect*/
    856 NFCSTATUS phHal4Nfc_Disconnect_Execute(
    857                             phHal_sHwReference_t  *psHwReference
    858                             )
    859 {
    860     NFCSTATUS RetStatus = NFCSTATUS_PENDING;
    861     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt =
    862         (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
    863     phHal_eSmartMX_Mode_t SmxMode = eSmartMx_Default;
    864     PHDBG_INFO("Hal4:Inside Hal4 disconnect execute");
    865     switch(Hal4Ctxt->sTgtConnectInfo.ReleaseType)
    866     {
    867         /*Switch mode to Default*/
    868         case NFC_SMARTMX_RELEASE:
    869             SmxMode = eSmartMx_Default;
    870             RetStatus = phHciNfc_Switch_SmxMode (
    871                 Hal4Ctxt->psHciHandle,
    872                 psHwReference,
    873                 SmxMode,
    874                 &(Hal4Ctxt->psADDCtxtInfo->sADDCfg)
    875                 );
    876             break;
    877         /*Disconnect and continue polling wheel*/
    878         case NFC_DISCOVERY_CONTINUE:
    879         {
    880             RetStatus = phHciNfc_Disconnect (
    881                                     Hal4Ctxt->psHciHandle,
    882                                     psHwReference,
    883                                     FALSE
    884                                     );
    885             if(NFCSTATUS_PENDING != RetStatus)
    886             {
    887                 PHDBG_INFO("Hal4:Hci disconnect failed.Restarting discovery");
    888                 RetStatus = phHciNfc_Restart_Discovery (
    889                                     (void *)Hal4Ctxt->psHciHandle,
    890                                     (void *)gpphHal4Nfc_Hwref,
    891                                     FALSE
    892                                     );
    893                 if(NFCSTATUS_PENDING != RetStatus)
    894                 {
    895                     PHDBG_INFO("Hal4:Hci Restart discovery also failed");
    896                 }
    897             }
    898             break;
    899         }
    900         /*Disconnect and restart polling wheel*/
    901         case NFC_DISCOVERY_RESTART:
    902             RetStatus = phHciNfc_Disconnect (
    903                                 Hal4Ctxt->psHciHandle,
    904                                 psHwReference,
    905                                 TRUE
    906                                 );
    907             break;
    908         default:
    909             RetStatus = PHNFCSTVAL(CID_NFC_HAL,
    910                 NFCSTATUS_FEATURE_NOT_SUPPORTED);
    911             break;
    912     }
    913     Hal4Ctxt->sTgtConnectInfo.ReleaseType = NFC_INVALID_RELEASE_TYPE;
    914     /*Update or rollback next state*/
    915     Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == RetStatus?
    916                     eHal4StateOpenAndReady:Hal4Ctxt->Hal4NextState);
    917     return  RetStatus;
    918 }
    919 
    920 /*The function allows to check for presence in vicinity of connected remote
    921   device.*/
    922 NFCSTATUS phHal4Nfc_PresenceCheck(
    923                                 phHal_sHwReference_t     *psHwReference,
    924                                 pphHal4Nfc_GenCallback_t  pPresenceChkCb,
    925                                 void *context
    926                                 )
    927 {
    928     NFCSTATUS RetStatus = NFCSTATUS_FAILED;
    929     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
    930     /*NULL  checks*/
    931     if((NULL == pPresenceChkCb) || (NULL == psHwReference))
    932     {
    933         RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_INVALID_PARAMETER);
    934     }
    935     /*Check Initialised state*/
    936     else if((NULL == psHwReference->hal_context)
    937                         || (((phHal4Nfc_Hal4Ctxt_t *)
    938                                 psHwReference->hal_context)->Hal4CurrentState
    939                                                < eHal4StateOpenAndReady)
    940                         || (((phHal4Nfc_Hal4Ctxt_t *)
    941                                 psHwReference->hal_context)->Hal4NextState
    942                                                == eHal4StateClosed))
    943     {
    944         PHDBG_INFO("HAL4:Context not Open");
    945         RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_NOT_INITIALISED);
    946     }
    947     /*check connected state and session alive*/
    948     else if((((phHal4Nfc_Hal4Ctxt_t *)
    949              psHwReference->hal_context)->Hal4CurrentState
    950                                 < eHal4StateTargetConnected)||
    951             (NULL == ((phHal4Nfc_Hal4Ctxt_t *)
    952               psHwReference->hal_context)->sTgtConnectInfo.psConnectedDevice)||
    953             (FALSE == ((phHal4Nfc_Hal4Ctxt_t *)
    954                         psHwReference->hal_context)->sTgtConnectInfo.
    955                                     psConnectedDevice->SessionOpened))
    956     {
    957         PHDBG_INFO("HAL4:No target connected");
    958         RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_RELEASED);
    959     }
    960     else
    961     {
    962         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
    963         /*allow only one Presence chk command at any point in time*/
    964         if (eHal4StatePresenceCheck != Hal4Ctxt->Hal4NextState)
    965         {
    966             /* Check if remote device is felica */
    967             if (Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemDevType ==
    968                 phHal_eFelica_PICC)
    969             {
    970                 /* If felica PICC then copy existing IDm to compare later,
    971                    If IDm will be same then same PICC is present after presence check
    972                    else PICC is changed */
    973                 (void) memcpy(Hal4Ctxt->FelicaIDm,
    974                               Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDm,
    975                               Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDmLength);
    976             }
    977             Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = context;
    978             Hal4Ctxt->sTgtConnectInfo.pPresenceChkCb = pPresenceChkCb;
    979             RetStatus = phHciNfc_Presence_Check(Hal4Ctxt->psHciHandle,
    980                                                 psHwReference
    981                                                 );
    982             Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == RetStatus?
    983                 eHal4StatePresenceCheck:Hal4Ctxt->Hal4NextState);
    984         }
    985         else/*Ongoing presence chk*/
    986         {
    987             RetStatus = PHNFCSTVAL(CID_NFC_HAL,NFCSTATUS_BUSY);
    988         }
    989     }
    990     return RetStatus;
    991 }
    992 
    993 void phHal4Nfc_PresenceChkComplete(
    994                                    phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
    995                                    void *pInfo
    996                                    )
    997 {
    998     NFCSTATUS RetStatus = ((phNfc_sCompletionInfo_t *)pInfo)->status;
    999     Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
   1000     /*Notify to upper layer*/
   1001     if(NULL != Hal4Ctxt->sTgtConnectInfo.pPresenceChkCb)
   1002     {
   1003         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->SessionOpened
   1004                      =(uint8_t)(NFCSTATUS_SUCCESS == RetStatus?TRUE:FALSE);
   1005         /* Check if remote device is felica */
   1006         if (Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemDevType ==
   1007             phHal_eFelica_PICC)
   1008         {
   1009             /* Check if IDm received is same as saved */
   1010             if (0 != phOsalNfc_MemCompare(Hal4Ctxt->FelicaIDm,
   1011                 Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDm,
   1012                 Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDmLength))
   1013             {
   1014                 RetStatus = NFCSTATUS_FAILED;
   1015 
   1016                 /* Presence check failed so reset remote device information */
   1017                 (void) memset(Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDm,
   1018                               0, PHHAL_FEL_ID_LEN + 2);
   1019                 (void) memset(Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.PMm,
   1020                               0, PHHAL_FEL_PM_LEN);
   1021             }
   1022 
   1023             /* Cleanup for stored IDm value for using it next time */
   1024             (void) memset(Hal4Ctxt->FelicaIDm, 0, PHHAL_FEL_ID_LEN + 2);
   1025         }
   1026 
   1027         (*Hal4Ctxt->sTgtConnectInfo.pPresenceChkCb)(
   1028                         Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1029                         RetStatus
   1030                         );
   1031     }
   1032     return;
   1033 }
   1034 
   1035 /*Callback for reactivate target and to select appropriate target incase
   1036  of multiple targets*/
   1037 void phHal4Nfc_ReactivationComplete(
   1038                                     phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
   1039                                     void *pInfo
   1040                                     )
   1041 {
   1042     NFCSTATUS Status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
   1043     /*A NFCSTATUS_SUCCESS status returned here means that the correct device
   1044      to connect to has now been selected.So issue connect from here to complete
   1045      activation*/
   1046     if(NFCSTATUS_SUCCESS == Status)
   1047     {
   1048         Hal4Ctxt->Hal4NextState = eHal4StateTargetConnected;
   1049         Status = phHciNfc_Connect(
   1050             Hal4Ctxt->psHciHandle,
   1051             gpphHal4Nfc_Hwref,
   1052             Hal4Ctxt->sTgtConnectInfo.psConnectedDevice
   1053             );
   1054         Status = (NFCSTATUS_PENDING == Status)?
   1055                     NFCSTATUS_PENDING:NFCSTATUS_FAILED;
   1056     }
   1057     else/*Device unavailable, return error in connect Callback*/
   1058     {
   1059         Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
   1060         if(NULL != Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb)
   1061         {
   1062             (*Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb)(
   1063                                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1064                                 Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
   1065                                 Status
   1066                                 );
   1067         }
   1068     }
   1069     return;
   1070 }
   1071 
   1072 void phHal4Nfc_Felica_RePoll(void     *context,
   1073                                         NFCSTATUS status)
   1074 {
   1075      phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt = gpHal4Ctxt;
   1076      pphHal4Nfc_ConnectCallback_t pUpperConnectCb
   1077                                 = Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb;
   1078 
   1079      Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = NULL;
   1080      PHDBG_INFO("Hal4:Calling Connect callback");
   1081 
   1082     if (pUpperConnectCb != NULL)
   1083     {
   1084          /*Notify to the upper layer*/
   1085          (*pUpperConnectCb)(
   1086                     Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1087                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
   1088                     status
   1089                     );
   1090     }
   1091 
   1092     return;
   1093 }
   1094 void phHal4Nfc_ConnectComplete(
   1095                                phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
   1096                                void *pInfo
   1097                                )
   1098 {
   1099     NFCSTATUS ConnectStatus = ((phNfc_sCompletionInfo_t *)pInfo)->status;
   1100     pphHal4Nfc_ConnectCallback_t pUpperConnectCb
   1101                                 = Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb;
   1102     /*Flag to decide whether or not upper layer callback has to be called*/
   1103     uint8_t CallConnectCb = TRUE;
   1104     uint8_t felicaRePoll = FALSE;
   1105 
   1106     /*Remote device Connect successful*/
   1107     if((NFCSTATUS_SUCCESS == ConnectStatus)
   1108 		||(eHal4StateTargetConnected == Hal4Ctxt->Hal4CurrentState))
   1109     {
   1110         phHal_sRemoteDevInformation_t *psRmtTgtConnected =
   1111                             Hal4Ctxt->sTgtConnectInfo.psConnectedDevice;
   1112         PHDBG_INFO("Hal4:Connect status Success");
   1113         Hal4Ctxt->Hal4CurrentState = eHal4StateTargetConnected;
   1114         Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
   1115         /* Open the Session */
   1116         psRmtTgtConnected->SessionOpened =
   1117             (uint8_t)(NFCSTATUS_SUCCESS == ConnectStatus?TRUE:FALSE);
   1118         Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = NULL;
   1119         if (psRmtTgtConnected->RemDevType == phHal_eFelica_PICC)
   1120         {
   1121             felicaRePoll = TRUE;
   1122         }
   1123     }
   1124     else/*Remote device Connect failed*/
   1125     {
   1126         Hal4Ctxt->Hal4CurrentState = eHal4StateOpenAndReady;
   1127         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->SessionOpened = FALSE;
   1128         /*For a NfcIp1 target and case where it is not a internal reconnect
   1129           from Hal4 ,notify callback to upper layer*/
   1130         if((phHal_eNfcIP1_Target
   1131             == Hal4Ctxt->rem_dev_list[0]->RemDevType)
   1132             || (NULL != Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb))
   1133         {
   1134             Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = NULL;
   1135         }
   1136         else/*do not notify callback*/
   1137         {
   1138             CallConnectCb = FALSE;
   1139         }
   1140         /*Free the remote device list*/
   1141         do
   1142         {
   1143             Hal4Ctxt->psADDCtxtInfo->nbr_of_devices--;
   1144             if(NULL != Hal4Ctxt->rem_dev_list[
   1145                         Hal4Ctxt->psADDCtxtInfo->nbr_of_devices])
   1146             {
   1147                 phOsalNfc_FreeMemory((void *)
   1148                         (Hal4Ctxt->rem_dev_list[
   1149                             Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]));
   1150                 Hal4Ctxt->rem_dev_list[
   1151                     Hal4Ctxt->psADDCtxtInfo->nbr_of_devices] = NULL;
   1152             }
   1153         }while(0 < Hal4Ctxt->psADDCtxtInfo->nbr_of_devices);
   1154 
   1155         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice = NULL;
   1156     }
   1157     if(TRUE == CallConnectCb)
   1158     {
   1159         if (felicaRePoll == TRUE)
   1160         {
   1161             /* Felica repoll through presence check */
   1162 
   1163             /* If felica PICC then copy existing IDm to compare later,
   1164                If IDm will be same then same PICC is present after presence check
   1165                else PICC is changed */
   1166             (void) memcpy(Hal4Ctxt->FelicaIDm,
   1167                           Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDm,
   1168                           Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemoteDevInfo.Felica_Info.IDmLength);
   1169 
   1170             gpHal4Ctxt = Hal4Ctxt;
   1171             Hal4Ctxt->sTgtConnectInfo.pPresenceChkCb = phHal4Nfc_Felica_RePoll;
   1172             ConnectStatus = phHciNfc_Presence_Check(Hal4Ctxt->psHciHandle,
   1173                                                     gpphHal4Nfc_Hwref
   1174                                                     );
   1175             Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == ConnectStatus?
   1176                     eHal4StatePresenceCheck:Hal4Ctxt->Hal4NextState);
   1177             felicaRePoll = FALSE;
   1178             Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = pUpperConnectCb;
   1179         }
   1180         else
   1181         {
   1182             PHDBG_INFO("Hal4:Calling Connect callback");
   1183             /*Notify to the upper layer*/
   1184             (*pUpperConnectCb)(
   1185                     Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1186                     Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
   1187                     ConnectStatus
   1188                     );
   1189 	 }
   1190     }
   1191     else
   1192     {
   1193         PHDBG_INFO("Hal4:Connect failed ,Restarting discovery");
   1194         /*Restart the Discovery wheel*/
   1195         ConnectStatus = phHciNfc_Restart_Discovery (
   1196                                     (void *)Hal4Ctxt->psHciHandle,
   1197                                     (void *)gpphHal4Nfc_Hwref,
   1198                                     FALSE
   1199                                     );
   1200         Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == ConnectStatus?
   1201                                     eHal4StateConfiguring:eHal4StateInvalid);
   1202     }
   1203     return;
   1204 }
   1205 
   1206 
   1207 
   1208 
   1209 void phHal4Nfc_DisconnectComplete(
   1210                                   phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
   1211                                   void *pInfo
   1212                                   )
   1213 {
   1214     NFCSTATUS ConnectStatus = ((phNfc_sCompletionInfo_t *)pInfo)->status;
   1215     phHal_sRemoteDevInformation_t *psConnectedDevice = NULL;
   1216     pphHal4Nfc_DiscntCallback_t pUpperDisconnectCb = NULL;
   1217     pphHal4Nfc_TransceiveCallback_t pUpperTrcvCb = NULL;
   1218     PHDBG_INFO("Hal4:Inside Hal4 disconnect callback");
   1219     if(NULL == Hal4Ctxt)
   1220     {
   1221         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
   1222     }
   1223     else if(NFCSTATUS_SUCCESS != ConnectStatus)/*Restart the Discovery wheel*/
   1224     {
   1225         ConnectStatus = phHciNfc_Restart_Discovery (
   1226                                     (void *)Hal4Ctxt->psHciHandle,
   1227                                     (void *)gpphHal4Nfc_Hwref,
   1228                                     FALSE
   1229                                     );
   1230         Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == ConnectStatus?
   1231                                     eHal4StateConfiguring:eHal4StateInvalid);
   1232     }
   1233     else/*Remote device Disconnect successful*/
   1234     {
   1235         psConnectedDevice = Hal4Ctxt->sTgtConnectInfo.psConnectedDevice;
   1236         pUpperDisconnectCb = Hal4Ctxt->sTgtConnectInfo.pUpperDisconnectCb;
   1237         /*Deallocate psTrcvCtxtInfo*/
   1238         if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
   1239         {
   1240             if(NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
   1241             {
   1242                if(NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData)
   1243                 {
   1244                     phOsalNfc_FreeMemory(
   1245                         Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData);
   1246                 }
   1247             }
   1248             else
   1249             {
   1250                 if(phHal_eNfcIP1_Target
   1251                     == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice->RemDevType)
   1252                 {
   1253                     pUpperTrcvCb = Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb;
   1254                     Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length = 0;
   1255                     pUpperTrcvCb = Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb;
   1256                     Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb = NULL;
   1257                 }
   1258             }
   1259             if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
   1260             {
   1261                 phOsalNfc_FreeMemory(
   1262                     Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer);
   1263             }
   1264 
   1265             phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo);
   1266             Hal4Ctxt->psTrcvCtxtInfo = NULL;
   1267         }
   1268         /*Free the remote device list*/
   1269         do
   1270         {
   1271             if(NULL != Hal4Ctxt->rem_dev_list[Hal4Ctxt->
   1272                 psADDCtxtInfo->nbr_of_devices-1])
   1273             {
   1274                 phOsalNfc_FreeMemory((void *)
   1275                     (Hal4Ctxt->rem_dev_list[Hal4Ctxt->
   1276                     psADDCtxtInfo->nbr_of_devices-1]));
   1277                 Hal4Ctxt->rem_dev_list[Hal4Ctxt->
   1278                     psADDCtxtInfo->nbr_of_devices-1] = NULL;
   1279             }
   1280         }while(--(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices));
   1281 
   1282         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice = NULL;
   1283         /*Disconnect successful.Go to Ready state*/
   1284         Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState;
   1285         Hal4Ctxt->sTgtConnectInfo.pUpperDisconnectCb = NULL;
   1286         Hal4Ctxt->Hal4NextState = (
   1287             eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState?
   1288             eHal4StateInvalid:Hal4Ctxt->Hal4NextState);
   1289         /*Issue any pending Trcv callback*/
   1290         if(NULL != pUpperTrcvCb)
   1291         {
   1292             (*pUpperTrcvCb)(
   1293                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1294                 psConnectedDevice,
   1295                 NULL,
   1296                 NFCSTATUS_FAILED
   1297                 );
   1298         }
   1299         /*Notify upper layer*/
   1300         if(NULL != pUpperDisconnectCb)
   1301         {
   1302             PHDBG_INFO("Hal4:Calling Upper layer disconnect callback");
   1303             (*pUpperDisconnectCb)(
   1304                         Hal4Ctxt->sUpperLayerInfo.psUpperLayerDisconnectCtxt,
   1305                         psConnectedDevice,
   1306                         ConnectStatus
   1307                         );
   1308         }
   1309     }
   1310     return;
   1311 }
   1312 
   1313 
   1314 /*Transceive complete handler function*/
   1315 void phHal4Nfc_TransceiveComplete(
   1316                                   phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
   1317                                   void *pInfo
   1318                                   )
   1319 {
   1320     /*Copy status code*/
   1321     NFCSTATUS TrcvStatus = ((phNfc_sCompletionInfo_t *)pInfo)->status;
   1322     /*Update next state*/
   1323     Hal4Ctxt->Hal4NextState = (eHal4StateTransaction
   1324              == Hal4Ctxt->Hal4NextState?eHal4StateInvalid:Hal4Ctxt->Hal4NextState);
   1325     /*Reset SelectSectorFlag for Mifare*/
   1326     if (Hal4Ctxt->SelectSectorFlag == 2)
   1327     {
   1328         TrcvStatus = NFCSTATUS_SUCCESS;
   1329         PHDBG_INFO("Inside Hal4TrcvComplete SelectSectorFlag is 2");
   1330         Hal4Ctxt->SelectSectorFlag = 0;
   1331     }
   1332 
   1333     if(NULL == Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData)
   1334     {
   1335         /*if recv buffer is Null*/
   1336         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
   1337         TrcvStatus = NFCSTATUS_FAILED;
   1338     }
   1339     else if(TrcvStatus == NFCSTATUS_SUCCESS)
   1340     {
   1341         /*Check if recvdata buffer given by upper layer is big enough to
   1342         receive all response bytes.If it is not big enough ,copy number
   1343         of bytes requested by upper layer to the buffer.Remaining
   1344         bytes are retained in Hal4 and upper layer has to issue another
   1345         transceive call to read the same.*/
   1346         if(((phNfc_sTransactionInfo_t *)pInfo)
   1347             ->length  > Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length )
   1348         {
   1349             TrcvStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_MORE_INFORMATION);
   1350             Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length
   1351                 = ((phNfc_sTransactionInfo_t *)pInfo)->length
   1352                 - Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length;
   1353 
   1354             Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
   1355                 = (uint8_t *)phOsalNfc_GetMemory(
   1356                 Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length
   1357                 );
   1358             if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
   1359             {
   1360                 (void)memcpy(
   1361                     Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer,
   1362                     (((phNfc_sTransactionInfo_t *)pInfo)->buffer
   1363                     + Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData
   1364                     ->length)
   1365                     ,Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length
   1366                     );
   1367             }
   1368             else
   1369             {
   1370                 TrcvStatus = PHNFCSTVAL(CID_NFC_HAL,
   1371                     NFCSTATUS_INSUFFICIENT_RESOURCES);
   1372                 phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
   1373             }
   1374 
   1375         }
   1376         else/*Buffer provided by upper layer is big enough to hold all read
   1377               bytes*/
   1378         {
   1379             Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length
   1380                 = ((phNfc_sTransactionInfo_t *)pInfo)->length;
   1381             Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.length = 0;
   1382         }
   1383         (void)memcpy(Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->buffer,
   1384             ((phNfc_sTransactionInfo_t *)pInfo)->buffer,
   1385             Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length
   1386             );
   1387 
   1388     }
   1389     else/*Error scenario.Set received bytes length to zero*/
   1390     {
   1391         Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData->length = 0;
   1392     }
   1393     (void)memset((void *)&(Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params),
   1394                   0,
   1395                   sizeof(Hal4Ctxt->psTrcvCtxtInfo->XchangeInfo.params)
   1396                 );
   1397     Hal4Ctxt->psTrcvCtxtInfo->LowerRecvBufferOffset = 0;
   1398     /*Issue transceive callback*/
   1399     (*Hal4Ctxt->psTrcvCtxtInfo->pUpperTranceiveCb)(
   1400         Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
   1401         Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
   1402         Hal4Ctxt->psTrcvCtxtInfo->psUpperRecvData,
   1403         TrcvStatus
   1404         );
   1405     return;
   1406 }
   1407