1 /* 2 * Copyright (C) 2010 NXP Semiconductors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /*! 18 * \file phLibNfc.c 19 20 * Project: NFC FRI / HALDL 21 * 22 * $Date: Tue Jun 1 14:53:48 2010 $ 23 * $Author: ing07385 $ 24 * $Revision: 1.89 $ 25 * $Aliases: NFC_FRI1.1_WK1024_SDK $ 26 * 27 */ 28 29 30 /* 31 ************************* Header Files **************************************** 32 */ 33 34 #define LOG_TAG "NFC" 35 36 #include <phLibNfc.h> 37 #include <phDal4Nfc.h> 38 #include <phHal4Nfc.h> 39 #include <phOsalNfc.h> 40 #include <phLibNfc_Internal.h> 41 #include <phLibNfc_ndef_raw.h> 42 #include <phLibNfc_initiator.h> 43 #include <phLibNfc_discovery.h> 44 #include <phNfcStatus.h> 45 #include <cutils/log.h> 46 /* 47 *************************** Macro's ****************************************** 48 */ 49 50 extern int dlopen_firmware(); 51 52 #ifndef STATIC_DISABLE 53 #define STATIC static 54 #else 55 #define STATIC 56 #endif 57 58 59 /* 60 *************************** Global Variables ********************************** 61 */ 62 63 64 pphLibNfc_LibContext_t gpphLibContext=NULL; 65 66 /* 67 *************************** Static Function Declaration *********************** 68 */ 69 70 /* Init callback */ 71 STATIC void phLibNfc_InitCb(void *pContext,NFCSTATUS status); 72 73 /* Shutdown callback */ 74 STATIC void phLibNfc_ShutdownCb(void *pContext,NFCSTATUS status); 75 76 /**Default notification handler registered with lower layer immediately after 77 successful initialization*/ 78 STATIC void phLibNfc_DefaultHandler( 79 void *context, 80 phHal_eNotificationType_t type, 81 phHal4Nfc_NotificationInfo_t info, 82 NFCSTATUS status 83 ); 84 /* 85 *************************** Function Definitions ****************************** 86 */ 87 88 NFCSTATUS phLibNfc_Mgt_ConfigureDriver (pphLibNfc_sConfig_t psConfig, 89 void ** ppDriverHandle) 90 { 91 if(NULL != gpphLibContext) 92 { 93 return NFCSTATUS_ALREADY_INITIALISED; 94 } 95 96 return phDal4Nfc_Config(psConfig, ppDriverHandle); 97 } 98 99 NFCSTATUS phLibNfc_Mgt_UnConfigureDriver (void * pDriverHandle) 100 { 101 if(NULL != gpphLibContext) 102 { 103 return NFCSTATUS_ALREADY_INITIALISED; 104 } 105 106 return phDal4Nfc_ConfigRelease(pDriverHandle); 107 } 108 109 NFCSTATUS phLibNfc_HW_Reset () 110 { 111 NFCSTATUS Status = NFCSTATUS_SUCCESS; 112 113 Status = phDal4Nfc_Reset(1); 114 Status = phDal4Nfc_Reset(0); 115 Status = phDal4Nfc_Reset(1); 116 117 return Status; 118 } 119 120 NFCSTATUS phLibNfc_Download_Mode () 121 { 122 return phDal4Nfc_Download(); 123 } 124 125 int phLibNfc_Load_Firmware_Image () 126 { 127 int status; 128 status = dlopen_firmware(); 129 return status; 130 } 131 132 133 extern uint8_t nxp_nfc_isoxchg_timeout; 134 NFCSTATUS phLibNfc_SetIsoXchgTimeout(uint8_t timeout) { 135 nxp_nfc_isoxchg_timeout = timeout; 136 return NFCSTATUS_SUCCESS; 137 } 138 139 int phLibNfc_GetIsoXchgTimeout() { 140 return nxp_nfc_isoxchg_timeout; 141 } 142 143 extern uint32_t nxp_nfc_hci_response_timeout; 144 NFCSTATUS phLibNfc_SetHciTimeout(uint32_t timeout_in_ms) { 145 nxp_nfc_hci_response_timeout = timeout_in_ms; 146 return NFCSTATUS_SUCCESS; 147 } 148 149 int phLibNfc_GetHciTimeout() { 150 return nxp_nfc_hci_response_timeout; 151 } 152 153 extern uint32_t nxp_nfc_felica_timeout; 154 NFCSTATUS phLibNfc_SetFelicaTimeout(uint8_t timeout_in_ms) { 155 nxp_nfc_felica_timeout = timeout_in_ms; 156 return NFCSTATUS_SUCCESS; 157 } 158 159 int phLibNfc_GetFelicaTimeout() { 160 return nxp_nfc_felica_timeout; 161 } 162 163 extern uint8_t nxp_nfc_mifareraw_timeout; 164 NFCSTATUS phLibNfc_SetMifareRawTimeout(uint8_t timeout) { 165 nxp_nfc_mifareraw_timeout = timeout; 166 return NFCSTATUS_SUCCESS; 167 } 168 169 int phLibNfc_GetMifareRawTimeout() { 170 return nxp_nfc_mifareraw_timeout; 171 } 172 173 /** 174 * Initialize the phLibNfc interface. 175 */ 176 177 NFCSTATUS phLibNfc_Mgt_Initialize(void *pDriverHandle, 178 pphLibNfc_RspCb_t pInitCb, 179 void *pContext) 180 { 181 NFCSTATUS Status = NFCSTATUS_SUCCESS; 182 if((NULL == pDriverHandle)||(NULL == pInitCb)) 183 { 184 Status = NFCSTATUS_INVALID_PARAMETER; 185 } 186 else if(NULL == gpphLibContext) 187 { 188 /* Initialize the Lib context */ 189 gpphLibContext=(pphLibNfc_LibContext_t)phOsalNfc_GetMemory( 190 (uint32_t)sizeof(phLibNfc_LibContext_t)); 191 if(NULL == gpphLibContext) 192 { 193 Status=NFCSTATUS_INSUFFICIENT_RESOURCES; 194 } 195 else 196 { 197 (void)memset((void *)gpphLibContext,0,( 198 (uint32_t)sizeof(phLibNfc_LibContext_t))); 199 200 /* Store the Callback and context in LibContext structure*/ 201 gpphLibContext->CBInfo.pClientInitCb=pInitCb; 202 gpphLibContext->CBInfo.pClientInitCntx=pContext; 203 /* Initialize the HwReferece structure */ 204 gpphLibContext->psHwReference=(phHal_sHwReference_t *) 205 phOsalNfc_GetMemory((uint32_t)sizeof(phHal_sHwReference_t)); 206 (void)memset((void *)gpphLibContext->psHwReference,0, 207 ((uint32_t)sizeof(phHal_sHwReference_t))); 208 /* Allocate the Memory for the Transceive info */ 209 if( gpphLibContext->psHwReference!=NULL) 210 { 211 gpphLibContext->psHwReference->p_board_driver = pDriverHandle; 212 Status = phLibNfc_UpdateNextState(gpphLibContext, 213 eLibNfcHalStateInitandIdle); 214 if(Status==NFCSTATUS_SUCCESS) 215 { 216 Status=phHal4Nfc_Open( 217 gpphLibContext->psHwReference, 218 eInitDefault, 219 phLibNfc_InitCb, 220 (void *)gpphLibContext); 221 } 222 } 223 else 224 { 225 Status = NFCSTATUS_INSUFFICIENT_RESOURCES; 226 } 227 phLibNfc_Ndef_Init(); 228 } 229 } 230 else if(gpphLibContext->LibNfcState.next_state==eLibNfcHalStateShutdown) 231 { 232 Status = NFCSTATUS_SHUTDOWN; 233 } 234 else 235 { 236 Status=NFCSTATUS_ALREADY_INITIALISED; 237 } 238 return Status; 239 } 240 241 /* 242 * This function called by the HAL4 when the initialization seq is completed. 243 */ 244 STATIC void phLibNfc_InitCb(void *pContext,NFCSTATUS status) 245 { 246 pphLibNfc_LibContext_t pLibContext=NULL; 247 pphLibNfc_RspCb_t pClientCb=NULL; 248 void *pUpperLayerContext=NULL; 249 250 251 /* Initialize the local variable */ 252 pLibContext = (pphLibNfc_LibContext_t)pContext; 253 254 pClientCb =pLibContext->CBInfo.pClientInitCb; 255 pUpperLayerContext=pLibContext->CBInfo.pClientInitCntx; 256 if(status == NFCSTATUS_SUCCESS) 257 { 258 /* Get the Lib context */ 259 pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 260 gpphLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeOff; 261 if(pLibContext->psHwReference->uicc_connected==TRUE) 262 { 263 /* populate state of the secured element */ 264 gpphLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeDefault; 265 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_CurrentState=phLibNfc_SE_Active; 266 pLibContext->sSeContext.uUiccActivate=TRUE; 267 } 268 if(pLibContext->psHwReference->smx_connected==TRUE) 269 { 270 /* populate state of the secured element */ 271 gpphLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeDefault; 272 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_CurrentState=phLibNfc_SE_Inactive; 273 pLibContext->sSeContext.uSmxActivate =FALSE; 274 } 275 276 phLibNfc_UpdateCurState(status,pLibContext); 277 (void)phHal4Nfc_RegisterNotification( 278 pLibContext->psHwReference, 279 eRegisterDefault, 280 phLibNfc_DefaultHandler, 281 (void*)pLibContext 282 ); 283 /* call the upper layer register function */ 284 (*pClientCb)(pUpperLayerContext,status); 285 286 } 287 else 288 { 289 /*Change the status code failed*/ 290 status = NFCSTATUS_FAILED; 291 /* Get the Lib context */ 292 pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 293 294 phLibNfc_UpdateCurState(status,pLibContext); 295 296 297 298 /* Allocate the Memory for the Transceive info */ 299 if(pLibContext->psHwReference!= NULL) 300 { 301 phOsalNfc_FreeMemory(pLibContext->psHwReference); 302 pLibContext->psHwReference = NULL; 303 } 304 (*pClientCb)(pUpperLayerContext, status); 305 306 phOsalNfc_FreeMemory(pLibContext); 307 pLibContext= NULL; 308 gpphLibContext = NULL; 309 310 } 311 return; 312 } 313 314 /**Default notification handler registered with lower layer immediately after 315 successful initialization*/ 316 STATIC void phLibNfc_DefaultHandler( 317 void *context, 318 phHal_eNotificationType_t type, 319 phHal4Nfc_NotificationInfo_t info, 320 NFCSTATUS status 321 ) 322 { 323 if(context != (void *)gpphLibContext) 324 { 325 phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1); 326 } 327 else 328 { 329 info = info; 330 if((NFC_EVENT_NOTIFICATION == type) && 331 (NFCSTATUS_BOARD_COMMUNICATION_ERROR == status)) 332 { 333 phLibNfc_UpdateCurState(NFCSTATUS_FAILED,gpphLibContext); 334 phOsalNfc_RaiseException(phOsalNfc_e_UnrecovFirmwareErr,1); 335 } 336 } 337 return; 338 } 339 /** 340 * De-Initialize the LIB NFC. 341 */ 342 NFCSTATUS phLibNfc_Mgt_DeInitialize(void * pDriverHandle, 343 pphLibNfc_RspCb_t pDeInitCb, 344 void* pContext 345 ) 346 { 347 NFCSTATUS Status = NFCSTATUS_SUCCESS; 348 pphLibNfc_LibContext_t pLibContext = gpphLibContext; 349 if(NULL==pDriverHandle) 350 { 351 /*Check for valid parameters */ 352 Status = NFCSTATUS_INVALID_PARAMETER; 353 } 354 else if((pLibContext==NULL) 355 || (pLibContext->LibNfcState.cur_state 356 == eLibNfcHalStateShutdown)) 357 { /*Lib Nfc not initlized*/ 358 Status = NFCSTATUS_NOT_INITIALISED; 359 } 360 else 361 { 362 if(pDeInitCb==NULL) 363 { 364 phHal4Nfc_Hal4Reset(pLibContext->psHwReference,(void *)pLibContext); 365 if(pLibContext->psHwReference!=NULL) 366 { 367 phOsalNfc_FreeMemory(pLibContext->psHwReference); 368 pLibContext->psHwReference = NULL; 369 } 370 /*Free the memory allocated during NDEF read,write 371 and NDEF formatting*/ 372 phLibNfc_Ndef_DeInit(); 373 phOsalNfc_FreeMemory(pLibContext); 374 gpphLibContext=NULL; 375 pLibContext= NULL; 376 } 377 else 378 { 379 if (NULL!= pLibContext->CBInfo.pClientShutdownCb) 380 { 381 /* Previous callback pending */ 382 Status = NFCSTATUS_BUSY; 383 } 384 Status = NFCSTATUS_PENDING; 385 if(TRUE != pLibContext->status.GenCb_pending_status) 386 { 387 Status = phHal4Nfc_Close(pLibContext->psHwReference, 388 phLibNfc_ShutdownCb, 389 (void *)pLibContext); 390 } 391 if(Status== NFCSTATUS_PENDING) 392 { 393 pLibContext->CBInfo.pClientShutdownCb = pDeInitCb; 394 pLibContext->CBInfo.pClientShtdwnCntx = pContext; 395 pLibContext->status.GenCb_pending_status=TRUE; 396 pLibContext->LibNfcState.next_state= eLibNfcHalStateShutdown; 397 } 398 else 399 { 400 Status =NFCSTATUS_FAILED; 401 } 402 } 403 } 404 return Status; 405 } 406 /* shutdown callback - 407 Free the allocated memory here */ 408 STATIC void phLibNfc_ShutdownCb(void *pContext,NFCSTATUS status) 409 { 410 pphLibNfc_RspCb_t pClientCb=NULL; 411 void *pUpperLayerContext=NULL; 412 pphLibNfc_LibContext_t pLibContext=NULL; 413 414 PHNFC_UNUSED_VARIABLE(pContext); 415 /* Get the Lib context */ 416 pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 417 418 if(pLibContext == NULL) 419 { 420 status = NFCSTATUS_FAILED; 421 } 422 else 423 { 424 /* Initialize the local variable */ 425 pClientCb =pLibContext->CBInfo.pClientShutdownCb; 426 pUpperLayerContext=pLibContext->CBInfo.pClientShtdwnCntx; 427 if(status == NFCSTATUS_SUCCESS) 428 { 429 pLibContext->LibNfcState.cur_state = eLibNfcHalStateShutdown; 430 phLibNfc_UpdateCurState(status,pLibContext); 431 432 pLibContext->status.GenCb_pending_status=FALSE; 433 434 /* Allocate the Memory for the Transceive info */ 435 if(pClientCb!=NULL) 436 { 437 (*pClientCb)(pUpperLayerContext, status); 438 } 439 if(pLibContext->psHwReference!=NULL) 440 { 441 phOsalNfc_FreeMemory(pLibContext->psHwReference); 442 pLibContext->psHwReference = NULL; 443 } 444 if(NULL != gpphLibContext->psBufferedAuth) 445 { 446 if(NULL != gpphLibContext->psBufferedAuth->sRecvData.buffer) 447 { 448 phOsalNfc_FreeMemory( 449 gpphLibContext->psBufferedAuth->sRecvData.buffer); 450 } 451 if(NULL != gpphLibContext->psBufferedAuth->sSendData.buffer) 452 { 453 phOsalNfc_FreeMemory( 454 gpphLibContext->psBufferedAuth->sSendData.buffer); 455 } 456 phOsalNfc_FreeMemory(gpphLibContext->psBufferedAuth); 457 gpphLibContext->psBufferedAuth = NULL; 458 } 459 /*Free the memory allocated during NDEF read,write 460 and NDEF formatting*/ 461 phLibNfc_Ndef_DeInit(); 462 phOsalNfc_FreeMemory(pLibContext); 463 gpphLibContext=NULL; 464 pLibContext= NULL; 465 466 } 467 else 468 { 469 /* shutdown sequence failed by HAL 4 */ 470 status= NFCSTATUS_FAILED; 471 pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 472 phLibNfc_UpdateCurState(status,pLibContext); 473 pLibContext->status.GenCb_pending_status=FALSE; 474 if(pClientCb!=NULL) 475 { 476 (*pClientCb)(pUpperLayerContext,status); 477 } 478 } 479 } 480 } 481 /** 482 * Pending shutdown call. 483 */ 484 485 486 void phLibNfc_Pending_Shutdown(void) 487 { 488 NFCSTATUS RetStatus = NFCSTATUS_SUCCESS ; 489 gpphLibContext->status.GenCb_pending_status = FALSE; 490 RetStatus = phHal4Nfc_Close( 491 gpphLibContext->psHwReference, 492 phLibNfc_ShutdownCb, 493 (void *)gpphLibContext); 494 PHNFC_UNUSED_VARIABLE(RetStatus); 495 return; 496 } 497 498 499 /** 500 * Reset the LIB NFC. 501 */ 502 NFCSTATUS phLibNfc_Mgt_Reset(void *pContext) 503 { 504 NFCSTATUS Status = NFCSTATUS_SUCCESS; 505 phLibNfc_LibContext_t *pLibNfc_Ctxt = (phLibNfc_LibContext_t *)pContext; 506 507 if((pLibNfc_Ctxt == NULL) 508 || (gpphLibContext->LibNfcState.cur_state 509 == eLibNfcHalStateShutdown)) 510 { /*Lib Nfc not initlized*/ 511 Status = NFCSTATUS_NOT_INITIALISED; 512 } 513 else if(NULL == pContext) 514 { 515 Status = NFCSTATUS_INVALID_PARAMETER; 516 } 517 /* Check for valid state,If De initialize is called then 518 return NFCSTATUS_SHUTDOWN */ 519 else if(gpphLibContext->LibNfcState.next_state 520 == eLibNfcHalStateShutdown) 521 { 522 Status = NFCSTATUS_SHUTDOWN; 523 } 524 else 525 { 526 /*Reset all callback status*/ 527 (void) memset(&(gpphLibContext->RegNtfType),0, 528 sizeof(phLibNfc_Registry_Info_t)); 529 (void) memset(&(gpphLibContext->sADDconfig),0, 530 sizeof(phLibNfc_sADD_Cfg_t)); 531 (void) memset(&(gpphLibContext->ndef_cntx),0, 532 sizeof(phLibNfc_NdefInfo_t)); 533 (void) memset(&(gpphLibContext->sNfcIp_Context),0, 534 sizeof(phLibNfc_NfcIpInfo_t)); 535 (void) memset(&(gpphLibContext->sCardEmulCfg),0, 536 sizeof(phHal_sEmulationCfg_t)); 537 (void) memset(&(gpphLibContext->Discov_handle),0, 538 MAX_REMOTE_DEVICES); 539 540 /*Free memory allocated for NDEF records*/ 541 if(NULL != gpphLibContext->psBufferedAuth) 542 { 543 if(NULL != gpphLibContext->psBufferedAuth->sRecvData.buffer) 544 { 545 phOsalNfc_FreeMemory( 546 gpphLibContext->psBufferedAuth->sRecvData.buffer); 547 gpphLibContext->psBufferedAuth->sRecvData.buffer = NULL; 548 } 549 if(NULL != gpphLibContext->psBufferedAuth->sSendData.buffer) 550 { 551 phOsalNfc_FreeMemory( 552 gpphLibContext->psBufferedAuth->sSendData.buffer); 553 gpphLibContext->psBufferedAuth->sSendData.buffer = NULL; 554 } 555 phOsalNfc_FreeMemory(gpphLibContext->psBufferedAuth); 556 gpphLibContext->psBufferedAuth = NULL; 557 } 558 if(NULL != gpphLibContext->psTransInfo) 559 { 560 phOsalNfc_FreeMemory(gpphLibContext->psTransInfo); 561 gpphLibContext->psTransInfo = NULL; 562 } 563 if(NULL != gpphLibContext->ndef_cntx.psNdefMap) 564 { 565 if(NULL != gpphLibContext->ndef_cntx.psNdefMap->SendRecvBuf) 566 { 567 phOsalNfc_FreeMemory(gpphLibContext->ndef_cntx.psNdefMap->SendRecvBuf); 568 gpphLibContext->ndef_cntx.psNdefMap->SendRecvBuf = NULL; 569 } 570 phOsalNfc_FreeMemory(gpphLibContext->ndef_cntx.psNdefMap); 571 gpphLibContext->ndef_cntx.psNdefMap = NULL; 572 } 573 if(NULL != gpphLibContext->psOverHalCtxt) 574 { 575 phOsalNfc_FreeMemory(gpphLibContext->psOverHalCtxt); 576 gpphLibContext->psTransInfo = NULL; 577 } 578 if(NULL != gpphLibContext->psDevInputParam) 579 { 580 phOsalNfc_FreeMemory(gpphLibContext->psDevInputParam); 581 gpphLibContext->psDevInputParam = NULL; 582 } 583 if(NULL != gpphLibContext->ndef_cntx.ndef_fmt) 584 { 585 phOsalNfc_FreeMemory(gpphLibContext->ndef_cntx.ndef_fmt); 586 gpphLibContext->ndef_cntx.ndef_fmt = NULL; 587 } 588 if(NULL != pNdefRecord) 589 { 590 if(NULL != pNdefRecord->Id) 591 { 592 phOsalNfc_FreeMemory(pNdefRecord->Id); 593 pNdefRecord->Id = NULL; 594 } 595 if(NULL != pNdefRecord->Type) 596 { 597 phOsalNfc_FreeMemory(pNdefRecord->Type); 598 pNdefRecord->Type = NULL; 599 } 600 if(NULL != pNdefRecord->PayloadData) 601 { 602 phOsalNfc_FreeMemory(pNdefRecord->PayloadData); 603 pNdefRecord->PayloadData = NULL; 604 } 605 } 606 if(NULL != NdefInfo.pNdefRecord) 607 { 608 phOsalNfc_FreeMemory(NdefInfo.pNdefRecord); 609 NdefInfo.pNdefRecord = NULL; 610 } 611 if(NULL != gpphLibContext->phLib_NdefRecCntx.NdefCb) 612 { 613 phOsalNfc_FreeMemory(gpphLibContext->phLib_NdefRecCntx.NdefCb); 614 gpphLibContext->phLib_NdefRecCntx.NdefCb = NULL; 615 } 616 if(NULL != gpphLibContext->phLib_NdefRecCntx.ndef_message.buffer) 617 { 618 phOsalNfc_FreeMemory(gpphLibContext->phLib_NdefRecCntx.ndef_message.buffer); 619 gpphLibContext->phLib_NdefRecCntx.ndef_message.buffer = NULL; 620 } 621 /* No device is connected */ 622 gpphLibContext->Connected_handle = 0x00; 623 gpphLibContext->Prev_Connected_handle = 0x00; 624 gpphLibContext->ReleaseType = NFC_INVALID_RELEASE_TYPE; 625 gpphLibContext->eLibNfcCfgMode = NFC_DISCOVERY_STOP; 626 /*Lib Nfc Stack is initilized and in idle state*/ 627 gpphLibContext->LibNfcState.cur_state = eLibNfcHalStateInitandIdle; 628 629 /* Reset all callback status */ 630 gpphLibContext->CBInfo.pClientCkNdefCb = NULL; 631 gpphLibContext->CBInfo.pClientCkNdefCntx = NULL; 632 gpphLibContext->CBInfo.pClientConCntx = NULL; 633 gpphLibContext->CBInfo.pClientConnectCb = NULL; 634 gpphLibContext->CBInfo.pClientDConCntx = NULL; 635 gpphLibContext->CBInfo.pClientDisCfgCntx = NULL; 636 gpphLibContext->CBInfo.pClientDisConfigCb = NULL; 637 gpphLibContext->CBInfo.pClientInitCb = NULL; 638 gpphLibContext->CBInfo.pClientInitCntx = gpphLibContext; 639 gpphLibContext->CBInfo.pClientNdefNtfRespCb = NULL; 640 gpphLibContext->CBInfo.pClientNdefNtfRespCntx = NULL; 641 gpphLibContext->CBInfo.pClientNtfRegRespCB = NULL; 642 gpphLibContext->CBInfo.pClientNtfRegRespCntx = NULL; 643 gpphLibContext->CBInfo.pClientPresChkCb = NULL; 644 gpphLibContext->CBInfo.pClientPresChkCntx = NULL; 645 gpphLibContext->CBInfo.pClientRdNdefCb = NULL; 646 gpphLibContext->CBInfo.pClientRdNdefCntx = NULL; 647 gpphLibContext->CBInfo.pClientShtdwnCntx = NULL; 648 gpphLibContext->CBInfo.pClientShutdownCb = NULL; 649 gpphLibContext->CBInfo.pClientTransceiveCb = NULL; 650 gpphLibContext->CBInfo.pClientTranseCntx = NULL; 651 gpphLibContext->CBInfo.pClientWrNdefCb = NULL; 652 gpphLibContext->CBInfo.pClientWrNdefCntx = NULL; 653 gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCb = NULL; 654 gpphLibContext->sNfcIp_Context.pClientNfcIpCfgCntx = NULL; 655 gpphLibContext->sNfcIp_Context.pClientNfcIpRxCb = NULL; 656 gpphLibContext->sNfcIp_Context.pClientNfcIpRxCntx = NULL; 657 gpphLibContext->sNfcIp_Context.pClientNfcIpTxCb = NULL; 658 gpphLibContext->sNfcIp_Context.pClientNfcIpTxCntx = NULL; 659 gpphLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb = NULL; 660 gpphLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt = NULL; 661 gpphLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCb = NULL; 662 gpphLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCtxt = NULL; 663 /*No callback is pending*/ 664 gpphLibContext->status.GenCb_pending_status = FALSE; 665 666 } 667 return Status; 668 } 669 /** 670 * LibNfc state machine next state update. 671 */ 672 673 NFCSTATUS 674 phLibNfc_UpdateNextState( 675 pphLibNfc_LibContext_t pLibContext, 676 phLibNfc_State_t next_state 677 ) 678 { 679 NFCSTATUS status = NFCSTATUS_INVALID_STATE; 680 switch(pLibContext->LibNfcState.cur_state) 681 { 682 case eLibNfcHalStateShutdown: 683 { 684 switch(next_state) 685 { 686 case eLibNfcHalStateShutdown: 687 case eLibNfcHalStateInitandIdle: 688 status = NFCSTATUS_SUCCESS; 689 break; 690 default: 691 break; 692 } 693 } 694 break; 695 case eLibNfcHalStateConfigReady: 696 { 697 switch(next_state) 698 { 699 case eLibNfcHalStateShutdown: 700 case eLibNfcHalStateConfigReady: 701 case eLibNfcHalStateInitandIdle: 702 case eLibNfcHalStateConnect: 703 status = NFCSTATUS_SUCCESS; 704 break; 705 default: 706 break; 707 } 708 } 709 break; 710 case eLibNfcHalStateConnect: 711 { 712 switch(next_state) 713 { 714 case eLibNfcHalStateShutdown: 715 case eLibNfcHalStateRelease: 716 case eLibNfcHalStateTransaction: 717 case eLibNfcHalStatePresenceChk: 718 status = NFCSTATUS_SUCCESS; 719 break; 720 default: 721 break; 722 } 723 } 724 break; 725 case eLibNfcHalStatePresenceChk: 726 { 727 switch(next_state) 728 { 729 case eLibNfcHalStateShutdown: 730 case eLibNfcHalStateConfigReady: 731 case eLibNfcHalStateRelease: 732 case eLibNfcHalStateTransaction: 733 case eLibNfcHalStatePresenceChk: 734 status = NFCSTATUS_SUCCESS; 735 break; 736 default: 737 break; 738 } 739 } 740 break; 741 case eLibNfcHalStateInitandIdle: 742 { 743 switch(next_state) 744 { 745 case eLibNfcHalStateShutdown: 746 case eLibNfcHalStateConfigReady: 747 status = NFCSTATUS_SUCCESS; 748 break; 749 default: 750 break; 751 } 752 } 753 break; 754 default: 755 break; 756 } 757 pLibContext->LibNfcState.next_state = 758 (uint8_t)((NFCSTATUS_SUCCESS == status)?next_state:pLibContext->LibNfcState.next_state); 759 760 return status; 761 } 762 763 /** 764 * LibNfc state machine current state update. 765 */ 766 767 void 768 phLibNfc_UpdateCurState( 769 NFCSTATUS status, 770 pphLibNfc_LibContext_t psLibContext 771 ) 772 { 773 switch(psLibContext->LibNfcState.next_state) 774 { 775 case eLibNfcHalStateTransaction: 776 psLibContext->LibNfcState.cur_state = (uint8_t)eLibNfcHalStateConnect; 777 break; 778 case eLibNfcHalStateRelease: 779 psLibContext->LibNfcState.cur_state 780 = (uint8_t)(psLibContext->status.DiscEnbl_status == TRUE? 781 eLibNfcHalStateInitandIdle:eLibNfcHalStateConfigReady); 782 break; 783 case eLibNfcHalStateInvalid: 784 break; 785 default: 786 psLibContext->LibNfcState.cur_state 787 = (uint8_t)((NFCSTATUS_SUCCESS == status)? 788 psLibContext->LibNfcState.next_state: 789 psLibContext->LibNfcState.cur_state); 790 } 791 psLibContext->LibNfcState.next_state = (uint8_t)eLibNfcHalStateInvalid; 792 return; 793 } 794 /* Interface to stack capabilities */ 795 796 NFCSTATUS phLibNfc_Mgt_GetstackCapabilities( 797 phLibNfc_StackCapabilities_t *phLibNfc_StackCapabilities, 798 void *pContext) 799 { 800 NFCSTATUS RetVal = NFCSTATUS_FAILED; 801 /*Check Lib Nfc stack is initilized*/ 802 if((NULL == gpphLibContext)|| 803 (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)) 804 { 805 RetVal = NFCSTATUS_NOT_INITIALISED; 806 } 807 /*Check application has sent the valid parameters*/ 808 else if((NULL == phLibNfc_StackCapabilities) 809 || (NULL == pContext)) 810 { 811 RetVal= NFCSTATUS_INVALID_PARAMETER; 812 } 813 else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown) 814 { 815 RetVal = NFCSTATUS_SHUTDOWN; 816 } 817 else if(TRUE == gpphLibContext->status.GenCb_pending_status) 818 { 819 /*Previous operation is pending */ 820 RetVal = NFCSTATUS_BUSY; 821 } 822 else 823 { 824 /* Tag Format Capabilities*/ 825 phLibNfc_StackCapabilities->psFormatCapabilities.Desfire = TRUE; 826 phLibNfc_StackCapabilities->psFormatCapabilities.MifareStd = TRUE; 827 phLibNfc_StackCapabilities->psFormatCapabilities.MifareUL = TRUE; 828 phLibNfc_StackCapabilities->psFormatCapabilities.FeliCa = FALSE; 829 phLibNfc_StackCapabilities->psFormatCapabilities.Jewel = FALSE; 830 phLibNfc_StackCapabilities->psFormatCapabilities.ISO14443_4A = FALSE; 831 phLibNfc_StackCapabilities->psFormatCapabilities.ISO14443_4B = FALSE; 832 phLibNfc_StackCapabilities->psFormatCapabilities.MifareULC = TRUE; 833 phLibNfc_StackCapabilities->psFormatCapabilities.ISO15693 = FALSE; 834 835 /* Tag Mapping Capabilities */ 836 phLibNfc_StackCapabilities->psMappingCapabilities.FeliCa = TRUE; 837 phLibNfc_StackCapabilities->psMappingCapabilities.Desfire = TRUE; 838 phLibNfc_StackCapabilities->psMappingCapabilities.ISO14443_4A = TRUE; 839 phLibNfc_StackCapabilities->psMappingCapabilities.ISO14443_4B = TRUE; 840 phLibNfc_StackCapabilities->psMappingCapabilities.MifareStd = TRUE; 841 phLibNfc_StackCapabilities->psMappingCapabilities.MifareUL = TRUE; 842 phLibNfc_StackCapabilities->psMappingCapabilities.MifareULC = TRUE; 843 phLibNfc_StackCapabilities->psMappingCapabilities.Jewel = TRUE; 844 phLibNfc_StackCapabilities->psMappingCapabilities.ISO15693 = FALSE; 845 846 /*Call Hal4 Get Dev Capabilities to get info about protocols supported 847 by Lib Nfc*/ 848 PHDBG_INFO("LibNfc:Get Stack capabilities "); 849 RetVal= phHal4Nfc_GetDeviceCapabilities( 850 gpphLibContext->psHwReference, 851 &(phLibNfc_StackCapabilities->psDevCapabilities), 852 (void *)gpphLibContext); 853 854 LIB_NFC_VERSION_SET(phLibNfc_StackCapabilities->psDevCapabilities.hal_version, 855 PH_HAL4NFC_VERSION, 856 PH_HAL4NFC_REVISION, 857 PH_HAL4NFC_PATCH, 858 PH_HAL4NFC_BUILD); 859 860 phLibNfc_StackCapabilities->psDevCapabilities.fw_version= 861 gpphLibContext->psHwReference->device_info.fw_version; 862 phLibNfc_StackCapabilities->psDevCapabilities.hci_version= 863 gpphLibContext->psHwReference->device_info.hci_version; 864 phLibNfc_StackCapabilities->psDevCapabilities.hw_version= 865 gpphLibContext->psHwReference->device_info.hw_version; 866 phLibNfc_StackCapabilities->psDevCapabilities.model_id= 867 gpphLibContext->psHwReference->device_info.model_id; 868 (void)memcpy(phLibNfc_StackCapabilities->psDevCapabilities.full_version, 869 gpphLibContext->psHwReference->device_info.full_version,NXP_FULL_VERSION_LEN); 870 /* Check the firmware version */ 871 if (nxp_nfc_full_version == NULL) { 872 // Couldn't load firmware, just pretend we're up to date. 873 LOGW("Firmware image not available: this device might be running old NFC firmware!"); 874 phLibNfc_StackCapabilities->psDevCapabilities.firmware_update_info = 0; 875 } else { 876 phLibNfc_StackCapabilities->psDevCapabilities.firmware_update_info = memcmp(phLibNfc_StackCapabilities->psDevCapabilities.full_version, nxp_nfc_full_version, 877 NXP_FULL_VERSION_LEN); 878 } 879 880 if(NFCSTATUS_SUCCESS != RetVal) 881 { 882 RetVal = NFCSTATUS_FAILED; 883 } 884 } 885 return RetVal; 886 } 887 888 889 890 891 892 893 NFCSTATUS phLibNfc_Mgt_ConfigureTestMode(void *pDriverHandle, 894 pphLibNfc_RspCb_t pTestModeCb, 895 phLibNfc_Cfg_Testmode_t eTstmode, 896 void *pContext) 897 { 898 NFCSTATUS Status = NFCSTATUS_SUCCESS; 899 phHal4Nfc_InitType_t eInitType=eInitDefault; 900 901 if((NULL == pDriverHandle)||(NULL == pTestModeCb)) 902 { 903 Status = NFCSTATUS_INVALID_PARAMETER; 904 } 905 else if((NULL != gpphLibContext) && \ 906 (gpphLibContext->LibNfcState.next_state==eLibNfcHalStateShutdown)) 907 { 908 Status = NFCSTATUS_SHUTDOWN; 909 } 910 else if( (eTstmode == phLibNfc_TstMode_On) && (NULL != gpphLibContext)) 911 { 912 Status=NFCSTATUS_ALREADY_INITIALISED; 913 } 914 else if( (eTstmode == phLibNfc_TstMode_Off) && (NULL == gpphLibContext)) 915 { 916 Status = NFCSTATUS_NOT_INITIALISED; 917 } 918 else if( (eTstmode == phLibNfc_TstMode_Off) && (NULL != gpphLibContext)) 919 { 920 if (NULL!= gpphLibContext->CBInfo.pClientShutdownCb) 921 { /* Previous callback pending */ 922 Status = NFCSTATUS_BUSY; 923 } 924 else 925 { 926 Status = NFCSTATUS_PENDING; 927 if(TRUE != gpphLibContext->status.GenCb_pending_status) 928 { 929 Status = phHal4Nfc_Close(gpphLibContext->psHwReference, 930 phLibNfc_ShutdownCb, 931 (void *)gpphLibContext); 932 } 933 if(Status== NFCSTATUS_PENDING) 934 { 935 gpphLibContext->CBInfo.pClientShutdownCb = pTestModeCb; 936 gpphLibContext->CBInfo.pClientShtdwnCntx = pContext; 937 gpphLibContext->status.GenCb_pending_status=TRUE; 938 gpphLibContext->LibNfcState.next_state= eLibNfcHalStateShutdown; 939 } 940 else 941 { 942 Status =NFCSTATUS_FAILED; 943 } 944 } 945 } 946 else 947 { 948 /* Initialize the Lib context */ 949 gpphLibContext=(pphLibNfc_LibContext_t)phOsalNfc_GetMemory( 950 (uint32_t)sizeof(phLibNfc_LibContext_t)); 951 if(NULL == gpphLibContext) 952 { 953 Status=NFCSTATUS_INSUFFICIENT_RESOURCES; 954 } 955 else 956 { 957 (void)memset((void *)gpphLibContext,0,( 958 (uint32_t)sizeof(phLibNfc_LibContext_t))); 959 960 /* Store the Callback and context in LibContext structure*/ 961 gpphLibContext->CBInfo.pClientInitCb=pTestModeCb; 962 gpphLibContext->CBInfo.pClientInitCntx=pContext; 963 /* Initialize the HwReferece structure */ 964 gpphLibContext->psHwReference=(phHal_sHwReference_t *) 965 phOsalNfc_GetMemory((uint32_t)sizeof(phHal_sHwReference_t)); 966 (void)memset((void *)gpphLibContext->psHwReference,0, 967 ((uint32_t)sizeof(phHal_sHwReference_t))); 968 /* Allocate the Memory for the Transceive info */ 969 if( gpphLibContext->psHwReference!=NULL) 970 { 971 gpphLibContext->psHwReference->p_board_driver = pDriverHandle; 972 Status = phLibNfc_UpdateNextState(gpphLibContext, 973 eLibNfcHalStateInitandIdle); 974 if(Status==NFCSTATUS_SUCCESS) 975 { 976 if(eTstmode == phLibNfc_TstMode_On) 977 eInitType = eInitTestModeOn; 978 if(eTstmode == phLibNfc_TstMode_Off) 979 eInitType = eInitDefault; 980 Status=phHal4Nfc_Open( 981 gpphLibContext->psHwReference, 982 eInitType, 983 phLibNfc_InitCb, 984 (void *)gpphLibContext); 985 } 986 } 987 else 988 { 989 Status = NFCSTATUS_INSUFFICIENT_RESOURCES; 990 } 991 phLibNfc_Ndef_Init(); 992 } 993 } 994 995 return Status; 996 } 997 998
