src/phHciNfc.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 * =========================================================================== *
  19 *                                                                             *
  20 *                                                                             *
  21 * \file  phHciNfc.c                                                           *
  22 * \brief HCI Interface Source for the HCI Management.                         *
  23 *                                                                             *
  24 *                                                                             *
  25 * Project: NFC-FRI-1.1                                                        *
  26 *                                                                             *
  27 * $Date: Thu Apr 22 17:49:47 2010 $                                           *
  28 * $Author: ing04880 $                                                         *
  29 * $Revision: 1.90 $                                                           *
  30 * $Aliases: NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $
  31 *                                                                             *
  32 * =========================================================================== *
  33 */
  34
  35
  36 /*
  37 ################################################################################
  38 ***************************** Header File Inclusion ****************************
  39 ################################################################################
  40 */
  41
  42 #include <phNfcConfig.h>
  43 #include <phNfcCompId.h>
  44 #include <phNfcIoctlCode.h>
  45 #include <phHciNfc.h>
  46 #include <phHciNfc_Sequence.h>
  47 #include <phHciNfc_RFReader.h>
  48 #include <phHciNfc_LinkMgmt.h>
  49 #ifdef ENABLE_P2P
  50 #include <phHciNfc_NfcIPMgmt.h>
  51 #endif
  52 #include <phHciNfc_Emulation.h>
  53 #include <phHciNfc_SWP.h>
  54 #include <phHciNfc_DevMgmt.h>
  55 #include <phOsalNfc.h>
  56
  57 /**/
  58
  59 /*
  60 *************************** Static Function Declaration **************************
  61 */
  62
  63
  64 static
  65 NFCSTATUS
  66 phHciNfc_Config_Emulation (
  67                         void                            *psHciHandle,
  68                         void                            *pHwRef,
  69                         phHal_sEmulationCfg_t           *pEmulationConfig
  70
  71                         );
  72
  73
  74 /*
  75 *************************** Function Definitions **************************
  76 */
  77
  78
  79 /*!
  80  * \brief Initialises the HCI Interface
  81  *
  82  * This function initialises the resources for the HCI Command and
  83  * Response Mechanism
  84  */
  85
  86  NFCSTATUS
  87  phHciNfc_Initialise (
  88                         void                            *psHciHandle,
  89                         void                            *pHwRef,
  90                         phHciNfc_Init_t                 init_mode,
  91                         phHal_sHwConfig_t               *pHwConfig,
  92                         pphNfcIF_Notification_CB_t       pHalNotify,
  93                         void                            *psContext,
  94                         phNfcLayer_sCfg_t               *psHciLayerCfg
  95                      )
  96 {
  97     phHciNfc_sContext_t *psHciContext = NULL;
  98     phNfcIF_sReference_t hciReference = { NULL, 0, 0 };
  99     phNfcIF_sCallBack_t  if_callback = { NULL, NULL, NULL, NULL };
 100     phNfc_sLowerIF_t    *plower_if = NULL;
 101     NFCSTATUS            status = NFCSTATUS_SUCCESS;
 102     uint8_t              lower_index=0;
 103
 104     if( (NULL == psHciHandle) || (NULL == pHwRef) || (NULL == pHalNotify)
 105         || (NULL== psContext) || (NULL == psHciLayerCfg) || (NULL == pHwConfig)
 106     )
 107     {
 108         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 109     }
 110     else if ( NULL != *(phHciNfc_sContext_t **)psHciHandle )
 111     {
 112         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_ALREADY_INITIALISED );
 113     }
 114     else
 115     {
 116         /* Create the memory for HCI Context */
 117         psHciContext = (phHciNfc_sContext_t *)
 118                         phOsalNfc_GetMemory(sizeof(phHciNfc_sContext_t));
 119
 120         if(psHciContext != NULL)
 121         {
 122             (void)memset((void *)psHciContext,0,
 123                                             sizeof(phHciNfc_sContext_t));
 124
 125             psHciContext->hci_state.cur_state = hciState_Reset;
 126             psHciContext->hci_mode = hciMode_Reset;
 127             psHciContext->p_hw_ref = pHwRef;
 128             psHciContext->host_rf_type = phHal_eUnknown_DevType;
 129             HCI_PRINT("HCI Initialisation in Progress.... \n");
 130
 131 #ifdef ESTABLISH_SESSION
 132             /*(void)memcpy(((phHal_sHwReference_t *)pHwRef)->session_id,
 133                 DEFAULT_SESSION, (sizeof(DEFAULT_SESSION) > 0x01) ?
 134                   sizeof(DEFAULT_SESSION):
 135                     sizeof(((phHal_sHwReference_t *)pHwRef)->session_id));*/
 136             (void)memcpy(pHwConfig->session_id,
 137                 DEFAULT_SESSION, ((sizeof(DEFAULT_SESSION) > 0x01)
 138                                     && (sizeof(DEFAULT_SESSION) <= 0x08 )) ?
 139                   sizeof(DEFAULT_SESSION):
 140                     sizeof(pHwConfig->session_id));
 141 #endif
 142             HCI_DEBUG("Sizeof Default Session %u\n",sizeof(DEFAULT_SESSION));
 143             psHciContext->p_upper_notify = pHalNotify;
 144             psHciContext->p_upper_context = psContext;
 145
 146             if_callback.pif_ctxt = psHciContext ;
 147             if_callback.send_complete = &phHciNfc_Send_Complete;
 148             if_callback.receive_complete= &phHciNfc_Receive_Complete;
 149             if_callback.notify = &phHciNfc_Notify_Event;
 150             plower_if = hciReference.plower_if = &(psHciContext->lower_interface);
 151             *((phHciNfc_sContext_t **)psHciHandle) = psHciContext;
 152             psHciContext->init_mode = init_mode;
 153             psHciContext->p_hci_layer = psHciLayerCfg ;
 154             lower_index = psHciLayerCfg->layer_index - 1;
 155
 156             if(NULL != psHciLayerCfg->layer_next->layer_registry)
 157             {
 158                 status = psHciLayerCfg->layer_next->layer_registry(
 159                                         &hciReference, if_callback,
 160                                         (void *)&psHciLayerCfg[lower_index]);
 161                 HCI_DEBUG("HCI Lower Layer Register, Status = %02X\n",status);
 162             }
 163             if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init) )
 164             {
 165                 status = phHciNfc_FSM_Update ( psHciContext,
 166                                         hciState_Initialise
 167                                         );
 168                 if(NFCSTATUS_SUCCESS == status)
 169                 {
 170                     psHciContext->hci_seq = ADMIN_INIT_SEQ;
 171                     psHciContext->target_release = FALSE;
 172                     psHciContext->config_type = POLL_LOOP_CFG;
 173                     psHciContext->p_config_params = pHwConfig ;
 174                     status = plower_if->init((void *)plower_if->pcontext,
 175                                             (void *)psHciContext->p_hw_ref);
 176                     HCI_DEBUG("HCI Lower Layer Initialisation, Status = %02X\n",status);
 177                     if( NFCSTATUS_PENDING != status )
 178                     {
 179                         /* Roll Back the State Machine to its Original State */
 180                         phHciNfc_FSM_Rollback ( psHciContext );
 181                     }
 182                 }
 183                 else
 184                 {
 185                     /* TODO: Handle Initialisation in the Invalid State */
 186                 }
 187             }/* End of Lower Layer Init */
 188         } /* End of Status Check for Memory */
 189         else
 190         {
 191             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
 192
 193             HCI_PRINT("HCI Context Memory Allocation Failed\n");
 194         }
 195
 196     }
 197     return status;
 198 }
 199
 200
 201 /*!
 202  * \brief Release of the HCI Interface .
 203  *
 204  * This function Closes all the open pipes and frees all the resources used by
 205  * HCI Layer
 206  */
 207
 208  NFCSTATUS
 209  phHciNfc_Release (
 210                     void                            *psHciHandle,
 211                     void                            *pHwRef,
 212                     pphNfcIF_Notification_CB_t      pHalReleaseCB,
 213                     void                            *psContext
 214                   )
 215 {
 216     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 217     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 218
 219     if( (NULL == psHciHandle)
 220         || (NULL == pHwRef)
 221         )
 222     {
 223         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 224     }
 225     /* This Scenario Forces the HCI and the lower layers
 226      * to release its Resources
 227      */
 228     else if ( NULL == pHalReleaseCB )
 229     {
 230         /* Release the lower layer Resources */
 231         phHciNfc_Release_Lower( psHciContext, pHwRef );
 232         /* Release the HCI layer Resources */
 233         phHciNfc_Release_Resources( &psHciContext );
 234     }
 235     else if ( NULL == psContext )
 236     {
 237         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 238     }
 239     else
 240     {
 241         HCI_PRINT("HCI Release in Progress.... \n");
 242         psHciContext->p_hw_ref = pHwRef;
 243         status = phHciNfc_FSM_Update ( psHciContext, hciState_Release );
 244         if ((NFCSTATUS_SUCCESS == status)
 245 #ifdef NXP_HCI_SHUTDOWN_OVERRIDE
 246             || (NFCSTATUS_INVALID_STATE == PHNFCSTATUS(status))
 247 #endif
 248             )
 249         {
 250             psHciContext->p_upper_notify = pHalReleaseCB;
 251             psHciContext->p_upper_context = psContext;
 252             /* psHciContext->hci_seq = EMULATION_REL_SEQ;*/
 253             /* psHciContext->hci_seq = READER_MGMT_REL_SEQ; */
 254             if (HCI_SELF_TEST != psHciContext->init_mode)
 255             {
 256                 psHciContext->hci_seq = PL_STOP_SEQ;
 257             }
 258             else
 259             {
 260                 psHciContext->hci_seq = ADMIN_REL_SEQ;
 261             }
 262
 263 #ifdef NXP_HCI_SHUTDOWN_OVERRIDE
 264             if (NFCSTATUS_SUCCESS != status)
 265             {
 266                 psHciContext->hci_state.next_state = (uint8_t) hciState_Release;
 267                 status = NFCSTATUS_PENDING;
 268             }
 269             else
 270 #endif
 271             {
 272                 status = phHciNfc_Release_Sequence(psHciContext,pHwRef);
 273             }
 274
 275             if( NFCSTATUS_PENDING != status )
 276             {
 277                 /* Roll Back the State Machine to its Original State */
 278                 phHciNfc_FSM_Rollback ( psHciContext );
 279             }
 280         }
 281         else
 282         {
 283             /* TODO: Return appropriate Error */
 284         }
 285
 286     }
 287
 288     return status;
 289 }
 290
 291 #if 0
 292 /*!
 293  * \brief  Interface to Starts the RF Device Discovery.
 294  *
 295  * This function Starts the Discovery Wheel.
 296  */
 297
 298
 299  NFCSTATUS
 300  phHciNfc_Start_Discovery (
 301                         void                            *psHciHandle,
 302                         void                            *pHwRef
 303                      )
 304 {
 305     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 306     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 307
 308     if ( (NULL == psHciHandle)
 309         || (NULL == pHwRef)
 310       )
 311     {
 312         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 313     }
 314     else
 315     {
 316         status = phHciNfc_ReaderMgmt_Enable_Discovery( psHciContext, pHwRef );
 317     }
 318
 319     return status;
 320 }
 321
 322
 323 /*!
 324  * \brief  Interface to Stop the RF Device Discovery.
 325  *
 326  * This function Stops the Discovery Wheel.
 327  */
 328
 329
 330  NFCSTATUS
 331  phHciNfc_Stop_Discovery (
 332                         void                            *psHciHandle,
 333                         void                            *pHwRef
 334                      )
 335 {
 336     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 337     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 338
 339     if ( (NULL == psHciHandle)
 340         || (NULL == pHwRef)
 341       )
 342     {
 343         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 344     }
 345     else
 346     {
 347         status = phHciNfc_ReaderMgmt_Disable_Discovery( psHciContext, pHwRef );
 348     }
 349
 350     return status;
 351 }
 352
 353
 354 #endif
 355
 356 /*!
 357  * \brief  Interface to Configure the Device With the appropriate
 358  * Configuration Parameters .
 359  *
 360  * This function configures the Devices with the provided
 361  * configuration attributes.
 362  */
 363
 364
 365  NFCSTATUS
 366  phHciNfc_Configure (
 367                         void                            *psHciHandle,
 368                         void                            *pHwRef,
 369                         phHal_eConfigType_t             config_type,
 370                         phHal_uConfig_t                 *pConfig
 371                      )
 372  {
 373     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 374
 375     if( (NULL == psHciHandle)
 376         || (NULL == pHwRef)
 377         || (NULL == pConfig)
 378         )
 379     {
 380         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 381     }
 382     else
 383     {
 384         switch(config_type)
 385         {
 386             case NFC_P2P_CONFIG:
 387             {
 388 #ifdef ENABLE_P2P
 389                 phHciNfc_sContext_t  *psHciContext =
 390                             ((phHciNfc_sContext_t *)psHciHandle);
 391                 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 392
 393                 if (NFCSTATUS_SUCCESS == status)
 394                 {
 395                     psHciContext->config_type = NFC_GENERAL_CFG;
 396                     psHciContext->p_config_params = &(pConfig->nfcIPConfig);
 397                     psHciContext->hci_seq = INITIATOR_GENERAL_SEQ;
 398                     status = phHciNfc_NfcIP_SetATRInfo( psHciHandle,
 399                                             pHwRef, NFCIP_INITIATOR,
 400                                                     &(pConfig->nfcIPConfig));
 401                     if( NFCSTATUS_PENDING != status )
 402                     {
 403                         /* Roll Back the State Machine to its Original State */
 404                         phHciNfc_FSM_Rollback ( psHciContext );
 405                     }
 406                     else
 407                     {
 408                         psHciContext->hci_seq = TARGET_GENERAL_SEQ;
 409                     }
 410                 }
 411 #else
 412                 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 413
 414 #endif
 415                 break;
 416             }
 417             case NFC_EMULATION_CONFIG:
 418             {
 419                 status = phHciNfc_Config_Emulation( psHciHandle,
 420                                             pHwRef, &(pConfig->emuConfig));
 421                 break;
 422             }
 423             case NFC_SE_PROTECTION_CONFIG:
 424             {
 425                 phHciNfc_sContext_t  *psHciContext =
 426                             ((phHciNfc_sContext_t *)psHciHandle);
 427                 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 428
 429                 if (NFCSTATUS_SUCCESS == status)
 430                 {
 431                     psHciContext->config_type = SWP_PROTECT_CFG;
 432                     psHciContext->p_config_params = &(pConfig->protectionConfig);
 433                     psHciContext->hci_seq = HCI_END_SEQ;
 434                     status = phHciNfc_SWP_Protection( psHciHandle,
 435                                 pHwRef, pConfig->protectionConfig.mode);
 436                     if( NFCSTATUS_PENDING != status )
 437                     {
 438                         /* Roll Back the State Machine to its Original State */
 439                         phHciNfc_FSM_Rollback ( psHciContext );
 440                     }
 441                 }
 442                 break;
 443             }
 444             default:
 445             {
 446                 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 447                 break;
 448             }
 449         }/* End of the Configuration Switch */
 450     }
 451
 452     return status;
 453  }
 454
 455
 456 /*!
 457  * \brief  Interface to Configure the RF Device Discovery using
 458  * HCI Polling Loop Gate .
 459  *
 460  * This function configures the HCI Polling Loop Gate with the provided
 461  * configuration attributes.
 462  */
 463
 464  NFCSTATUS
 465  phHciNfc_Config_Discovery (
 466                         void                            *psHciHandle,
 467                         void                            *pHwRef,
 468                         phHal_sADD_Cfg_t                *pPollConfig
 469                      )
 470 {
 471     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 472     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 473
 474     if( (NULL == psHciHandle)
 475         || (NULL == pHwRef)
 476         || (NULL == pPollConfig)
 477         )
 478     {
 479         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 480     }
 481     else
 482     {
 483         psHciContext->p_hw_ref = pHwRef;
 484         HCI_PRINT("HCI Poll Configuration .... \n");
 485         status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 486
 487         if (NFCSTATUS_SUCCESS == status)
 488         {
 489 #if 0
 490             if(pPollConfig->PollDevInfo.PollEnabled)
 491             {
 492                 psHciContext->hci_seq = PL_DURATION_SEQ;
 493             }
 494             else
 495             {
 496                 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
 497                 /* psHciContext->hci_seq = (pPollConfig->NfcIP_Mode != 0 )?
 498                                                     PL_CONFIG_PHASE_SEQ:
 499                                                         READER_DISABLE_SEQ; */
 500             }
 501 #endif
 502             psHciContext->hci_seq = PL_DURATION_SEQ;
 503             psHciContext->config_type = POLL_LOOP_CFG;
 504             psHciContext->p_config_params = pPollConfig;
 505             status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef );
 506
 507             if( NFCSTATUS_PENDING != status )
 508             {
 509                 /* Roll Back the State Machine to its Original State */
 510                 phHciNfc_FSM_Rollback ( psHciContext );
 511             }
 512         }
 513         else
 514         {
 515             /* TODO: Return appropriate Error */
 516         }
 517     }
 518     return status;
 519 }
 520
 521 /*!
 522  * \brief  Interface to Restart the RF Device Discovery.
 523  *
 524  * This function restarts the Discovery Wheel.
 525  */
 526
 527
 528  NFCSTATUS
 529  phHciNfc_Restart_Discovery (
 530                         void                            *psHciHandle,
 531                         void                            *pHwRef,
 532                         uint8_t                         re_poll
 533                      )
 534 {
 535     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 536     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 537     phHal_eRemDevType_t     target_type = phHal_eUnknown_DevType;
 538
 539     if ( (NULL == psHciHandle)
 540         || (NULL == pHwRef)
 541       )
 542     {
 543         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 544     }
 545     else
 546     {
 547         psHciContext->p_hw_ref = pHwRef;
 548
 549         /* To be back in the Poll State to Re-Poll the Target */
 550         status = phHciNfc_FSM_Update ( psHciContext, hciState_Initialise );
 551         if (NFCSTATUS_SUCCESS == status)
 552         {
 553             switch (psHciContext->host_rf_type)
 554             {
 555                 case phHal_eISO14443_A_PCD:
 556                 {
 557                     target_type = phHal_eISO14443_A_PICC;
 558                     break;
 559                 }
 560                 case phHal_eNfcIP1_Initiator:
 561                 {
 562                     target_type = phHal_eNfcIP1_Target;
 563                     break;
 564                 }
 565 #ifdef TYPE_B
 566                 case phHal_eISO14443_B_PCD:
 567                 {
 568                     target_type = phHal_eISO14443_B_PICC;
 569                     break;
 570                 }
 571 #endif
 572 #ifdef TYPE_FELICA
 573                 case phHal_eFelica_PCD:
 574                 {
 575                     target_type = phHal_eFelica_PICC;
 576                     break;
 577                 }
 578 #endif
 579 #ifdef TYPE_JEWEL
 580                 case phHal_eJewel_PCD:
 581                 {
 582                     target_type = phHal_eJewel_PICC;
 583                     break;
 584                 }
 585 #endif
 586 #ifdef  TYPE_ISO15693
 587                 case phHal_eISO15693_PCD:
 588                 {
 589                     target_type = phHal_eISO15693_PICC;
 590                     break;
 591                 }
 592 #endif /* #ifdef    TYPE_ISO15693 */
 593 #ifndef TYPE_B
 594                 case phHal_eISO14443_B_PCD:
 595 #endif
 596 #ifndef TYPE_FELICA
 597                 case phHal_eFelica_PCD:
 598 #endif
 599 #ifndef TYPE_JEWEL
 600                 case phHal_eJewel_PCD:
 601 #endif
 602 #ifndef TYPE_B_PRIME
 603                 case phHal_eISO14443_BPrime_PCD:
 604 #endif
 605                 {
 606                     /* Roll Back the State Machine to its Original State */
 607                     phHciNfc_FSM_Rollback ( psHciContext );
 608                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 609                     break;
 610                 }
 611                 case phHal_eUnknown_DevType:
 612                 default:
 613                 {
 614                     /* Roll Back the State Machine to its Original State */
 615                     phHciNfc_FSM_Rollback ( psHciContext );
 616                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 617                     break;
 618                 }
 619             }/* End of the Remote Target Type Switch */
 620             if( NFCSTATUS_SUCCESS == status )
 621             {
 622                 status = phHciNfc_ReaderMgmt_Deselect(
 623                     psHciContext, pHwRef, target_type, re_poll);
 624                 if( NFCSTATUS_PENDING != status )
 625                 {
 626                     /* Roll Back the State Machine to its Original State */
 627                     phHciNfc_FSM_Rollback ( psHciContext );
 628                 }
 629                 else
 630                 {
 631                     psHciContext->host_rf_type = phHal_eUnknown_DevType;
 632                 }
 633             }
 634         }
 635         else
 636         {
 637             /* TODO: Return appropriate Error */
 638         }
 639     }
 640
 641     return status;
 642 }
 643
 644
 645
 646 /*!
 647  * \brief  Interface to Configure the device to emulation as
 648  * the tag, smart tag or p2p target .
 649  *
 650  * This function configures the HCI Polling Loop Gate with the provided
 651  * configuration attributes.
 652  */
 653
 654  static
 655  NFCSTATUS
 656  phHciNfc_Config_Emulation (
 657                         void                            *psHciHandle,
 658                         void                            *pHwRef,
 659                         phHal_sEmulationCfg_t           *pEmulationCfg
 660                      )
 661 {
 662     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 663     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 664
 665     if( (NULL == psHciHandle)
 666         || (NULL == pHwRef)
 667         || (NULL == pEmulationCfg)
 668         )
 669     {
 670         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 671     }
 672     else
 673     {
 674         psHciContext->p_hw_ref = pHwRef;
 675
 676         HCI_PRINT("HCI Configure Emulation .... \n");
 677         status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 678
 679         if (NFCSTATUS_SUCCESS == status)
 680         {
 681             psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
 682             psHciContext->p_config_params = pEmulationCfg;
 683             switch( pEmulationCfg->emuType )
 684             {
 685                 case NFC_SMARTMX_EMULATION:
 686                 {
 687                     psHciContext->config_type = SMX_WI_CFG;
 688                     status = phHciNfc_Emulation_Cfg(psHciContext,
 689                                 pHwRef, SMX_WI_CFG);
 690                     break;
 691                 }
 692                 case NFC_UICC_EMULATION:
 693                 {
 694                     psHciContext->config_type = UICC_SWP_CFG;
 695                     psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
 696                     (void)phHciNfc_SWP_Update_Sequence(
 697                                         psHciContext, CONFIG_SEQ );
 698                     status = phHciNfc_EmulationCfg_Sequence(
 699                                                 psHciContext, pHwRef);
 700                     break;
 701                 }
 702                 case NFC_HOST_CE_A_EMULATION:
 703                 case NFC_HOST_CE_B_EMULATION:
 704 #if defined(HOST_EMULATION)
 705                 {
 706                     if(TRUE == pEmulationCfg->config.
 707                         hostEmuCfg_A.enableEmulation)
 708                     {
 709                         psHciContext->hci_seq = ADMIN_CE_SEQ;
 710                     }
 711                     status = phHciNfc_EmulationCfg_Sequence(
 712                                                 psHciContext, pHwRef);
 713                     break;
 714                 }
 715 #endif
 716                 default:
 717                 {
 718                     break;
 719                 }
 720
 721             } /* End of Config Switch */
 722             if( NFCSTATUS_PENDING != status )
 723             {
 724                 /* Roll Back the State Machine to its Original State */
 725                 phHciNfc_FSM_Rollback ( psHciContext );
 726             }
 727         }
 728         else
 729         {
 730             /* TODO: Return appropriate Error */
 731         }
 732     }
 733
 734     return status;
 735 }
 736
 737  NFCSTATUS
 738  phHciNfc_Switch_SwpMode (
 739                         void                            *psHciHandle,
 740                         void                            *pHwRef,
 741                         phHal_eSWP_Mode_t               swp_mode /* ,
 742                         void                            *pSwpCfg */
 743                      )
 744 {
 745     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 746     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 747
 748     if( (NULL == psHciHandle)
 749         || (NULL == pHwRef)
 750         )
 751     {
 752         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 753     }
 754     else
 755     {
 756         psHciContext->p_hw_ref = pHwRef;
 757
 758         HCI_PRINT("HCI SWP Switch .... ");
 759         status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 760         if (NFCSTATUS_SUCCESS == status)
 761         {
 762             psHciContext->config_type = SWP_EVT_CFG;
 763             status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef ,
 764                                                        (uint8_t) swp_mode );
 765
 766             /* Send the Success Status as this is an event */
 767             status = ((status == NFCSTATUS_SUCCESS)?
 768                     NFCSTATUS_PENDING : status);
 769
 770             if( NFCSTATUS_PENDING != status )
 771             {
 772                 /* Roll Back the State Machine to its Original State */
 773                 phHciNfc_FSM_Rollback ( psHciContext );
 774
 775                 HCI_PRINT(" Execution Error \n");
 776             }
 777             else
 778             {
 779                 HCI_PRINT(" Successful \n");
 780             }
 781         }
 782         else
 783         {
 784             HCI_PRINT(" Not allowed - Invalid State \n");
 785             /* TODO: Return appropriate Error */
 786         }
 787     }
 788
 789     return status;
 790 }
 791
 792
 793
 794 /*!
 795  * \brief  Interface to Switch the Mode of the SmartMx from Virtual/Wired
 796  * to the other mode.
 797  *
 798  * This function switches the mode of the SmartMX connected through WI(S2C)
 799  * Interface to virtual/wired mode.
 800  */
 801
 802
 803  NFCSTATUS
 804  phHciNfc_Switch_SmxMode (
 805                         void                            *psHciHandle,
 806                         void                            *pHwRef,
 807                         phHal_eSmartMX_Mode_t           smx_mode,
 808                         phHal_sADD_Cfg_t                *pPollConfig
 809                     )
 810 {
 811     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 812     NFCSTATUS   status = NFCSTATUS_SUCCESS;
 813
 814     if( (NULL == psHciHandle)
 815         || (NULL == pHwRef)
 816         || (NULL == pPollConfig)
 817         )
 818     {
 819         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 820     }
 821     else
 822     {
 823         psHciContext->p_hw_ref = pHwRef;
 824
 825         HCI_PRINT("HCI Smart MX Mode Switch .... \n");
 826         status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
 827
 828         if (NFCSTATUS_SUCCESS == status)
 829         {
 830             psHciContext->hci_seq = READER_DISABLE_SEQ;
 831             if ( (eSmartMx_Wired == psHciContext->smx_mode)
 832                 && ( hciState_Connect == psHciContext->hci_state.cur_state)
 833                 &&( eSmartMx_Wired != smx_mode)
 834                 )
 835             {
 836                 /* Workaround: For Wired Mode Disconnect
 837                    All the statemachine updates should be done only with the
 838                    Statemachine API and should not be overridden.
 839                  */
 840                  psHciContext->hci_state.cur_state = hciState_Disconnect;
 841             }
 842             psHciContext->config_type = SMX_WI_MODE;
 843             psHciContext->smx_mode = smx_mode;
 844             psHciContext->p_config_params = pPollConfig;
 845             status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef );
 846             if( NFCSTATUS_PENDING != status )
 847             {
 848                 /* Roll Back the State Machine to its Original State */
 849                 phHciNfc_FSM_Rollback ( psHciContext );
 850             }
 851         }
 852         else
 853         {
 854             /* TODO: Return appropriate Error */
 855         }
 856     }
 857
 858     return status;
 859 }
 860
 861
 862 /*!
 863  * \brief  Interface to Select the Next Remote Target Discovered during the
 864  * discovery sequence using the particular HCI Reader Gate .
 865  *
 866  *
 867  * This function Selects and Activates the next Remote Target
 868  * Detected using the particular HCI Reader Gate.
 869  */
 870
 871
 872
 873 NFCSTATUS
 874 phHciNfc_Select_Next_Target (
 875                     void                            *psHciHandle,
 876                     void                            *pHwRef
 877                     )
 878 {
 879     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 880     NFCSTATUS            status = NFCSTATUS_SUCCESS;
 881
 882     if( (NULL == psHciHandle)
 883         || (NULL == pHwRef)
 884         )
 885     {
 886         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 887     }
 888     else
 889     {
 890         psHciContext->p_hw_ref = pHwRef;
 891         status = phHciNfc_FSM_Update ( psHciContext, hciState_Select );
 892         if (NFCSTATUS_SUCCESS == status)
 893         {
 894             psHciContext->hci_seq = READER_SELECT_SEQ;
 895             status = phHciNfc_ReaderMgmt_Activate_Next( psHciContext, pHwRef );
 896             if( NFCSTATUS_PENDING != status )
 897             {
 898                 /* Roll Back the State Machine to its Original State */
 899                 phHciNfc_FSM_Rollback ( psHciContext );
 900             }
 901         }
 902         else
 903         {
 904             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
 905         }
 906     }
 907
 908     return status;
 909
 910 }
 911
 912
 913 /*!
 914  * \brief  Interface to Connect the Remote Target Discovered during the
 915  * discovery sequence using the particular HCI Reader Gate .
 916  *
 917  *
 918  * This function connects the Remote Target Detected using the particular
 919  * HCI Reader Gate with the appropriate configuration setup.
 920  */
 921
 922
 923  NFCSTATUS
 924  phHciNfc_Connect (
 925                     void                            *psHciHandle,
 926                     void                            *pHwRef,
 927                     phHal_sRemoteDevInformation_t   *p_target_info
 928                  )
 929  {
 930     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 931     NFCSTATUS            status = NFCSTATUS_SUCCESS;
 932     /* phHal_eRemDevType_t  target_type = phHal_eUnknown_DevType; */
 933
 934     if( (NULL == psHciHandle)
 935         || (NULL == pHwRef)
 936         || (NULL == p_target_info)
 937         )
 938     {
 939         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 940     }
 941     else
 942     {
 943         psHciContext->p_hw_ref = pHwRef;
 944         status = phHciNfc_FSM_Update ( psHciContext, hciState_Connect );
 945         if (NFCSTATUS_SUCCESS == status)
 946         {
 947             psHciContext->hci_seq = READER_SELECT_SEQ;
 948             switch (p_target_info->RemDevType)
 949             {
 950                 case phHal_eISO14443_A_PICC:
 951                 case phHal_eISO14443_4A_PICC:
 952                 case phHal_eMifare_PICC:
 953                 case phHal_eISO14443_3A_PICC:
 954 #ifdef ENABLE_P2P
 955                 case phHal_eNfcIP1_Target:
 956 #endif
 957 #ifdef TYPE_B
 958                 case phHal_eISO14443_B_PICC:
 959                 case phHal_eISO14443_4B_PICC:
 960 #endif
 961 #ifdef TYPE_FELICA
 962                 case phHal_eFelica_PICC:
 963 #endif
 964 #ifdef TYPE_JEWEL
 965                 case phHal_eJewel_PICC:
 966 #endif
 967 #ifdef  TYPE_ISO15693
 968                 case phHal_eISO15693_PICC:
 969 #endif /* #ifdef    TYPE_ISO15693 */
 970
 971                 {
 972                     psHciContext->p_target_info = p_target_info;
 973                     status = phHciNfc_ReaderMgmt_Select(
 974                                     psHciContext, pHwRef,
 975                                     p_target_info->RemDevType );
 976                     break;
 977                 }
 978 #ifndef TYPE_B_PRIME
 979                 case phHal_eISO14443_BPrime_PICC:
 980 #endif
 981                 case phHal_eUnknown_DevType:
 982                 default:
 983                 {
 984                     /* Roll Back the State Machine to its Original State */
 985                     phHciNfc_FSM_Rollback ( psHciContext );
 986                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 987                     break;
 988                 }
 989             }/* End of the Remote Target Type Switch */
 990             if( NFCSTATUS_PENDING != status )
 991             {
 992                 /* Roll Back the State Machine to its Original State */
 993                 phHciNfc_FSM_Rollback ( psHciContext );
 994             }
 995         }
 996         else
 997         {
 998             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
 999         }
1000
1001     } /* End of the HCI Handle Validation */
1002
1003     return status;
1004 }
1005
1006
1007 /*!
1008  * \brief  Interface to Reactivate the Remote Targets Discovered during the
1009  * discovery sequence using the particular HCI Reader Gate .
1010  *
1011  *
1012  * This function reactivates the Remote Target Detected using the particular
1013  * HCI Reader Gate with the appropriate configuration setup.
1014  */
1015
1016
1017  NFCSTATUS
1018  phHciNfc_Reactivate (
1019                     void                            *psHciHandle,
1020                     void                            *pHwRef,
1021                     phHal_sRemoteDevInformation_t   *p_target_info
1022                  )
1023  {
1024     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1025     NFCSTATUS            status = NFCSTATUS_SUCCESS;
1026     /* phHal_eRemDevType_t  target_type = phHal_eUnknown_DevType; */
1027
1028     if( (NULL == psHciHandle)
1029         || (NULL == pHwRef)
1030         || (NULL == p_target_info)
1031         )
1032     {
1033         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1034     }
1035     else
1036     {
1037         psHciContext->p_hw_ref = pHwRef;
1038         status = phHciNfc_FSM_Update ( psHciContext, hciState_Reactivate );
1039         if (NFCSTATUS_SUCCESS == status)
1040         {
1041             psHciContext->hci_seq = READER_REACTIVATE_SEQ;
1042             switch (p_target_info->RemDevType)
1043             {
1044                 case phHal_eISO14443_A_PICC:
1045                 case phHal_eISO14443_4A_PICC:
1046                 case phHal_eMifare_PICC:
1047                 case phHal_eISO14443_3A_PICC:
1048                 {
1049                     psHciContext->host_rf_type = phHal_eISO14443_A_PCD;
1050                     break;
1051                 }
1052                 case phHal_eNfcIP1_Target:
1053                 {
1054                     psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
1055                     break;
1056                 }
1057 #ifdef TYPE_B
1058                 case phHal_eISO14443_4B_PICC:
1059                 case phHal_eISO14443_B_PICC:
1060                 {
1061                     psHciContext->host_rf_type = phHal_eISO14443_B_PCD;
1062                     break;
1063                 }
1064 #endif
1065 #ifdef TYPE_FELICA
1066                 case phHal_eFelica_PICC:
1067                 {
1068                     psHciContext->host_rf_type = phHal_eFelica_PCD;
1069                     break;
1070                 }
1071 #endif
1072 #ifdef TYPE_B_PRIME
1073                 case phHal_eISO14443_BPrime_PICC:
1074 #endif
1075                     /* Reactivate for Jewel is not Supported */
1076                 case phHal_eJewel_PICC:
1077                 case phHal_eUnknown_DevType:
1078                 default:
1079                 {
1080                     /* Roll Back the State Machine to its Original State */
1081                     phHciNfc_FSM_Rollback ( psHciContext );
1082                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1083                     break;
1084                 }
1085             }/* End of the Remote Target Type Switch */
1086         }
1087         else
1088         {
1089             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1090         }
1091
1092         if(NFCSTATUS_SUCCESS == status )
1093         {
1094             psHciContext->p_target_info = p_target_info;
1095             status = phHciNfc_ReaderMgmt_Reactivate(
1096                             psHciContext, pHwRef, p_target_info->RemDevType );
1097             if( NFCSTATUS_PENDING != status )
1098             {
1099                 /* Roll Back the State Machine to its Original State */
1100                 phHciNfc_FSM_Rollback ( psHciContext );
1101             }
1102         }
1103     } /* End of the HCI Handle Validation */
1104
1105
1106     return status;
1107 }
1108
1109
1110 /*!
1111  * \brief  Interface to Disconnect the selected target.
1112  *
1113  * This function disconnects the remote target selected.
1114  */
1115
1116
1117  NFCSTATUS
1118  phHciNfc_Disconnect (
1119                     void                            *psHciHandle,
1120                     void                            *pHwRef,
1121                     uint8_t                         re_poll
1122                  )
1123  {
1124     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1125     NFCSTATUS            status = NFCSTATUS_SUCCESS;
1126     phHal_eRemDevType_t  target_type = phHal_eUnknown_DevType;
1127     /* phHal_eSmartMX_Mode_t smx_mode = (phHal_eSmartMX_Mode_t)type; */
1128     static  uint8_t      repoll=0;
1129
1130
1131     if( (NULL == psHciHandle)
1132         || (NULL == pHwRef)
1133         || ( NULL == psHciContext->p_target_info)
1134     )
1135     {
1136         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1137     }
1138     else
1139     {
1140         psHciContext->p_hw_ref = pHwRef;
1141         repoll = re_poll;
1142         psHciContext->p_config_params = &repoll;
1143         /* psHciContext->hci_seq = HCI_END_SEQ; */
1144
1145         /* To be back in the Poll State to Re-Poll the Target */
1146         status = phHciNfc_FSM_Update ( psHciContext, hciState_Disconnect );
1147         if (NFCSTATUS_SUCCESS == status)
1148         {
1149             psHciContext->hci_seq = READER_UICC_DISPATCH_SEQ;
1150             target_type = psHciContext->p_target_info->RemDevType;
1151             switch (target_type)
1152             {
1153                 case phHal_eMifare_PICC:
1154                 case phHal_eISO14443_A_PICC:
1155                 case phHal_eISO14443_4A_PICC:
1156                 case phHal_eISO14443_3A_PICC:
1157                 case phHal_eNfcIP1_Target:
1158 #ifdef TYPE_B
1159                 case phHal_eISO14443_B_PICC:
1160                 case phHal_eISO14443_4B_PICC:
1161 #endif
1162 #ifdef TYPE_FELICA
1163                 case phHal_eFelica_PICC:
1164 #endif
1165 #ifdef TYPE_JEWEL
1166                 case phHal_eJewel_PICC:
1167 #endif
1168 #ifdef  TYPE_ISO15693
1169                 case phHal_eISO15693_PICC:
1170 #endif /* #ifdef    TYPE_ISO15693 */
1171
1172                 {
1173                     status = phHciNfc_Disconnect_Sequence(
1174                                     psHciContext, pHwRef );
1175                     break;
1176                 }
1177 #ifndef TYPE_B
1178                 case phHal_eISO14443_B_PICC:
1179                 case phHal_eISO14443_4B_PICC:
1180 #endif
1181 #ifndef TYPE_FELICA
1182                 case phHal_eFelica_PICC:
1183 #endif
1184 #ifndef TYPE_JEWEL
1185                 case phHal_eJewel_PICC:
1186 #endif
1187 #ifndef TYPE_B_PRIME
1188                 case phHal_eISO14443_BPrime_PICC:
1189 #endif
1190                 {
1191                     /* Roll Back the State Machine to its Original State */
1192                     phHciNfc_FSM_Rollback ( psHciContext );
1193                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1194                     break;
1195                 }
1196                 case phHal_eUnknown_DevType:
1197                 default:
1198                 {
1199                     /* Roll Back the State Machine to its Original State */
1200                     phHciNfc_FSM_Rollback ( psHciContext );
1201                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1202                     break;
1203                 }
1204             }/* End of the Remote Target Type Switch */
1205             if( NFCSTATUS_PENDING != status )
1206             {
1207                 /* Roll Back the State Machine to its Original State */
1208                 phHciNfc_FSM_Rollback ( psHciContext );
1209             }
1210         }
1211         else
1212         {
1213             /* TODO: Return appropriate Error */
1214         }
1215     } /* End of the HCI Handle Validation */
1216
1217     return status;
1218 }
1219
1220 /*!
1221  * \brief  Interface to exchange the data to/from
1222  * the selected target.
1223  *
1224  * This function sends and receives the data to/from
1225  * the selected remote target.
1226  */
1227
1228  NFCSTATUS
1229  phHciNfc_Exchange_Data (
1230                     void                            *psHciHandle,
1231                     void                            *pHwRef,
1232                     phHal_sRemoteDevInformation_t   *p_target_info,
1233                     phHciNfc_XchgInfo_t             *p_xchg_info
1234                  )
1235  {
1236     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1237     NFCSTATUS   status = NFCSTATUS_SUCCESS;
1238
1239     if( (NULL == psHciHandle)
1240         || (NULL == pHwRef)
1241         || (NULL == p_target_info)
1242         || (NULL == p_xchg_info)
1243         )
1244     {
1245         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1246     }
1247     else if (p_target_info != psHciContext->p_target_info )
1248     {
1249         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_REMOTE_DEVICE);
1250     }
1251     else
1252     {
1253         psHciContext->p_hw_ref = pHwRef;
1254         status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact );
1255         if (NFCSTATUS_SUCCESS == status)
1256         {
1257             switch (p_target_info->RemDevType)
1258             {
1259                 case phHal_eMifare_PICC:
1260                 case phHal_eISO14443_A_PICC:
1261                 case phHal_eISO14443_4A_PICC:
1262                 case phHal_eISO14443_3A_PICC:
1263 #ifdef TYPE_B
1264                 case phHal_eISO14443_B_PICC:
1265                 case phHal_eISO14443_4B_PICC:
1266 #endif
1267 #ifdef TYPE_FELICA
1268                 case phHal_eFelica_PICC:
1269 #endif
1270 #ifdef TYPE_JEWEL
1271                 case phHal_eJewel_PICC:
1272 #endif
1273 #ifdef  TYPE_ISO15693
1274                 case phHal_eISO15693_PICC:
1275 #endif /* #ifdef    TYPE_ISO15693 */
1276                 {
1277                     psHciContext->p_xchg_info = p_xchg_info;
1278                     status = phHciNfc_ReaderMgmt_Exchange_Data(
1279                                     psHciContext, pHwRef, p_xchg_info );
1280                     break;
1281                 }
1282 #ifndef TYPE_B
1283                 case phHal_eISO14443_B_PICC:
1284                 case phHal_eISO14443_4B_PICC:
1285 #endif
1286 #ifndef TYPE_FELICA
1287                 case phHal_eFelica_PICC:
1288 #endif
1289 #ifndef TYPE_JEWEL
1290                 case phHal_eJewel_PICC:
1291 #endif
1292                 case phHal_eNfcIP1_Target:
1293 #ifndef TYPE_B_PRIME
1294                 case phHal_eISO14443_BPrime_PICC:
1295 #endif
1296                 {
1297                     /* Roll Back the State Machine to its Original State */
1298                     phHciNfc_FSM_Rollback ( psHciContext );
1299                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1300                     break;
1301                 }
1302                 case phHal_eUnknown_DevType:
1303                 default:
1304                 {
1305                     /* Roll Back the State Machine to its Original State */
1306                     phHciNfc_FSM_Rollback ( psHciContext );
1307                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1308                     break;
1309                 }
1310
1311             }/* End of the Remote Target Type Switch */
1312             if( NFCSTATUS_PENDING != status )
1313             {
1314                 /* Roll Back the State Machine to its Original State */
1315                 phHciNfc_FSM_Rollback ( psHciContext );
1316             }
1317         }
1318         else
1319         {
1320             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1321         }
1322     } /* End of the HCI Handle Validation */
1323
1324     return status;
1325 }
1326
1327 /*!
1328  * \brief  Interface to Send the data to/from
1329  * the selected NfcIP.
1330  *
1331  * This function sends and receives the data to/from
1332  * the selected remote target.
1333  */
1334
1335  NFCSTATUS
1336  phHciNfc_Send_Data (
1337                     void                            *psHciHandle,
1338                     void                            *pHwRef,
1339                     phHal_sRemoteDevInformation_t   *p_remote_dev_info,
1340                     phHciNfc_XchgInfo_t             *p_send_param
1341                  )
1342  {
1343     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1344     NFCSTATUS   status = NFCSTATUS_SUCCESS;
1345
1346     if( (NULL == psHciHandle)
1347         || (NULL == pHwRef)
1348         || (NULL == p_send_param)
1349         )
1350     {
1351         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1352     }
1353     else
1354     {
1355         psHciContext->p_hw_ref = pHwRef;
1356         status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact );
1357         if (NFCSTATUS_SUCCESS == status)
1358         {
1359             switch (psHciContext->host_rf_type)
1360             {
1361                 case phHal_eISO14443_A_PICC:
1362                 case phHal_eISO14443_B_PICC:
1363                 case phHal_eISO14443_4A_PICC:
1364                 case phHal_eISO14443_4B_PICC:
1365                 {
1366                     break;
1367                 }
1368 #ifdef ENABLE_P2P
1369                 case phHal_eNfcIP1_Initiator:
1370                 {
1371                     if (p_remote_dev_info !=
1372                                     psHciContext->p_target_info )
1373                     {
1374                         status = PHNFCSTVAL(CID_NFC_HCI,
1375                                         NFCSTATUS_INVALID_REMOTE_DEVICE);
1376                     }
1377                     else
1378                     {
1379                         psHciContext->p_xchg_info = p_send_param;
1380                         status = phHciNfc_NfcIP_Send_Data( psHciContext,
1381                                                     pHwRef, p_send_param );
1382                     }
1383                     break;
1384                 }
1385                 case phHal_eNfcIP1_Target:
1386                 {
1387                     psHciContext->p_xchg_info = p_send_param;
1388                     status = phHciNfc_NfcIP_Send_Data( psHciContext,
1389                                                 pHwRef, p_send_param );
1390                     break;
1391                 }
1392 #endif
1393 #ifdef TYPE_B_PRIME
1394                 case phHal_eISO14443_BPrime_PCD:
1395                 case phHal_eFelica_PCD:
1396                 {
1397                     /* Roll Back the State Machine to its Original State */
1398                     phHciNfc_FSM_Rollback ( psHciContext );
1399                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1400                     break;
1401                 }
1402 #endif
1403                 case phHal_eUnknown_DevType:
1404                 default:
1405                 {
1406                     /* Roll Back the State Machine to its Original State */
1407                     phHciNfc_FSM_Rollback ( psHciContext );
1408                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1409                     break;
1410                 }
1411
1412             }/* End of the Remote Target Type Switch */
1413 #if defined( ENABLE_P2P ) || defined (TYPE_B_PRIME)
1414             if( NFCSTATUS_PENDING != status )
1415 #endif
1416             {
1417                 /* Roll Back the State Machine to its Original State */
1418                 phHciNfc_FSM_Rollback ( psHciContext );
1419             }
1420         }
1421         else
1422         {
1423             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1424         }
1425     } /* End of the HCI Handle Validation */
1426
1427     return status;
1428
1429  }
1430
1431 #if 0
1432
1433 /*!
1434  * \brief  Interface to Send the data from
1435  * the selected NfcIP.
1436  *
1437  * This function sends and receives the data to/from
1438  * the selected remote target.
1439  */
1440
1441  NFCSTATUS
1442  phHciNfc_Receive_Data (
1443                     void                            *psHciHandle,
1444                     void                            *pHwRef,
1445                     uint8_t                         *p_data,
1446                     uint8_t                         length
1447                  )
1448  {
1449     phHciNfc_sContext_t  *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1450     NFCSTATUS   status = NFCSTATUS_SUCCESS;
1451
1452     if( (NULL == psHciHandle)
1453         || (NULL == pHwRef)
1454         )
1455     {
1456         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1457     }
1458     else
1459     {
1460         if (NFCSTATUS_SUCCESS == status)
1461         {
1462             status = phHciNfc_Receive(psHciHandle, pHwRef, p_data, length);
1463             if( NFCSTATUS_PENDING != status )
1464             {
1465                 /* Roll Back the State Machine to its Original State */
1466                 phHciNfc_FSM_Rollback ( psHciContext );
1467             }
1468         }
1469     }
1470     return status;
1471
1472  }
1473
1474 #endif
1475
1476  /*!
1477  * \brief  Interface to Check for the presence of
1478  * the selected target in the field .
1479  *
1480  * This function checks the presence of the
1481  * the selected remote target in the field .
1482  */
1483
1484
1485
1486 NFCSTATUS
1487 phHciNfc_Presence_Check (
1488                     void                            *psHciHandle,
1489                     void                            *pHwRef
1490                     )
1491 {
1492     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1493     phHciNfc_sContext_t     *psHciContext =
1494                             ((phHciNfc_sContext_t *)psHciHandle);
1495     phHal_eRemDevType_t     target_type = phHal_eUnknown_DevType;
1496
1497     if( (NULL == psHciContext)
1498         || (NULL == pHwRef)
1499         )
1500     {
1501         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1502     }
1503     else
1504     {
1505         psHciContext->p_hw_ref = pHwRef;
1506         status = phHciNfc_FSM_Update ( psHciContext, hciState_Presence );
1507         if (NFCSTATUS_SUCCESS == status)
1508         {
1509             target_type = psHciContext->p_target_info->RemDevType;
1510             switch (target_type)
1511             {
1512                 case phHal_eISO14443_A_PICC:
1513                 case phHal_eMifare_PICC:
1514                 case phHal_eISO14443_4A_PICC:
1515                 case phHal_eISO14443_3A_PICC:
1516 #ifdef TYPE_B
1517                 case phHal_eISO14443_B_PICC:
1518                 case phHal_eISO14443_4B_PICC:
1519 #endif
1520 #ifdef TYPE_FELICA
1521                 case phHal_eFelica_PICC:
1522 #endif
1523 #ifdef TYPE_JEWEL
1524                 case phHal_eJewel_PICC:
1525 #endif
1526 #ifdef  TYPE_ISO15693
1527                 case phHal_eISO15693_PICC:
1528 #endif /* #ifdef    TYPE_ISO15693 */
1529 #ifdef ENABLE_P2P
1530                 case phHal_eNfcIP1_Target:
1531 #endif
1532                 {
1533                     status = phHciNfc_ReaderMgmt_Presence_Check(
1534                                             psHciContext, pHwRef );
1535                     break;
1536                 }
1537 #ifdef TYPE_B_PRIME
1538                 case phHal_eISO14443_BPrime_PICC:
1539 #endif
1540 #ifndef TYPE_B
1541                 case phHal_eISO14443_B_PICC:
1542                 case phHal_eISO14443_4B_PICC:
1543 #endif
1544 #ifndef TYPE_FELICA
1545                 case phHal_eFelica_PICC:
1546 #endif
1547 #ifndef TYPE_JEWEL
1548                 case phHal_eJewel_PICC:
1549 #endif
1550                 case phHal_eUnknown_DevType:
1551                 {
1552                     /* Roll Back the State Machine to its Original State */
1553                     phHciNfc_FSM_Rollback ( psHciContext );
1554                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1555                     break;
1556                 }
1557                 default:
1558                 {
1559                     /* Roll Back the State Machine to its Original State */
1560                     phHciNfc_FSM_Rollback ( psHciContext );
1561                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1562                     break;
1563                 }
1564
1565             }/* End of the Remote Target Type Switch */
1566             if( NFCSTATUS_PENDING != status )
1567             {
1568                 /* Roll Back the State Machine to its Original State */
1569                 phHciNfc_FSM_Rollback ( psHciContext );
1570             }
1571         }
1572         else
1573         {
1574             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1575         }
1576     } /* End of the HCI Handle Validation */
1577
1578     return status;
1579 }
1580
1581  NFCSTATUS
1582  phHciNfc_PRBS_Test (
1583                     void                            *psHciHandle,
1584                     void                            *pHwRef,
1585                     uint32_t                        test_type,
1586                     phNfc_sData_t                   *test_param
1587                  )
1588  {
1589     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1590     phHciNfc_sContext_t     *psHciContext =
1591                             ((phHciNfc_sContext_t *)psHciHandle);
1592
1593     if( (NULL == psHciContext)
1594         || (NULL == pHwRef)
1595         || (test_type != DEVMGMT_PRBS_TEST)
1596         )
1597     {
1598         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1599     }
1600     else
1601     {
1602         psHciContext->p_hw_ref = pHwRef;
1603         status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1604         if (NFCSTATUS_SUCCESS == status)
1605         {
1606             status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef,
1607                 (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param);
1608             if( NFCSTATUS_PENDING != status )
1609             {
1610                 /* Roll Back the State Machine to its Original State */
1611                 phHciNfc_FSM_Rollback ( psHciContext );
1612             }
1613         }
1614     }
1615     return status;
1616  }
1617
1618
1619  NFCSTATUS
1620  phHciNfc_System_Test (
1621                     void                            *psHciHandle,
1622                     void                            *pHwRef,
1623                     uint32_t                        test_type,
1624                     phNfc_sData_t                   *test_param
1625                  )
1626 {
1627     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1628     phHciNfc_sContext_t     *psHciContext =
1629                             ((phHciNfc_sContext_t *)psHciHandle);
1630     static phNfc_sData_t test_result;
1631     static uint8_t       gpio_status = 0;
1632
1633     if( (NULL == psHciContext)
1634         || (NULL == pHwRef)
1635         )
1636     {
1637         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1638     }
1639     else
1640     {
1641         psHciContext->p_hw_ref = pHwRef;
1642         status = phHciNfc_FSM_Update ( psHciContext, hciState_Test );
1643         if (NFCSTATUS_SUCCESS == status)
1644         {
1645             if (test_type != NFC_GPIO_READ)
1646             {
1647                 status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef,
1648                     (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param);
1649             }
1650             else
1651             {
1652                 test_result.buffer = &gpio_status;
1653                 status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
1654                     (uint16_t)NFC_GPIO_READ, test_result.buffer);
1655
1656             }
1657             if( NFCSTATUS_PENDING != status )
1658             {
1659                 /* Roll Back the State Machine to its Original State */
1660                 phHciNfc_FSM_Rollback ( psHciContext );
1661             }
1662         }
1663     }
1664
1665      return status;
1666 }
1667
1668
1669  NFCSTATUS
1670  phHciNfc_System_Configure (
1671                     void                            *psHciHandle,
1672                     void                            *pHwRef,
1673                     uint32_t                        config_type,
1674                     uint8_t                         config_value
1675                  )
1676 {
1677     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1678     phHciNfc_sContext_t     *psHciContext =
1679                             ((phHciNfc_sContext_t *)psHciHandle);
1680
1681     if( (NULL == psHciContext)
1682         || (NULL == pHwRef)
1683         )
1684     {
1685         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1686     }
1687     else
1688     {
1689         psHciContext->p_hw_ref = pHwRef;
1690         status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1691         if (NFCSTATUS_SUCCESS == status)
1692         {
1693             status = phHciNfc_DevMgmt_Configure(psHciContext, pHwRef,
1694                 (uint16_t)config_type, config_value);
1695
1696             if( NFCSTATUS_PENDING != status )
1697             {
1698                 /* Roll Back the State Machine to its Original State */
1699                 phHciNfc_FSM_Rollback ( psHciContext );
1700             }
1701         }
1702     }
1703  return status;
1704 }
1705
1706 NFCSTATUS
1707  phHciNfc_System_Get_Info(
1708                     void                            *psHciHandle,
1709                     void                            *pHwRef,
1710                     uint32_t                        config_type,
1711                     uint8_t                         *p_config_value
1712                  )
1713 {
1714     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1715     phHciNfc_sContext_t     *psHciContext =
1716                             ((phHciNfc_sContext_t *)psHciHandle);
1717
1718     if( (NULL == psHciContext)
1719         || (NULL == pHwRef)
1720         || (NULL == p_config_value)
1721         )
1722     {
1723         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1724     }
1725     else
1726     {
1727         psHciContext->p_hw_ref = pHwRef;
1728         status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1729         if (NFCSTATUS_SUCCESS == status)
1730         {
1731             status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
1732                 (uint16_t)config_type, p_config_value);
1733
1734             if( NFCSTATUS_PENDING != status )
1735             {
1736                 /* Roll Back the State Machine to its Original State */
1737                 phHciNfc_FSM_Rollback ( psHciContext );
1738             }
1739         }
1740     }
1741
1742  return status;
1743 }
1744
1745
1746  NFCSTATUS
1747  phHciNfc_Get_Link_Status(
1748                     void                            *psHciHandle,
1749                     void                            *pHwRef
1750                  )
1751 {
1752     NFCSTATUS               status = NFCSTATUS_SUCCESS;
1753     phHciNfc_sContext_t     *psHciContext =
1754                             ((phHciNfc_sContext_t *)psHciHandle);
1755
1756     if( (NULL == psHciContext)
1757         || (NULL == pHwRef)
1758         )
1759     {
1760         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1761     }
1762     else
1763     {
1764         psHciContext->p_hw_ref = pHwRef;
1765         status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1766         if (NFCSTATUS_SUCCESS == status)
1767         {
1768             status = phHciNfc_LinkMgmt_Open(psHciContext, pHwRef);
1769
1770             if( NFCSTATUS_PENDING != status )
1771             {
1772                 /* Roll Back the State Machine to its Original State */
1773                 phHciNfc_FSM_Rollback ( psHciContext );
1774             }
1775         }
1776     }
1777
1778  return status;
1779 }
1780
1781
1782