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
phLibNfc_Mgt_ConfigureDriver(pphLibNfc_sConfig_t psConfig,void ** ppDriverHandle)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
phLibNfc_Mgt_UnConfigureDriver(void * pDriverHandle)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
phLibNfc_HW_Reset()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
phLibNfc_Download_Mode()120 NFCSTATUS phLibNfc_Download_Mode ()
121 {
122 return phDal4Nfc_Download();
123 }
124
phLibNfc_Load_Firmware_Image()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;
phLibNfc_SetIsoXchgTimeout(uint8_t timeout)134 NFCSTATUS phLibNfc_SetIsoXchgTimeout(uint8_t timeout) {
135 nxp_nfc_isoxchg_timeout = timeout;
136 return NFCSTATUS_SUCCESS;
137 }
138
phLibNfc_GetIsoXchgTimeout()139 int phLibNfc_GetIsoXchgTimeout() {
140 return nxp_nfc_isoxchg_timeout;
141 }
142
143 extern uint32_t nxp_nfc_hci_response_timeout;
phLibNfc_SetHciTimeout(uint32_t timeout_in_ms)144 NFCSTATUS phLibNfc_SetHciTimeout(uint32_t timeout_in_ms) {
145 nxp_nfc_hci_response_timeout = timeout_in_ms;
146 return NFCSTATUS_SUCCESS;
147 }
148
phLibNfc_GetHciTimeout()149 int phLibNfc_GetHciTimeout() {
150 return nxp_nfc_hci_response_timeout;
151 }
152
153 extern uint32_t nxp_nfc_felica_timeout;
phLibNfc_SetFelicaTimeout(uint8_t timeout_in_ms)154 NFCSTATUS phLibNfc_SetFelicaTimeout(uint8_t timeout_in_ms) {
155 nxp_nfc_felica_timeout = timeout_in_ms;
156 return NFCSTATUS_SUCCESS;
157 }
158
phLibNfc_GetFelicaTimeout()159 int phLibNfc_GetFelicaTimeout() {
160 return nxp_nfc_felica_timeout;
161 }
162
163 extern uint8_t nxp_nfc_mifareraw_timeout;
phLibNfc_SetMifareRawTimeout(uint8_t timeout)164 NFCSTATUS phLibNfc_SetMifareRawTimeout(uint8_t timeout) {
165 nxp_nfc_mifareraw_timeout = timeout;
166 return NFCSTATUS_SUCCESS;
167 }
168
phLibNfc_GetMifareRawTimeout()169 int phLibNfc_GetMifareRawTimeout() {
170 return nxp_nfc_mifareraw_timeout;
171 }
172
173 /**
174 * Initialize the phLibNfc interface.
175 */
176
phLibNfc_Mgt_Initialize(void * pDriverHandle,pphLibNfc_RspCb_t pInitCb,void * pContext)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 */
phLibNfc_InitCb(void * pContext,NFCSTATUS status)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*/
phLibNfc_DefaultHandler(void * context,phHal_eNotificationType_t type,phHal4Nfc_NotificationInfo_t info,NFCSTATUS status)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 */
phLibNfc_Mgt_DeInitialize(void * pDriverHandle,pphLibNfc_RspCb_t pDeInitCb,void * pContext)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 */
phLibNfc_ShutdownCb(void * pContext,NFCSTATUS status)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
phLibNfc_Pending_Shutdown(void)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 */
phLibNfc_Mgt_Reset(void * pContext)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
phLibNfc_UpdateNextState(pphLibNfc_LibContext_t pLibContext,phLibNfc_State_t next_state)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
phLibNfc_UpdateCurState(NFCSTATUS status,pphLibNfc_LibContext_t psLibContext)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
phLibNfc_Mgt_GetstackCapabilities(phLibNfc_StackCapabilities_t * phLibNfc_StackCapabilities,void * pContext)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
phLibNfc_Mgt_ConfigureTestMode(void * pDriverHandle,pphLibNfc_RspCb_t pTestModeCb,phLibNfc_Cfg_Testmode_t eTstmode,void * pContext)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