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