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 64static 65NFCSTATUS 66phHciNfc_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 873NFCSTATUS 874phHciNfc_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 1486NFCSTATUS 1487phHciNfc_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 1706NFCSTATUS 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