src/phLibNfc_initiator.c

   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 /*!
  18  * \file phLibNfc_initiator.c
  19
  20  * Project: NFC FRI 1.1
  21  *
  22  * $Date: Fri Apr 23 14:34:08 2010 $
  23  * $Author: ing07385 $
  24  * $Revision: 1.53 $
  25  * $Aliases: NFC_FRI1.1_WK1014_SDK,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1019_SDK,NFC_FRI1.1_WK1024_SDK $
  26  *
  27  */
  28
  29 /*
  30 ************************* Header Files ****************************************
  31 */
  32
  33 #include <phLibNfcStatus.h>
  34 #include <phLibNfc.h>
  35 #include <phHal4Nfc.h>
  36 #include <phOsalNfc.h>
  37 #include <phLibNfc_Internal.h>
  38 #include <phLibNfc_SE.h>
  39 #include <phLibNfc_ndef_raw.h>
  40 #include <phLibNfc_initiator.h>
  41 #include <phLibNfc_discovery.h>
  42
  43
  44 /*
  45 *************************** Macro's  ****************************************
  46 */
  47
  48 #ifndef STATIC_DISABLE
  49 #define STATIC static
  50 #else
  51 #define STATIC
  52 #endif
  53
  54 /*
  55 *************************** Global Variables **********************************
  56 */
  57
  58 #define PN544_IO_TIMEOUT_RESPONSE 0x89
  59
  60 /*
  61 *************************** Static Function Declaration ***********************
  62 */
  63
  64 /* Target discvovery notification callback */
  65 STATIC void phLibNfc_NotificationRegister_Resp_Cb (
  66                                 void                             *context,
  67                                 phHal_eNotificationType_t        type,
  68                                 phHal4Nfc_NotificationInfo_t     info,
  69                                 NFCSTATUS                        status
  70                                 );
  71
  72 /*Remote device connect response callback*/
  73 STATIC void phLibNfc_RemoteDev_Connect_Cb(
  74                            void        *pContext,
  75                            phHal_sRemoteDevInformation_t *pRmtdev_info,
  76                            NFCSTATUS    status
  77                            );
  78
  79 #ifdef RECONNECT_SUPPORT
  80 STATIC
  81 void
  82 phLibNfc_config_discovery_con_failure_cb (
  83     void                *context,
  84     NFCSTATUS           status);
  85 #endif /* #ifdef RECONNECT_SUPPORT */
  86
  87 /*Remote device disconnect response callback*/
  88 STATIC void phLibNfc_RemoteDev_Disconnect_cb(
  89                                 void                          *context,
  90                                 phHal_sRemoteDevInformation_t *reg_handle,
  91                                 NFCSTATUS                      status
  92                                 );
  93 /*Remote device Transceive response callback*/
  94 STATIC void phLibNfc_RemoteDev_Transceive_Cb(void *context,
  95                                 phHal_sRemoteDevInformation_t *pRmtdev_info,
  96                                 phNfc_sData_t *response,
  97                                 NFCSTATUS status
  98                                 );
  99 /*Set P2P config paramater response callback*/
 100 STATIC void phLibNfc_Mgt_SetP2P_ConfigParams_Cb(
 101                                 void                             *context,
 102                                 NFCSTATUS                        status
 103                                 );
 104
 105
 106 /*
 107 *************************** Function Definitions ******************************
 108 */
 109
 110 /**
 111 * Response to target discovery.
 112 */
 113 STATIC
 114 void phLibNfc_NotificationRegister_Resp_Cb (
 115                                 void                            *context,
 116                                 phHal_eNotificationType_t       type,
 117                                 phHal4Nfc_NotificationInfo_t    info,
 118                                 NFCSTATUS                       status
 119                                 )
 120 {
 121     NFCSTATUS RetVal = NFCSTATUS_SUCCESS,
 122               Status = NFCSTATUS_SUCCESS;
 123     uint16_t DeviceIndx, DeviceIndx1;
 124     uint8_t sak_byte=0;
 125     uint8_t tag_disc_flg = 0;
 126     phLibNfc_NtfRegister_RspCb_t pClientCb=NULL;
 127     pClientCb =gpphLibContext->CBInfo.pClientNtfRegRespCB;
 128         PHNFC_UNUSED_VARIABLE(context);
 129
 130
 131     if(( type != NFC_DISCOVERY_NOTIFICATION )
 132         &&(PHNFCSTATUS(status)!=NFCSTATUS_DESELECTED))
 133     {
 134         Status = NFCSTATUS_FAILED;
 135     }
 136     else if (PHNFCSTATUS(status) == NFCSTATUS_DESELECTED)
 137     {
 138         return;
 139     }
 140         else
 141         {
 142                 DeviceIndx=0;DeviceIndx1=0;
 143                 while(DeviceIndx < info.psDiscoveryInfo->NumberOfDevices)
 144                 {
 145                         switch(info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx]->RemDevType)
 146                         {
 147                                 case  phHal_eMifare_PICC:
 148                                 {
 149                                         /*Mifare Tag discovered*/
 150                                         sak_byte =  info.psDiscoveryInfo->
 151                                                                 ppRemoteDevInfo[DeviceIndx]->RemoteDevInfo.Iso14443A_Info.Sak;
 152                                         if((TRUE == gpphLibContext->RegNtfType.MifareUL)&& (sak_byte==0x00))
 153                                         {
 154                                                 /*Copy the tag related info*/
 155                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 156                                                         info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 157                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 158                                                         (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 159                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 160                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 161                                                 DeviceIndx1++;
 162                                                 tag_disc_flg++;
 163                                         }
 164
 165                                         if((TRUE == gpphLibContext->RegNtfType.MifareStd)&&
 166                                                 (((sak_byte & 0x18)==0x08)||((sak_byte & 0x18)==0x18)))
 167                                         {
 168                                                 /*Copy the tag related info*/
 169                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 170                                                         info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 171                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 172                                                         (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 173                                                 gpphLibContext->Discov_handle[DeviceIndx1]=
 174                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 175                                                 DeviceIndx1++;
 176                                                 tag_disc_flg++;
 177                                         }
 178
 179                                 }break;
 180                                 case  phHal_eISO14443_A_PICC:
 181                                 {
 182                                         /*ISO 14443-A type tag discovered*/
 183                                         if(TRUE == gpphLibContext->RegNtfType.ISO14443_4A)
 184                                         {
 185                                                 /*Copy the ISO type A tag info*/
 186                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 187                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 188                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 189                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 190                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 191                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 192                                                 DeviceIndx1++;
 193                                                 tag_disc_flg++;
 194                                         }
 195                                 }break;
 196                                 case  phHal_eISO14443_3A_PICC:
 197                                 {
 198                                         /*ISO 14443-A type tag discovered*/
 199                                         if(TRUE == gpphLibContext->RegNtfType.MifareUL)
 200                                         {
 201                                                 /*Copy the ISO type A tag info*/
 202                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 203                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 204                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 205                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 206                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 207                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 208                                                 DeviceIndx1++;
 209                                                 tag_disc_flg++;
 210                                         }
 211                                 }break;
 212                                 case  phHal_eISO14443_B_PICC:
 213                                 {
 214                                         /*ISO 14443-B type tag Discovered */
 215                                         if(TRUE == gpphLibContext->RegNtfType.ISO14443_4B)
 216                                         {
 217                                                 /*Copy the Type B tag info */
 218                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 219                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 220                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 221                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 222                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 223                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 224                                                 DeviceIndx1++;
 225                                                 tag_disc_flg++;
 226                                         }
 227                                 }break;
 228                                 case  phHal_eFelica_PICC:
 229                                 {
 230                                         /*Felica Type Tag Discovered */
 231                                         if(TRUE == gpphLibContext->RegNtfType.Felica)
 232                                         {
 233                                                 /*Copy the Felica tag info */
 234                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 235                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 236                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 237                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 238                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 239                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 240                                                 DeviceIndx1++;
 241                                                 tag_disc_flg++;
 242                                         }
 243                                 }break;
 244                                 case  phHal_eJewel_PICC:
 245                                 {
 246                                         /*Jewel Type Tag Discovered */
 247                                         if(TRUE == gpphLibContext->RegNtfType.Jewel)
 248                                         {
 249                                                 /*Copy the Felica tag info */
 250                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 251                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 252                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 253                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 254                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 255                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 256                                                 DeviceIndx1++;
 257                                                 tag_disc_flg++;
 258                                         }
 259                                 }
 260                                 break;
 261                                 case  phHal_eISO15693_PICC:
 262                                 {
 263                                         /*Jewel Type Tag Discovered */
 264                                         if(TRUE == gpphLibContext->RegNtfType.ISO15693)
 265                                         {
 266                                                 /*Copy the Felica tag info */
 267                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 268                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 269                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 270                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 271                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 272                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 273                                                 DeviceIndx1++;
 274                                                 tag_disc_flg++;
 275                                         }
 276                                 }
 277                                 break;
 278                                 case  phHal_eNfcIP1_Target:
 279                                 {
 280                                         if(TRUE == gpphLibContext->RegNtfType.NFC)
 281                                         {
 282                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 283                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 284                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 285                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx].psRemoteDevInfo;
 286                                                 gpphLibContext->Discov_handle[DeviceIndx1] =
 287                                                         gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 288                                                 DeviceIndx1++;
 289                                                 tag_disc_flg++;
 290                                         }
 291                                 }
 292                                 break;
 293                                 case  phHal_eNfcIP1_Initiator:
 294                                 {
 295                                         if(TRUE == gpphLibContext->RegNtfType.NFC)
 296                                         {
 297                                                 gpphLibContext->LibNfcState.cur_state=eLibNfcHalStateConnect;
 298                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo=
 299                                                                 info.psDiscoveryInfo->ppRemoteDevInfo[DeviceIndx];
 300                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev =
 301                                                                 (uint32_t)gpphLibContext->psRemoteDevList[DeviceIndx1].psRemoteDevInfo;
 302                                                 gpphLibContext->sNfcIp_Context.Rem_Initiator_Handle=
 303                                                                 gpphLibContext->psRemoteDevList[DeviceIndx1].hTargetDev;
 304                                                 DeviceIndx1++;
 305                                                 tag_disc_flg++;
 306                                         }
 307                                 }
 308                                 break;
 309                                 default :
 310                                 {
 311                                         break;
 312                                 }
 313                         }
 314                         DeviceIndx++;
 315                 }
 316         }
 317
 318     if((tag_disc_flg >0 )&&(status != NFCSTATUS_FAILED))
 319     {
 320         gpphLibContext->dev_cnt = tag_disc_flg;
 321         /* Check for if the discovered tags are multiple or
 322          Multiple protocol tag */
 323         if((gpphLibContext->dev_cnt > 1)&&(
 324             (status ==NFCSTATUS_MULTIPLE_PROTOCOLS) ||
 325             (status ==NFCSTATUS_MULTIPLE_TAGS)) )
 326         {
 327             status = status;
 328         }
 329         else
 330         {
 331             status =NFCSTATUS_SUCCESS;
 332         }
 333         /*Notify to upper layer the no of tag discovered and
 334           the protocol */
 335         if (NULL != pClientCb)
 336         {
 337             pClientCb(
 338                                         (void*)gpphLibContext->CBInfo.pClientNtfRegRespCntx,
 339                     gpphLibContext->psRemoteDevList,
 340                     gpphLibContext->dev_cnt,
 341                                         status
 342                     );
 343         }
 344
 345     }
 346     else if(PHNFCSTATUS(status)==NFCSTATUS_DESELECTED)
 347     {
 348         info.psDiscoveryInfo->NumberOfDevices = 0;
 349         if (NULL != pClientCb)
 350         {
 351             gpphLibContext->LibNfcState.cur_state=eLibNfcHalStateRelease;
 352             pClientCb((void*)gpphLibContext->CBInfo.pClientNtfRegRespCntx,
 353                     NULL,
 354                     0,
 355                     status);
 356         }
 357
 358     }
 359     else /*Reconfigure the discovery wheel*/
 360     {
 361         RetVal = phHal4Nfc_ConfigureDiscovery ( gpphLibContext->psHwReference,
 362                                             NFC_DISCOVERY_RESUME,
 363                                             &(gpphLibContext->sADDconfig),
 364                                             phLibNfc_config_discovery_cb,
 365                                             gpphLibContext);
 366
 367         if((RetVal!=NFCSTATUS_SUCCESS) &&(RetVal!=NFCSTATUS_PENDING))
 368         {
 369             Status = NFCSTATUS_FAILED;
 370         }
 371
 372     }
 373     if(Status == NFCSTATUS_FAILED)
 374     {
 375         if (NULL != pClientCb)
 376         {
 377             pClientCb(gpphLibContext->CBInfo.pClientNtfRegRespCntx,
 378                 NULL,
 379                 0,
 380                 Status);
 381         }
 382     }
 383     return;
 384 }
 385
 386 /**
 387 * This interface registers notification handler for target discovery.
 388 */
 389 NFCSTATUS
 390 phLibNfc_RemoteDev_NtfRegister(
 391                         phLibNfc_Registry_Info_t*       pRegistryInfo,
 392                         phLibNfc_NtfRegister_RspCb_t    pNotificationHandler,
 393                         void                            *pContext
 394                         )
 395 {
 396     NFCSTATUS RetVal = NFCSTATUS_SUCCESS;
 397
 398
 399     /*Check for valid parameters*/
 400     if((NULL == pNotificationHandler)
 401         || (NULL == pContext)
 402         ||(NULL== pRegistryInfo))
 403     {
 404         RetVal= NFCSTATUS_INVALID_PARAMETER;
 405     }
 406     else if((NULL == gpphLibContext) ||
 407         (gpphLibContext->LibNfcState.cur_state
 408                             == eLibNfcHalStateShutdown))
 409     {
 410         RetVal = NFCSTATUS_NOT_INITIALISED;
 411     }
 412     else if(gpphLibContext->LibNfcState.next_state
 413                             == eLibNfcHalStateShutdown)
 414     {
 415         /*Next state is shutdown*/
 416         RetVal= NFCSTATUS_SHUTDOWN;
 417     }
 418     else
 419     {
 420
 421         PHDBG_INFO("LibNfc:Registering Notification Handler");
 422
 423
 424         (void) memcpy(&(gpphLibContext->RegNtfType),pRegistryInfo,
 425                         sizeof(phLibNfc_Registry_Info_t));
 426         /* Register Discovery Notification Handler*/
 427
 428                 /*Register for NFCIP1 target type*/
 429                 RetVal = phHal4Nfc_RegisterNotification(
 430                                 gpphLibContext->psHwReference,
 431                                 eRegisterP2PDiscovery,
 432                                 phLibNfc_NotificationRegister_Resp_Cb,
 433                                 (void*)gpphLibContext
 434                                 );
 435         /*Register for Tag discovery*/
 436                 RetVal = phHal4Nfc_RegisterNotification(
 437                             gpphLibContext->psHwReference,
 438                             eRegisterTagDiscovery,
 439                             phLibNfc_NotificationRegister_Resp_Cb,
 440                             (void*)gpphLibContext
 441                             );
 442         gpphLibContext->CBInfo.pClientNtfRegRespCB = pNotificationHandler;
 443         gpphLibContext->CBInfo.pClientNtfRegRespCntx = pContext;
 444         /*Register notification handler with below layer*/
 445
 446     }
 447     return RetVal;
 448 }
 449 /**
 450 * This interface unregisters notification handler for target discovery.
 451 */
 452 NFCSTATUS phLibNfc_RemoteDev_NtfUnregister(void)
 453 {
 454     NFCSTATUS RetVal = NFCSTATUS_SUCCESS;
 455     if((NULL == gpphLibContext) ||
 456        (gpphLibContext->LibNfcState.cur_state
 457                             == eLibNfcHalStateShutdown))
 458     {
 459         /*Lib Nfc not Initialized*/
 460         RetVal = NFCSTATUS_NOT_INITIALISED;
 461     }
 462     else if(gpphLibContext->LibNfcState.next_state
 463                             == eLibNfcHalStateShutdown)
 464     {
 465         /*Lib Nfc Shutdown*/
 466         RetVal= NFCSTATUS_SHUTDOWN;
 467     }
 468     else
 469     {
 470         /*Unregister notification handler with lower layer */
 471         RetVal = phHal4Nfc_UnregisterNotification(
 472                                     gpphLibContext->psHwReference,
 473                                     eRegisterP2PDiscovery,
 474                                     gpphLibContext);
 475
 476                 RetVal = phHal4Nfc_UnregisterNotification(
 477                                     gpphLibContext->psHwReference,
 478                                     eRegisterTagDiscovery,
 479                                     gpphLibContext);
 480
 481         gpphLibContext->CBInfo.pClientNtfRegRespCB = NULL;
 482         gpphLibContext->CBInfo.pClientNtfRegRespCntx =NULL;
 483         PHDBG_INFO("LibNfc:Unregister Notification Handler");
 484     }
 485     return RetVal;
 486 }
 487
 488 #ifdef RECONNECT_SUPPORT
 489
 490 NFCSTATUS
 491 phLibNfc_RemoteDev_ReConnect (
 492     phLibNfc_Handle                 hRemoteDevice,
 493     pphLibNfc_ConnectCallback_t     pNotifyReConnect_RspCb,
 494     void                            *pContext)
 495 {
 496
 497     NFCSTATUS                           ret_val = NFCSTATUS_FAILED;
 498     phLibNfc_sRemoteDevInformation_t    *psRemoteDevInfo = NULL;
 499
 500     if ((NULL == gpphLibContext)
 501       || (eLibNfcHalStateShutdown ==
 502         gpphLibContext->LibNfcState.cur_state))
 503     {
 504          ret_val = NFCSTATUS_NOT_INITIALISED;
 505     }
 506     else if ((NULL == pContext)
 507         || (NULL == pNotifyReConnect_RspCb)
 508         || (NULL == (void *)hRemoteDevice))
 509     {
 510         /* Check valid parameters */
 511         ret_val = NFCSTATUS_INVALID_PARAMETER;
 512     }
 513     /* Check valid lib nfc State */
 514     else if (gpphLibContext->LibNfcState.next_state
 515              == eLibNfcHalStateShutdown)
 516     {
 517         ret_val = NFCSTATUS_SHUTDOWN;
 518     }
 519     else if (0 == gpphLibContext->Connected_handle)
 520     {
 521         ret_val = NFCSTATUS_TARGET_NOT_CONNECTED;
 522     }
 523     else if ((gpphLibContext->Discov_handle[0] != hRemoteDevice)
 524                 && (gpphLibContext->Discov_handle[1] != hRemoteDevice)
 525                 && (gpphLibContext->Discov_handle[2] != hRemoteDevice)
 526                 && (gpphLibContext->Discov_handle[3] != hRemoteDevice)
 527                 && (gpphLibContext->Discov_handle[4] != hRemoteDevice)
 528                 && (gpphLibContext->Discov_handle[5] != hRemoteDevice)
 529                 && (gpphLibContext->Discov_handle[6] != hRemoteDevice)
 530                 && (gpphLibContext->Discov_handle[7] != hRemoteDevice)
 531                 && (gpphLibContext->Discov_handle[8] != hRemoteDevice)
 532                 && (gpphLibContext->Discov_handle[9] != hRemoteDevice))
 533     {
 534         ret_val = NFCSTATUS_INVALID_HANDLE;
 535     }
 536     else
 537     {
 538         psRemoteDevInfo = (phLibNfc_sRemoteDevInformation_t *)hRemoteDevice;
 539
 540         /* Call the HAL connect*/
 541         ret_val = phHal4Nfc_Connect (gpphLibContext->psHwReference,
 542                                psRemoteDevInfo,
 543                                phLibNfc_RemoteDev_Connect_Cb,
 544                                (void *)gpphLibContext);
 545
 546         if (NFCSTATUS_PENDING == ret_val)
 547         {
 548             /* If HAL Connect is pending update the LibNFC state machine
 549                 and store the CB pointer and Context,
 550                 mark the General CB pending status is TRUE */
 551             gpphLibContext->CBInfo.pClientConnectCb = pNotifyReConnect_RspCb;
 552             gpphLibContext->CBInfo.pClientConCntx = pContext;
 553             gpphLibContext->status.GenCb_pending_status = TRUE;
 554                         gpphLibContext->LibNfcState.next_state = eLibNfcHalStateConnect;
 555
 556             gpphLibContext->Prev_Connected_handle = gpphLibContext->Connected_handle;
 557
 558                         gpphLibContext->Connected_handle = hRemoteDevice;
 559          }
 560          else if (NFCSTATUS_INVALID_REMOTE_DEVICE == PHNFCSTATUS(ret_val))
 561          {
 562            /* The Handle given for connect is invalid*/
 563             ret_val = NFCSTATUS_TARGET_NOT_CONNECTED;
 564          }
 565          else
 566          {
 567             /* Lower layer returns internal error code return NFCSTATUS_FAILED*/
 568             ret_val = NFCSTATUS_FAILED;
 569          }
 570     }
 571
 572     return ret_val;
 573 }
 574 #endif /* #ifdef RECONNECT_SUPPORT */
 575
 576
 577 /**
 578 * Connect to a single Remote Device
 579 */
 580 NFCSTATUS phLibNfc_RemoteDev_Connect(
 581                     phLibNfc_Handle             hRemoteDevice,
 582                     pphLibNfc_ConnectCallback_t pNotifyConnect_RspCb,
 583                     void                        *pContext
 584                     )
 585 {
 586
 587     NFCSTATUS RetVal = NFCSTATUS_FAILED;
 588     phLibNfc_sRemoteDevInformation_t *psRemoteDevInfo;
 589
 590     if((NULL == gpphLibContext) ||
 591       (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown))
 592     {
 593          RetVal = NFCSTATUS_NOT_INITIALISED;
 594     }/* Check valid parameters*/
 595     else if((NULL == pContext)
 596         || (NULL == pNotifyConnect_RspCb)
 597         || (NULL == (void*)hRemoteDevice))
 598     {
 599        RetVal= NFCSTATUS_INVALID_PARAMETER;
 600     }
 601     /* Check valid lib nfc State*/
 602     else if(gpphLibContext->LibNfcState.next_state
 603                             == eLibNfcHalStateShutdown)
 604     {
 605         RetVal= NFCSTATUS_SHUTDOWN;
 606     }
 607     else if((gpphLibContext->Discov_handle[0] != hRemoteDevice)&&
 608                 (gpphLibContext->Discov_handle[1] != hRemoteDevice)&&
 609                 (gpphLibContext->Discov_handle[2] != hRemoteDevice)&&
 610                 (gpphLibContext->Discov_handle[3] != hRemoteDevice)&&
 611                 (gpphLibContext->Discov_handle[4] != hRemoteDevice)&&
 612                 (gpphLibContext->Discov_handle[5] != hRemoteDevice)&&
 613                 (gpphLibContext->Discov_handle[6] != hRemoteDevice)&&
 614                 (gpphLibContext->Discov_handle[7] != hRemoteDevice)&&
 615                 (gpphLibContext->Discov_handle[8] != hRemoteDevice)&&
 616                 (gpphLibContext->Discov_handle[9] != hRemoteDevice))
 617     {
 618         RetVal= NFCSTATUS_INVALID_HANDLE;
 619     }
 620     else if ((hRemoteDevice != gpphLibContext->Connected_handle)
 621         && (0 != gpphLibContext->Connected_handle))
 622     {
 623         RetVal = NFCSTATUS_FAILED;
 624     }
 625     else
 626     {
 627         psRemoteDevInfo = (phLibNfc_sRemoteDevInformation_t*)hRemoteDevice;
 628
 629         /* Call the HAL connect*/
 630         RetVal = phHal4Nfc_Connect(gpphLibContext->psHwReference,
 631                                psRemoteDevInfo,
 632                                phLibNfc_RemoteDev_Connect_Cb,
 633                                (void* )gpphLibContext);
 634         if(RetVal== NFCSTATUS_PENDING)
 635         {
 636             /* If HAL Connect is pending update the LibNFC state machine
 637                 and store the CB pointer and Context,
 638                 mark the General CB pending status is TRUE*/
 639             gpphLibContext->CBInfo.pClientConnectCb = pNotifyConnect_RspCb;
 640             gpphLibContext->CBInfo.pClientConCntx = pContext;
 641             gpphLibContext->status.GenCb_pending_status=TRUE;
 642                         gpphLibContext->LibNfcState.next_state = eLibNfcHalStateConnect;
 643             gpphLibContext->Prev_Connected_handle = gpphLibContext->Connected_handle;
 644                         gpphLibContext->Connected_handle = hRemoteDevice;
 645          }
 646          else if(PHNFCSTATUS(RetVal) == NFCSTATUS_INVALID_REMOTE_DEVICE)
 647          {
 648            /* The Handle given for connect is invalid*/
 649             RetVal= NFCSTATUS_TARGET_NOT_CONNECTED;
 650          }
 651          else
 652          {
 653             /* Lower layer returns internal error code return NFCSTATUS_FAILED*/
 654             RetVal = NFCSTATUS_FAILED;
 655          }
 656     }
 657     return RetVal;
 658 }
 659
 660 #ifdef RECONNECT_SUPPORT
 661 STATIC
 662 void
 663 phLibNfc_config_discovery_con_failure_cb (
 664     void                *context,
 665     NFCSTATUS           status)
 666 {
 667     if((phLibNfc_LibContext_t *)context == gpphLibContext)
 668     {   /*check for same context*/
 669         pphLibNfc_ConnectCallback_t    ps_client_con_cb =
 670                                     gpphLibContext->CBInfo.pClientConnectCb;
 671
 672         if(eLibNfcHalStateShutdown == gpphLibContext->LibNfcState.next_state)
 673         {
 674             /*If shutdown called in between allow shutdown to happen*/
 675             phLibNfc_Pending_Shutdown();
 676             status = NFCSTATUS_SHUTDOWN;
 677         }
 678         else
 679         {
 680             gpphLibContext->status.GenCb_pending_status = FALSE;
 681             gpphLibContext->status.DiscEnbl_status = FALSE;
 682             status = NFCSTATUS_TARGET_LOST;
 683
 684             phLibNfc_UpdateCurState (status,gpphLibContext);
 685 #ifdef RESTART_CFG
 686             if(gpphLibContext->status.Discovery_pending_status == TRUE)
 687             {
 688                 NFCSTATUS RetStatus = NFCSTATUS_FAILED;
 689                 /* Application has called discovery before receiving this callback,
 690                 so NO notification to the upper layer, instead lower layer
 691                 discovery is called */
 692                 gpphLibContext->status.Discovery_pending_status = FALSE;
 693                 RetStatus =  phHal4Nfc_ConfigureDiscovery(
 694                         gpphLibContext->psHwReference,
 695                         gpphLibContext->eLibNfcCfgMode,
 696                         &gpphLibContext->sADDconfig,
 697                         (pphLibNfc_RspCb_t)
 698                         phLibNfc_config_discovery_cb,
 699                         (void *)gpphLibContext);
 700                 if (NFCSTATUS_PENDING == RetStatus)
 701                 {
 702                     (void)phLibNfc_UpdateNextState(gpphLibContext,
 703                                             eLibNfcHalStateConfigReady);
 704                     gpphLibContext->status.GenCb_pending_status = TRUE;
 705                     gpphLibContext->status.DiscEnbl_status = TRUE;
 706                 }
 707             }
 708
 709 #endif /* #ifdef RESTART_CFG */
 710         }
 711
 712         if (NULL != ps_client_con_cb)
 713         {
 714             gpphLibContext->CBInfo.pClientConnectCb = NULL;
 715             /* Call the upper layer callback*/
 716             ps_client_con_cb (gpphLibContext->CBInfo.pClientConCntx,
 717                             0, NULL, status);
 718         }
 719     } /*End of if-context check*/
 720     else
 721     {   /*exception: wrong context pointer returned*/
 722         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
 723         status = NFCSTATUS_FAILED;
 724     }
 725
 726
 727 }
 728 #endif /* #ifdef RECONNECT_SUPPORT */
 729 /**
 730 * Response callback for remote device connect
 731 */
 732 STATIC void phLibNfc_RemoteDev_Connect_Cb(
 733                            void        *pContext,
 734                            phHal_sRemoteDevInformation_t *pRmtdev_info,
 735                            NFCSTATUS    status
 736                            )
 737 {
 738     NFCSTATUS             Connect_status = NFCSTATUS_SUCCESS;
 739     /*Check valid lib nfc context is returned from lower layer*/
 740     if((phLibNfc_LibContext_t *)pContext == gpphLibContext)
 741     {
 742         gpphLibContext->LastTrancvSuccess = FALSE;
 743
 744         /* Mark General Callback pending status as false*/
 745         gpphLibContext->status.GenCb_pending_status = FALSE;
 746
 747         /* Check the shutdown is called during the lower layer Connect in process,
 748            If yes call shutdown call and return NFCSTATUS_SHUTDOWN */
 749         if((eLibNfcHalStateShutdown == gpphLibContext->LibNfcState.next_state))
 750         {
 751             phLibNfc_Pending_Shutdown();
 752             Connect_status = NFCSTATUS_SHUTDOWN;
 753
 754         }
 755         else if(PHNFCSTATUS(status)==NFCSTATUS_SUCCESS)
 756         {
 757             /* Copy the Remote device address as connected handle*/
 758             gpphLibContext->Connected_handle =(uint32_t) pRmtdev_info;
 759             /* Update the state to connected and return status as SUCCESS*/
 760             gpphLibContext->LibNfcState.next_state = eLibNfcHalStateConnect;
 761             Connect_status = NFCSTATUS_SUCCESS;
 762         }
 763         else
 764         {  /* if(PHNFCSTATUS(status)==NFCSTATUS_INVALID_REMOTE_DEVICE) */
 765             /* If remote device is invalid return as TARGET LOST to upper layer*/
 766             /* If error code is other than SUCCESS return NFCSTATUS_TARGET_LOST */
 767             Connect_status = NFCSTATUS_TARGET_LOST;
 768             gpphLibContext->Connected_handle = gpphLibContext->Prev_Connected_handle ;
 769         }
 770         gpphLibContext->ndef_cntx.is_ndef = CHK_NDEF_NOT_DONE;
 771         /* Update the Current Sate*/
 772         phLibNfc_UpdateCurState(Connect_status,(phLibNfc_LibContext_t *)pContext);
 773         /* Call the upper layer callback*/
 774         gpphLibContext->CBInfo.pClientConnectCb(
 775                     gpphLibContext->CBInfo.pClientConCntx,
 776                     (uint32_t)pRmtdev_info,
 777                     (phLibNfc_sRemoteDevInformation_t*)pRmtdev_info,
 778                     Connect_status);
 779     }
 780     else
 781     {   /*exception: wrong context pointer returned*/
 782         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
 783     }
 784     return;
 785 }
 786
 787 /**
 788 * Allows to disconnect from already connected target.
 789 */
 790 NFCSTATUS phLibNfc_RemoteDev_Disconnect( phLibNfc_Handle                 hRemoteDevice,
 791                                         phLibNfc_eReleaseType_t          ReleaseType,
 792                                         pphLibNfc_DisconnectCallback_t   pDscntCallback,
 793                                         void*                            pContext
 794                                         )
 795 {
 796     NFCSTATUS RetVal = NFCSTATUS_SUCCESS;
 797     phLibNfc_sRemoteDevInformation_t *psRemoteDevInfo=NULL;
 798
 799     /*Check for valid parameter*/
 800     if((NULL == gpphLibContext) ||
 801         (gpphLibContext->LibNfcState.cur_state
 802                             == eLibNfcHalStateShutdown))
 803     {
 804         RetVal = NFCSTATUS_NOT_INITIALISED;
 805     }
 806     else if((NULL == pContext) ||
 807         (NULL == pDscntCallback)||(hRemoteDevice == 0))
 808     {
 809         RetVal= NFCSTATUS_INVALID_PARAMETER;
 810     }
 811     /* Check for valid state,If De initialize is called then
 812     return NFCSTATUS_SHUTDOWN */
 813     else if(gpphLibContext->LibNfcState.next_state
 814                             == eLibNfcHalStateShutdown)
 815     {
 816         RetVal= NFCSTATUS_SHUTDOWN;
 817     }
 818     else if(gpphLibContext->Connected_handle==0)
 819     {
 820         RetVal=NFCSTATUS_TARGET_NOT_CONNECTED;
 821     }
 822     /* The given handle is not the connected handle return NFCSTATUS_INVALID_HANDLE*/
 823     else if(hRemoteDevice != gpphLibContext->Connected_handle )
 824     {
 825         RetVal=NFCSTATUS_INVALID_HANDLE;
 826     }
 827     else
 828     {
 829         if((eLibNfcHalStateRelease == gpphLibContext->LibNfcState.next_state)
 830             ||((gpphLibContext->sSeContext.eActivatedMode == phLibNfc_SE_ActModeWired)&&
 831                     (ReleaseType != NFC_SMARTMX_RELEASE))
 832                     ||((gpphLibContext->sSeContext.eActivatedMode != phLibNfc_SE_ActModeWired)&&
 833                             (ReleaseType == NFC_SMARTMX_RELEASE)))
 834         {   /* Previous disconnect callback is pending */
 835             RetVal = NFCSTATUS_REJECTED;
 836         }
 837 #ifndef LLCP_CHANGES
 838         else if(eLibNfcHalStateTransaction == gpphLibContext->LibNfcState.next_state)
 839         {   /* Previous  Transaction is Pending*/
 840             RetVal = NFCSTATUS_BUSY;
 841             PHDBG_INFO("LibNfc:Transaction is Pending");
 842         }
 843 #endif /* #ifdef LLCP_CHANGES */
 844         else
 845         {
 846             gpphLibContext->ReleaseType = ReleaseType;
 847             psRemoteDevInfo = (phLibNfc_sRemoteDevInformation_t*)hRemoteDevice;
 848             RetVal = phHal4Nfc_Disconnect(gpphLibContext->psHwReference,
 849                                 (phHal_sRemoteDevInformation_t*)psRemoteDevInfo,
 850                                 gpphLibContext->ReleaseType,
 851                                 (pphHal4Nfc_DiscntCallback_t)
 852                                 phLibNfc_RemoteDev_Disconnect_cb,
 853                                 (void *)gpphLibContext);
 854             if( NFCSTATUS_PENDING == PHNFCSTATUS(RetVal))
 855             {
 856                 /*Copy the upper layer Callback pointer and context*/
 857                 gpphLibContext->CBInfo.pClientDisConnectCb = pDscntCallback;
 858                 gpphLibContext->CBInfo.pClientDConCntx = pContext;
 859                 /* Mark general callback pending status as TRUE and update the state*/
 860                 gpphLibContext->status.GenCb_pending_status=TRUE;
 861                                 gpphLibContext->LibNfcState.next_state = eLibNfcHalStateRelease;
 862
 863             }
 864             else
 865             {
 866                 /*If lower layer returns other than pending
 867                 (internal error codes) return NFCSTATUS_FAILED */
 868                 RetVal = NFCSTATUS_FAILED;
 869             }
 870         }
 871     }
 872     return RetVal;
 873 }
 874 /**
 875 * Response callback for Remote device Disconnect.
 876 */
 877 STATIC void phLibNfc_RemoteDev_Disconnect_cb(
 878                                 void                          *context,
 879                                 phHal_sRemoteDevInformation_t *reg_handle,
 880                                 NFCSTATUS                      status
 881                                 )
 882 {
 883     NFCSTATUS             DisCnct_status = NFCSTATUS_SUCCESS;
 884     pphLibNfc_DisconnectCallback_t pUpper_NtfCb = NULL;
 885         void  *pUpper_Context = NULL;
 886
 887     /* Copy the upper layer Callback and context*/
 888     pUpper_NtfCb = gpphLibContext->CBInfo.pClientDisConnectCb;
 889     pUpper_Context = gpphLibContext->CBInfo.pClientDConCntx;
 890
 891     /* Check valid context is returned or not */
 892     if((phLibNfc_LibContext_t *)context != gpphLibContext)
 893     {
 894         /*exception: wrong context pointer returned*/
 895         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
 896     }
 897     else
 898     {
 899         /* Mark the General callback pending status FALSE   */
 900         gpphLibContext->status.GenCb_pending_status = FALSE;
 901         gpphLibContext->CBInfo.pClientDisConnectCb = NULL;
 902         gpphLibContext->CBInfo.pClientDConCntx = NULL;
 903
 904         gpphLibContext->ndef_cntx.is_ndef = CHK_NDEF_NOT_DONE;
 905         gpphLibContext->LastTrancvSuccess = FALSE;
 906         /*Reset Connected handle */
 907         gpphLibContext->Connected_handle=0x0000;
 908         /*Reset previous Connected handle */
 909         gpphLibContext->Prev_Connected_handle = 0x0000;
 910
 911         if(gpphLibContext->sSeContext.eActivatedMode == phLibNfc_SE_ActModeWired)
 912         {
 913           gpphLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeDefault;
 914         }
 915         if(NULL != gpphLibContext->psBufferedAuth)
 916         {
 917             if(NULL != gpphLibContext->psBufferedAuth->sRecvData.buffer)
 918             {
 919                 phOsalNfc_FreeMemory(
 920                     gpphLibContext->psBufferedAuth->sRecvData.buffer);
 921             }
 922             if(NULL != gpphLibContext->psBufferedAuth->sSendData.buffer)
 923             {
 924                 phOsalNfc_FreeMemory(
 925                     gpphLibContext->psBufferedAuth->sSendData.buffer);
 926             }
 927             phOsalNfc_FreeMemory(gpphLibContext->psBufferedAuth);
 928             gpphLibContext->psBufferedAuth = NULL;
 929         }
 930     }
 931     /* Check DeInit is called or not */
 932     if(eLibNfcHalStateShutdown == gpphLibContext->LibNfcState.next_state)
 933     {
 934         /*call shutdown and return  status as NFCSTATUS_SHUTDOWN */
 935         phLibNfc_Pending_Shutdown();
 936         DisCnct_status = NFCSTATUS_SHUTDOWN;
 937     }
 938     else if(NFCSTATUS_SUCCESS == status)
 939     {
 940         DisCnct_status = NFCSTATUS_SUCCESS;
 941                 gpphLibContext->LibNfcState.next_state = eLibNfcHalStateRelease;
 942     }
 943     else
 944     {
 945         DisCnct_status = NFCSTATUS_FAILED;
 946         phLibNfc_UpdateCurState(DisCnct_status,(phLibNfc_LibContext_t *)context);
 947     }
 948     /* Call the upper layer Callback */
 949     (*pUpper_NtfCb)(pUpper_Context,
 950                     (uint32_t)reg_handle,
 951                     DisCnct_status);
 952     return;
 953 }
 954
 955 /**
 956 * This interface allows to perform Read/write operation on remote device.
 957 */
 958 NFCSTATUS
 959 phLibNfc_RemoteDev_Transceive(phLibNfc_Handle                   hRemoteDevice,
 960                               phLibNfc_sTransceiveInfo_t*       psTransceiveInfo,
 961                               pphLibNfc_TransceiveCallback_t    pTransceive_RspCb,
 962                               void*                             pContext
 963                               )
 964 {
 965     NFCSTATUS RetVal = NFCSTATUS_SUCCESS;
 966
 967     /*Check for valid parameter */
 968
 969     if((NULL == gpphLibContext) ||
 970         (gpphLibContext->LibNfcState.cur_state
 971                             == eLibNfcHalStateShutdown))
 972     {
 973         RetVal = NFCSTATUS_NOT_INITIALISED;
 974     }
 975     else if((NULL == psTransceiveInfo)
 976         || (NULL == pTransceive_RspCb)
 977         || (NULL == (void *)hRemoteDevice)
 978         || (NULL == psTransceiveInfo->sRecvData.buffer)
 979         || (NULL == psTransceiveInfo->sSendData.buffer)
 980         || (NULL == pContext))
 981     {
 982         RetVal= NFCSTATUS_INVALID_PARAMETER;
 983     }
 984     /* Check the state for DeInit is called or not,if yes return NFCSTATUS_SHUTDOWN*/
 985     else if(gpphLibContext->LibNfcState.next_state
 986                             == eLibNfcHalStateShutdown)
 987     {
 988         RetVal= NFCSTATUS_SHUTDOWN;
 989     }/* If there is no handle connected return NFCSTATUS_TARGET_NOT_CONNECTED*/
 990     else if(gpphLibContext->Connected_handle==0)
 991     {
 992         RetVal=NFCSTATUS_TARGET_NOT_CONNECTED;
 993     }/* If the given handle is not the connected handle return NFCSTATUS_INVALID_HANDLE */
 994         else if(gpphLibContext->Connected_handle!= hRemoteDevice )
 995     {
 996         RetVal=NFCSTATUS_INVALID_HANDLE;
 997     } /*If the transceive is called before finishing the previous transceive function
 998       return NFCSTATUS_REJECTED  */
 999     else if((eLibNfcHalStateTransaction ==
1000         gpphLibContext->LibNfcState.next_state)
1001         ||(phHal_eNfcIP1_Initiator==
1002         ((phHal_sRemoteDevInformation_t*)hRemoteDevice)->RemDevType))
1003     {
1004         RetVal = NFCSTATUS_REJECTED;
1005     }
1006 #ifdef LLCP_TRANSACT_CHANGES
1007     else if ((LLCP_STATE_RESET_INIT != gpphLibContext->llcp_cntx.sLlcpContext.state)
1008             && (LLCP_STATE_CHECKED != gpphLibContext->llcp_cntx.sLlcpContext.state))
1009     {
1010         RetVal= NFCSTATUS_BUSY;
1011     }
1012 #endif /* #ifdef LLCP_TRANSACT_CHANGES */
1013     else
1014     {
1015         gpphLibContext->ndef_cntx.eLast_Call = RawTrans;
1016         (void)memcpy((void *)(gpphLibContext->psTransInfo),
1017                     (void *)psTransceiveInfo,
1018                     sizeof(phLibNfc_sTransceiveInfo_t));
1019         /* Check the given Mifare command is supported or not ,
1020                             If not return NFCSTATUS_COMMAND_NOT_SUPPORTED */
1021         if( (((phHal_sRemoteDevInformation_t*)hRemoteDevice)->RemDevType ==
1022                phHal_eMifare_PICC)&&
1023             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareRaw ) &&
1024             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareAuthentA ) &&
1025             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareAuthentB ) &&
1026             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareRead16 ) &&
1027             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareRead ) &&
1028             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareWrite16 ) &&
1029             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareWrite4 ) &&
1030             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareDec ) &&
1031             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareTransfer ) &&
1032             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareRestore ) &&
1033             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareReadSector ) &&
1034             ( gpphLibContext->psTransInfo->cmd.MfCmd != phHal_eMifareWriteSector ))
1035         {
1036             RetVal = NFCSTATUS_COMMAND_NOT_SUPPORTED;
1037         }
1038         if(eLibNfcHalStatePresenceChk !=
1039                      gpphLibContext->LibNfcState.next_state)
1040         {
1041             PHDBG_INFO("LibNfc:Transceive In Progress");
1042             if((((phHal_sRemoteDevInformation_t*)hRemoteDevice)->RemDevType ==
1043                phHal_eMifare_PICC) && (((phHal_sRemoteDevInformation_t*)
1044                hRemoteDevice)->RemoteDevInfo.Iso14443A_Info.Sak != 0)&&
1045                (phHal_eMifareAuthentA == gpphLibContext->psTransInfo->cmd.MfCmd))
1046             {
1047                 if(NULL != gpphLibContext->psBufferedAuth)
1048                 {
1049                     if(NULL != gpphLibContext->psBufferedAuth->sRecvData.buffer)
1050                     {
1051                         phOsalNfc_FreeMemory(
1052                             gpphLibContext->psBufferedAuth->sRecvData.buffer);
1053                     }
1054                     if(NULL != gpphLibContext->psBufferedAuth->sSendData.buffer)
1055                     {
1056                         phOsalNfc_FreeMemory(
1057                             gpphLibContext->psBufferedAuth->sSendData.buffer);
1058                     }
1059                     phOsalNfc_FreeMemory(gpphLibContext->psBufferedAuth);
1060                 }
1061                 gpphLibContext->psBufferedAuth
1062                     =(phLibNfc_sTransceiveInfo_t *)
1063                     phOsalNfc_GetMemory(sizeof(phLibNfc_sTransceiveInfo_t));
1064                 gpphLibContext->psBufferedAuth->addr = psTransceiveInfo->addr;
1065                 gpphLibContext->psBufferedAuth->cmd = psTransceiveInfo->cmd;
1066                 gpphLibContext->psBufferedAuth->sSendData.length
1067                     = psTransceiveInfo->sSendData.length;
1068                 gpphLibContext->psBufferedAuth->sRecvData.length
1069                     = psTransceiveInfo->sRecvData.length;
1070                 gpphLibContext->psBufferedAuth->sSendData.buffer
1071                   = (uint8_t *)
1072                       phOsalNfc_GetMemory(
1073                       gpphLibContext->psTransInfo->sSendData.length);
1074
1075                 (void)memcpy((void *)
1076                         (gpphLibContext->psBufferedAuth->sSendData.buffer),
1077                         (void *)psTransceiveInfo->sSendData.buffer,
1078                         psTransceiveInfo->sSendData.length);
1079
1080                 gpphLibContext->psBufferedAuth->sRecvData.buffer
1081                   = (uint8_t *)
1082                       phOsalNfc_GetMemory(
1083                         gpphLibContext->psTransInfo->sRecvData.length);
1084             }
1085             /*Call the lower layer Transceive function */
1086             RetVal = phHal4Nfc_Transceive( gpphLibContext->psHwReference,
1087                                         (phHal_sTransceiveInfo_t*)gpphLibContext->psTransInfo,
1088                                         (phLibNfc_sRemoteDevInformation_t*)hRemoteDevice,
1089                                         (pphHal4Nfc_TransceiveCallback_t)
1090                                         phLibNfc_RemoteDev_Transceive_Cb,
1091                                         (void* )gpphLibContext);
1092             if(PHNFCSTATUS(RetVal) == NFCSTATUS_PENDING)
1093             {
1094                 /* Copy the upper layer callback pointer and context */
1095                 gpphLibContext->CBInfo.pClientTransceiveCb = pTransceive_RspCb;
1096                 gpphLibContext->CBInfo.pClientTranseCntx = pContext;
1097                 /* Mark the General callback pending status is TRUE */
1098                 gpphLibContext->status.GenCb_pending_status = TRUE;
1099                 /*Transceive is in Progress-Used in Release API*/
1100
1101                 /*Update the state machine*/
1102                 gpphLibContext->LibNfcState.next_state = eLibNfcHalStateTransaction;
1103             }
1104         }
1105         else
1106         {
1107             gpphLibContext->status.GenCb_pending_status = FALSE;
1108             RetVal = NFCSTATUS_FAILED;
1109         }
1110     }
1111     return RetVal;
1112 }
1113 /**
1114 * Response for Remote device transceive.
1115 */
1116 STATIC
1117 void phLibNfc_RemoteDev_Transceive_Cb(void *context,
1118                                     phHal_sRemoteDevInformation_t *pRmtdev_info,
1119                                     phNfc_sData_t *response,
1120                                     NFCSTATUS status
1121                                     )
1122 {
1123     NFCSTATUS             trans_status = NFCSTATUS_SUCCESS;
1124     phNfc_sData_t         *trans_resp= NULL;
1125     void                  *pUpper_Context = NULL;
1126     pphLibNfc_TransceiveCallback_t pUpper_TagNtfCb =
1127                             gpphLibContext->CBInfo.pClientTransceiveCb;
1128
1129     /*Check valid context is returned or not */
1130     if((phLibNfc_LibContext_t *)context == gpphLibContext)
1131     {
1132         trans_resp = &gpphLibContext->psTransInfo->sRecvData;
1133
1134         pUpper_Context = gpphLibContext->CBInfo.pClientTranseCntx;
1135         gpphLibContext->status.GenCb_pending_status = FALSE;
1136
1137         /*If DeInit is called during the transceive,
1138            call the shutdown and return NFCSTATUS_SHUTDOWN*/
1139         if(gpphLibContext->LibNfcState.next_state
1140                             == eLibNfcHalStateShutdown)
1141         {
1142             phLibNfc_Pending_Shutdown();
1143             trans_status = NFCSTATUS_SHUTDOWN;
1144         }
1145          /* If Disconnect is called return NFCSTATUS_ABORTED */
1146         else if(eLibNfcHalStateRelease ==
1147                 gpphLibContext->LibNfcState.next_state)
1148         {
1149             trans_status = NFCSTATUS_ABORTED;
1150         }
1151         /* If the received lower layer status is not SUCCESS return NFCSTATUS_FAILED */
1152         else if( NFCSTATUS_SUCCESS == status)
1153         {
1154             trans_status = NFCSTATUS_SUCCESS;
1155         }
1156         else if((PHNFCSTATUS(status) != NFCSTATUS_SUCCESS) &&
1157                 (phHal_eMifare_PICC == pRmtdev_info->RemDevType) &&
1158                 (0x00 != pRmtdev_info->RemoteDevInfo.Iso14443A_Info.Sak))
1159         {
1160             gpphLibContext->LastTrancvSuccess = FALSE;
1161             trans_status = NFCSTATUS_FAILED;
1162             /* card type is mifare 1k/4k, then reconnect */
1163             trans_status = phHal4Nfc_Connect(gpphLibContext->psHwReference,
1164                         pRmtdev_info,
1165                         (pphHal4Nfc_ConnectCallback_t)
1166                         phLibNfc_Reconnect_Mifare_Cb,
1167                         (void *)gpphLibContext);
1168         }
1169         else if ((PHNFCSTATUS(status) == PN544_IO_TIMEOUT_RESPONSE) ||
1170                  (PHNFCSTATUS(status) == NFCSTATUS_RF_TIMEOUT))
1171         {
1172             // 0x89, 0x09 HCI response values from PN544 indicate timeout
1173             trans_status = NFCSTATUS_TARGET_LOST;
1174         }
1175         else
1176         {
1177             // PN544 did get some reply from tag, just not valid
1178             trans_status = NFCSTATUS_FAILED;
1179         }
1180         /*Update the state machine */
1181         phLibNfc_UpdateCurState(status,gpphLibContext);
1182         gpphLibContext->LibNfcState.next_state = eLibNfcHalStateConnect;
1183         if(NFCSTATUS_PENDING != trans_status)
1184         {
1185             /* Tranceive over */
1186             PHDBG_INFO("LibNfc:TXRX Callback-Update the Transceive responce");
1187             if (NULL != pUpper_TagNtfCb)
1188             {
1189                 if(trans_status == NFCSTATUS_SUCCESS)
1190                 {
1191                     gpphLibContext->LastTrancvSuccess = TRUE;
1192                     pUpper_Context = gpphLibContext->CBInfo.pClientTranseCntx;
1193                     trans_resp->buffer = response->buffer;
1194                     trans_resp->length = response->length;
1195                             /* Notify the upper layer */
1196                     PHDBG_INFO("LibNfc:Transceive Complete");
1197                     /* Notify the Transceive Completion to upper layer */
1198                     gpphLibContext->CBInfo.pClientTransceiveCb(pUpper_Context,
1199                                 (uint32_t)pRmtdev_info,
1200                                 trans_resp,
1201                                 trans_status);
1202                 }
1203                 else
1204                 {
1205                     gpphLibContext->LastTrancvSuccess = FALSE;
1206                     pUpper_Context = gpphLibContext->CBInfo.pClientTranseCntx;
1207                     trans_resp->length = 0;
1208                             /* Notify the upper layer */
1209                     PHDBG_INFO("LibNfc:Transceive Complete");
1210                     /* Notify the Transceive Completion to upper layer */
1211                     gpphLibContext->CBInfo.pClientTransceiveCb(pUpper_Context,
1212                                 (uint32_t)pRmtdev_info,
1213                                 trans_resp,
1214                                 trans_status);
1215                 }
1216             }
1217        }
1218
1219     }
1220     else
1221     {    /*exception: wrong context pointer returned*/
1222         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
1223     }
1224
1225     return;
1226 }
1227 /**
1228 * Interface to configure P2P configurations.
1229 */
1230 NFCSTATUS
1231 phLibNfc_Mgt_SetP2P_ConfigParams(phLibNfc_sNfcIPCfg_t*          pConfigInfo,
1232                                 pphLibNfc_RspCb_t                       pConfigRspCb,
1233                                 void*                                           pContext
1234                                 )
1235 {
1236     NFCSTATUS RetVal = NFCSTATUS_FAILED;
1237     /* LibNfc Initialized or not */
1238     if((NULL == gpphLibContext)||
1239         (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown))
1240     {
1241         RetVal = NFCSTATUS_NOT_INITIALISED;
1242     }/* Check for valid parameters */
1243     else if((NULL == pConfigInfo) || (NULL == pConfigRspCb)
1244         || (NULL == pContext))
1245     {
1246         RetVal= NFCSTATUS_INVALID_PARAMETER;
1247     }
1248     else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown)
1249     {
1250         RetVal = NFCSTATUS_SHUTDOWN;
1251     }
1252     else if(TRUE == gpphLibContext->status.GenCb_pending_status)
1253     { /*Previous callback is pending */
1254         RetVal = NFCSTATUS_BUSY;
1255     }
1256     else
1257     {
1258         if(eLibNfcHalStatePresenceChk !=
1259                 gpphLibContext->LibNfcState.next_state)
1260         {
1261             phHal_uConfig_t uConfig;
1262             /* copy General bytes of Max length = 48 bytes */
1263             (void)memcpy((void *)&(uConfig.nfcIPConfig.generalBytes),
1264                     (void *)pConfigInfo->generalBytes,
1265                     pConfigInfo->generalBytesLength);
1266             /* also copy the General Bytes length*/
1267             uConfig.nfcIPConfig.generalBytesLength = pConfigInfo->generalBytesLength;
1268
1269             RetVal = phHal4Nfc_ConfigParameters(
1270                                 gpphLibContext->psHwReference,
1271                                 NFC_P2P_CONFIG,
1272                                 &uConfig,
1273                                 phLibNfc_Mgt_SetP2P_ConfigParams_Cb,
1274                                 (void *)gpphLibContext
1275                                 );
1276         }
1277         else
1278         {
1279              gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCb= NULL;
1280              RetVal = NFCSTATUS_PENDING;
1281         }
1282         if(NFCSTATUS_PENDING == RetVal)
1283         {
1284             /* save the context and callback for later use */
1285             gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCb = pConfigRspCb;
1286             gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCntx = pContext;
1287             gpphLibContext->status.GenCb_pending_status=TRUE;
1288             /* Next state is configured */
1289             gpphLibContext->LibNfcState.next_state =eLibNfcHalStateConfigReady;
1290         }
1291         else
1292         {
1293             RetVal = NFCSTATUS_FAILED;
1294         }
1295     }
1296     return RetVal;
1297 }
1298 /**
1299 * Response callback for P2P configurations.
1300 */
1301 STATIC void phLibNfc_Mgt_SetP2P_ConfigParams_Cb(void     *context,
1302                                         NFCSTATUS status)
1303 {
1304         pphLibNfc_RspCb_t       pClientCb=NULL;
1305     void                    *pUpperLayerContext=NULL;
1306      /* Check for the context returned by below layer */
1307     if((phLibNfc_LibContext_t *)context != gpphLibContext)
1308     {   /*wrong context returned*/
1309         phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
1310     }
1311     else
1312     {
1313         if(eLibNfcHalStateShutdown == gpphLibContext->LibNfcState.next_state)
1314         {   /*shutdown called before completion of this api allow
1315             shutdown to happen */
1316             phLibNfc_Pending_Shutdown();
1317             status = NFCSTATUS_SHUTDOWN;
1318         }
1319         else
1320         {
1321             gpphLibContext->status.GenCb_pending_status = FALSE;
1322             if(NFCSTATUS_SUCCESS != status)
1323             {
1324                 status = NFCSTATUS_FAILED;
1325             }
1326             else
1327             {
1328                 status = NFCSTATUS_SUCCESS;
1329             }
1330         }
1331         /*update the current state */
1332         phLibNfc_UpdateCurState(status,gpphLibContext);
1333
1334         pClientCb = gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCb;
1335         pUpperLayerContext = gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCntx;
1336
1337         gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCb = NULL;
1338         gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCntx = NULL;
1339         if (NULL != pClientCb)
1340         {
1341             /* Notify to upper layer status of configure operation */
1342             pClientCb(pUpperLayerContext, status);
1343         }
1344     }
1345     return;
1346 }
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356