Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2010 NXP Semiconductors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*!
     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 };
     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 
   1783