• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_ADD.c
18  * \brief Hal4Nfc_ADD source.
19  *
20  * Project: NFC-FRI 1.1
21  *
22  * $Date: Mon May 31 11:43:42 2010 $
23  * $Author: ing07385 $
24  * $Revision: 1.151 $
25  * $Aliases: NFC_FRI1.1_WK1023_R35_1 $
26  *
27  */
28 
29 /* ---------------------------Include files ----------------------------------*/
30 #include <phHciNfc.h>
31 #include <phHal4Nfc.h>
32 #include <phHal4Nfc_Internal.h>
33 #include <phOsalNfc.h>
34 
35 /* ------------------------------- Macros ------------------------------------*/
36 #define     NFCIP_ACTIVE_SHIFT      0x03U
37 #define     NXP_UID                 0x04U
38 #define     NXP_MIN_UID_LEN         0x07U
39 /* --------------------Structures and enumerations --------------------------*/
40 
phHal4Nfc_ConfigParameters(phHal_sHwReference_t * psHwReference,phHal_eConfigType_t CfgType,phHal_uConfig_t * puConfig,pphHal4Nfc_GenCallback_t pConfigCallback,void * pContext)41 NFCSTATUS phHal4Nfc_ConfigParameters(
42                         phHal_sHwReference_t     *psHwReference,
43                         phHal_eConfigType_t       CfgType,
44                         phHal_uConfig_t          *puConfig,
45                         pphHal4Nfc_GenCallback_t  pConfigCallback,
46                         void                     *pContext
47                         )
48 {
49     NFCSTATUS CfgStatus = NFCSTATUS_SUCCESS;
50     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
51     /*NULL checks*/
52     if(NULL == psHwReference
53         || NULL == pConfigCallback
54         || NULL == puConfig
55         )
56     {
57         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
58         CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
59     }
60     /*Check if initialised*/
61     else if((NULL == psHwReference->hal_context)
62                         || (((phHal4Nfc_Hal4Ctxt_t *)
63                                 psHwReference->hal_context)->Hal4CurrentState
64                                                < eHal4StateOpenAndReady)
65                         || (((phHal4Nfc_Hal4Ctxt_t *)
66                                 psHwReference->hal_context)->Hal4NextState
67                                                == eHal4StateClosed))
68     {
69         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
70         CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
71     }
72     else
73     {
74         Hal4Ctxt = psHwReference->hal_context;
75         /*If previous Configuration request has not completed,do not allow new
76           configuration*/
77         if(Hal4Ctxt->Hal4NextState == eHal4StateConfiguring)
78         {
79             PHDBG_INFO("Hal4:PollCfg in progress.Returning status Busy");
80             CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_BUSY);
81         }
82         else if(Hal4Ctxt->Hal4CurrentState >= eHal4StateOpenAndReady)
83         {
84             /*Allocate ADD context*/
85             if (NULL == Hal4Ctxt->psADDCtxtInfo)
86             {
87                 Hal4Ctxt->psADDCtxtInfo= (pphHal4Nfc_ADDCtxtInfo_t)
88                     phOsalNfc_GetMemory((uint32_t)
89                     (sizeof(phHal4Nfc_ADDCtxtInfo_t)));
90                 if(NULL != Hal4Ctxt->psADDCtxtInfo)
91                 {
92                     (void)memset(Hal4Ctxt->psADDCtxtInfo,0,
93                         sizeof(phHal4Nfc_ADDCtxtInfo_t)
94                         );
95                 }
96             }
97             if(NULL == Hal4Ctxt->psADDCtxtInfo)
98             {
99                 phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
100                 CfgStatus= PHNFCSTVAL(CID_NFC_HAL ,
101                     NFCSTATUS_INSUFFICIENT_RESOURCES);
102             }
103             else
104             {
105                 /*Register Upper layer context*/
106 #ifdef LLCP_DISCON_CHANGES
107                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCfgDiscCtxt = pContext;
108 #else /* #ifdef LLCP_DISCON_CHANGES */
109                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
110 #endif /* #ifdef LLCP_DISCON_CHANGES */
111                 switch(CfgType)
112                 {
113                 /*NFC_EMULATION_CONFIG*/
114                 case NFC_EMULATION_CONFIG:
115                 {
116                     (void)memcpy((void *)&Hal4Ctxt->uConfig,
117                         (void *)puConfig,
118                         sizeof(phHal_uConfig_t)
119                         );
120                     break;
121                 }
122                 /*P2P Configuration*/
123                 case NFC_P2P_CONFIG:
124                 {
125                     /*If general bytes are not provided by above layer copy zeros
126                       in general bytes*/
127                     if(puConfig->nfcIPConfig.generalBytesLength == 0)
128                     {
129                         Hal4Ctxt->uConfig.nfcIPConfig.generalBytesLength = 0x00;
130                         (void)memset(Hal4Ctxt->uConfig.nfcIPConfig.generalBytes,
131                                     0,Hal4Ctxt->uConfig.nfcIPConfig.generalBytesLength
132                                     );
133                     }
134                     else
135                     {
136                         (void)memcpy((void *)&Hal4Ctxt->uConfig,
137                             (void *)puConfig,
138                             sizeof(phHal_uConfig_t)
139                             );
140                     }
141                     break;
142                 }
143                 /*Protection config*/
144                 case NFC_SE_PROTECTION_CONFIG:
145                 {
146 #ifdef IGNORE_EVT_PROTECTED
147                     Hal4Ctxt->Ignore_Event_Protected = FALSE;
148 #endif/*#ifdef IGNORE_EVT_PROTECTED*/
149                     (void)memcpy((void *)&Hal4Ctxt->uConfig,
150                         (void *)puConfig,
151                         sizeof(phHal_uConfig_t)
152                         );
153                     break;
154                 }
155                 default:
156                     CfgStatus = NFCSTATUS_FAILED;
157                     break;
158                 }
159                 if ( NFCSTATUS_SUCCESS == CfgStatus )
160                 {
161                     /*Issue configure with given configuration*/
162                     CfgStatus = phHciNfc_Configure(
163                                     (void *)Hal4Ctxt->psHciHandle,
164                                     (void *)psHwReference,
165                                     CfgType,
166                                     &Hal4Ctxt->uConfig
167                                     );
168                     /* Change the State of the HAL only if status is Pending */
169                     if ( NFCSTATUS_PENDING == CfgStatus )
170                     {
171                         Hal4Ctxt->Hal4NextState = eHal4StateConfiguring;
172                         Hal4Ctxt->sUpperLayerInfo.pConfigCallback
173                             = pConfigCallback;
174                     }
175                 }
176             }
177         }
178         else
179         {
180             phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
181             CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
182         }
183     }
184     return CfgStatus;
185 }
186 
187 
188 /**Configure the discovery*/
phHal4Nfc_ConfigureDiscovery(phHal_sHwReference_t * psHwReference,phHal_eDiscoveryConfigMode_t discoveryMode,phHal_sADD_Cfg_t * discoveryCfg,pphHal4Nfc_GenCallback_t pConfigCallback,void * pContext)189 NFCSTATUS phHal4Nfc_ConfigureDiscovery(
190                         phHal_sHwReference_t          *psHwReference,
191                         phHal_eDiscoveryConfigMode_t   discoveryMode,
192                         phHal_sADD_Cfg_t              *discoveryCfg,
193                         pphHal4Nfc_GenCallback_t       pConfigCallback,
194                         void                          *pContext
195                         )
196 {
197     NFCSTATUS CfgStatus = NFCSTATUS_SUCCESS;
198     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
199     if(NULL == psHwReference
200         || NULL == pConfigCallback
201         || NULL == discoveryCfg
202         )
203     {
204         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
205         CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
206     }
207     else if((NULL == psHwReference->hal_context)
208                         || (((phHal4Nfc_Hal4Ctxt_t *)
209                                 psHwReference->hal_context)->Hal4CurrentState
210                                                < eHal4StateOpenAndReady)
211                         || (((phHal4Nfc_Hal4Ctxt_t *)
212                                 psHwReference->hal_context)->Hal4NextState
213                                                == eHal4StateClosed))
214     {
215         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
216         CfgStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
217     }
218     else
219     {
220         Hal4Ctxt = psHwReference->hal_context;
221         /*If previous Configuration request has not completed ,do not allow
222           new configuration*/
223         if(Hal4Ctxt->Hal4NextState == eHal4StateConfiguring)
224         {
225             PHDBG_INFO("Hal4:PollCfg in progress.Returning status Busy");
226             CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_BUSY);
227         }
228         else if(Hal4Ctxt->Hal4CurrentState >= eHal4StateOpenAndReady)
229         {
230             if (NULL == Hal4Ctxt->psADDCtxtInfo)
231             {
232                 Hal4Ctxt->psADDCtxtInfo= (pphHal4Nfc_ADDCtxtInfo_t)
233                     phOsalNfc_GetMemory((uint32_t)
234                     (sizeof(phHal4Nfc_ADDCtxtInfo_t)));
235                 if(NULL != Hal4Ctxt->psADDCtxtInfo)
236                 {
237                     (void)memset(Hal4Ctxt->psADDCtxtInfo,0,
238                         sizeof(phHal4Nfc_ADDCtxtInfo_t)
239                         );
240                 }
241             }
242             if(NULL == Hal4Ctxt->psADDCtxtInfo)
243             {
244                 phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
245                 CfgStatus= PHNFCSTVAL(CID_NFC_HAL ,
246                     NFCSTATUS_INSUFFICIENT_RESOURCES);
247             }
248             else
249             {
250                 /*Register Upper layer context*/
251 #ifdef LLCP_DISCON_CHANGES
252                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCfgDiscCtxt = pContext;
253 #else /* #ifdef LLCP_DISCON_CHANGES */
254                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = pContext;
255 #endif /* #ifdef LLCP_DISCON_CHANGES */
256                 switch(discoveryMode)
257                 {
258                 case NFC_DISCOVERY_START:
259                     PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_START");
260                     break;
261                 case NFC_DISCOVERY_CONFIG:
262                     PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_CONFIG");
263                     /*Since sADDCfg is allocated in stack ,copy the ADD
264                       configuration structure to HAL4 context*/
265                     (void)memcpy((void *)
266                         &(Hal4Ctxt->psADDCtxtInfo->sADDCfg),
267                         (void *)discoveryCfg,
268                         sizeof(phHal_sADD_Cfg_t)
269                         );
270                     PHDBG_INFO("Hal4:Finished copying sADDCfg");
271                     Hal4Ctxt->psADDCtxtInfo->smx_discovery = FALSE;
272 #ifdef UPDATE_NFC_ACTIVE
273                     Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollCfgInfo.EnableNfcActive
274                         = ( 0 == Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode?
275                            Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode:
276                            NXP_NFCIP_ACTIVE_DEFAULT);
277                     Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode = ((
278                     Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode <<
279                     (NXP_NFCIP_ACTIVE_DEFAULT * NFCIP_ACTIVE_SHIFT))
280                     | Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode);
281 #endif/*#ifdef UPDATE_NFC_ACTIVE*/
282                     /* information system_code(Felica) and
283                     AFI(ReaderB) to be populated later */
284 
285                     CfgStatus = phHciNfc_Config_Discovery(
286                         (void *)Hal4Ctxt->psHciHandle,
287                         (void *)psHwReference,
288                         &(Hal4Ctxt->psADDCtxtInfo->sADDCfg)
289                         );/*Configure HCI Discovery*/
290                     break;
291                 case NFC_DISCOVERY_STOP:
292                     break;
293                 /*Restart Discovery wheel*/
294                 case NFC_DISCOVERY_RESUME:
295                     PHDBG_INFO("Hal4:Call to NFC_DISCOVERY_RESUME");
296                     Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
297                     CfgStatus = phHciNfc_Restart_Discovery (
298                                     (void *)Hal4Ctxt->psHciHandle,
299                                     (void *)psHwReference,
300                                     FALSE
301                                     );
302                     break;
303                 default:
304                     break;
305                 }
306                 /* Change the State of the HAL only if HCI Configure
307                    Returns status as Pending */
308                 if ( NFCSTATUS_PENDING == CfgStatus )
309                 {
310                     (void)memcpy((void *)
311                         &(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig),
312                         (void *)&(discoveryCfg->PollDevInfo.PollCfgInfo),
313                         sizeof(phHal_sPollDevInfo_t)
314                         );
315                     PHDBG_INFO("Hal4:Finished copying PollCfgInfo");
316                     PHDBG_INFO("Hal4:Configure returned NFCSTATUS_PENDING");
317                     Hal4Ctxt->Hal4NextState = eHal4StateConfiguring;
318                     Hal4Ctxt->sUpperLayerInfo.pConfigCallback
319                         = pConfigCallback;
320                 }
321                 else/*Configure failed.Restore old poll dev info*/
322                 {
323                     (void)memcpy((void *)
324                         &(Hal4Ctxt->psADDCtxtInfo->sADDCfg.PollDevInfo.PollCfgInfo),
325                         (void *)&(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig),
326                         sizeof(phHal_sPollDevInfo_t)
327                         );
328                 }
329             }
330         }
331         else
332         {
333             phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
334             CfgStatus= PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
335         }
336     }
337     return CfgStatus;
338 }
339 
340 
341 /*Configuration completion handler*/
phHal4Nfc_ConfigureComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo,uint8_t type)342 void phHal4Nfc_ConfigureComplete(phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
343                                  void                  *pInfo,
344                                  uint8_t                type
345                                  )
346 {
347     pphHal4Nfc_GenCallback_t    pConfigCallback
348                                 = Hal4Ctxt->sUpperLayerInfo.pConfigCallback;
349     pphHal4Nfc_ConnectCallback_t pUpperConnectCb
350                     = Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb;
351     NFCSTATUS Status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
352     if((type == NFC_NOTIFY_POLL_ENABLED) ||(type == NFC_NOTIFY_POLL_RESTARTED))
353     {
354         Hal4Ctxt->psADDCtxtInfo->IsPollConfigured = TRUE;
355         PHDBG_INFO("Hal4:Poll Config Complete");
356     }
357     else
358     {
359         Hal4Ctxt->psADDCtxtInfo->IsPollConfigured = FALSE;
360         PHDBG_WARNING("Hal4:Poll disabled,config success or config error");
361     }
362     if(NULL != Hal4Ctxt->sUpperLayerInfo.pConfigCallback)
363     {
364 #ifdef MERGE_SAK_SW2
365         if((NFC_UICC_EMULATION == Hal4Ctxt->uConfig.emuConfig.emuType)&&
366            (FALSE ==
367             Hal4Ctxt->uConfig.emuConfig.config.uiccEmuCfg.enableUicc))
368         {
369             Status = phHciNfc_System_Configure (
370                                 Hal4Ctxt->psHciHandle,
371                                 (void *)gpphHal4Nfc_Hwref,
372                                 PH_HAL4NFC_TGT_MERGE_ADDRESS,
373                                 PH_HAL4NFC_TGT_MERGE_SAK /*config value*/
374                                 );
375         }
376         if(NFCSTATUS_PENDING != Status)
377         {
378 #endif/*#ifdef MERGE_SAK_SW2*/
379             Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
380             Hal4Ctxt->sUpperLayerInfo.pConfigCallback = NULL;
381             (*pConfigCallback)(
382 #ifdef LLCP_DISCON_CHANGES
383                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCfgDiscCtxt,
384 #else /* #ifdef LLCP_DISCON_CHANGES */
385                 Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
386 #endif /* #ifdef LLCP_DISCON_CHANGES */
387                 Status
388                 );
389 #ifdef MERGE_SAK_SW2
390         }
391 #endif/*#ifdef MERGE_SAK_SW2*/
392     }
393     /**if connect failed and discovery wheel was restarted*/
394     else if(Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb)
395     {
396         Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
397         Hal4Ctxt->sTgtConnectInfo.pUpperConnectCb = NULL;
398         /*Notify to the upper layer*/
399         (*pUpperConnectCb)(
400             Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt,
401             Hal4Ctxt->sTgtConnectInfo.psConnectedDevice,
402             NFCSTATUS_FAILED
403             );
404     }
405     else
406     {
407         Hal4Ctxt->Hal4NextState = eHal4StateInvalid;
408         /**if disconnect failed and discovery wheel was restarted*/
409         if ( NULL != Hal4Ctxt->sTgtConnectInfo.pUpperDisconnectCb)
410         {
411             ((phNfc_sCompletionInfo_t *)pInfo)->status = NFCSTATUS_SUCCESS;
412             phHal4Nfc_DisconnectComplete(Hal4Ctxt,pInfo);
413         }
414     }
415 }
416 
417 
418 /**Handler for Target discovery completion for all remote device types*/
phHal4Nfc_TargetDiscoveryComplete(phHal4Nfc_Hal4Ctxt_t * Hal4Ctxt,void * pInfo)419 void phHal4Nfc_TargetDiscoveryComplete(
420                                        phHal4Nfc_Hal4Ctxt_t  *Hal4Ctxt,
421                                        void                  *pInfo
422                                        )
423 {
424     static phHal4Nfc_DiscoveryInfo_t sDiscoveryInfo;
425     NFCSTATUS status = NFCSTATUS_SUCCESS;
426     /**SAK byte*/
427     uint8_t Sak = 0;
428     /*Union type to encapsulate and return the discovery info*/
429     phHal4Nfc_NotificationInfo_t uNotificationInfo;
430     /*All the following types will be discovered as type A ,and differentiation
431       will have to be done within this module based on SAK byte and UID info*/
432     phHal_eRemDevType_t  aRemoteDevTypes[3] = {
433                                                phHal_eISO14443_A_PICC,
434                                                phHal_eNfcIP1_Target,
435                                                phHal_eMifare_PICC
436                                               };
437     /*Count is used to add multiple info into remote dvice list for devices that
438       support multiple protocols*/
439     uint8_t Count = 0,
440         NfcIpDeviceCount = 0;/**<Number of NfcIp devices discovered*/
441     uint16_t nfc_id = 0;
442     /*remote device info*/
443     phHal_sRemoteDevInformation_t *psRemoteDevInfo = NULL;
444     status = ((phNfc_sCompletionInfo_t *)pInfo)->status;
445     /*Update Hal4 state*/
446     Hal4Ctxt->Hal4CurrentState = eHal4StateTargetDiscovered;
447     Hal4Ctxt->Hal4NextState  = eHal4StateInvalid;
448      PHDBG_INFO("Hal4:Remotedevice Discovered");
449     if(NULL != ((phNfc_sCompletionInfo_t *)pInfo)->info)
450     {
451         /*Extract Remote device Info*/
452         psRemoteDevInfo = (phHal_sRemoteDevInformation_t *)
453                                     ((phNfc_sCompletionInfo_t *)pInfo)->info;
454 
455         switch(psRemoteDevInfo->RemDevType)
456         {
457             case phHal_eISO14443_A_PICC:/*for TYPE A*/
458             {
459                 Sak = psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak;
460                 if((Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso14443A)
461                     || (TRUE == Hal4Ctxt->psADDCtxtInfo->smx_discovery))
462                 {
463                     /*Check if Iso is Supported*/
464                     if(Sak & ISO_14443_BITMASK)
465                     {
466                         Count++;
467                     }
468                     /*Check for Mifare Supported*/
469                     switch( Sak )
470                     {
471                       case 0x09: // Mini
472                       case 0x08: // 1K
473                       case 0x18: // 4K
474                       case 0x88: // Infineon 1K
475                       case 0x98: // Pro 4K
476                       case 0xB8: // Pro 4K
477                       case 0x28: // 1K emulation
478                       case 0x38: // 4K emulation
479                         aRemoteDevTypes[Count] = phHal_eMifare_PICC;
480                         Count++;
481                         break;
482                     }
483                     if((0 == Sak)&& (0 == Count))
484                     {
485                         /*Mifare check*/
486                         if((NXP_UID ==
487                         psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Uid[0])
488                         &&(NXP_MIN_UID_LEN <=
489                         psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.UidLength))
490                         {
491                             aRemoteDevTypes[Count] = phHal_eMifare_PICC;
492                             Count++;
493                         }
494                     }
495                     if ( !(Sak & NFCIP_BITMASK) )
496                     {
497                         // Always add a separate 3A target on a separate
498                         // handle, so the upper layers can connect to it.
499                         aRemoteDevTypes[Count] = phHal_eISO14443_3A_PICC;
500                         Count++;
501                     }
502                 }
503                 /*Check for P2P target passive*/
504                 if((Sak & NFCIP_BITMASK) &&
505                     (NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)&&
506                     (Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
507                     & phHal_ePassive106))
508                 {
509                   if( Sak == 0x53 // Fudan card incompatible to ISO18092
510                       && psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0] == 0x04
511                       && psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[1] == 0x00
512                     )
513                   {
514                     aRemoteDevTypes[Count] = phHal_eISO14443_3A_PICC;
515                     Count++;
516                   }
517                   else
518                   {
519                     aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
520                     Count++;
521 									}
522                 }
523             }/*case phHal_eISO14443_A_PICC:*/
524                 break;
525             case phHal_eNfcIP1_Target:/*P2P target detected*/
526                 aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
527                 Count++;
528                 break;
529              case phHal_eISO14443_B_PICC: /*TYPE_B*/
530 #ifdef TYPE_B
531                 aRemoteDevTypes[Count] = phHal_eISO14443_B_PICC;
532                 Count++;
533                 break;
534 #endif
535             case phHal_eFelica_PICC: /*Felica*/
536 #ifdef TYPE_FELICA
537             {
538                 /*nfc_id is used to differentiate between Felica and NfcIp target
539                   discovered in Type F*/
540                 nfc_id = (((uint16_t)psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm[0])
541                     << BYTE_SIZE) |
542                     psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm[1];
543                 /*check  for NfcIp target*/
544                 if(NXP_NFCIP_NFCID2_ID  == nfc_id)
545                 {
546                     if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)
547                         &&((Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
548                              & phHal_ePassive212) ||
549                             (Hal4Ctxt->psADDCtxtInfo->sADDCfg.NfcIP_Mode
550                              & phHal_ePassive424)))
551                     {
552                         aRemoteDevTypes[Count] = phHal_eNfcIP1_Target;
553                         Count++;
554                     }
555                 }
556                 else/*Felica*/
557                 {
558                     if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableFelica212
559                     || Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableFelica424)
560                     {
561                         aRemoteDevTypes[Count] = phHal_eFelica_PICC;
562                         Count++;
563                     }
564                 }
565                 break;
566             }
567 #endif
568             case phHal_eJewel_PICC: /*Jewel*/
569 #ifdef TYPE_JEWEL
570             {
571                 /*Report Jewel tags only if TYPE A is enabled*/
572                 if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso14443A)
573                 {
574                     aRemoteDevTypes[Count] = phHal_eJewel_PICC;
575                     Count++;
576                 }
577                 break;
578             }
579 #endif
580 #ifdef  TYPE_ISO15693
581             case phHal_eISO15693_PICC: /*ISO15693*/
582             {
583                 if(Hal4Ctxt->psADDCtxtInfo->sCurrentPollConfig.EnableIso15693)
584                 {
585                     aRemoteDevTypes[Count] = phHal_eISO15693_PICC;
586                     Count++;
587                 }
588                 break;
589             }
590 #endif /* #ifdef    TYPE_ISO15693 */
591             /*Types currently not supported*/
592             case phHal_eISO14443_BPrime_PICC:
593             default:
594                 PHDBG_WARNING("Hal4:Notification for Not supported types");
595                 break;
596         }/*End of switch*/
597         /*Update status code to success if atleast one device info is available*/
598         status = (((NFCSTATUS_SUCCESS != status)
599                   && (NFCSTATUS_MULTIPLE_TAGS != status))
600                    &&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices != 0))?
601                     NFCSTATUS_SUCCESS:status;
602 
603         /*Update status to NFCSTATUS_MULTIPLE_PROTOCOLS if count > 1 ,and this
604           is first discovery notification from Hci*/
605         status = ((NFCSTATUS_SUCCESS == status)
606                     &&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 0)
607                     &&(Count > 1)?NFCSTATUS_MULTIPLE_PROTOCOLS:status);
608          /*If multiple protocols are supported ,allocate separate remote device
609           information for each protocol supported*/
610         /*Allocate and copy Remote device info into Hal4 Context*/
611         while(Count)
612         {
613             PHDBG_INFO("Hal4:Count is not zero");
614             --Count;
615             /*Allocate memory for each of Count number of
616               devices*/
617             if(NULL == Hal4Ctxt->rem_dev_list[
618                 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices])
619             {
620                 Hal4Ctxt->rem_dev_list[
621                     Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]
622                 = (phHal_sRemoteDevInformation_t *)
623                     phOsalNfc_GetMemory(
624                     (uint32_t)(
625                     sizeof(phHal_sRemoteDevInformation_t))
626                     );
627             }
628             if(NULL == Hal4Ctxt->rem_dev_list[
629                 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices])
630             {
631                 status =  PHNFCSTVAL(CID_NFC_HAL,
632                     NFCSTATUS_INSUFFICIENT_RESOURCES);
633                 phOsalNfc_RaiseException(phOsalNfc_e_NoMemory,0);
634                 break;
635             }
636             else
637             {
638                 (void)memcpy(
639                     (void *)Hal4Ctxt->rem_dev_list[
640                         Hal4Ctxt->psADDCtxtInfo->nbr_of_devices],
641                         (void *)psRemoteDevInfo,
642                         sizeof(phHal_sRemoteDevInformation_t)
643                         );
644                 /*Now copy appropriate device type from aRemoteDevTypes array*/
645                 Hal4Ctxt->rem_dev_list[
646                         Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]->RemDevType
647                             =   aRemoteDevTypes[Count];
648                 /*Increment number of devices*/
649                 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices++;
650             }/*End of else*/
651         }/*End of while*/
652 
653         /*If Upper layer is interested only in P2P notifications*/
654         if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)
655            &&(((Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 1)
656               &&(phHal_eNfcIP1_Target == Hal4Ctxt->rem_dev_list[0]->RemDevType))
657               ||(NULL == Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification))
658             )
659         {
660             PHDBG_INFO("Hal4:Trying to notify P2P Listener");
661             /*NFCSTATUS_SUCCESS or NFCSTATUS_MULTIPLE_PROTOCOLS*/
662             if((NFCSTATUS_SUCCESS == status)
663                 ||(NFCSTATUS_MULTIPLE_PROTOCOLS == status))
664             {
665                 /*Pick only the P2P target device info from the list*/
666                 for(Count = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
667                     Count > 0;--Count)
668                 {
669                     /*Only one P2P target can be detected in one discovery*/
670                     if(phHal_eNfcIP1_Target ==
671                         Hal4Ctxt->rem_dev_list[Count-1]->RemDevType)
672                     {
673                         (void)memcpy(
674                             (void *)Hal4Ctxt->rem_dev_list[0],
675                             (void *)Hal4Ctxt->rem_dev_list[Count-1],
676                                     sizeof(phHal_sRemoteDevInformation_t)
677                                     );
678                         NfcIpDeviceCount = 1;
679                         break;
680                     }
681                 }
682                 /*If any P2p devices are discovered free other device info*/
683                 while(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > NfcIpDeviceCount)
684                 {
685                     phOsalNfc_FreeMemory(Hal4Ctxt->rem_dev_list[
686                         --Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]);
687                     Hal4Ctxt->rem_dev_list[
688                         Hal4Ctxt->psADDCtxtInfo->nbr_of_devices] = NULL;
689                 }
690                 /*Issue P2P notification*/
691                 if(NfcIpDeviceCount == 1)
692                 {
693                     sDiscoveryInfo.NumberOfDevices
694                         = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
695                     sDiscoveryInfo.ppRemoteDevInfo = Hal4Ctxt->rem_dev_list;
696                     uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
697                     PHDBG_INFO("Hal4:Calling P2P listener");
698                     (*Hal4Ctxt->sUpperLayerInfo.pP2PNotification)(
699                             (void *)(Hal4Ctxt->sUpperLayerInfo.P2PDiscoveryCtxt),
700                             NFC_DISCOVERY_NOTIFICATION,
701                             uNotificationInfo,
702                             NFCSTATUS_SUCCESS
703                             );
704                 }
705                 else/*Restart Discovery wheel*/
706                 {
707                     PHDBG_INFO("Hal4:No P2P device in list");
708                     Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
709                     PHDBG_INFO("Hal4:Restart discovery1");
710                     status = phHciNfc_Restart_Discovery (
711                                         (void *)Hal4Ctxt->psHciHandle,
712                                         (void *)gpphHal4Nfc_Hwref,
713                                         FALSE
714                                         );
715                     Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
716                                                         eHal4StateConfiguring:
717                                                     Hal4Ctxt->Hal4NextState);
718                 }
719             }
720             /*More discovery info available ,get next info from HCI*/
721             else if((NFCSTATUS_MULTIPLE_TAGS == status)
722                 &&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices
723                      < MAX_REMOTE_DEVICES))
724             {
725                 status = phHciNfc_Select_Next_Target (
726                     Hal4Ctxt->psHciHandle,
727                     (void *)gpphHal4Nfc_Hwref
728                     );
729             }
730             else/*Failed discovery ,restart discovery*/
731             {
732                 Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
733                 PHDBG_INFO("Hal4:Restart discovery2");
734                 status = phHciNfc_Restart_Discovery (
735                                         (void *)Hal4Ctxt->psHciHandle,
736                                         (void *)gpphHal4Nfc_Hwref,
737                                         FALSE
738                                         );/*Restart Discovery wheel*/
739                 Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
740                                                 eHal4StateConfiguring:
741                                                 Hal4Ctxt->Hal4NextState);
742             }
743         }/*if((NULL != Hal4Ctxt->sUpperLayerInfo.pP2PNotification)...*/
744         /*Notify if Upper layer is interested in tag notifications,also notify
745           P2p if its in the list with other tags*/
746         else if(NULL != Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)
747         {
748             PHDBG_INFO("Hal4:Trying to notify Tag notification");
749             /*Multiple tags in field, get discovery info a second time for the
750               other devices*/
751             if((NFCSTATUS_MULTIPLE_TAGS == status)
752                 &&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices < MAX_REMOTE_DEVICES))
753             {
754                 PHDBG_INFO("Hal4:select next target1");
755                 status = phHciNfc_Select_Next_Target (
756                                                     Hal4Ctxt->psHciHandle,
757                                                     (void *)gpphHal4Nfc_Hwref
758                                                     );
759             }
760             /*Single tag multiple protocols scenario,Notify Multiple Protocols
761               status to upper layer*/
762             else if(status == NFCSTATUS_MULTIPLE_PROTOCOLS)
763             {
764                 PHDBG_INFO("Hal4:Multiple Tags or protocols");
765                 sDiscoveryInfo.NumberOfDevices
766                     = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
767                 sDiscoveryInfo.ppRemoteDevInfo = Hal4Ctxt->rem_dev_list;
768                 uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
769                 (*Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)(
770                             (void *)(Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt),
771                             NFC_DISCOVERY_NOTIFICATION,
772                             uNotificationInfo,
773                             status
774                             );
775             }
776             else /*NFCSTATUS_SUCCESS*/
777             {
778                 if(((Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 1)
779                      &&(phHal_eNfcIP1_Target
780                      == Hal4Ctxt->rem_dev_list[0]->RemDevType))
781                      ||(NFCSTATUS_SUCCESS != status)
782                      || (Hal4Ctxt->psADDCtxtInfo->nbr_of_devices == 0)
783                      )/*device detected but upper layer is not interested
784                        in the type(P2P) or activate next failed*/
785                 {
786                     while(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > 0)
787                     {
788                         phOsalNfc_FreeMemory(Hal4Ctxt->rem_dev_list[
789                             --Hal4Ctxt->psADDCtxtInfo->nbr_of_devices]);
790                         Hal4Ctxt->rem_dev_list[
791                             Hal4Ctxt->psADDCtxtInfo->nbr_of_devices] = NULL;
792                     }
793                     PHDBG_INFO("Hal4:Restart discovery3");
794                     status = phHciNfc_Restart_Discovery (
795                         (void *)Hal4Ctxt->psHciHandle,
796                         (void *)gpphHal4Nfc_Hwref,
797                         FALSE
798                         );/*Restart Discovery wheel*/
799                     Hal4Ctxt->Hal4NextState = (
800                         NFCSTATUS_PENDING == status?eHal4StateConfiguring
801                                                     :Hal4Ctxt->Hal4NextState
802                                                     );
803                 }
804                 else/*All remote device info available.Notify to upper layer*/
805                 {
806                     /*Update status for MULTIPLE_TAGS here*/
807                     status = (Hal4Ctxt->psADDCtxtInfo->nbr_of_devices > 1?
808                                 NFCSTATUS_MULTIPLE_TAGS:status);
809                     /*If listener is registered ,call it*/
810                     sDiscoveryInfo.NumberOfDevices
811                         = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
812                     sDiscoveryInfo.ppRemoteDevInfo
813                         = Hal4Ctxt->rem_dev_list;
814                     uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
815                     PHDBG_INFO("Hal4:Calling Discovery Handler1");
816                     (*Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)(
817                         (void *)(Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt),
818                         NFC_DISCOVERY_NOTIFICATION,
819                         uNotificationInfo,
820                         status
821                         );
822                 }
823             }
824         } /*else if(NULL != Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)*/
825         else/*listener not registered ,Restart Discovery wheel*/
826         {
827             PHDBG_INFO("Hal4:No listener registered.Ignoring Discovery  \
828                         Notification");
829             Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
830             PHDBG_INFO("Hal4:Restart discovery4");
831             status = phHciNfc_Restart_Discovery (
832                                 (void *)Hal4Ctxt->psHciHandle,
833                                 (void *)gpphHal4Nfc_Hwref,
834                                 FALSE
835                                 );
836             Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
837                                                 eHal4StateConfiguring:
838                                             Hal4Ctxt->Hal4NextState);
839         }
840     }/*if(NULL != ((phNfc_sCompletionInfo_t *)pInfo)->info)*/
841     else/*NULL info received*/
842     {
843         sDiscoveryInfo.NumberOfDevices
844             = Hal4Ctxt->psADDCtxtInfo->nbr_of_devices;
845         sDiscoveryInfo.ppRemoteDevInfo = Hal4Ctxt->rem_dev_list;
846         uNotificationInfo.psDiscoveryInfo = &sDiscoveryInfo;
847         /*If Discovery info is available from previous notifications try to
848           notify that to the upper layer*/
849         if((NULL != Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)
850 #ifdef NFC_RF_NOISE_SW
851           &&((NFCSTATUS_SUCCESS == status)
852             || (NFCSTATUS_MULTIPLE_TAGS == status))
853 #endif /* #ifdef NFC_RF_NOISE_SW */
854             )
855         {
856 #ifndef NFC_RF_NOISE_SW
857             status = (((NFCSTATUS_SUCCESS != status)
858                   && (NFCSTATUS_MULTIPLE_TAGS != status))
859                    &&(Hal4Ctxt->psADDCtxtInfo->nbr_of_devices != 0))?
860                     NFCSTATUS_SUCCESS:status;
861 #endif/*#ifndef NFC_RF_NOISE_SW*/
862             PHDBG_INFO("Hal4:Calling Discovery Handler2");
863             (*Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification)(
864                 (void *)(Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt),
865                 NFC_DISCOVERY_NOTIFICATION,
866                 uNotificationInfo,
867                 status
868                 );
869         }
870         else/*Restart Discovery wheel*/
871         {
872             Hal4Ctxt->psADDCtxtInfo->nbr_of_devices = 0;
873             PHDBG_INFO("Hal4:Restart discovery5");
874             status = phHciNfc_Restart_Discovery (
875                 (void *)Hal4Ctxt->psHciHandle,
876                 (void *)gpphHal4Nfc_Hwref,
877                 FALSE
878                 );
879             Hal4Ctxt->Hal4NextState = (NFCSTATUS_PENDING == status?
880                                    eHal4StateConfiguring:Hal4Ctxt->Hal4NextState);
881         }
882     }/*else*/
883     return;
884 }
885 
886 
887 /**Register Notification handlers*/
phHal4Nfc_RegisterNotification(phHal_sHwReference_t * psHwReference,phHal4Nfc_RegisterType_t eRegisterType,pphHal4Nfc_Notification_t pNotificationHandler,void * Context)888 NFCSTATUS phHal4Nfc_RegisterNotification(
889                         phHal_sHwReference_t         *psHwReference,
890                         phHal4Nfc_RegisterType_t      eRegisterType,
891                         pphHal4Nfc_Notification_t     pNotificationHandler,
892                         void                         *Context
893                         )
894 {
895     NFCSTATUS RetStatus = NFCSTATUS_SUCCESS;
896     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
897     if(NULL == pNotificationHandler || NULL == psHwReference)
898     {
899         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
900         RetStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
901     }
902     else if((NULL == psHwReference->hal_context)
903                         || (((phHal4Nfc_Hal4Ctxt_t *)
904                                 psHwReference->hal_context)->Hal4CurrentState
905                                                < eHal4StateOpenAndReady)
906                         || (((phHal4Nfc_Hal4Ctxt_t *)
907                                 psHwReference->hal_context)->Hal4NextState
908                                                == eHal4StateClosed))
909     {
910         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
911         RetStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
912     }
913     else
914     {
915         /*Extract context from hardware reference*/
916         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
917         switch(eRegisterType)
918         {
919             case eRegisterTagDiscovery:
920                 Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt = Context;
921                 Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification
922                     = pNotificationHandler;  /*Register the tag Notification*/
923                 break;
924             case eRegisterP2PDiscovery:
925                 Hal4Ctxt->sUpperLayerInfo.P2PDiscoveryCtxt = Context;
926                 Hal4Ctxt->sUpperLayerInfo.pP2PNotification
927                     = pNotificationHandler;  /*Register the P2P Notification*/
928                 break;
929             case eRegisterHostCardEmulation:
930                 RetStatus = NFCSTATUS_FEATURE_NOT_SUPPORTED;
931                 break;
932             case eRegisterSecureElement:
933                 Hal4Ctxt->sUpperLayerInfo.EventNotificationCtxt = Context;
934                 Hal4Ctxt->sUpperLayerInfo.pEventNotification
935                        = pNotificationHandler; /*Register the Se Notification*/
936                 break;
937             default:
938                 Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt = Context;
939                 Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler
940                     = pNotificationHandler;  /*Register the default Notification*/
941                 break;
942         }
943         PHDBG_INFO("Hal4:listener registered");
944     }
945     return RetStatus;
946 }
947 
948 
949 /**Unregister Notification handlers*/
phHal4Nfc_UnregisterNotification(phHal_sHwReference_t * psHwReference,phHal4Nfc_RegisterType_t eRegisterType,void * Context)950 NFCSTATUS phHal4Nfc_UnregisterNotification(
951                                   phHal_sHwReference_t     *psHwReference,
952                                   phHal4Nfc_RegisterType_t  eRegisterType,
953                                   void                     *Context
954                                   )
955 {
956     NFCSTATUS RetStatus = NFCSTATUS_SUCCESS;
957     phHal4Nfc_Hal4Ctxt_t *Hal4Ctxt = NULL;
958     if(psHwReference == NULL)
959     {
960         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
961         RetStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_INVALID_PARAMETER);
962     }
963     else if((NULL == psHwReference->hal_context)
964                         || (((phHal4Nfc_Hal4Ctxt_t *)
965                                 psHwReference->hal_context)->Hal4CurrentState
966                                                < eHal4StateOpenAndReady)
967                         || (((phHal4Nfc_Hal4Ctxt_t *)
968                                 psHwReference->hal_context)->Hal4NextState
969                                                == eHal4StateClosed))
970     {
971         phOsalNfc_RaiseException(phOsalNfc_e_PrecondFailed,1);
972         RetStatus = PHNFCSTVAL(CID_NFC_HAL , NFCSTATUS_NOT_INITIALISED);
973     }
974     else
975     {
976         /*Extract context from hardware reference*/
977         Hal4Ctxt = (phHal4Nfc_Hal4Ctxt_t *)psHwReference->hal_context;
978         switch(eRegisterType)
979         {
980         case eRegisterTagDiscovery:
981             Hal4Ctxt->sUpperLayerInfo.psUpperLayerCtxt = Context;
982             Hal4Ctxt->sUpperLayerInfo.DiscoveryCtxt = NULL;
983             /*UnRegister the tag Notification*/
984             Hal4Ctxt->sUpperLayerInfo.pTagDiscoveryNotification = NULL;
985             PHDBG_INFO("Hal4:Tag Discovery Listener Unregistered");
986             break;
987         case eRegisterP2PDiscovery:
988             Hal4Ctxt->sUpperLayerInfo.P2PDiscoveryCtxt = NULL;
989             /*UnRegister the p2p Notification*/
990             Hal4Ctxt->sUpperLayerInfo.pP2PNotification = NULL;
991             PHDBG_INFO("Hal4:P2P Discovery Listener Unregistered");
992             break;
993         case eRegisterHostCardEmulation:/*RFU*/
994             RetStatus = NFCSTATUS_FEATURE_NOT_SUPPORTED;
995             break;
996             /*UnRegister the Se Notification*/
997         case eRegisterSecureElement:
998             Hal4Ctxt->sUpperLayerInfo.EventNotificationCtxt = NULL;
999             Hal4Ctxt->sUpperLayerInfo.pEventNotification = NULL;
1000             PHDBG_INFO("Hal4:SE Listener Unregistered");
1001             break;
1002         default:
1003             Hal4Ctxt->sUpperLayerInfo.DefaultListenerCtxt = NULL;
1004             /*UnRegister the default Notification*/
1005             Hal4Ctxt->sUpperLayerInfo.pDefaultEventHandler = NULL;
1006             PHDBG_INFO("Hal4:Default Listener Unregistered");
1007             break;
1008         }
1009     }
1010     return RetStatus;
1011 }
1012 
1013 
1014