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_SE.c 19 20 * Project: NFC FRI / HALDL 21 * 22 * $Date: Thu Apr 22 13:59:50 2010 $ 23 * $Author: ing07385 $ 24 * $Revision: 1.65 $ 25 * $Aliases: NFC_FRI1.1_WK1014_SDK,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1019_SDK,NFC_FRI1.1_WK1024_SDK $ 26 * 27 */ 28 29 /* 30 ************************* Header Files *************************************** 31 */ 32 33 #include <phNfcStatus.h> 34 #include <phLibNfc.h> 35 #include <phHal4Nfc.h> 36 #include <phOsalNfc.h> 37 #include <phLibNfc_Internal.h> 38 #include <phLibNfc_SE.h> 39 #include <phLibNfc_ndef_raw.h> 40 #include <phLibNfc_initiator.h> 41 #include <phLibNfc_discovery.h> 42 43 /* 44 *************************** Macro's **************************************** 45 */ 46 47 #ifndef STATIC_DISABLE 48 #define STATIC static 49 #else 50 #define STATIC 51 #endif 52 53 /* 54 *************************** Global Variables ********************************** 55 */ 56 57 /*This Structure contains the Secure Element information*/ 58 phLibNfc_SE_List_t sSecuredElementInfo[PHLIBNFC_MAXNO_OF_SE]; 59 60 /* 61 *************************** Static Function Declaration *********************** 62 */ 63 64 /* Response callback for SE Set Mode*/ 65 STATIC 66 void phLibNfc_SE_SetMode_cb(void *context, NFCSTATUS status); 67 68 69 /* SE register listner response notification */ 70 STATIC 71 void phLibNfc_SeNotification(void *context, 72 phHal_eNotificationType_t type, 73 phHal4Nfc_NotificationInfo_t info, 74 NFCSTATUS status 75 ); 76 /* 77 *************************** Function Definitions ****************************** 78 */ 79 80 /** 81 * Registers notification handler to handle secure element specific events 82 */ 83 NFCSTATUS phLibNfc_SE_NtfRegister ( 84 pphLibNfc_SE_NotificationCb_t pSE_NotificationCb, 85 void *pContext 86 ) 87 { 88 NFCSTATUS Status = NFCSTATUS_SUCCESS; 89 pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 90 91 if((NULL == gpphLibContext) || 92 (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)) 93 { 94 Status = NFCSTATUS_NOT_INITIALISED; 95 } 96 else if((pSE_NotificationCb == NULL) 97 ||(NULL == pContext)) 98 { 99 /*parameters sent by upper layer are not valid*/ 100 Status = NFCSTATUS_INVALID_PARAMETER; 101 } 102 else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown) 103 { 104 Status = NFCSTATUS_SHUTDOWN; 105 } 106 else 107 { 108 /*Register SE notification with lower layer. 109 Any activity on Smx or UICC will be notified */ 110 Status = phHal4Nfc_RegisterNotification( 111 pLibContext->psHwReference, 112 eRegisterSecureElement, 113 phLibNfc_SeNotification, 114 (void*)pLibContext); 115 if(Status == NFCSTATUS_SUCCESS) 116 { 117 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb = pSE_NotificationCb; 118 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt=pContext; 119 } 120 else 121 { 122 /* Registration failed */ 123 Status = NFCSTATUS_FAILED; 124 } 125 } 126 return Status; 127 } 128 /** 129 * SE Notification events are notified with this callback 130 */ 131 STATIC void phLibNfc_SeNotification(void *context, 132 phHal_eNotificationType_t type, 133 phHal4Nfc_NotificationInfo_t info, 134 NFCSTATUS status) 135 { 136 pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)context; 137 phHal_sEventInfo_t *pEvtInfo = NULL; 138 phLibNfc_uSeEvtInfo_t Se_Trans_Info={{{0,0},{0,0}}}; 139 phLibNfc_SE_List_t *pSeInfo=NULL; 140 141 if(pLibContext != gpphLibContext) 142 { 143 /*wrong context returned*/ 144 phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1); 145 } 146 else 147 { 148 if((status == NFCSTATUS_SUCCESS) && (type == NFC_EVENT_NOTIFICATION)) 149 { 150 pEvtInfo = info.psEventInfo; 151 status = NFCSTATUS_SUCCESS; 152 if((pEvtInfo->eventSource == phHal_ePICC_DevType ) 153 && (pEvtInfo->eventHost == phHal_eHostController) ) 154 { 155 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_Type = phLibNfc_SE_Type_SmartMX; 156 /* Smartx Mx is Activated */ 157 pSeInfo = &sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX]; 158 } 159 if(pEvtInfo->eventHost == phHal_eUICCHost) 160 { 161 /* UICC is Activate */ 162 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_Type = phLibNfc_SE_Type_UICC; 163 pSeInfo = &sSecuredElementInfo[LIBNFC_SE_UICC_INDEX]; 164 } 165 else 166 { 167 /*presently Smx event source is not supported */ 168 } 169 if(pSeInfo!=NULL) 170 { 171 switch(pEvtInfo->eventType) 172 { 173 case NFC_EVT_TRANSACTION: 174 { 175 if((pEvtInfo->eventInfo.aid.length != 0) && ((pEvtInfo->eventInfo.aid.length <= 16))) // PLG 176 { 177 /*copy the Application id on which transaction happened*/ 178 Se_Trans_Info.UiccEvtInfo.aid.buffer =pEvtInfo->eventInfo.aid.buffer; 179 Se_Trans_Info.UiccEvtInfo.aid.length =pEvtInfo->eventInfo.aid.length; 180 } 181 else 182 { 183 // PLG patch 184 Se_Trans_Info.UiccEvtInfo.aid.buffer = NULL; 185 Se_Trans_Info.UiccEvtInfo.aid.length = 0; 186 } 187 if((pEvtInfo->eventHost == phHal_eUICCHost) 188 && (info.psEventInfo->eventInfo.uicc_info.param.length 189 != 0)) 190 { 191 /*copy the parameters info on which transaction happened*/ 192 Se_Trans_Info.UiccEvtInfo.param.buffer = 193 info.psEventInfo->eventInfo.uicc_info.param.buffer; 194 Se_Trans_Info.UiccEvtInfo.param.length = 195 info.psEventInfo->eventInfo.uicc_info.param.length; 196 } 197 /*Notify to upper layer that transaction had happened on the 198 one of the application stored in UICC or Smx*/ 199 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 200 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 201 phLibNfc_eSE_EvtStartTransaction, 202 pSeInfo->hSecureElement, 203 &Se_Trans_Info, 204 status); 205 break; 206 } 207 208 case NFC_EVT_APDU_RECEIVED: 209 { 210 if ((pEvtInfo->eventInfo.aid.length != 0) && ((pEvtInfo->eventInfo.aid.length <= 16))) 211 { 212 /* Copy received APDU to aid buffer. */ 213 Se_Trans_Info.UiccEvtInfo.aid.buffer = pEvtInfo->eventInfo.aid.buffer; 214 Se_Trans_Info.UiccEvtInfo.aid.length = pEvtInfo->eventInfo.aid.length; 215 } 216 217 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 218 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 219 phLibNfc_eSE_EvtApduReceived, 220 pSeInfo->hSecureElement, 221 &Se_Trans_Info, 222 status); 223 break; 224 } 225 226 case NFC_EVT_MIFARE_ACCESS: 227 { 228 /* copy the Block MIFARE accessed */ 229 Se_Trans_Info.UiccEvtInfo.aid.buffer = pEvtInfo->eventInfo.aid.buffer; 230 Se_Trans_Info.UiccEvtInfo.aid.length = pEvtInfo->eventInfo.aid.length; 231 232 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 233 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 234 phLibNfc_eSE_EvtMifareAccess, 235 pSeInfo->hSecureElement, 236 &Se_Trans_Info, 237 status); 238 break; 239 } 240 241 case NFC_EVT_EMV_CARD_REMOVAL: 242 { 243 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 244 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 245 phLibNfc_eSE_EvtCardRemoval, 246 pSeInfo->hSecureElement, 247 &Se_Trans_Info, 248 status); 249 break; 250 } 251 252 case NFC_EVT_END_OF_TRANSACTION: 253 { 254 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 255 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 256 phLibNfc_eSE_EvtEndTransaction, 257 pSeInfo->hSecureElement, 258 &Se_Trans_Info, 259 status); 260 break; 261 } 262 case NFC_EVT_CONNECTIVITY: 263 { 264 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 265 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 266 phLibNfc_eSE_EvtConnectivity, 267 pSeInfo->hSecureElement, 268 &Se_Trans_Info, 269 status); 270 break; 271 } 272 case NFC_EVT_START_OF_TRANSACTION: 273 { 274 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 275 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 276 phLibNfc_eSE_EvtTypeTransaction, 277 pSeInfo->hSecureElement, 278 &Se_Trans_Info, 279 status); 280 break; 281 } 282 case NFC_EVT_FIELD_ON: 283 { 284 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 285 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 286 phLibNfc_eSE_EvtFieldOn, 287 pSeInfo->hSecureElement, 288 &Se_Trans_Info, 289 status); 290 break; 291 } 292 case NFC_EVT_FIELD_OFF: 293 { 294 (*pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb)( 295 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt, 296 phLibNfc_eSE_EvtFieldOff, 297 pSeInfo->hSecureElement, 298 &Se_Trans_Info, 299 status); 300 break; 301 } 302 default: 303 { 304 break; 305 } 306 } 307 } 308 else 309 { 310 311 } 312 } 313 } 314 return; 315 } 316 317 /** 318 * Unregister the Secured Element Notification. 319 */ 320 NFCSTATUS phLibNfc_SE_NtfUnregister(void) 321 { 322 NFCSTATUS Status = NFCSTATUS_SUCCESS; 323 pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 324 325 if((NULL == gpphLibContext) || 326 (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)) 327 { 328 /*Lib Nfc is not initialized*/ 329 Status = NFCSTATUS_NOT_INITIALISED; 330 } 331 else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown) 332 { 333 Status = NFCSTATUS_SHUTDOWN; 334 } 335 else 336 { 337 /*Unregister SE event notification with lower layer. 338 even some transaction happens on UICC or Smx will not 339 be notified afterworlds */ 340 Status = phHal4Nfc_UnregisterNotification( 341 pLibContext->psHwReference, 342 eRegisterSecureElement, 343 pLibContext); 344 if(Status != NFCSTATUS_SUCCESS) 345 { 346 /*Unregister failed*/ 347 Status=NFCSTATUS_FAILED; 348 } 349 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerNtfCb=NULL; 350 pLibContext->sSeContext.sSeCallabackInfo.pSeListenerCtxt=NULL; 351 } 352 return Status; 353 } 354 355 /** 356 * Get list of available Secure Elements 357 */ 358 NFCSTATUS phLibNfc_SE_GetSecureElementList( 359 phLibNfc_SE_List_t* pSE_List, 360 uint8_t* uSE_count 361 ) 362 { 363 NFCSTATUS Status = NFCSTATUS_SUCCESS; 364 uint8_t uNo_Of_SE = 0; 365 366 if((NULL == gpphLibContext) || 367 (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)) 368 { 369 Status = NFCSTATUS_NOT_INITIALISED; 370 } 371 else if((NULL ==pSE_List) || (NULL ==uSE_count)) 372 { 373 Status = NFCSTATUS_INVALID_PARAMETER; 374 } 375 else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown) 376 { 377 Status = NFCSTATUS_SHUTDOWN; 378 } 379 else 380 { 381 /*Check for which type of Secure Element is available*/ 382 if(gpphLibContext->psHwReference->uicc_connected==TRUE) 383 { 384 /* Populate the UICC type */ 385 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_Type = phLibNfc_SE_Type_UICC; 386 387 /* Populate the UICC handle */ 388 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement =(phLibNfc_Handle) 389 (LIBNFC_SE_UICC_INDEX + LIBNFC_SE_BASE_HANDLE); 390 391 #ifdef NXP_HAL_ENABLE_SMX 392 393 pSE_List[LIBNFC_SE_UICC_INDEX].eSE_Type = 394 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_Type; 395 pSE_List[LIBNFC_SE_UICC_INDEX].hSecureElement = (phLibNfc_Handle) 396 (LIBNFC_SE_UICC_INDEX + LIBNFC_SE_BASE_HANDLE); 397 pSE_List[LIBNFC_SE_UICC_INDEX].eSE_CurrentState = 398 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_CurrentState; 399 #else 400 pSE_List->eSE_Type = 401 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_Type; 402 pSE_List->hSecureElement = (phLibNfc_Handle) 403 (LIBNFC_SE_UICC_INDEX + LIBNFC_SE_BASE_HANDLE); 404 pSE_List->eSE_CurrentState = 405 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_CurrentState; 406 #endif 407 /* update the No of SE retrieved */ 408 uNo_Of_SE ++; 409 410 } 411 if (gpphLibContext->psHwReference->smx_connected ==TRUE) 412 { 413 /* if the Smx is also connected to the PN544 */ 414 /* Populate the SMX type */ 415 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_Type = phLibNfc_SE_Type_SmartMX; 416 417 /* Populate the SMX handle */ 418 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement =(phLibNfc_Handle) 419 (LIBNFC_SE_SMARTMX_INDEX + LIBNFC_SE_BASE_HANDLE); 420 pSE_List[LIBNFC_SE_SMARTMX_INDEX].eSE_Type = 421 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_Type; 422 pSE_List[LIBNFC_SE_SMARTMX_INDEX].hSecureElement = (phLibNfc_Handle) 423 (LIBNFC_SE_SMARTMX_INDEX + LIBNFC_SE_BASE_HANDLE); 424 pSE_List[LIBNFC_SE_SMARTMX_INDEX].eSE_CurrentState = 425 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_CurrentState; 426 427 /* update the No of SE retrieved */ 428 uNo_Of_SE ++; 429 430 } 431 *uSE_count = uNo_Of_SE; 432 } 433 return Status; 434 } 435 436 /** 437 * Sets secure element mode. 438 * This function configures SE to specific mode based on activation mode type 439 */ 440 441 NFCSTATUS phLibNfc_SE_SetMode ( phLibNfc_Handle hSE_Handle, 442 phLibNfc_eSE_ActivationMode eActivation_mode, 443 pphLibNfc_SE_SetModeRspCb_t pSE_SetMode_Rsp_cb, 444 void * pContext 445 ) 446 { 447 NFCSTATUS Status = NFCSTATUS_SUCCESS; 448 phHal_eEmulationType_t eEmulationType = NFC_SMARTMX_EMULATION; 449 pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)gpphLibContext; 450 451 if((NULL == gpphLibContext) || 452 (gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)) 453 { 454 Status = NFCSTATUS_NOT_INITIALISED; 455 } 456 else if((pSE_SetMode_Rsp_cb ==NULL) 457 ||(NULL == pContext)||(NULL==(void *)hSE_Handle)) 458 { 459 Status=NFCSTATUS_INVALID_PARAMETER; 460 } 461 else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown) 462 { 463 Status = NFCSTATUS_SHUTDOWN; 464 } 465 else if((pLibContext->status.GenCb_pending_status == TRUE) 466 ||(NULL!=pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCb)) 467 { 468 /*previous callback is pending still*/ 469 Status =NFCSTATUS_REJECTED; 470 } 471 else 472 { 473 switch(eActivation_mode) 474 { 475 case phLibNfc_SE_ActModeVirtual: 476 { 477 if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 478 { 479 eEmulationType = NFC_UICC_EMULATION; 480 /*Enable the UICC -External reader can see it*/ 481 pLibContext->sCardEmulCfg.config.uiccEmuCfg.enableUicc = TRUE; 482 } 483 else if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 484 { 485 eEmulationType = NFC_SMARTMX_EMULATION; 486 /*Enable the SMX -External reader can see it*/ 487 pLibContext->sCardEmulCfg.config.smartMxCfg.enableEmulation = TRUE; 488 } 489 else 490 { 491 Status=NFCSTATUS_INVALID_HANDLE; 492 } 493 if(Status==NFCSTATUS_SUCCESS) 494 { 495 if(pLibContext->sSeContext.eActivatedMode != phLibNfc_SE_ActModeWired) 496 { 497 pLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeVirtual; 498 } 499 pLibContext->sCardEmulCfg.emuType = eEmulationType; 500 Status = phHal4Nfc_ConfigParameters( 501 pLibContext->psHwReference, 502 NFC_EMULATION_CONFIG, 503 (phHal_uConfig_t*)&pLibContext->sCardEmulCfg, 504 phLibNfc_SE_SetMode_cb, 505 pLibContext); 506 } 507 } 508 break; 509 case phLibNfc_SE_ActModeVirtualVolatile: 510 { 511 if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 512 { 513 eEmulationType = NFC_SMARTMX_EMULATION; 514 /*Enable the SMX -External reader can see it*/ 515 pLibContext->sCardEmulCfg.config.smartMxCfg.enableEmulation = TRUE; 516 pLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeVirtualVolatile; 517 518 Status = phHal4Nfc_Switch_SMX_Mode( 519 pLibContext->psHwReference, 520 eSmartMx_Virtual, 521 phLibNfc_SE_SetMode_cb, 522 pLibContext 523 ); 524 } 525 else if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 526 { 527 eEmulationType = NFC_UICC_EMULATION; 528 /*Enable the UICC -External reader can see it*/ 529 pLibContext->sCardEmulCfg.config.uiccEmuCfg.enableUicc = TRUE; 530 pLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeVirtualVolatile; 531 532 Status = phHal4Nfc_Switch_Swp_Mode( 533 pLibContext->psHwReference, 534 eSWP_Switch_On, 535 phLibNfc_SE_SetMode_cb, 536 pLibContext 537 ); 538 } 539 else 540 { 541 Status = NFCSTATUS_INVALID_HANDLE; 542 } 543 } 544 break; 545 case phLibNfc_SE_ActModeDefault: 546 { 547 if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 548 { 549 Status = phHal4Nfc_Switch_SMX_Mode( 550 pLibContext->psHwReference, 551 eSmartMx_Default, 552 phLibNfc_SE_SetMode_cb, 553 pLibContext 554 ); 555 } 556 else if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 557 { 558 Status = phHal4Nfc_Switch_Swp_Mode( 559 pLibContext->psHwReference, 560 eSWP_Switch_Default, 561 phLibNfc_SE_SetMode_cb, 562 pLibContext 563 ); 564 } 565 else 566 { 567 Status = NFCSTATUS_INVALID_HANDLE; 568 } 569 } 570 break; 571 572 case phLibNfc_SE_ActModeWired: 573 { 574 if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 575 { 576 if(pLibContext->CBInfo.pClientNtfRegRespCB!=NULL) 577 { 578 /*Disable the SMX -External reader can't see it anymore*/ 579 pLibContext->sCardEmulCfg.config.smartMxCfg.enableEmulation = FALSE; 580 pLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeWired; 581 582 Status = phHal4Nfc_Switch_SMX_Mode( 583 pLibContext->psHwReference, 584 eSmartMx_Wired, 585 phLibNfc_SE_SetMode_cb, 586 pLibContext 587 ); 588 } 589 } 590 else if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 591 { 592 /*This mode is not applicable to UICC*/ 593 Status = NFCSTATUS_REJECTED; 594 } 595 else 596 { 597 Status = NFCSTATUS_INVALID_HANDLE; 598 } 599 } 600 break; 601 602 case phLibNfc_SE_ActModeOff: 603 { 604 /*UICC emulation deactivate*/ 605 if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 606 { 607 eEmulationType = NFC_UICC_EMULATION; 608 /*Disable the UICC -External reader can't see it anymore*/ 609 pLibContext->sCardEmulCfg.config.uiccEmuCfg.enableUicc = FALSE; 610 611 } 612 else if(hSE_Handle == sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 613 { 614 eEmulationType = NFC_SMARTMX_EMULATION; 615 /*Disable the SMX -External reader can't see it anymore*/ 616 pLibContext->sCardEmulCfg.config.smartMxCfg.enableEmulation=FALSE; 617 618 } 619 else 620 { 621 Status = NFCSTATUS_INVALID_HANDLE; 622 } 623 if(Status==NFCSTATUS_SUCCESS) 624 { 625 pLibContext->sCardEmulCfg.emuType = eEmulationType; 626 627 if(pLibContext->sSeContext.eActivatedMode != phLibNfc_SE_ActModeWired) 628 { 629 pLibContext->sSeContext.eActivatedMode = phLibNfc_SE_ActModeOff; 630 } 631 632 Status = phHal4Nfc_ConfigParameters(pLibContext->psHwReference, 633 NFC_EMULATION_CONFIG, 634 (phHal_uConfig_t*)&pLibContext->sCardEmulCfg, 635 phLibNfc_SE_SetMode_cb, 636 pLibContext); 637 } 638 } 639 break; 640 default: 641 Status=NFCSTATUS_INVALID_PARAMETER; 642 break; 643 644 }/*End of eActivation_mode switch */ 645 if(Status==NFCSTATUS_PENDING) 646 { 647 pLibContext->sSeContext.hSetemp=hSE_Handle; 648 pLibContext->status.GenCb_pending_status = TRUE; 649 pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCb = pSE_SetMode_Rsp_cb; 650 pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCtxt=pContext; 651 } 652 else if(Status == NFCSTATUS_INVALID_HANDLE) 653 { 654 Status= Status; 655 } 656 else 657 { 658 Status = NFCSTATUS_FAILED; 659 } 660 } 661 return Status; 662 } 663 /** 664 * Callback for Se Set mode 665 */ 666 STATIC void phLibNfc_SE_SetMode_cb(void *context, NFCSTATUS status) 667 { 668 pphLibNfc_LibContext_t pLibContext=(pphLibNfc_LibContext_t)context; 669 pphLibNfc_SE_SetModeRspCb_t pUpperLayerCb=NULL; 670 void *pUpperContext=NULL; 671 phLibNfc_Handle hSeHandle=0; 672 uint8_t TempState=FALSE; 673 674 if(pLibContext != gpphLibContext) 675 { 676 /*wrong context returned*/ 677 phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1); 678 } 679 else 680 { 681 if(eLibNfcHalStateShutdown == gpphLibContext->LibNfcState.next_state) 682 { 683 /*If shutdown is called in between allow shutdown to happen*/ 684 phLibNfc_Pending_Shutdown(); 685 status = NFCSTATUS_SHUTDOWN; 686 } 687 else 688 { 689 if(status == NFCSTATUS_SUCCESS) 690 { 691 hSeHandle = pLibContext->sSeContext.hSetemp; 692 693 if(hSeHandle == sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].hSecureElement) 694 { 695 if(TRUE==pLibContext->sCardEmulCfg.config.uiccEmuCfg.enableUicc) 696 { 697 /*If Activation mode was virtual allow external reader to see it*/ 698 pLibContext->sSeContext.uUiccActivate = TRUE; 699 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_CurrentState = phLibNfc_SE_Active; 700 } 701 else 702 { 703 /*If Activation mode was wired don't allow external reader to see it*/ 704 pLibContext->sSeContext.uUiccActivate = FALSE; 705 sSecuredElementInfo[LIBNFC_SE_UICC_INDEX].eSE_CurrentState = 706 phLibNfc_SE_Inactive; 707 } 708 status = NFCSTATUS_SUCCESS; 709 TempState = pLibContext->sSeContext.uUiccActivate; 710 } 711 else if (hSeHandle==sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].hSecureElement) 712 { 713 if(TRUE==pLibContext->sCardEmulCfg.config.smartMxCfg.enableEmulation) 714 { 715 /*If Activation mode was virtual allow external reader to see it*/ 716 pLibContext->sSeContext.uSmxActivate = TRUE; 717 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_CurrentState = 718 phLibNfc_SE_Active; 719 } 720 else 721 { 722 /*If Activation mode was wired don't allow external reader to see it*/ 723 pLibContext->sSeContext.uSmxActivate = FALSE; 724 sSecuredElementInfo[LIBNFC_SE_SMARTMX_INDEX].eSE_CurrentState= 725 phLibNfc_SE_Inactive; 726 } 727 status = NFCSTATUS_SUCCESS; 728 TempState = pLibContext->sSeContext.uSmxActivate; 729 } 730 else 731 { 732 status = NFCSTATUS_FAILED; 733 } 734 } 735 else 736 { 737 status = NFCSTATUS_FAILED; 738 } 739 pLibContext->status.GenCb_pending_status = FALSE; 740 } 741 742 } 743 pUpperLayerCb = pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCb; 744 pUpperContext = pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCtxt; 745 pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCb = NULL; 746 pLibContext->sSeContext.sSeCallabackInfo.pSEsetModeCtxt = NULL; 747 PHNFC_UNUSED_VARIABLE(TempState); 748 /* Call the upper layer cb */ 749 if(pUpperLayerCb!= NULL ) 750 { 751 (*pUpperLayerCb)(pUpperContext, 752 hSeHandle, 753 status); 754 } 755 return; 756 } 757 758 759 760
