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