Gitiles
Code Review Sign In
review.blissroms.org / platform_external_libnfc-nxp / refs/heads/o8.0-rebase / . / src / phHciNfc.c
blob: d6990c133f9a90bc2e6da1c0c903bfd6f6851d64 [file] [log] [blame]
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1/*
2 * Copyright (C) 2010 NXP Semiconductors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*!
18* =========================================================================== *
19* *
20* *
21* \file phHciNfc.c *
22* \brief HCI Interface Source for the HCI Management. *
23* *
24* *
25* Project: NFC-FRI-1.1 *
26* *
27* $Date: Thu Apr 22 17:49:47 2010 $ *
28* $Author: ing04880 $ *
29* $Revision: 1.90 $ *
30* $Aliases: NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $
31* *
32* =========================================================================== *
33*/
34
35
36/*
37################################################################################
38***************************** Header File Inclusion ****************************
39################################################################################
40*/
41
42#include <phNfcConfig.h>
43#include <phNfcCompId.h>
44#include <phNfcIoctlCode.h>
45#include <phHciNfc.h>
46#include <phHciNfc_Sequence.h>
47#include <phHciNfc_RFReader.h>
48#include <phHciNfc_LinkMgmt.h>
49#ifdef ENABLE_P2P
50#include <phHciNfc_NfcIPMgmt.h>
51#endif
52#include <phHciNfc_Emulation.h>
53#include <phHciNfc_SWP.h>
54#include <phHciNfc_DevMgmt.h>
55#include <phOsalNfc.h>
56
57/**/
58
59/*
60*************************** Static Function Declaration **************************
61*/
62
63
64static
65NFCSTATUS
66phHciNfc_Config_Emulation (
67 void *psHciHandle,
68 void *pHwRef,
69 phHal_sEmulationCfg_t *pEmulationConfig
70
71 );
72
73
74/*
75*************************** Function Definitions **************************
76*/
77
78
79/*!
80 * \brief Initialises the HCI Interface
81 *
82 * This function initialises the resources for the HCI Command and
83 * Response Mechanism
84 */
85
86 NFCSTATUS
87 phHciNfc_Initialise (
88 void *psHciHandle,
89 void *pHwRef,
90 phHciNfc_Init_t init_mode,
91 phHal_sHwConfig_t *pHwConfig,
92 pphNfcIF_Notification_CB_t pHalNotify,
93 void *psContext,
94 phNfcLayer_sCfg_t *psHciLayerCfg
95 )
96{
97 phHciNfc_sContext_t *psHciContext = NULL;
Nick Pelly34ff48f2011-06-27 09:01:51 -0700[diff] [blame]98 phNfcIF_sReference_t hciReference = { NULL, 0, 0 };
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]99 phNfcIF_sCallBack_t if_callback = { NULL, NULL, NULL, NULL };
100 phNfc_sLowerIF_t *plower_if = NULL;
101 NFCSTATUS status = NFCSTATUS_SUCCESS;
102 uint8_t lower_index=0;
103
104 if( (NULL == psHciHandle) || (NULL == pHwRef) || (NULL == pHalNotify)
105 || (NULL== psContext) || (NULL == psHciLayerCfg) || (NULL == pHwConfig)
106 )
107 {
108 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
109 }
110 else if ( NULL != *(phHciNfc_sContext_t **)psHciHandle )
111 {
112 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_ALREADY_INITIALISED );
113 }
114 else
115 {
116 /* Create the memory for HCI Context */
117 psHciContext = (phHciNfc_sContext_t *)
118 phOsalNfc_GetMemory(sizeof(phHciNfc_sContext_t));
119
120 if(psHciContext != NULL)
121 {
122 (void)memset((void *)psHciContext,0,
123 sizeof(phHciNfc_sContext_t));
124
125 psHciContext->hci_state.cur_state = hciState_Reset;
126 psHciContext->hci_mode = hciMode_Reset;
127 psHciContext->p_hw_ref = pHwRef;
128 psHciContext->host_rf_type = phHal_eUnknown_DevType;
129 HCI_PRINT("HCI Initialisation in Progress.... \n");
130
131#ifdef ESTABLISH_SESSION
132 /*(void)memcpy(((phHal_sHwReference_t *)pHwRef)->session_id,
133 DEFAULT_SESSION, (sizeof(DEFAULT_SESSION) > 0x01) ?
134 sizeof(DEFAULT_SESSION):
135 sizeof(((phHal_sHwReference_t *)pHwRef)->session_id));*/
136 (void)memcpy(pHwConfig->session_id,
137 DEFAULT_SESSION, ((sizeof(DEFAULT_SESSION) > 0x01)
138 && (sizeof(DEFAULT_SESSION) <= 0x08 )) ?
139 sizeof(DEFAULT_SESSION):
140 sizeof(pHwConfig->session_id));
141#endif
142 HCI_DEBUG("Sizeof Default Session %u\n",sizeof(DEFAULT_SESSION));
143 psHciContext->p_upper_notify = pHalNotify;
144 psHciContext->p_upper_context = psContext;
145
146 if_callback.pif_ctxt = psHciContext ;
147 if_callback.send_complete = &phHciNfc_Send_Complete;
148 if_callback.receive_complete= &phHciNfc_Receive_Complete;
149 if_callback.notify = &phHciNfc_Notify_Event;
150 plower_if = hciReference.plower_if = &(psHciContext->lower_interface);
151 *((phHciNfc_sContext_t **)psHciHandle) = psHciContext;
152 psHciContext->init_mode = init_mode;
153 psHciContext->p_hci_layer = psHciLayerCfg ;
154 lower_index = psHciLayerCfg->layer_index - 1;
155
156 if(NULL != psHciLayerCfg->layer_next->layer_registry)
157 {
158 status = psHciLayerCfg->layer_next->layer_registry(
159 &hciReference, if_callback,
160 (void *)&psHciLayerCfg[lower_index]);
161 HCI_DEBUG("HCI Lower Layer Register, Status = %02X\n",status);
162 }
163 if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init) )
164 {
165 status = phHciNfc_FSM_Update ( psHciContext,
166 hciState_Initialise
167 );
168 if(NFCSTATUS_SUCCESS == status)
169 {
170 psHciContext->hci_seq = ADMIN_INIT_SEQ;
171 psHciContext->target_release = FALSE;
172 psHciContext->config_type = POLL_LOOP_CFG;
173 psHciContext->p_config_params = pHwConfig ;
174 status = plower_if->init((void *)plower_if->pcontext,
175 (void *)psHciContext->p_hw_ref);
176 HCI_DEBUG("HCI Lower Layer Initialisation, Status = %02X\n",status);
177 if( NFCSTATUS_PENDING != status )
178 {
179 /* Roll Back the State Machine to its Original State */
180 phHciNfc_FSM_Rollback ( psHciContext );
181 }
182 }
183 else
184 {
185 /* TODO: Handle Initialisation in the Invalid State */
186 }
187 }/* End of Lower Layer Init */
188 } /* End of Status Check for Memory */
189 else
190 {
191 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
192
193 HCI_PRINT("HCI Context Memory Allocation Failed\n");
194 }
195
196 }
197 return status;
198}
199
200
201/*!
202 * \brief Release of the HCI Interface .
203 *
204 * This function Closes all the open pipes and frees all the resources used by
205 * HCI Layer
206 */
207
208 NFCSTATUS
209 phHciNfc_Release (
210 void *psHciHandle,
211 void *pHwRef,
212 pphNfcIF_Notification_CB_t pHalReleaseCB,
213 void *psContext
214 )
215{
216 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
217 NFCSTATUS status = NFCSTATUS_SUCCESS;
218
219 if( (NULL == psHciHandle)
220 || (NULL == pHwRef)
221 )
222 {
223 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
224 }
225 /* This Scenario Forces the HCI and the lower layers
226 * to release its Resources
227 */
228 else if ( NULL == pHalReleaseCB )
229 {
230 /* Release the lower layer Resources */
231 phHciNfc_Release_Lower( psHciContext, pHwRef );
232 /* Release the HCI layer Resources */
233 phHciNfc_Release_Resources( &psHciContext );
234 }
235 else if ( NULL == psContext )
236 {
237 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
238 }
239 else
240 {
241 HCI_PRINT("HCI Release in Progress.... \n");
242 psHciContext->p_hw_ref = pHwRef;
243 status = phHciNfc_FSM_Update ( psHciContext, hciState_Release );
244 if ((NFCSTATUS_SUCCESS == status)
245#ifdef NXP_HCI_SHUTDOWN_OVERRIDE
246 || (NFCSTATUS_INVALID_STATE == PHNFCSTATUS(status))
247#endif
248 )
249 {
250 psHciContext->p_upper_notify = pHalReleaseCB;
251 psHciContext->p_upper_context = psContext;
252 /* psHciContext->hci_seq = EMULATION_REL_SEQ;*/
253 /* psHciContext->hci_seq = READER_MGMT_REL_SEQ; */
254 if (HCI_SELF_TEST != psHciContext->init_mode)
255 {
256 psHciContext->hci_seq = PL_STOP_SEQ;
257 }
258 else
259 {
260 psHciContext->hci_seq = ADMIN_REL_SEQ;
261 }
262
263#ifdef NXP_HCI_SHUTDOWN_OVERRIDE
264 if (NFCSTATUS_SUCCESS != status)
265 {
266 psHciContext->hci_state.next_state = (uint8_t) hciState_Release;
267 status = NFCSTATUS_PENDING;
268 }
269 else
270#endif
271 {
272 status = phHciNfc_Release_Sequence(psHciContext,pHwRef);
273 }
274
275 if( NFCSTATUS_PENDING != status )
276 {
277 /* Roll Back the State Machine to its Original State */
278 phHciNfc_FSM_Rollback ( psHciContext );
279 }
280 }
281 else
282 {
283 /* TODO: Return appropriate Error */
284 }
285
286 }
287
288 return status;
289}
290
291#if 0
292/*!
293 * \brief Interface to Starts the RF Device Discovery.
294 *
295 * This function Starts the Discovery Wheel.
296 */
297
298
299 NFCSTATUS
300 phHciNfc_Start_Discovery (
301 void *psHciHandle,
302 void *pHwRef
303 )
304{
305 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
306 NFCSTATUS status = NFCSTATUS_SUCCESS;
307
308 if ( (NULL == psHciHandle)
309 || (NULL == pHwRef)
310 )
311 {
312 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
313 }
314 else
315 {
316 status = phHciNfc_ReaderMgmt_Enable_Discovery( psHciContext, pHwRef );
317 }
318
319 return status;
320}
321
322
323/*!
324 * \brief Interface to Stop the RF Device Discovery.
325 *
326 * This function Stops the Discovery Wheel.
327 */
328
329
330 NFCSTATUS
331 phHciNfc_Stop_Discovery (
332 void *psHciHandle,
333 void *pHwRef
334 )
335{
336 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
337 NFCSTATUS status = NFCSTATUS_SUCCESS;
338
339 if ( (NULL == psHciHandle)
340 || (NULL == pHwRef)
341 )
342 {
343 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
344 }
345 else
346 {
347 status = phHciNfc_ReaderMgmt_Disable_Discovery( psHciContext, pHwRef );
348 }
349
350 return status;
351}
352
353
354#endif
355
356/*!
357 * \brief Interface to Configure the Device With the appropriate
358 * Configuration Parameters .
359 *
360 * This function configures the Devices with the provided
361 * configuration attributes.
362 */
363
364
365 NFCSTATUS
366 phHciNfc_Configure (
367 void *psHciHandle,
368 void *pHwRef,
369 phHal_eConfigType_t config_type,
370 phHal_uConfig_t *pConfig
371 )
372 {
373 NFCSTATUS status = NFCSTATUS_SUCCESS;
374
375 if( (NULL == psHciHandle)
376 || (NULL == pHwRef)
377 || (NULL == pConfig)
378 )
379 {
380 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
381 }
382 else
383 {
384 switch(config_type)
385 {
386 case NFC_P2P_CONFIG:
387 {
388#ifdef ENABLE_P2P
389 phHciNfc_sContext_t *psHciContext =
390 ((phHciNfc_sContext_t *)psHciHandle);
391 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
392
393 if (NFCSTATUS_SUCCESS == status)
394 {
395 psHciContext->config_type = NFC_GENERAL_CFG;
396 psHciContext->p_config_params = &(pConfig->nfcIPConfig);
397 psHciContext->hci_seq = INITIATOR_GENERAL_SEQ;
398 status = phHciNfc_NfcIP_SetATRInfo( psHciHandle,
399 pHwRef, NFCIP_INITIATOR,
400 &(pConfig->nfcIPConfig));
401 if( NFCSTATUS_PENDING != status )
402 {
403 /* Roll Back the State Machine to its Original State */
404 phHciNfc_FSM_Rollback ( psHciContext );
405 }
406 else
407 {
408 psHciContext->hci_seq = TARGET_GENERAL_SEQ;
409 }
410 }
411#else
412 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
413
414#endif
415 break;
416 }
417 case NFC_EMULATION_CONFIG:
418 {
419 status = phHciNfc_Config_Emulation( psHciHandle,
420 pHwRef, &(pConfig->emuConfig));
421 break;
422 }
423 case NFC_SE_PROTECTION_CONFIG:
424 {
425 phHciNfc_sContext_t *psHciContext =
426 ((phHciNfc_sContext_t *)psHciHandle);
427 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
428
429 if (NFCSTATUS_SUCCESS == status)
430 {
431 psHciContext->config_type = SWP_PROTECT_CFG;
432 psHciContext->p_config_params = &(pConfig->protectionConfig);
433 psHciContext->hci_seq = HCI_END_SEQ;
434 status = phHciNfc_SWP_Protection( psHciHandle,
435 pHwRef, pConfig->protectionConfig.mode);
436 if( NFCSTATUS_PENDING != status )
437 {
438 /* Roll Back the State Machine to its Original State */
439 phHciNfc_FSM_Rollback ( psHciContext );
440 }
441 }
442 break;
443 }
444 default:
445 {
446 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
447 break;
448 }
449 }/* End of the Configuration Switch */
450 }
451
452 return status;
453 }
454
455
456/*!
457 * \brief Interface to Configure the RF Device Discovery using
458 * HCI Polling Loop Gate .
459 *
460 * This function configures the HCI Polling Loop Gate with the provided
461 * configuration attributes.
462 */
463
464 NFCSTATUS
465 phHciNfc_Config_Discovery (
466 void *psHciHandle,
467 void *pHwRef,
468 phHal_sADD_Cfg_t *pPollConfig
469 )
470{
471 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
472 NFCSTATUS status = NFCSTATUS_SUCCESS;
473
474 if( (NULL == psHciHandle)
475 || (NULL == pHwRef)
476 || (NULL == pPollConfig)
477 )
478 {
479 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
480 }
481 else
482 {
483 psHciContext->p_hw_ref = pHwRef;
484 HCI_PRINT("HCI Poll Configuration .... \n");
485 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
486
487 if (NFCSTATUS_SUCCESS == status)
488 {
489#if 0
490 if(pPollConfig->PollDevInfo.PollEnabled)
491 {
492 psHciContext->hci_seq = PL_DURATION_SEQ;
493 }
494 else
495 {
496 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
497 /* psHciContext->hci_seq = (pPollConfig->NfcIP_Mode != 0 )?
498 PL_CONFIG_PHASE_SEQ:
499 READER_DISABLE_SEQ; */
500 }
501#endif
502 psHciContext->hci_seq = PL_DURATION_SEQ;
503 psHciContext->config_type = POLL_LOOP_CFG;
504 psHciContext->p_config_params = pPollConfig;
505 status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef );
506
507 if( NFCSTATUS_PENDING != status )
508 {
509 /* Roll Back the State Machine to its Original State */
510 phHciNfc_FSM_Rollback ( psHciContext );
511 }
512 }
513 else
514 {
515 /* TODO: Return appropriate Error */
516 }
517 }
518 return status;
519}
520
521/*!
522 * \brief Interface to Restart the RF Device Discovery.
523 *
524 * This function restarts the Discovery Wheel.
525 */
526
527
528 NFCSTATUS
529 phHciNfc_Restart_Discovery (
530 void *psHciHandle,
531 void *pHwRef,
532 uint8_t re_poll
533 )
534{
535 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
536 NFCSTATUS status = NFCSTATUS_SUCCESS;
537 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
538
539 if ( (NULL == psHciHandle)
540 || (NULL == pHwRef)
541 )
542 {
543 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
544 }
545 else
546 {
547 psHciContext->p_hw_ref = pHwRef;
548
549 /* To be back in the Poll State to Re-Poll the Target */
550 status = phHciNfc_FSM_Update ( psHciContext, hciState_Initialise );
551 if (NFCSTATUS_SUCCESS == status)
552 {
553 switch (psHciContext->host_rf_type)
554 {
555 case phHal_eISO14443_A_PCD:
556 {
557 target_type = phHal_eISO14443_A_PICC;
558 break;
559 }
560 case phHal_eNfcIP1_Initiator:
561 {
562 target_type = phHal_eNfcIP1_Target;
563 break;
564 }
565#ifdef TYPE_B
566 case phHal_eISO14443_B_PCD:
567 {
568 target_type = phHal_eISO14443_B_PICC;
569 break;
570 }
571#endif
572#ifdef TYPE_FELICA
573 case phHal_eFelica_PCD:
574 {
575 target_type = phHal_eFelica_PICC;
576 break;
577 }
578#endif
579#ifdef TYPE_JEWEL
580 case phHal_eJewel_PCD:
581 {
582 target_type = phHal_eJewel_PICC;
583 break;
584 }
585#endif
586#ifdef TYPE_ISO15693
587 case phHal_eISO15693_PCD:
588 {
589 target_type = phHal_eISO15693_PICC;
590 break;
591 }
592#endif /* #ifdef TYPE_ISO15693 */
593#ifndef TYPE_B
594 case phHal_eISO14443_B_PCD:
595#endif
596#ifndef TYPE_FELICA
597 case phHal_eFelica_PCD:
598#endif
599#ifndef TYPE_JEWEL
600 case phHal_eJewel_PCD:
601#endif
602#ifndef TYPE_B_PRIME
603 case phHal_eISO14443_BPrime_PCD:
604#endif
605 {
606 /* Roll Back the State Machine to its Original State */
607 phHciNfc_FSM_Rollback ( psHciContext );
608 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
609 break;
610 }
611 case phHal_eUnknown_DevType:
612 default:
613 {
614 /* Roll Back the State Machine to its Original State */
615 phHciNfc_FSM_Rollback ( psHciContext );
616 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
617 break;
618 }
619 }/* End of the Remote Target Type Switch */
620 if( NFCSTATUS_SUCCESS == status )
621 {
622 status = phHciNfc_ReaderMgmt_Deselect(
623 psHciContext, pHwRef, target_type, re_poll);
624 if( NFCSTATUS_PENDING != status )
625 {
626 /* Roll Back the State Machine to its Original State */
627 phHciNfc_FSM_Rollback ( psHciContext );
628 }
629 else
630 {
631 psHciContext->host_rf_type = phHal_eUnknown_DevType;
632 }
633 }
634 }
635 else
636 {
637 /* TODO: Return appropriate Error */
638 }
639 }
640
641 return status;
642}
643
644
645
646/*!
647 * \brief Interface to Configure the device to emulation as
648 * the tag, smart tag or p2p target .
649 *
650 * This function configures the HCI Polling Loop Gate with the provided
651 * configuration attributes.
652 */
653
654 static
655 NFCSTATUS
656 phHciNfc_Config_Emulation (
657 void *psHciHandle,
658 void *pHwRef,
659 phHal_sEmulationCfg_t *pEmulationCfg
660 )
661{
662 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
663 NFCSTATUS status = NFCSTATUS_SUCCESS;
664
665 if( (NULL == psHciHandle)
666 || (NULL == pHwRef)
667 || (NULL == pEmulationCfg)
668 )
669 {
670 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
671 }
672 else
673 {
674 psHciContext->p_hw_ref = pHwRef;
675
676 HCI_PRINT("HCI Configure Emulation .... \n");
677 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
678
679 if (NFCSTATUS_SUCCESS == status)
680 {
681 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
682 psHciContext->p_config_params = pEmulationCfg;
683 switch( pEmulationCfg->emuType )
684 {
685 case NFC_SMARTMX_EMULATION:
686 {
687 psHciContext->config_type = SMX_WI_CFG;
688 status = phHciNfc_Emulation_Cfg(psHciContext,
689 pHwRef, SMX_WI_CFG);
690 break;
691 }
692 case NFC_UICC_EMULATION:
693 {
694 psHciContext->config_type = UICC_SWP_CFG;
695 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
696 (void)phHciNfc_SWP_Update_Sequence(
697 psHciContext, CONFIG_SEQ );
698 status = phHciNfc_EmulationCfg_Sequence(
699 psHciContext, pHwRef);
700 break;
701 }
702 case NFC_HOST_CE_A_EMULATION:
703 case NFC_HOST_CE_B_EMULATION:
704#if defined(HOST_EMULATION)
705 {
706 if(TRUE == pEmulationCfg->config.
707 hostEmuCfg_A.enableEmulation)
708 {
709 psHciContext->hci_seq = ADMIN_CE_SEQ;
710 }
711 status = phHciNfc_EmulationCfg_Sequence(
712 psHciContext, pHwRef);
713 break;
714 }
715#endif
716 default:
717 {
718 break;
719 }
720
721 } /* End of Config Switch */
722 if( NFCSTATUS_PENDING != status )
723 {
724 /* Roll Back the State Machine to its Original State */
725 phHciNfc_FSM_Rollback ( psHciContext );
726 }
727 }
728 else
729 {
730 /* TODO: Return appropriate Error */
731 }
732 }
733
734 return status;
735}
736
737 NFCSTATUS
738 phHciNfc_Switch_SwpMode (
739 void *psHciHandle,
740 void *pHwRef,
741 phHal_eSWP_Mode_t swp_mode /* ,
742 void *pSwpCfg */
743 )
744{
745 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
746 NFCSTATUS status = NFCSTATUS_SUCCESS;
747
748 if( (NULL == psHciHandle)
749 || (NULL == pHwRef)
750 )
751 {
752 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
753 }
754 else
755 {
756 psHciContext->p_hw_ref = pHwRef;
757
758 HCI_PRINT("HCI SWP Switch .... ");
759 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
760 if (NFCSTATUS_SUCCESS == status)
761 {
762 psHciContext->config_type = SWP_EVT_CFG;
763 status = phHciNfc_SWP_Configure_Mode( psHciContext, pHwRef ,
764 (uint8_t) swp_mode );
765
766 /* Send the Success Status as this is an event */
767 status = ((status == NFCSTATUS_SUCCESS)?
768 NFCSTATUS_PENDING : status);
769
770 if( NFCSTATUS_PENDING != status )
771 {
772 /* Roll Back the State Machine to its Original State */
773 phHciNfc_FSM_Rollback ( psHciContext );
774
775 HCI_PRINT(" Execution Error \n");
776 }
777 else
778 {
779 HCI_PRINT(" Successful \n");
780 }
781 }
782 else
783 {
784 HCI_PRINT(" Not allowed - Invalid State \n");
785 /* TODO: Return appropriate Error */
786 }
787 }
788
789 return status;
790}
791
792
793
794/*!
795 * \brief Interface to Switch the Mode of the SmartMx from Virtual/Wired
796 * to the other mode.
797 *
798 * This function switches the mode of the SmartMX connected through WI(S2C)
799 * Interface to virtual/wired mode.
800 */
801
802
803 NFCSTATUS
804 phHciNfc_Switch_SmxMode (
805 void *psHciHandle,
806 void *pHwRef,
807 phHal_eSmartMX_Mode_t smx_mode,
808 phHal_sADD_Cfg_t *pPollConfig
809 )
810{
811 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
812 NFCSTATUS status = NFCSTATUS_SUCCESS;
813
814 if( (NULL == psHciHandle)
815 || (NULL == pHwRef)
816 || (NULL == pPollConfig)
817 )
818 {
819 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
820 }
821 else
822 {
823 psHciContext->p_hw_ref = pHwRef;
824
825 HCI_PRINT("HCI Smart MX Mode Switch .... \n");
826 status = phHciNfc_FSM_Update ( psHciContext, hciState_Config );
827
828 if (NFCSTATUS_SUCCESS == status)
829 {
830 psHciContext->hci_seq = READER_DISABLE_SEQ;
831 if ( (eSmartMx_Wired == psHciContext->smx_mode)
832 && ( hciState_Connect == psHciContext->hci_state.cur_state)
833 &&( eSmartMx_Wired != smx_mode)
834 )
835 {
836 /* Workaround: For Wired Mode Disconnect
837 All the statemachine updates should be done only with the
838 Statemachine API and should not be overridden.
839 */
840 psHciContext->hci_state.cur_state = hciState_Disconnect;
841 }
842 psHciContext->config_type = SMX_WI_MODE;
843 psHciContext->smx_mode = smx_mode;
844 psHciContext->p_config_params = pPollConfig;
845 status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef );
846 if( NFCSTATUS_PENDING != status )
847 {
848 /* Roll Back the State Machine to its Original State */
849 phHciNfc_FSM_Rollback ( psHciContext );
850 }
851 }
852 else
853 {
854 /* TODO: Return appropriate Error */
855 }
856 }
857
858 return status;
859}
860
861
862/*!
863 * \brief Interface to Select the Next Remote Target Discovered during the
864 * discovery sequence using the particular HCI Reader Gate .
865 *
866 *
867 * This function Selects and Activates the next Remote Target
868 * Detected using the particular HCI Reader Gate.
869 */
870
871
872
873NFCSTATUS
874phHciNfc_Select_Next_Target (
875 void *psHciHandle,
876 void *pHwRef
877 )
878{
879 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
880 NFCSTATUS status = NFCSTATUS_SUCCESS;
881
882 if( (NULL == psHciHandle)
883 || (NULL == pHwRef)
884 )
885 {
886 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
887 }
888 else
889 {
890 psHciContext->p_hw_ref = pHwRef;
891 status = phHciNfc_FSM_Update ( psHciContext, hciState_Select );
892 if (NFCSTATUS_SUCCESS == status)
893 {
894 psHciContext->hci_seq = READER_SELECT_SEQ;
895 status = phHciNfc_ReaderMgmt_Activate_Next( psHciContext, pHwRef );
896 if( NFCSTATUS_PENDING != status )
897 {
898 /* Roll Back the State Machine to its Original State */
899 phHciNfc_FSM_Rollback ( psHciContext );
900 }
901 }
902 else
903 {
904 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
905 }
906 }
907
908 return status;
909
910}
911
912
913/*!
914 * \brief Interface to Connect the Remote Target Discovered during the
915 * discovery sequence using the particular HCI Reader Gate .
916 *
917 *
918 * This function connects the Remote Target Detected using the particular
919 * HCI Reader Gate with the appropriate configuration setup.
920 */
921
922
923 NFCSTATUS
924 phHciNfc_Connect (
925 void *psHciHandle,
926 void *pHwRef,
927 phHal_sRemoteDevInformation_t *p_target_info
928 )
929 {
930 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
931 NFCSTATUS status = NFCSTATUS_SUCCESS;
932 /* phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; */
933
934 if( (NULL == psHciHandle)
935 || (NULL == pHwRef)
936 || (NULL == p_target_info)
937 )
938 {
939 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
940 }
941 else
942 {
943 psHciContext->p_hw_ref = pHwRef;
944 status = phHciNfc_FSM_Update ( psHciContext, hciState_Connect );
945 if (NFCSTATUS_SUCCESS == status)
946 {
947 psHciContext->hci_seq = READER_SELECT_SEQ;
948 switch (p_target_info->RemDevType)
949 {
950 case phHal_eISO14443_A_PICC:
951 case phHal_eISO14443_4A_PICC:
952 case phHal_eMifare_PICC:
953 case phHal_eISO14443_3A_PICC:
954#ifdef ENABLE_P2P
955 case phHal_eNfcIP1_Target:
956#endif
957#ifdef TYPE_B
958 case phHal_eISO14443_B_PICC:
959 case phHal_eISO14443_4B_PICC:
960#endif
961#ifdef TYPE_FELICA
962 case phHal_eFelica_PICC:
963#endif
964#ifdef TYPE_JEWEL
965 case phHal_eJewel_PICC:
966#endif
967#ifdef TYPE_ISO15693
968 case phHal_eISO15693_PICC:
969#endif /* #ifdef TYPE_ISO15693 */
970
971 {
972 psHciContext->p_target_info = p_target_info;
973 status = phHciNfc_ReaderMgmt_Select(
974 psHciContext, pHwRef,
975 p_target_info->RemDevType );
976 break;
977 }
978#ifndef TYPE_B_PRIME
979 case phHal_eISO14443_BPrime_PICC:
980#endif
981 case phHal_eUnknown_DevType:
982 default:
983 {
984 /* Roll Back the State Machine to its Original State */
985 phHciNfc_FSM_Rollback ( psHciContext );
986 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
987 break;
988 }
989 }/* End of the Remote Target Type Switch */
990 if( NFCSTATUS_PENDING != status )
991 {
992 /* Roll Back the State Machine to its Original State */
993 phHciNfc_FSM_Rollback ( psHciContext );
994 }
995 }
996 else
997 {
998 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
999 }
1000
1001 } /* End of the HCI Handle Validation */
1002
1003 return status;
1004}
1005
1006
1007/*!
1008 * \brief Interface to Reactivate the Remote Targets Discovered during the
1009 * discovery sequence using the particular HCI Reader Gate .
1010 *
1011 *
1012 * This function reactivates the Remote Target Detected using the particular
1013 * HCI Reader Gate with the appropriate configuration setup.
1014 */
1015
1016
1017 NFCSTATUS
1018 phHciNfc_Reactivate (
1019 void *psHciHandle,
1020 void *pHwRef,
1021 phHal_sRemoteDevInformation_t *p_target_info
1022 )
1023 {
1024 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1025 NFCSTATUS status = NFCSTATUS_SUCCESS;
1026 /* phHal_eRemDevType_t target_type = phHal_eUnknown_DevType; */
1027
1028 if( (NULL == psHciHandle)
1029 || (NULL == pHwRef)
1030 || (NULL == p_target_info)
1031 )
1032 {
1033 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1034 }
1035 else
1036 {
1037 psHciContext->p_hw_ref = pHwRef;
1038 status = phHciNfc_FSM_Update ( psHciContext, hciState_Reactivate );
1039 if (NFCSTATUS_SUCCESS == status)
1040 {
1041 psHciContext->hci_seq = READER_REACTIVATE_SEQ;
1042 switch (p_target_info->RemDevType)
1043 {
1044 case phHal_eISO14443_A_PICC:
1045 case phHal_eISO14443_4A_PICC:
1046 case phHal_eMifare_PICC:
1047 case phHal_eISO14443_3A_PICC:
1048 {
1049 psHciContext->host_rf_type = phHal_eISO14443_A_PCD;
1050 break;
1051 }
1052 case phHal_eNfcIP1_Target:
1053 {
1054 psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
1055 break;
1056 }
1057#ifdef TYPE_B
1058 case phHal_eISO14443_4B_PICC:
1059 case phHal_eISO14443_B_PICC:
1060 {
1061 psHciContext->host_rf_type = phHal_eISO14443_B_PCD;
1062 break;
1063 }
1064#endif
1065#ifdef TYPE_FELICA
1066 case phHal_eFelica_PICC:
1067 {
1068 psHciContext->host_rf_type = phHal_eFelica_PCD;
1069 break;
1070 }
1071#endif
1072#ifdef TYPE_B_PRIME
1073 case phHal_eISO14443_BPrime_PICC:
1074#endif
1075 /* Reactivate for Jewel is not Supported */
1076 case phHal_eJewel_PICC:
1077 case phHal_eUnknown_DevType:
1078 default:
1079 {
1080 /* Roll Back the State Machine to its Original State */
1081 phHciNfc_FSM_Rollback ( psHciContext );
1082 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1083 break;
1084 }
1085 }/* End of the Remote Target Type Switch */
1086 }
1087 else
1088 {
1089 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1090 }
1091
1092 if(NFCSTATUS_SUCCESS == status )
1093 {
1094 psHciContext->p_target_info = p_target_info;
1095 status = phHciNfc_ReaderMgmt_Reactivate(
1096 psHciContext, pHwRef, p_target_info->RemDevType );
1097 if( NFCSTATUS_PENDING != status )
1098 {
1099 /* Roll Back the State Machine to its Original State */
1100 phHciNfc_FSM_Rollback ( psHciContext );
1101 }
1102 }
1103 } /* End of the HCI Handle Validation */
1104
1105
1106 return status;
1107}
1108
1109
1110/*!
1111 * \brief Interface to Disconnect the selected target.
1112 *
1113 * This function disconnects the remote target selected.
1114 */
1115
1116
1117 NFCSTATUS
1118 phHciNfc_Disconnect (
1119 void *psHciHandle,
1120 void *pHwRef,
1121 uint8_t re_poll
1122 )
1123 {
1124 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1125 NFCSTATUS status = NFCSTATUS_SUCCESS;
1126 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
1127 /* phHal_eSmartMX_Mode_t smx_mode = (phHal_eSmartMX_Mode_t)type; */
1128 static uint8_t repoll=0;
1129
1130
1131 if( (NULL == psHciHandle)
1132 || (NULL == pHwRef)
1133 || ( NULL == psHciContext->p_target_info)
1134 )
1135 {
1136 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1137 }
1138 else
1139 {
1140 psHciContext->p_hw_ref = pHwRef;
1141 repoll = re_poll;
1142 psHciContext->p_config_params = &repoll;
1143 /* psHciContext->hci_seq = HCI_END_SEQ; */
1144
1145 /* To be back in the Poll State to Re-Poll the Target */
1146 status = phHciNfc_FSM_Update ( psHciContext, hciState_Disconnect );
1147 if (NFCSTATUS_SUCCESS == status)
1148 {
1149 psHciContext->hci_seq = READER_UICC_DISPATCH_SEQ;
1150 target_type = psHciContext->p_target_info->RemDevType;
1151 switch (target_type)
1152 {
1153 case phHal_eMifare_PICC:
1154 case phHal_eISO14443_A_PICC:
1155 case phHal_eISO14443_4A_PICC:
1156 case phHal_eISO14443_3A_PICC:
1157 case phHal_eNfcIP1_Target:
1158#ifdef TYPE_B
1159 case phHal_eISO14443_B_PICC:
1160 case phHal_eISO14443_4B_PICC:
1161#endif
1162#ifdef TYPE_FELICA
1163 case phHal_eFelica_PICC:
1164#endif
1165#ifdef TYPE_JEWEL
1166 case phHal_eJewel_PICC:
1167#endif
1168#ifdef TYPE_ISO15693
1169 case phHal_eISO15693_PICC:
1170#endif /* #ifdef TYPE_ISO15693 */
1171
1172 {
1173 status = phHciNfc_Disconnect_Sequence(
1174 psHciContext, pHwRef );
1175 break;
1176 }
1177#ifndef TYPE_B
1178 case phHal_eISO14443_B_PICC:
1179 case phHal_eISO14443_4B_PICC:
1180#endif
1181#ifndef TYPE_FELICA
1182 case phHal_eFelica_PICC:
1183#endif
1184#ifndef TYPE_JEWEL
1185 case phHal_eJewel_PICC:
1186#endif
1187#ifndef TYPE_B_PRIME
1188 case phHal_eISO14443_BPrime_PICC:
1189#endif
1190 {
1191 /* Roll Back the State Machine to its Original State */
1192 phHciNfc_FSM_Rollback ( psHciContext );
1193 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1194 break;
1195 }
1196 case phHal_eUnknown_DevType:
1197 default:
1198 {
1199 /* Roll Back the State Machine to its Original State */
1200 phHciNfc_FSM_Rollback ( psHciContext );
1201 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1202 break;
1203 }
1204 }/* End of the Remote Target Type Switch */
1205 if( NFCSTATUS_PENDING != status )
1206 {
1207 /* Roll Back the State Machine to its Original State */
1208 phHciNfc_FSM_Rollback ( psHciContext );
1209 }
1210 }
1211 else
1212 {
1213 /* TODO: Return appropriate Error */
1214 }
1215 } /* End of the HCI Handle Validation */
1216
1217 return status;
1218}
1219
1220/*!
1221 * \brief Interface to exchange the data to/from
1222 * the selected target.
1223 *
1224 * This function sends and receives the data to/from
1225 * the selected remote target.
1226 */
1227
1228 NFCSTATUS
1229 phHciNfc_Exchange_Data (
1230 void *psHciHandle,
1231 void *pHwRef,
1232 phHal_sRemoteDevInformation_t *p_target_info,
1233 phHciNfc_XchgInfo_t *p_xchg_info
1234 )
1235 {
1236 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1237 NFCSTATUS status = NFCSTATUS_SUCCESS;
1238
1239 if( (NULL == psHciHandle)
1240 || (NULL == pHwRef)
1241 || (NULL == p_target_info)
1242 || (NULL == p_xchg_info)
1243 )
1244 {
1245 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1246 }
1247 else if (p_target_info != psHciContext->p_target_info )
1248 {
1249 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_REMOTE_DEVICE);
1250 }
1251 else
1252 {
1253 psHciContext->p_hw_ref = pHwRef;
1254 status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact );
1255 if (NFCSTATUS_SUCCESS == status)
1256 {
1257 switch (p_target_info->RemDevType)
1258 {
1259 case phHal_eMifare_PICC:
1260 case phHal_eISO14443_A_PICC:
1261 case phHal_eISO14443_4A_PICC:
1262 case phHal_eISO14443_3A_PICC:
1263#ifdef TYPE_B
1264 case phHal_eISO14443_B_PICC:
1265 case phHal_eISO14443_4B_PICC:
1266#endif
1267#ifdef TYPE_FELICA
1268 case phHal_eFelica_PICC:
1269#endif
1270#ifdef TYPE_JEWEL
1271 case phHal_eJewel_PICC:
1272#endif
1273#ifdef TYPE_ISO15693
1274 case phHal_eISO15693_PICC:
1275#endif /* #ifdef TYPE_ISO15693 */
1276 {
1277 psHciContext->p_xchg_info = p_xchg_info;
1278 status = phHciNfc_ReaderMgmt_Exchange_Data(
1279 psHciContext, pHwRef, p_xchg_info );
1280 break;
1281 }
1282#ifndef TYPE_B
1283 case phHal_eISO14443_B_PICC:
1284 case phHal_eISO14443_4B_PICC:
1285#endif
1286#ifndef TYPE_FELICA
1287 case phHal_eFelica_PICC:
1288#endif
1289#ifndef TYPE_JEWEL
1290 case phHal_eJewel_PICC:
1291#endif
1292 case phHal_eNfcIP1_Target:
1293#ifndef TYPE_B_PRIME
1294 case phHal_eISO14443_BPrime_PICC:
1295#endif
1296 {
1297 /* Roll Back the State Machine to its Original State */
1298 phHciNfc_FSM_Rollback ( psHciContext );
1299 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1300 break;
1301 }
1302 case phHal_eUnknown_DevType:
1303 default:
1304 {
1305 /* Roll Back the State Machine to its Original State */
1306 phHciNfc_FSM_Rollback ( psHciContext );
1307 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1308 break;
1309 }
1310
1311 }/* End of the Remote Target Type Switch */
1312 if( NFCSTATUS_PENDING != status )
1313 {
1314 /* Roll Back the State Machine to its Original State */
1315 phHciNfc_FSM_Rollback ( psHciContext );
1316 }
1317 }
1318 else
1319 {
1320 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1321 }
1322 } /* End of the HCI Handle Validation */
1323
1324 return status;
1325}
1326
1327/*!
1328 * \brief Interface to Send the data to/from
1329 * the selected NfcIP.
1330 *
1331 * This function sends and receives the data to/from
1332 * the selected remote target.
1333 */
1334
1335 NFCSTATUS
1336 phHciNfc_Send_Data (
1337 void *psHciHandle,
1338 void *pHwRef,
1339 phHal_sRemoteDevInformation_t *p_remote_dev_info,
1340 phHciNfc_XchgInfo_t *p_send_param
1341 )
1342 {
1343 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1344 NFCSTATUS status = NFCSTATUS_SUCCESS;
1345
1346 if( (NULL == psHciHandle)
1347 || (NULL == pHwRef)
1348 || (NULL == p_send_param)
1349 )
1350 {
1351 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1352 }
1353 else
1354 {
1355 psHciContext->p_hw_ref = pHwRef;
1356 status = phHciNfc_FSM_Update ( psHciContext, hciState_Transact );
1357 if (NFCSTATUS_SUCCESS == status)
1358 {
1359 switch (psHciContext->host_rf_type)
1360 {
1361 case phHal_eISO14443_A_PICC:
1362 case phHal_eISO14443_B_PICC:
1363 case phHal_eISO14443_4A_PICC:
1364 case phHal_eISO14443_4B_PICC:
1365 {
1366 break;
1367 }
1368#ifdef ENABLE_P2P
1369 case phHal_eNfcIP1_Initiator:
1370 {
1371 if (p_remote_dev_info !=
1372 psHciContext->p_target_info )
1373 {
1374 status = PHNFCSTVAL(CID_NFC_HCI,
1375 NFCSTATUS_INVALID_REMOTE_DEVICE);
1376 }
1377 else
1378 {
1379 psHciContext->p_xchg_info = p_send_param;
1380 status = phHciNfc_NfcIP_Send_Data( psHciContext,
1381 pHwRef, p_send_param );
1382 }
1383 break;
1384 }
1385 case phHal_eNfcIP1_Target:
1386 {
1387 psHciContext->p_xchg_info = p_send_param;
1388 status = phHciNfc_NfcIP_Send_Data( psHciContext,
1389 pHwRef, p_send_param );
1390 break;
1391 }
1392#endif
1393#ifdef TYPE_B_PRIME
1394 case phHal_eISO14443_BPrime_PCD:
1395 case phHal_eFelica_PCD:
1396 {
1397 /* Roll Back the State Machine to its Original State */
1398 phHciNfc_FSM_Rollback ( psHciContext );
1399 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1400 break;
1401 }
1402#endif
1403 case phHal_eUnknown_DevType:
1404 default:
1405 {
1406 /* Roll Back the State Machine to its Original State */
1407 phHciNfc_FSM_Rollback ( psHciContext );
1408 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1409 break;
1410 }
1411
1412 }/* End of the Remote Target Type Switch */
1413#if defined( ENABLE_P2P ) || defined (TYPE_B_PRIME)
1414 if( NFCSTATUS_PENDING != status )
1415#endif
1416 {
1417 /* Roll Back the State Machine to its Original State */
1418 phHciNfc_FSM_Rollback ( psHciContext );
1419 }
1420 }
1421 else
1422 {
1423 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1424 }
1425 } /* End of the HCI Handle Validation */
1426
1427 return status;
1428
1429 }
1430
1431#if 0
1432
1433/*!
1434 * \brief Interface to Send the data from
1435 * the selected NfcIP.
1436 *
1437 * This function sends and receives the data to/from
1438 * the selected remote target.
1439 */
1440
1441 NFCSTATUS
1442 phHciNfc_Receive_Data (
1443 void *psHciHandle,
1444 void *pHwRef,
1445 uint8_t *p_data,
1446 uint8_t length
1447 )
1448 {
1449 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
1450 NFCSTATUS status = NFCSTATUS_SUCCESS;
1451
1452 if( (NULL == psHciHandle)
1453 || (NULL == pHwRef)
1454 )
1455 {
1456 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1457 }
1458 else
1459 {
1460 if (NFCSTATUS_SUCCESS == status)
1461 {
1462 status = phHciNfc_Receive(psHciHandle, pHwRef, p_data, length);
1463 if( NFCSTATUS_PENDING != status )
1464 {
1465 /* Roll Back the State Machine to its Original State */
1466 phHciNfc_FSM_Rollback ( psHciContext );
1467 }
1468 }
1469 }
1470 return status;
1471
1472 }
1473
1474#endif
1475
1476 /*!
1477 * \brief Interface to Check for the presence of
1478 * the selected target in the field .
1479 *
1480 * This function checks the presence of the
1481 * the selected remote target in the field .
1482 */
1483
1484
1485
1486NFCSTATUS
1487phHciNfc_Presence_Check (
1488 void *psHciHandle,
1489 void *pHwRef
1490 )
1491{
1492 NFCSTATUS status = NFCSTATUS_SUCCESS;
1493 phHciNfc_sContext_t *psHciContext =
1494 ((phHciNfc_sContext_t *)psHciHandle);
1495 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
1496
1497 if( (NULL == psHciContext)
1498 || (NULL == pHwRef)
1499 )
1500 {
1501 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1502 }
1503 else
1504 {
1505 psHciContext->p_hw_ref = pHwRef;
1506 status = phHciNfc_FSM_Update ( psHciContext, hciState_Presence );
1507 if (NFCSTATUS_SUCCESS == status)
1508 {
1509 target_type = psHciContext->p_target_info->RemDevType;
1510 switch (target_type)
1511 {
1512 case phHal_eISO14443_A_PICC:
1513 case phHal_eMifare_PICC:
1514 case phHal_eISO14443_4A_PICC:
1515 case phHal_eISO14443_3A_PICC:
1516#ifdef TYPE_B
1517 case phHal_eISO14443_B_PICC:
1518 case phHal_eISO14443_4B_PICC:
1519#endif
1520#ifdef TYPE_FELICA
1521 case phHal_eFelica_PICC:
1522#endif
1523#ifdef TYPE_JEWEL
1524 case phHal_eJewel_PICC:
1525#endif
1526#ifdef TYPE_ISO15693
1527 case phHal_eISO15693_PICC:
1528#endif /* #ifdef TYPE_ISO15693 */
1529#ifdef ENABLE_P2P
1530 case phHal_eNfcIP1_Target:
1531#endif
1532 {
1533 status = phHciNfc_ReaderMgmt_Presence_Check(
1534 psHciContext, pHwRef );
1535 break;
1536 }
1537#ifdef TYPE_B_PRIME
1538 case phHal_eISO14443_BPrime_PICC:
1539#endif
1540#ifndef TYPE_B
1541 case phHal_eISO14443_B_PICC:
1542 case phHal_eISO14443_4B_PICC:
1543#endif
1544#ifndef TYPE_FELICA
1545 case phHal_eFelica_PICC:
1546#endif
1547#ifndef TYPE_JEWEL
1548 case phHal_eJewel_PICC:
1549#endif
1550 case phHal_eUnknown_DevType:
1551 {
1552 /* Roll Back the State Machine to its Original State */
1553 phHciNfc_FSM_Rollback ( psHciContext );
1554 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1555 break;
1556 }
1557 default:
1558 {
1559 /* Roll Back the State Machine to its Original State */
1560 phHciNfc_FSM_Rollback ( psHciContext );
1561 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1562 break;
1563 }
1564
1565 }/* End of the Remote Target Type Switch */
1566 if( NFCSTATUS_PENDING != status )
1567 {
1568 /* Roll Back the State Machine to its Original State */
1569 phHciNfc_FSM_Rollback ( psHciContext );
1570 }
1571 }
1572 else
1573 {
1574 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1575 }
1576 } /* End of the HCI Handle Validation */
1577
1578 return status;
1579}
1580
1581 NFCSTATUS
1582 phHciNfc_PRBS_Test (
1583 void *psHciHandle,
1584 void *pHwRef,
1585 uint32_t test_type,
1586 phNfc_sData_t *test_param
1587 )
1588 {
1589 NFCSTATUS status = NFCSTATUS_SUCCESS;
1590 phHciNfc_sContext_t *psHciContext =
1591 ((phHciNfc_sContext_t *)psHciHandle);
1592
1593 if( (NULL == psHciContext)
1594 || (NULL == pHwRef)
1595 || (test_type != DEVMGMT_PRBS_TEST)
1596 )
1597 {
1598 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1599 }
1600 else
1601 {
1602 psHciContext->p_hw_ref = pHwRef;
1603 status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1604 if (NFCSTATUS_SUCCESS == status)
1605 {
1606 status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef,
1607 (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param);
1608 if( NFCSTATUS_PENDING != status )
1609 {
1610 /* Roll Back the State Machine to its Original State */
1611 phHciNfc_FSM_Rollback ( psHciContext );
1612 }
1613 }
1614 }
1615 return status;
1616 }
1617
1618
1619 NFCSTATUS
1620 phHciNfc_System_Test (
1621 void *psHciHandle,
1622 void *pHwRef,
1623 uint32_t test_type,
1624 phNfc_sData_t *test_param
1625 )
1626{
1627 NFCSTATUS status = NFCSTATUS_SUCCESS;
1628 phHciNfc_sContext_t *psHciContext =
1629 ((phHciNfc_sContext_t *)psHciHandle);
1630 static phNfc_sData_t test_result;
1631 static uint8_t gpio_status = 0;
1632
1633 if( (NULL == psHciContext)
1634 || (NULL == pHwRef)
1635 )
1636 {
1637 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1638 }
1639 else
1640 {
1641 psHciContext->p_hw_ref = pHwRef;
1642 status = phHciNfc_FSM_Update ( psHciContext, hciState_Test );
1643 if (NFCSTATUS_SUCCESS == status)
1644 {
1645 if (test_type != NFC_GPIO_READ)
1646 {
1647 status = phHciNfc_DevMgmt_Test(psHciContext, pHwRef,
1648 (uint8_t)(test_type & DEVMGMT_TEST_MASK), test_param);
1649 }
1650 else
1651 {
1652 test_result.buffer = &gpio_status;
1653 status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
1654 (uint16_t)NFC_GPIO_READ, test_result.buffer);
1655
1656 }
1657 if( NFCSTATUS_PENDING != status )
1658 {
1659 /* Roll Back the State Machine to its Original State */
1660 phHciNfc_FSM_Rollback ( psHciContext );
1661 }
1662 }
1663 }
1664
1665 return status;
1666}
1667
1668
1669 NFCSTATUS
1670 phHciNfc_System_Configure (
1671 void *psHciHandle,
1672 void *pHwRef,
1673 uint32_t config_type,
1674 uint8_t config_value
1675 )
1676{
1677 NFCSTATUS status = NFCSTATUS_SUCCESS;
1678 phHciNfc_sContext_t *psHciContext =
1679 ((phHciNfc_sContext_t *)psHciHandle);
1680
1681 if( (NULL == psHciContext)
1682 || (NULL == pHwRef)
1683 )
1684 {
1685 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1686 }
1687 else
1688 {
1689 psHciContext->p_hw_ref = pHwRef;
1690 status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1691 if (NFCSTATUS_SUCCESS == status)
1692 {
1693 status = phHciNfc_DevMgmt_Configure(psHciContext, pHwRef,
1694 (uint16_t)config_type, config_value);
1695
1696 if( NFCSTATUS_PENDING != status )
1697 {
1698 /* Roll Back the State Machine to its Original State */
1699 phHciNfc_FSM_Rollback ( psHciContext );
1700 }
1701 }
1702 }
1703 return status;
1704}
1705
1706NFCSTATUS
1707 phHciNfc_System_Get_Info(
1708 void *psHciHandle,
1709 void *pHwRef,
1710 uint32_t config_type,
1711 uint8_t *p_config_value
1712 )
1713{
1714 NFCSTATUS status = NFCSTATUS_SUCCESS;
1715 phHciNfc_sContext_t *psHciContext =
1716 ((phHciNfc_sContext_t *)psHciHandle);
1717
1718 if( (NULL == psHciContext)
1719 || (NULL == pHwRef)
1720 || (NULL == p_config_value)
1721 )
1722 {
1723 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1724 }
1725 else
1726 {
1727 psHciContext->p_hw_ref = pHwRef;
1728 status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1729 if (NFCSTATUS_SUCCESS == status)
1730 {
1731 status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
1732 (uint16_t)config_type, p_config_value);
1733
1734 if( NFCSTATUS_PENDING != status )
1735 {
1736 /* Roll Back the State Machine to its Original State */
1737 phHciNfc_FSM_Rollback ( psHciContext );
1738 }
1739 }
1740 }
1741
1742 return status;
1743}
1744
1745
1746 NFCSTATUS
1747 phHciNfc_Get_Link_Status(
1748 void *psHciHandle,
1749 void *pHwRef
1750 )
1751{
1752 NFCSTATUS status = NFCSTATUS_SUCCESS;
1753 phHciNfc_sContext_t *psHciContext =
1754 ((phHciNfc_sContext_t *)psHciHandle);
1755
1756 if( (NULL == psHciContext)
1757 || (NULL == pHwRef)
1758 )
1759 {
1760 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1761 }
1762 else
1763 {
1764 psHciContext->p_hw_ref = pHwRef;
1765 status = phHciNfc_FSM_Update ( psHciContext, hciState_IO );
1766 if (NFCSTATUS_SUCCESS == status)
1767 {
1768 status = phHciNfc_LinkMgmt_Open(psHciContext, pHwRef);
1769
1770 if( NFCSTATUS_PENDING != status )
1771 {
1772 /* Roll Back the State Machine to its Original State */
1773 phHciNfc_FSM_Rollback ( psHciContext );
1774 }
1775 }
1776 }
1777
1778 return status;
1779}
1780
1781
1782