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 * \file phHal4Nfc.c
18 * \brief Hal4Nfc source.
19 *
20 * Project: NFC-FRI 1.1
21 *
22 * $Date: Fri Jun 11 09:32:23 2010 $
23 * $Author: ing07385 $
24 * $Revision: 1.192 $
25 * $Aliases: NFC_FRI1.1_WK1023_R35_1 $
26 *
27 */
28
29 /* ---------------------------Include files ---------------------------------*/
30
31 #include <phHal4Nfc.h>
32 #include <phHal4Nfc_Internal.h>
33 #include <phOsalNfc.h>
34 #include <phHciNfc.h>
35 #include <phLlcNfc.h>
36 #include <phDal4Nfc.h>
37 #include <phDnldNfc.h>
38 #include <phOsalNfc_Timer.h>
39
40 /* ------------------------------- Macros -----------------------------------*/
41 #ifndef HAL_UNIT_TEST
42 #define STATIC static
43 #else
44 #define STATIC
45 #endif/*#ifndef UNIT_TEST*/
46 #define HAL4_LAYERS 3
47 #define LAYER_HCI 2
48 #define LAYER_LLC 1
49 #define LAYER_DAL 0
50
51 /* --------------------Structures and enumerations --------------------------*/
52
53 phHal_sHwReference_t *gpphHal4Nfc_Hwref;
54
55 static void phHal4Nfc_IoctlComplete(
56 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
57 void *pInfo
58 );
59
60 static void phHal4Nfc_LowerNotificationHandler(
61 void *pContext,
62 void *pHwRef,
63 uint8_t type,
64 void *pInfo
65 );
66 static void phHal4Nfc_HandleEvent(
67 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
68 void *pInfo
69 );
70
71 static void phHal4Nfc_OpenComplete(
72 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
73 void *pInfo
74 );
75
76 static void phHal4Nfc_CloseComplete(
77 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
78 void *pInfo
79 );
80
81 static void phHal4Nfc_DownloadComplete(
82 void *pContext,
83 void *pHwRef,
84 uint8_t type,
85 void *pInfo
86 );
87
88 static NFCSTATUS phHal4Nfc_Configure_Layers(
89 phNfcLayer_sCfg_t **pphLayer
90 );
91
92
93 /*Callback for Self tests*/
94 static void phHal4Nfc_SelfTestComplete(
95 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
96 void *pInfo
97 );
98
99 /**
100 * The open callback function to be called by the HCI when open (initializaion)
101 * sequence is completed or if there is an error in initialization.
102 * It is passed as a parameter to HCI when calling HCI Init.
103 */
104
phHal4Nfc_OpenComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)105 static void phHal4Nfc_OpenComplete(
106 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
107 void *pInfo
108 )
109 {
110 NFCSTATUS status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
111 pphHal4Nfc_GenCallback_t pUpper_OpenCb
112 = Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb;
113 void *pUpper_Context
114 = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
115 if(status == NFCSTATUS_SUCCESS)
116 {
117 PHDBG_INFO("Hal4:Open Successful");
118 #ifdef MERGE_SAK_SW1 /*Software Workaround*/
119 if(eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState)
120 {
121 status = phHciNfc_System_Configure (
122 Hal4Ctxt->psHciHandle,
123 (void *)gpphHal4Nfc_Hwref,
124 PH_HAL4NFC_TGT_MERGE_ADDRESS,
125 PH_HAL4NFC_TGT_MERGE_SAK /*config value*/
126 );
127 }
128 if(NFCSTATUS_PENDING != status)
129 #endif/*#ifdef MERGE_SAK_SW1*/
130 {
131 /*Update State*/
132 Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState;
133 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
134 Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb = NULL;
135 if(NULL != pUpper_OpenCb)
136 {
137 /*Upper layer's Open Cb*/
138 (*pUpper_OpenCb)(Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
139 NFCSTATUS_SUCCESS
140 );
141 }
142 }
143 }
144 else/*Open did not succeed.Go back to reset state*/
145 {
146 Hal4Ctxt->Hal4CurrentState = eHal4StateClosed;
147 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
148 Hal4Ctxt->psHciHandle = NULL;
149 phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg);
150 Hal4Ctxt->pHal4Nfc_LayerCfg = NULL;
151 phOsalNfc_FreeMemory((void *)Hal4Ctxt);
152 gpphHal4Nfc_Hwref->hal_context = NULL;
153 gpphHal4Nfc_Hwref = NULL;
154 PHDBG_INFO("Hal4:Open Failed");
155 /*Call upper layer's Open Cb with error status*/
156 if(NULL != pUpper_OpenCb)
157 {
158 /*Upper layer's Open Cb*/
159 (*pUpper_OpenCb)(pUpper_Context,status);
160 }
161 }
162 return;
163 }
164
165 /**
166 * The close callback function called by the HCI when close sequence is
167 * completed or if there is an error in closing.
168 * It is passed as a parameter to HCI when calling HCI Release.
169 */
phHal4Nfc_CloseComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)170 static void phHal4Nfc_CloseComplete(
171 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
172 void *pInfo
173 )
174 {
175 NFCSTATUS status= ((phNfc_sCompletionInfo_t *)pInfo)->status;
176 pphHal4Nfc_GenCallback_t pUpper_CloseCb;
177 void *pUpper_Context;
178 uint8_t RemoteDevNumber = 0;
179 pUpper_CloseCb = Hal4Ctxt->sUpperLayerInfo.pUpperCloseCb;
180 pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
181 /*Update state*/
182 Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState;
183 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
184 /*If Closed successfully*/
185 if(NFCSTATUS_SUCCESS == status)
186 {
187 Hal4Ctxt->psHciHandle = NULL;
188 /*Free all heap allocations*/
189 phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg);
190 Hal4Ctxt->pHal4Nfc_LayerCfg = NULL;
191 /*Free ADD context info*/
192 if(NULL != Hal4Ctxt->psADDCtxtInfo)
193 {
194 while(RemoteDevNumber < MAX_REMOTE_DEVICES)
195 {
196 if(NULL != Hal4Ctxt->rem_dev_list[RemoteDevNumber])
197 {
198 phOsalNfc_FreeMemory((void *)
199 (Hal4Ctxt->rem_dev_list[RemoteDevNumber]));
200 Hal4Ctxt->rem_dev_list[RemoteDevNumber] = NULL;
201 }
202 RemoteDevNumber++;
203 }
204 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
205 phOsalNfc_FreeMemory(Hal4Ctxt->psADDCtxtInfo);
206 }/*if(NULL != Hal4Ctxt->psADDCtxtInfo)*/
207 /*Free Trcv context info*/
208 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
209 {
210 if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
211 {
212 phOsalNfc_FreeMemory(
213 Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer
214 );
215 }
216 if((NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
217 && (NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData))
218 {
219 phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData);
220 }
221 phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo);
222 }/*if(NULL != Hal4Ctxt->psTrcvCtxtInfo)*/
223 /*Free Hal context and Hardware reference*/
224 gpphHal4Nfc_Hwref->hal_context = NULL;
225 gpphHal4Nfc_Hwref = NULL;
226 phOsalNfc_FreeMemory((void *)Hal4Ctxt);
227 }/* if(NFCSTATUS_SUCCESS == status)*/
228 /*Call Upper layer's Close Cb with status*/
229 (*pUpper_CloseCb)(pUpper_Context,status);
230 return;
231 }
232
233
234 /*
235 * For configuring the various layers during the Initialization call
236 *
237 *
238 */
239 static
240 NFCSTATUS
phHal4Nfc_Configure_Layers(phNfcLayer_sCfg_t ** pphLayer)241 phHal4Nfc_Configure_Layers(
242 phNfcLayer_sCfg_t **pphLayer
243 )
244 {
245 uint8_t index = HAL4_LAYERS - 1;
246 uint8_t i = 0;
247 NFCSTATUS status = NFCSTATUS_SUCCESS ;
248 PHDBG_INFO("Hal4:Configuring layers");
249 *pphLayer = (phNfcLayer_sCfg_t *) phOsalNfc_GetMemory(
250 sizeof(phNfcLayer_sCfg_t) * HAL4_LAYERS);
251
252 if( NULL == *pphLayer)
253 {
254 status = PHNFCSTVAL(CID_NFC_HAL,
255 NFCSTATUS_INSUFFICIENT_RESOURCES);/*Memory allocation error*/
256 }
257 else
258 {
259
260 (void)memset((void *)*pphLayer,0,(
261 sizeof(phNfcLayer_sCfg_t) * HAL4_LAYERS));
262
263 for(i=0 ; i < HAL4_LAYERS ;i++, index-- )
264 {
265 (*pphLayer + i)->layer_index = index;
266 switch(index)
267 {
268 case LAYER_HCI: /*Configure Hci*/
269 {
270 (*pphLayer+i)->layer_name =(uint8_t *) "Hci";
271 (*pphLayer+i)->layer_registry = NULL;
272 (*pphLayer+i)->layer_next =
273 (((phNfcLayer_sCfg_t *)*pphLayer) + i + 1);
274 break;
275 }
276 case LAYER_LLC:/*Configure LLC*/
277 {
278 (*pphLayer+i)->layer_registry = phLlcNfc_Register;
279 (*pphLayer+i)->layer_name = (uint8_t *)"Llc";
280 (*pphLayer+i)->layer_next =
281 (((phNfcLayer_sCfg_t *)*pphLayer) + i + 1);
282 break;
283 }
284 case LAYER_DAL: /*Configure the DAL*/
285 {
286 (*pphLayer+i)->layer_registry = phDal4Nfc_Register;
287 (*pphLayer+i)->layer_name = (uint8_t *)"Dal";
288 (*pphLayer+i)->layer_next = NULL ;
289 break;
290 }
291 default:
292 break;
293 } /* End of Switch */
294 } /* End of For Loop */
295 } /* End of NULL Check */
296
297 return status ;
298 }
299
300
301
302 #ifdef ANDROID
303
304 #define LOG_TAG "NFC-HCI"
305
306 #include <utils/Log.h>
307 #include <dlfcn.h>
308
309 const unsigned char *nxp_nfc_full_version;
310 const unsigned char *nxp_nfc_fw;
311
dlopen_firmware()312 int dlopen_firmware() {
313 void *p;
314
315 void *handle = dlopen("/system/lib/libpn544_fw.so", RTLD_NOW);
316 if (handle == NULL) {
317 LOGE("Could not open libpn544.so");
318 return -1;
319 }
320
321 p = dlsym(handle, "nxp_nfc_full_version");
322 if (p == NULL) {
323 LOGE("Could not link nxp_nfc_full_version");
324 return -1;
325 }
326 nxp_nfc_full_version = (unsigned char *)p;
327
328 p = dlsym(handle, "nxp_nfc_fw");
329 if (p == NULL) {
330 LOGE("Could not link nxp_nfc_fw");
331 return -1;
332 }
333 nxp_nfc_fw = (unsigned char *)p;
334
335 return 0;
336 }
337 #endif
338
339 /**
340 * The open function called by the upper HAL when HAL4 is to be opened
341 * (initialized).
342 *
343 */
phHal4Nfc_Open(phHal_sHwReference_t * psHwReference,phHal4Nfc_InitType_t InitType,pphHal4Nfc_GenCallback_t pOpenCallback,void * pContext)344 NFCSTATUS phHal4Nfc_Open(
345 phHal_sHwReference_t *psHwReference,
346 phHal4Nfc_InitType_t InitType,
347 pphHal4Nfc_GenCallback_t pOpenCallback,
348 void *pContext
349 )
350 {
351 NFCSTATUS openRetVal = NFCSTATUS_SUCCESS;
352 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
353 phHciNfc_Init_t eHciInitType = (phHciNfc_Init_t)InitType;
354 /*Set Default Clock settings once*/
355 static phHal_sHwConfig_t sHwConfig = {
356 {0},
357 NXP_DEFAULT_CLK_REQUEST,
358 NXP_DEFAULT_INPUT_CLK
359 };
360 /*NULL checks*/
361 if(NULL == psHwReference || NULL == pOpenCallback)
362 {
363 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
364 openRetVal = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
365 }
366 else if(NULL != gpphHal4Nfc_Hwref)
367 {
368 /*Hal4 context is open or open in progress ,return Ctxt already open*/
369 openRetVal = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_ALREADY_INITIALISED);
370 }
371 else/*Do an initialization*/
372 {
373 #ifdef ANDROID
374 dlopen_firmware();
375 #endif
376
377 /*If hal4 ctxt in Hwreference is NULL create a new context*/
378 if(NULL == ((phHal_sHwReference_t *)psHwReference)->hal_context)
379 {
380 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)
381 phOsalNfc_GetMemory((uint32_t)sizeof(
382 phHal4Nfc_Hal4Ctxt_t)
383 );
384 ((phHal_sHwReference_t *)psHwReference)->hal_context = Hal4Ctxt;
385 }
386 else/*Take context from Hw reference*/
387 {
388 Hal4Ctxt = ((phHal_sHwReference_t *)psHwReference)->hal_context;
389 }
390 if(NULL == Hal4Ctxt)
391 {
392 openRetVal = PHNFCSTVAL(CID_NFC_HAL,
393 NFCSTATUS_INSUFFICIENT_RESOURCES);
394 }
395 else
396 {
397 (void)memset((void *)Hal4Ctxt,
398 0,
399 ((uint32_t)sizeof(phHal4Nfc_Hal4Ctxt_t)));
400 /* Configure layers if not configured */
401 if( NULL == Hal4Ctxt->pHal4Nfc_LayerCfg )
402 {
403 openRetVal = phHal4Nfc_Configure_Layers(
404 &(Hal4Ctxt->pHal4Nfc_LayerCfg)
405 );
406 }
407
408 if( openRetVal == NFCSTATUS_SUCCESS )
409 {
410 /*update Next state*/
411 Hal4Ctxt->Hal4NextState = (HCI_NFC_DEVICE_TEST == eHciInitType?
412 eHal4StateSelfTestMode:eHal4StateOpenAndReady);
413 /*Store callback and context ,and set Default settings in Context*/
414 Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb = pOpenCallback;
415 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
416 Hal4Ctxt->sTgtConnectInfo.EmulationState = NFC_EVT_DEACTIVATED;
417 gpphHal4Nfc_Hwref = psHwReference;
418 PHDBG_INFO("Hal4:Calling Hci-Init");
419 openRetVal = phHciNfc_Initialise (
420 (void *)&Hal4Ctxt->psHciHandle,
421 psHwReference,
422 eHciInitType,
423 &sHwConfig,
424 (pphNfcIF_Notification_CB_t)
425 phHal4Nfc_LowerNotificationHandler,
426 (void *)Hal4Ctxt,
427 Hal4Ctxt->pHal4Nfc_LayerCfg
428 );
429 /*Hci Init did not succeed.free Resources and return*/
430 if( (openRetVal != NFCSTATUS_SUCCESS)
431 && (PHNFCSTATUS (openRetVal) != NFCSTATUS_PENDING) )
432 {
433 phOsalNfc_FreeMemory(Hal4Ctxt->pHal4Nfc_LayerCfg);
434 phOsalNfc_FreeMemory(Hal4Ctxt);
435 Hal4Ctxt = NULL;
436 }
437 }/*if( openRetVal == NFCSTATUS_SUCCESS )*/
438 else/*Free the context*/
439 {
440 phOsalNfc_FreeMemory(Hal4Ctxt);
441 }/*else*/
442 }
443 }
444 return openRetVal;
445 }
446
447 /** The I/O Control function allows the caller to use (vendor-) specific
448 * functionality provided by the lower layer or by the hardware. */
phHal4Nfc_Ioctl(phHal_sHwReference_t * psHwReference,uint32_t IoctlCode,phNfc_sData_t * pInParam,phNfc_sData_t * pOutParam,pphHal4Nfc_IoctlCallback_t pIoctlCallback,void * pContext)449 NFCSTATUS phHal4Nfc_Ioctl(
450 phHal_sHwReference_t *psHwReference,
451 uint32_t IoctlCode,
452 phNfc_sData_t *pInParam,
453 phNfc_sData_t *pOutParam,
454 pphHal4Nfc_IoctlCallback_t pIoctlCallback,
455 void *pContext
456 )
457 {
458 NFCSTATUS RetStatus = NFCSTATUS_FAILED;
459 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
460 uint32_t config_type = 0;
461 uint8_t ind = 0;
462 /*NULL checks*/
463 if((NULL == psHwReference)
464 || (NULL == pIoctlCallback)
465 )
466 {
467 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
468 RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
469 }
470 /*Only the Ioctls NFC_FW_DOWNLOAD_CHECK and NFC_FW_DOWNLOAD are allowed in
471 the uninitialized state of HAL*/
472 else if(NULL == psHwReference->hal_context)
473 {
474 #ifdef FW_DOWNLOAD
475
476 #if !defined (NXP_FW_INTEGRITY_VERIFY)
477 if(NFC_FW_DOWNLOAD_CHECK == IoctlCode)
478 {
479 RetStatus = phDnldNfc_Run_Check(
480 psHwReference
481 );
482 }
483 else
484 #endif /* !defined (NXP_FW_INTEGRITY_VERIFY) */
485 if((NFC_FW_DOWNLOAD == IoctlCode)
486 &&(NULL == gpphHal4Nfc_Hwref))/*Indicates current state is shutdown*/
487 {
488 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)
489 phOsalNfc_GetMemory((uint32_t)sizeof(
490 phHal4Nfc_Hal4Ctxt_t)
491 );
492 if(NULL == Hal4Ctxt)
493 {
494 RetStatus = PHNFCSTVAL(CID_NFC_HAL,
495 NFCSTATUS_INSUFFICIENT_RESOURCES);
496 }
497 else
498 {
499 ((phHal_sHwReference_t *)psHwReference)->hal_context
500 = Hal4Ctxt;
501 (void)memset((void *)Hal4Ctxt,
502 0,
503 ((uint32_t)sizeof(phHal4Nfc_Hal4Ctxt_t)));
504 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
505 Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb
506 = pIoctlCallback;/*Register upper layer callback*/
507 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam = pOutParam;
508 /*Upgrade the firmware*/
509 RetStatus = phDnldNfc_Upgrade (
510 psHwReference,
511 phHal4Nfc_DownloadComplete,
512 Hal4Ctxt
513 );
514 if((NFCSTATUS_SUCCESS == RetStatus)
515 || (NFCSTATUS_PENDING != PHNFCSTATUS(RetStatus))
516 )
517 {
518 phOsalNfc_FreeMemory(Hal4Ctxt);
519 ((phHal_sHwReference_t *)psHwReference)->hal_context = NULL;
520 }
521 }
522 }
523 else
524 #endif/*NFC_FW_DOWNLOAD*/
525 {
526 RetStatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
527 }
528 }
529 else/*Status is Initialised*/
530 {
531 /*Register upper layer context*/
532 Hal4Ctxt = psHwReference->hal_context;
533 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam = pOutParam;
534 switch(IoctlCode)
535 {
536 /*Self test Ioctls*/
537 case DEVMGMT_ANTENNA_TEST:
538 case DEVMGMT_SWP_TEST:
539 case DEVMGMT_NFCWI_TEST:
540 if(eHal4StateSelfTestMode ==Hal4Ctxt->Hal4CurrentState)
541 {
542 RetStatus = phHciNfc_System_Test(
543 Hal4Ctxt->psHciHandle,
544 (void *)psHwReference,
545 IoctlCode ,
546 pInParam
547 );
548 }
549 break;
550 /*PRBS Test*/
551 case DEVMGMT_PRBS_TEST:
552 RetStatus = phHciNfc_PRBS_Test(
553 Hal4Ctxt->psHciHandle,
554 (void *)psHwReference,
555 IoctlCode ,
556 pInParam
557 );
558 break;
559 /*To Set Antenna Power Level*/
560 case NFC_ANTENNA_CWG:
561 if(eHal4StateSelfTestMode ==Hal4Ctxt->Hal4CurrentState)
562 {
563 RetStatus = phHciNfc_System_Configure (
564 Hal4Ctxt->psHciHandle,
565 (void *)psHwReference,
566 NFC_ANTENNA_CWG,
567 pInParam->buffer[0] /**Set Power Level*/
568 );
569
570 }
571 break;
572 /*Not allowed when Init is complete*/
573 case NFC_FW_DOWNLOAD_CHECK:
574 case NFC_FW_DOWNLOAD:
575 RetStatus = PHNFCSTVAL(CID_NFC_HAL,
576 NFCSTATUS_BUSY);
577 break;
578 /*Gpio read*/
579 case NFC_GPIO_READ:
580 /* if(eHal4StateSelfTestMode == Hal4Ctxt->Hal4CurrentState) */
581 {
582 RetStatus = phHciNfc_System_Get_Info(
583 Hal4Ctxt->psHciHandle,
584 (void *)psHwReference,
585 IoctlCode ,
586 pOutParam->buffer
587 );
588 }
589 break;
590 /*Used to Read Memory/Registers .3 bytes of Array passed form the
591 address to read from in MSB first format.*/
592 case NFC_MEM_READ:
593 {
594 if((NULL != pInParam)
595 && (pInParam->length == 3))
596 {
597 for( ind = 0; ind < 3; ind++ )
598 {
599 config_type = ((config_type << BYTE_SIZE )
600 | (pInParam->buffer[ind] ));
601 }
602 RetStatus = phHciNfc_System_Get_Info(
603 Hal4Ctxt->psHciHandle,
604 (void *)psHwReference,
605 config_type ,
606 pOutParam->buffer
607 );
608 }
609 else
610 {
611 RetStatus = PHNFCSTVAL(CID_NFC_HAL,
612 NFCSTATUS_INVALID_PARAMETER);
613 }
614 }
615 break;
616 /*Used to Write Memory/Registers .First 3 bytes of Array passed in MSB
617 first format form the address to write to.The 4th Byte is the 8 bit
618 value to be written to the address*/
619 case NFC_MEM_WRITE:
620 {
621 if((NULL != pInParam)
622 && (pInParam->length == 4))
623 {
624 for( ind = 0; ind < 3; ind++ )
625 {
626 config_type = ((config_type << BYTE_SIZE )
627 | (pInParam->buffer[ind] ));
628 }
629 RetStatus = phHciNfc_System_Configure (
630 Hal4Ctxt->psHciHandle,
631 (void *)psHwReference,
632 config_type,
633 pInParam->buffer[3] /*config value*/
634 );
635 }
636 else
637 {
638 RetStatus = PHNFCSTVAL(CID_NFC_HAL ,
639 NFCSTATUS_INVALID_PARAMETER);
640 }
641 }
642 break;
643 default:
644 break;
645 }
646 if(NFCSTATUS_PENDING == RetStatus)/*Callback Pending*/
647 {
648 /*Register upper layer callback and context*/
649 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
650 Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb= pIoctlCallback;
651 /*Store the Ioctl code*/
652 Hal4Ctxt->Ioctl_Type = IoctlCode;
653 }
654 }
655 return RetStatus;
656 }
657
658
659 /**
660 * The close function called by the upper layer when HAL4 is to be closed
661 * (shutdown).
662 */
phHal4Nfc_Close(phHal_sHwReference_t * psHwReference,pphHal4Nfc_GenCallback_t pCloseCallback,void * pContext)663 NFCSTATUS phHal4Nfc_Close(
664 phHal_sHwReference_t *psHwReference,
665 pphHal4Nfc_GenCallback_t pCloseCallback,
666 void *pContext
667 )
668 {
669 NFCSTATUS closeRetVal = NFCSTATUS_SUCCESS;
670 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
671 /*NULL checks*/
672 if(NULL == psHwReference || NULL == pCloseCallback)
673 {
674 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
675 closeRetVal = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
676 }
677 else if((NULL == psHwReference->hal_context)
678 || (((phHal4Nfc_Hal4Ctxt_t *)
679 psHwReference->hal_context)->Hal4CurrentState
680 < eHal4StateSelfTestMode)
681 || (((phHal4Nfc_Hal4Ctxt_t *)
682 psHwReference->hal_context)->Hal4NextState
683 == eHal4StateClosed))
684 {
685 /*return already closed*/
686 closeRetVal= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
687 }
688 else /*Close the HAL*/
689 {
690 /*Get Hal4 context from Hw reference*/
691 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)((phHal_sHwReference_t *)
692 psHwReference)->hal_context;
693 /*Unregister Tag Listener*/
694 if(NULL != Hal4Ctxt->psADDCtxtInfo)
695 {
696 Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL;
697 }
698 /*store Callback and Context*/
699 Hal4Ctxt->sUpperLayerInfo.pUpperCloseCb = pCloseCallback;
700 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
701 /*Call Hci Release*/
702 PHDBG_INFO("Hal4:Calling Hci Release");
703 closeRetVal =(NFCSTATUS)phHciNfc_Release(
704 (void *)Hal4Ctxt->psHciHandle,
705 psHwReference,
706 (pphNfcIF_Notification_CB_t)
707 phHal4Nfc_LowerNotificationHandler,
708 (void *)Hal4Ctxt
709 );
710 /*Update Next state and exit*/
711 if( PHNFCSTATUS (closeRetVal) == NFCSTATUS_PENDING )
712 {
713 Hal4Ctxt->Hal4NextState = eHal4StateClosed;
714 Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL;
715 }
716 else
717 {
718
719 }
720 }
721 return closeRetVal;
722 }
723
724 /*Forcibly shutdown the HAl4.Frees all Resources in use by Hal4 before shutting
725 down*/
phHal4Nfc_Hal4Reset(phHal_sHwReference_t * pHwRef,void * pContext)726 void phHal4Nfc_Hal4Reset(
727 phHal_sHwReference_t *pHwRef,
728 void *pContext
729 )
730 {
731 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
732 NFCSTATUS closeRetVal = NFCSTATUS_SUCCESS;
733 uint8_t RemoteDevNumber = 0;
734 if(pHwRef ==NULL)
735 {
736 closeRetVal = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
737 }
738 else if(pHwRef->hal_context != NULL)
739 {
740 /*Get the Hal context*/
741 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pHwRef->hal_context;
742 /*store the upper layer context*/
743 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
744 Hal4Ctxt->Hal4NextState = eHal4StateClosed;
745 Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL;
746 /*Call Hci Release*/
747 PHDBG_INFO("Hal4:Calling Hci Release");
748 closeRetVal =(NFCSTATUS)phHciNfc_Release(
749 (void *)Hal4Ctxt->psHciHandle,
750 pHwRef,
751 (pphNfcIF_Notification_CB_t)NULL,
752 (void *)Hal4Ctxt
753 );/*Clean up Hci*/
754 Hal4Ctxt->Hal4CurrentState = eHal4StateClosed;
755 phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg);
756 Hal4Ctxt->pHal4Nfc_LayerCfg = NULL;
757 /*Free ADD context*/
758 if(NULL != Hal4Ctxt->psADDCtxtInfo)
759 {
760 Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL;
761 while(RemoteDevNumber < MAX_REMOTE_DEVICES)
762 {
763 if(NULL != Hal4Ctxt->rem_dev_list[RemoteDevNumber])
764 {
765 phOsalNfc_FreeMemory((void *)
766 (Hal4Ctxt->rem_dev_list[RemoteDevNumber]));
767 Hal4Ctxt->rem_dev_list[RemoteDevNumber] = NULL;
768 }
769 RemoteDevNumber++;
770 }
771 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
772 phOsalNfc_FreeMemory(Hal4Ctxt->psADDCtxtInfo);
773 }
774 /*Free Trcv context*/
775 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
776 {
777 if(NULL != Hal4Ctxt->psTrcvCtxtInfo->sLowerRecvData.buffer)
778 {
779 phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo
780 ->sLowerRecvData.buffer);
781 }
782 if((NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
783 && (NULL != Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData))
784 {
785 phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo->psUpperSendData);
786 }
787 phOsalNfc_FreeMemory(Hal4Ctxt->psTrcvCtxtInfo);
788 }
789 phOsalNfc_FreeMemory(Hal4Ctxt);/*Free the context*/
790 pHwRef->hal_context = NULL;
791 gpphHal4Nfc_Hwref = NULL;
792 }
793 else
794 {
795 /*Hal4 Context is already closed.Return Success*/
796 }
797 /*Reset Should always return Success*/
798 if(closeRetVal != NFCSTATUS_SUCCESS)
799 {
800 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
801 }
802 return;
803 }
804
805 /**
806 * \if hal
807 * \ingroup grp_hal_common
808 * \else
809 * \ingroup grp_mw_external_hal_funcs
810 * \endif
811 *
812 * Retrieves the capabilities of the device represented by the Hardware
813 * Reference parameter.
814 * The HW, SW versions, the MTU and other mandatory information are located
815 * inside the pDevCapabilities parameter.
816 */
phHal4Nfc_GetDeviceCapabilities(phHal_sHwReference_t * psHwReference,phHal_sDeviceCapabilities_t * psDevCapabilities,void * pContext)817 NFCSTATUS phHal4Nfc_GetDeviceCapabilities(
818 phHal_sHwReference_t *psHwReference,
819 phHal_sDeviceCapabilities_t *psDevCapabilities,
820 void *pContext
821 )
822 {
823 NFCSTATUS retstatus = NFCSTATUS_SUCCESS;
824 /*NULL checks*/
825 if(psDevCapabilities == NULL || psHwReference == NULL || pContext == NULL)
826 {
827 retstatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_INVALID_PARAMETER);
828 }
829 /*Check for Initialized state*/
830 else if((NULL == psHwReference->hal_context)
831 || (((phHal4Nfc_Hal4Ctxt_t *)
832 psHwReference->hal_context)->Hal4CurrentState
833 < eHal4StateOpenAndReady)
834 || (((phHal4Nfc_Hal4Ctxt_t *)
835 psHwReference->hal_context)->Hal4NextState
836 == eHal4StateClosed))
837 {
838 retstatus = PHNFCSTVAL(CID_NFC_HAL ,NFCSTATUS_NOT_INITIALISED);
839 }
840 else/*Provide Device capabilities and Version Info to the caller*/
841 {
842 (void)memcpy((void *)psDevCapabilities,
843 (void *)&(psHwReference->device_info),
844 sizeof(phHal_sDeviceCapabilities_t));
845 psDevCapabilities->ReaderSupProtocol.Felica = TRUE;
846 psDevCapabilities->ReaderSupProtocol.ISO14443_4A = TRUE;
847 psDevCapabilities->ReaderSupProtocol.ISO14443_4B = TRUE;
848 psDevCapabilities->ReaderSupProtocol.ISO15693 = TRUE;
849 psDevCapabilities->ReaderSupProtocol.Jewel = TRUE;
850 psDevCapabilities->ReaderSupProtocol.MifareStd = TRUE;
851 psDevCapabilities->ReaderSupProtocol.MifareUL = TRUE;
852 psDevCapabilities->ReaderSupProtocol.NFC = TRUE;
853 psDevCapabilities->EmulationSupProtocol.Felica = FALSE;
854 psDevCapabilities->EmulationSupProtocol.ISO14443_4A = FALSE;
855 psDevCapabilities->EmulationSupProtocol.ISO14443_4B = FALSE;
856 psDevCapabilities->EmulationSupProtocol.ISO15693 = FALSE;
857 psDevCapabilities->EmulationSupProtocol.Jewel = FALSE;
858 psDevCapabilities->EmulationSupProtocol.MifareStd = FALSE;
859 psDevCapabilities->EmulationSupProtocol.MifareUL = FALSE;
860 psDevCapabilities->EmulationSupProtocol.NFC = TRUE;
861 psDevCapabilities->hal_version = (
862 (((PH_HAL4NFC_INTERFACE_VERSION << BYTE_SIZE)
863 |(PH_HAL4NFC_INTERFACE_REVISION)<<BYTE_SIZE)
864 |(PH_HAL4NFC_INTERFACE_PATCH)<<BYTE_SIZE)
865 |PH_HAL4NFC_INTERAFECE_BUILD
866 );
867 }
868 return retstatus;
869 }
870
871 /*
872 * Handles all notifications received from HCI layer.
873 *
874 */
phHal4Nfc_LowerNotificationHandler(void * pContext,void * pHwRef,uint8_t type,void * pInfo)875 static void phHal4Nfc_LowerNotificationHandler(
876 void *pContext,
877 void *pHwRef,
878 uint8_t type,
879 void *pInfo
880 )
881 {
882 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
883 if((NULL == pInfo) || (NULL == pHwRef)
884 || (NULL == pContext))
885 {
886 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
887 }
888 else
889 {
890 /*A copy of hardware reference is maintained in HAL for comparing passed
891 and returned context.Set to NULL after a Shutdown*/
892 if(NULL != gpphHal4Nfc_Hwref)/*Get context from Hw ref*/
893 {
894 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)gpphHal4Nfc_Hwref->hal_context;
895 if(NFC_INVALID_RELEASE_TYPE == Hal4Ctxt->sTgtConnectInfo.ReleaseType)
896 {
897 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext;
898 gpphHal4Nfc_Hwref = (phHal_sHwReference_t *)pHwRef;
899 }
900 }
901 else/*No Copy of Hw ref in HAL.Copy both Hwref and Hal context passed
902 by Hci*/
903 {
904 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext;
905 gpphHal4Nfc_Hwref = (phHal_sHwReference_t *)pHwRef;
906 }
907 /*Check the type of notification received from Hci and handle it
908 accordingly*/
909 switch(type)
910 {
911 case NFC_NOTIFY_INIT_COMPLETED:
912 case NFC_NOTIFY_INIT_FAILED:
913 phHal4Nfc_OpenComplete(Hal4Ctxt,pInfo);
914 break;
915 case NFC_IO_SUCCESS:
916 case NFC_IO_ERROR:
917 phHal4Nfc_IoctlComplete(Hal4Ctxt,pInfo);
918 break;
919 case NFC_NOTIFY_RESULT:
920 phHal4Nfc_SelfTestComplete(Hal4Ctxt,pInfo);
921 break;
922 case NFC_NOTIFY_DEINIT_COMPLETED:
923 case NFC_NOTIFY_DEINIT_FAILED:
924 phHal4Nfc_CloseComplete(Hal4Ctxt,pInfo);
925 break;
926 case NFC_NOTIFY_POLL_ENABLED:
927 case NFC_NOTIFY_POLL_DISABLED:
928 case NFC_NOTIFY_POLL_RESTARTED:
929 case NFC_NOTIFY_CONFIG_ERROR:
930 case NFC_NOTIFY_CONFIG_SUCCESS:
931 phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type);
932 break;
933 case NFC_NOTIFY_TARGET_DISCOVERED:
934 case NFC_NOTIFY_DISCOVERY_ERROR:
935 phHal4Nfc_TargetDiscoveryComplete(Hal4Ctxt,pInfo);
936 break;
937 case NFC_NOTIFY_TARGET_REACTIVATED:
938 phHal4Nfc_ReactivationComplete(Hal4Ctxt,pInfo);
939 break;
940 case NFC_NOTIFY_EVENT:
941 PHDBG_INFO("Hal4:Calling Event callback");
942 phHal4Nfc_HandleEvent(Hal4Ctxt,pInfo);
943 break;
944 case NFC_NOTIFY_TARGET_CONNECTED:
945 PHDBG_INFO("Hal4:Calling Hal4 Connect complete");
946 phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo);
947 break;
948
949 case NFC_NOTIFY_TARGET_DISCONNECTED:
950 {
951 PHDBG_INFO("Hal4:Target Disconnected");
952 if(Hal4Ctxt->Hal4NextState == eHal4StatePresenceCheck)
953 {
954 phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo);
955 }
956 else
957 {
958 phHal4Nfc_DisconnectComplete(Hal4Ctxt,pInfo);
959 }
960 break;
961 }
962 case NFC_NOTIFY_TRANSCEIVE_COMPLETED:
963 case NFC_NOTIFY_TRANSCEIVE_ERROR :
964 PHDBG_INFO("Hal4:Transceive Callback");
965 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
966 {
967 #ifdef TRANSACTION_TIMER
968 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
969 != PH_OSALNFC_INVALID_TIMER_ID)
970 {
971 phOsalNfc_Timer_Stop(
972 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
973 );
974 phOsalNfc_Timer_Delete(
975 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
976 );
977 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
978 = PH_OSALNFC_INVALID_TIMER_ID;
979 }
980 #endif /*TRANSACTION_TIMER*/
981 phHal4Nfc_TransceiveComplete(Hal4Ctxt,pInfo);
982 }
983 break;
984 case NFC_NOTIFY_SEND_COMPLETED :
985 PHDBG_INFO("Hal4:NfcIp1 Send Callback");
986 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
987 {
988 phHal4Nfc_SendCompleteHandler(Hal4Ctxt,pInfo);
989 }
990 break;
991 case NFC_NOTIFY_TRANSACTION :
992 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
993 break;
994 case NFC_NOTIFY_RECV_ERROR :
995 case NFC_NOTIFY_RECV_EVENT :
996 PHDBG_INFO("Hal4:Receive Event");
997 if(NULL != Hal4Ctxt->psTrcvCtxtInfo)
998 {
999 if(Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
1000 != PH_OSALNFC_INVALID_TIMER_ID)
1001 {
1002 phOsalNfc_Timer_Stop(
1003 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
1004 );
1005 phOsalNfc_Timer_Delete(
1006 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
1007 );
1008 Hal4Ctxt->psTrcvCtxtInfo->TransactionTimerId
1009 = PH_OSALNFC_INVALID_TIMER_ID;
1010 }
1011 }
1012 phHal4Nfc_RecvCompleteHandler(Hal4Ctxt,pInfo);
1013 break;
1014 case NFC_NOTIFY_TARGET_PRESENT:
1015 phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo);
1016 break;
1017 case NFC_NOTIFY_DEVICE_ERROR:
1018 {
1019 NFCSTATUS status = NFCSTATUS_BOARD_COMMUNICATION_ERROR;
1020 pphHal4Nfc_GenCallback_t pUpper_OpenCb
1021 = Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb;
1022 void *pUpper_Context
1023 = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
1024 static phHal4Nfc_NotificationInfo_t uNotificationInfo;
1025 if(NULL != Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler)
1026 {
1027 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
1028 Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler(
1029 Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt,
1030 NFC_EVENT_NOTIFICATION,
1031 uNotificationInfo,
1032 NFCSTATUS_BOARD_COMMUNICATION_ERROR
1033 );
1034 }
1035 else if (( eHal4StateSelfTestMode == Hal4Ctxt->Hal4NextState )
1036 || ( eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState ) )
1037 {
1038 Hal4Ctxt->Hal4CurrentState = eHal4StateClosed;
1039 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
1040 (void)phHciNfc_Release((void *)Hal4Ctxt->psHciHandle,
1041 pHwRef, (pphNfcIF_Notification_CB_t)NULL,
1042 (void *)Hal4Ctxt);/*Clean up Hci*/
1043 Hal4Ctxt->psHciHandle = NULL;
1044 phOsalNfc_FreeMemory((void *)Hal4Ctxt->pHal4Nfc_LayerCfg);
1045 Hal4Ctxt->pHal4Nfc_LayerCfg = NULL;
1046 phOsalNfc_FreeMemory((void *)Hal4Ctxt);
1047 gpphHal4Nfc_Hwref->hal_context = NULL;
1048 gpphHal4Nfc_Hwref = NULL;
1049 PHDBG_INFO("Hal4:Open Failed");
1050 /*Call upper layer's Open Cb with error status*/
1051 if(NULL != pUpper_OpenCb)
1052 {
1053 /*Upper layer's Open Cb*/
1054 (*pUpper_OpenCb)(pUpper_Context,status);
1055 }
1056 }
1057 else
1058 {
1059 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
1060 phOsalNfc_RaiseException(phOsalNfc_e_UnrecovFirmwareErr,1);
1061 }
1062 break;
1063 }
1064 case NFC_NOTIFY_CONNECT_FAILED:
1065 case NFC_NOTIFY_DISCONNECT_FAILED:
1066 /*Generic Error type received from Hci.Handle the error based on
1067 Hal4 next state and which past callback was Pending*/
1068 case NFC_NOTIFY_ERROR:
1069 {
1070 PHDBG_WARNING("Hal4:Error Notification from HCI");
1071 switch(Hal4Ctxt->Hal4NextState)
1072 {
1073 case eHal4StateClosed:
1074 phHal4Nfc_CloseComplete(Hal4Ctxt,pInfo);
1075 break;
1076 case eHal4StateSelfTestMode:
1077 phHal4Nfc_SelfTestComplete(Hal4Ctxt,pInfo);
1078 break;
1079 case eHal4StateConfiguring:
1080 phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type);
1081 break;
1082 case eHal4StateTargetDiscovered:
1083 case eHal4StateTargetActivate:
1084 {
1085 if(NULL != Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb)
1086 {
1087 if(NULL == Hal4Ctxt->sTgtConnectInfo.psConnectedDevice)
1088 {
1089 phHal4Nfc_ConfigureComplete(Hal4Ctxt,pInfo,type);
1090 }
1091 else
1092 {
1093 phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo);
1094 }
1095 }
1096 else
1097 {
1098 phHal4Nfc_TargetDiscoveryComplete(Hal4Ctxt,pInfo);
1099 }
1100 break;
1101 }
1102 case eHal4StateTargetConnected:
1103 phHal4Nfc_ConnectComplete(Hal4Ctxt,pInfo);
1104 break;
1105 case eHal4StateOpenAndReady:
1106 phHal4Nfc_DisconnectComplete(Hal4Ctxt,pInfo);
1107 break;
1108 case eHal4StatePresenceCheck:
1109 phHal4Nfc_PresenceChkComplete(Hal4Ctxt,pInfo);
1110 break;
1111 default:
1112 PHDBG_WARNING("Unknown Error notification");
1113 break;
1114 }
1115 break;
1116 }/*End of switch(Hal4Ctxt->Hal4State)*/
1117 default:
1118 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
1119 break;
1120 }/*End of switch(type)*/
1121 }
1122 return;
1123 }
1124
1125
1126 /*Event handler for HAL-HCI interface*/
phHal4Nfc_HandleEvent(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)1127 static void phHal4Nfc_HandleEvent(
1128 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
1129 void *pInfo
1130 )
1131 {
1132 phHal_sEventInfo_t *psEventInfo = (phHal_sEventInfo_t *)pInfo;
1133 static phNfc_sNotificationInfo_t sNotificationInfo;
1134 phHal4Nfc_NotificationInfo_t uNotificationInfo = {NULL};
1135 NFCSTATUS RetStatus = NFCSTATUS_FAILED;
1136 /*Check if Hal4 Close has already been called*/
1137 if(eHal4StateClosed != Hal4Ctxt->Hal4NextState)
1138 {
1139 switch(psEventInfo->eventType)
1140 {
1141 case NFC_EVT_ACTIVATED:/*Target Activated*/
1142 {
1143 if(psEventInfo->eventHost == phHal_eHostController)
1144 {
1145 switch(psEventInfo->eventSource)
1146 {
1147 case phHal_eNfcIP1_Target:
1148 phHal4Nfc_P2PActivateComplete(Hal4Ctxt,pInfo);
1149 break;
1150 case phHal_eISO14443_A_PICC:
1151 case phHal_eISO14443_B_PICC:
1152 sNotificationInfo.info = psEventInfo;
1153 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1154 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1155 pInfo = &sNotificationInfo;
1156 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1157 break;
1158 default:
1159 break;
1160 }
1161 }
1162 }
1163 break;
1164 case NFC_EVT_DEACTIVATED:/*Target Deactivated*/
1165 {
1166 if(psEventInfo->eventHost == phHal_eHostController)
1167 {
1168 switch(psEventInfo->eventSource)
1169 {
1170 case phHal_eNfcIP1_Target:
1171 phHal4Nfc_HandleP2PDeActivate(Hal4Ctxt,pInfo);
1172 break;
1173 case phHal_eISO14443_A_PICC:
1174 case phHal_eISO14443_B_PICC:
1175 sNotificationInfo.info = psEventInfo;
1176 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1177 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1178 pInfo = &sNotificationInfo;
1179 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1180 break;
1181 default:
1182 break;
1183 }
1184 }
1185 }
1186 break;
1187 /*Set Protection Event*/
1188 case NFC_EVT_PROTECTED:
1189 {
1190 #ifdef IGNORE_EVT_PROTECTED
1191 /*Ignore_Event_Protected is set to false during Field Off event and
1192 Set protection Configuration.After a NFC_EVT_PROTECTED is received
1193 once all subsequent NFC_EVT_PROTECTED events are ignored*/
1194 if(FALSE == Hal4Ctxt->Ignore_Event_Protected)
1195 {
1196 Hal4Ctxt->Ignore_Event_Protected = TRUE;
1197 #endif/*#ifdef IGNORE_EVT_PROTECTED*/
1198 sNotificationInfo.info = psEventInfo;
1199 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1200 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1201 pInfo = &sNotificationInfo;
1202 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1203 #ifdef IGNORE_EVT_PROTECTED
1204 }
1205 #endif/*#ifdef IGNORE_EVT_PROTECTED*/
1206 break;
1207 }
1208 /*NFC_UICC_RDPHASES_DEACTIVATE_REQ*/
1209 case NFC_UICC_RDPHASES_DEACTIVATE_REQ:
1210 {
1211 if(NULL != gpphHal4Nfc_Hwref)
1212 {
1213 gpphHal4Nfc_Hwref->uicc_rdr_active = FALSE;
1214 }
1215 break;
1216 }
1217 case NFC_UICC_RDPHASES_ACTIVATE_REQ:
1218 {
1219 if(NULL != gpphHal4Nfc_Hwref)
1220 {
1221 gpphHal4Nfc_Hwref->uicc_rdr_active = TRUE;
1222 }
1223 /*If a NFC_UICC_RDPHASES_ACTIVATE_REQ is received before a configure
1224 discovery,then create a ADD context info*/
1225 if (NULL == Hal4Ctxt->psADDCtxtInfo)
1226 {
1227 Hal4Ctxt->psADDCtxtInfo= (pphHal4Nfc_ADDCtxtInfo_t)
1228 phOsalNfc_GetMemory((uint32_t)
1229 (sizeof(phHal4Nfc_ADDCtxtInfo_t)));
1230 if(NULL != Hal4Ctxt->psADDCtxtInfo)
1231 {
1232 (void)memset(Hal4Ctxt->psADDCtxtInfo,0,
1233 sizeof(phHal4Nfc_ADDCtxtInfo_t)
1234 );
1235 }
1236 }
1237 if(NULL != Hal4Ctxt->psADDCtxtInfo)
1238 {
1239 Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollEnabled
1240 |= psEventInfo->eventInfo.rd_phases;
1241 /*Configure HCI Discovery*/
1242 RetStatus = phHciNfc_Config_Discovery(
1243 (void *)Hal4Ctxt->psHciHandle,
1244 gpphHal4Nfc_Hwref,
1245 &(Hal4Ctxt->psADDCtxtInfo->sADDCfg)
1246 );
1247 Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == RetStatus?
1248 eHal4StateConfiguring:
1249 Hal4Ctxt->Hal4NextState);
1250 }
1251 break;
1252 }
1253 /*Call Default Event handler for these Events*/
1254 case NFC_INFO_TXLDO_OVERCUR:
1255 case NFC_INFO_MEM_VIOLATION:
1256 case NFC_INFO_TEMP_OVERHEAT:
1257 case NFC_INFO_LLC_ERROR:
1258 {
1259 sNotificationInfo.info = psEventInfo;
1260 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1261 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1262 pInfo = &sNotificationInfo;
1263 PHDBG_INFO("Hal4:Exception events");
1264 if(NULL != Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler)
1265 {
1266 /*Pass on Event notification info from Hci to Upper layer*/
1267 uNotificationInfo.psEventInfo = psEventInfo;
1268 Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler(
1269 Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt,
1270 sNotificationInfo.type,
1271 uNotificationInfo,
1272 NFCSTATUS_SUCCESS
1273 );
1274 }
1275 break;
1276 }
1277 /*Call emulation Event handler fto handle these Events*/
1278 case NFC_EVT_TRANSACTION:
1279 case NFC_EVT_START_OF_TRANSACTION:
1280 case NFC_EVT_END_OF_TRANSACTION:
1281 case NFC_EVT_CONNECTIVITY:
1282 case NFC_EVT_OPERATION_ENDED:
1283 case NFC_EVT_MIFARE_ACCESS:
1284 case NFC_EVT_APDU_RECEIVED:
1285 case NFC_EVT_EMV_CARD_REMOVAL:
1286 sNotificationInfo.info = psEventInfo;
1287 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1288 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1289 pInfo = &sNotificationInfo;
1290 PHDBG_INFO("Hal4:Event transaction\n");
1291 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1292 break;
1293 case NFC_EVT_FIELD_ON:
1294 Hal4Ctxt->psEventInfo = sNotificationInfo.info = psEventInfo;
1295 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1296 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1297 pInfo = &sNotificationInfo;
1298 PHDBG_INFO("Hal4:Event Field ON\n");
1299 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1300 break;
1301 case NFC_EVT_FIELD_OFF:
1302 #ifdef IGNORE_EVT_PROTECTED
1303 Hal4Ctxt->Ignore_Event_Protected = FALSE;
1304 #endif/*#ifdef IGNORE_EVT_PROTECTED*/
1305 Hal4Ctxt->psEventInfo = sNotificationInfo.info = psEventInfo;
1306 sNotificationInfo.status = NFCSTATUS_SUCCESS;
1307 sNotificationInfo.type = NFC_EVENT_NOTIFICATION;
1308 pInfo = &sNotificationInfo;
1309 PHDBG_INFO("Hal4:Event Field OFF\n");
1310 phHal4Nfc_HandleEmulationEvent(Hal4Ctxt,pInfo);
1311 break;
1312 default:
1313 PHDBG_WARNING("Hal4:Unhandled Event type received");
1314 break;
1315 }/*End of switch*/
1316 }/*if(eHal4StateClosed != Hal4Ctxt->Hal4NextState)*/
1317 return;
1318 }
1319
1320
1321 /*Callback handler for Self Test Ioctl completion*/
phHal4Nfc_SelfTestComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)1322 static void phHal4Nfc_SelfTestComplete(
1323 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
1324 void *pInfo
1325 )
1326 {
1327 NFCSTATUS status = NFCSTATUS_FAILED;
1328 phNfc_sData_t *SelfTestResults
1329 = (phNfc_sData_t *)(((phNfc_sCompletionInfo_t *)pInfo)->info);
1330 pphHal4Nfc_IoctlCallback_t pUpper_IoctlCb
1331 = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb;
1332 void *pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
1333 /*check for Success*/
1334 if(( DEVMGMT_SWP_TEST == Hal4Ctxt->Ioctl_Type )
1335 || ( DEVMGMT_ANTENNA_TEST == Hal4Ctxt->Ioctl_Type ))
1336 {
1337 status = NFCSTATUS_SUCCESS;
1338 }
1339 else if((SelfTestResults->length > 0) && (0 == SelfTestResults->buffer[0]))
1340 {
1341 status = NFCSTATUS_SUCCESS;
1342 }
1343 else
1344 {
1345 if (NULL != pInfo)
1346 {
1347 status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
1348 }
1349 }
1350
1351 /*Copy response buffer and length*/
1352 (void)memcpy(Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->buffer,
1353 SelfTestResults->buffer,
1354 SelfTestResults->length);
1355 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->length
1356 = SelfTestResults->length;
1357 /*Call registered Ioctl callback*/
1358 (*pUpper_IoctlCb)(
1359 pUpper_Context,
1360 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam,
1361 status
1362 );
1363 return;
1364 }
1365
1366
phHal4Nfc_IoctlComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)1367 static void phHal4Nfc_IoctlComplete(
1368 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt,
1369 void *pInfo
1370 )
1371 {
1372 /*Copy status*/
1373 NFCSTATUS status = (((phNfc_sCompletionInfo_t *)pInfo)->status);
1374 pphHal4Nfc_IoctlCallback_t pUpper_IoctlCb
1375 = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb;
1376 #ifdef MERGE_SAK_SW2
1377 pphHal4Nfc_GenCallback_t pConfigCallback =
1378 Hal4Ctxt->sUpperLayerInfo.pConfigCallback;
1379 #endif/*#ifdef MERGE_SAK_SW2*/
1380 void *pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
1381 Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb = NULL;
1382 #ifdef MERGE_SAK_SW1 /*Software workaround 1*/
1383 if(eHal4StateOpenAndReady == Hal4Ctxt->Hal4NextState)
1384 {
1385 Hal4Ctxt->Hal4CurrentState = Hal4Ctxt->Hal4NextState;
1386 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
1387 /*Upper layer's Open Cb*/
1388 (*Hal4Ctxt->sUpperLayerInfo.pUpperOpenCb)(
1389 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
1390 NFCSTATUS_SUCCESS
1391 );
1392 }
1393 #endif/*#ifdef MERGE_SAK_SW1*/
1394 #ifdef MERGE_SAK_SW2 /*Software workaround 2*/
1395 else if((eHal4StateConfiguring == Hal4Ctxt->Hal4NextState)
1396 &&(NULL != pConfigCallback))
1397 {
1398 Hal4Ctxt->sUpperLayerInfo.pConfigCallback = NULL;
1399 Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
1400 (*pConfigCallback)(
1401 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,status
1402 );
1403 }
1404 else
1405 #endif/*#ifdef MERGE_SAK_SW2*/
1406 {
1407 /*for NFC_MEM_READ and NFC_GPIO_READ ,provide one Byte Response*/
1408 if ((NFC_MEM_READ == Hal4Ctxt->Ioctl_Type)
1409 || (NFC_GPIO_READ == Hal4Ctxt->Ioctl_Type)
1410 )
1411 {
1412 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam->length
1413 = sizeof (uint8_t);
1414 }
1415 /*Call registered Ioctl callback*/
1416 if(NULL != pUpper_IoctlCb)
1417 {
1418 (*pUpper_IoctlCb)(
1419 pUpper_Context,
1420 Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam,
1421 status
1422 );
1423 }
1424 }
1425 return;
1426 }
1427
1428 #ifdef FW_DOWNLOAD
1429 /**Callback handler for Download completion*/
phHal4Nfc_DownloadComplete(void * pContext,void * pHwRef,uint8_t type,void * pInfo)1430 STATIC void phHal4Nfc_DownloadComplete(
1431 void *pContext,
1432 void *pHwRef,
1433 uint8_t type,
1434 void *pInfo
1435 )
1436 {
1437 phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
1438 NFCSTATUS status = NFCSTATUS_FAILED;
1439 pphHal4Nfc_IoctlCallback_t pUpper_DnldCb = NULL;
1440 phNfc_sData_t *pIoctlOutParam = NULL;
1441 phHal_sHwReference_t *psHwRef = NULL;
1442 void *pUpper_Context = NULL;
1443 /*NULL checks*/
1444 if((NULL == pInfo) || (NULL == pHwRef) || (NULL == pContext))
1445 {
1446 phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
1447 }
1448 else
1449 {
1450 type = type;
1451 Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)pContext;
1452 /*Copy back stored context/callback for the upper layer*/
1453 pUpper_Context = Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt;
1454 pIoctlOutParam = Hal4Ctxt->sUpperLayerInfo.pIoctlOutParam;
1455 pUpper_DnldCb = Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb;
1456 Hal4Ctxt->sUpperLayerInfo.pUpperIoctlCb = NULL;
1457 /*Copy download status*/
1458 status = (((phNfc_sCompletionInfo_t *)pInfo)->status);
1459 /*copy hw reference*/
1460 psHwRef = (phHal_sHwReference_t *)pHwRef;
1461 /*Free the temporary hal context used only for the sake of download*/
1462 phOsalNfc_FreeMemory(psHwRef->hal_context);
1463 psHwRef->hal_context = NULL;
1464 /*Call upper layer callback*/
1465 if(NULL != pUpper_DnldCb)
1466 {
1467 (*pUpper_DnldCb)(
1468 pUpper_Context,
1469 pIoctlOutParam,
1470 status
1471 );
1472 }
1473 }
1474 return;
1475 }
1476 #endif /*FW_DOWNLOAD*/
1477
1478