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 */
phLibNfc_SE_NtfRegister(pphLibNfc_SE_NotificationCb_t pSE_NotificationCb,void * pContext)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 */
phLibNfc_SeNotification(void * context,phHal_eNotificationType_t type,phHal4Nfc_NotificationInfo_t info,NFCSTATUS status)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 */
phLibNfc_SE_NtfUnregister(void)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 */
phLibNfc_SE_GetSecureElementList(phLibNfc_SE_List_t * pSE_List,uint8_t * uSE_count)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
phLibNfc_SE_SetMode(phLibNfc_Handle hSE_Handle,phLibNfc_eSE_ActivationMode eActivation_mode,pphLibNfc_SE_SetModeRspCb_t pSE_SetMode_Rsp_cb,void * pContext)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 */
phLibNfc_SE_SetMode_cb(void * context,NFCSTATUS status)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