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 * *
22 * \file phHciNfc_Sequence.c *
23 * \brief State Machine Implementation for the HCI Management and *
24 * and the Function Sequence for a particular State *
25 * *
26 * *
27 * Project: NFC-FRI-1.1 *
28 * *
29 * $Date: Tue Jun 8 09:33:46 2010 $ *
30 * $Author: ing04880 $ *
31 * $Revision: 1.85 $ *
32 * $Aliases: NFC_FRI1.1_WK1023_R35_1 $
33 * *
34 * =========================================================================== *
35 */
36
37 /*
38 ################################################################################
39 ***************************** Header File Inclusion ****************************
40 ################################################################################
41 */
42
43 #include <phNfcCompId.h>
44 #include <phNfcConfig.h>
45 #include <phHciNfc.h>
46 #include <phHciNfc_Sequence.h>
47 #include <phHciNfc_AdminMgmt.h>
48 #include <phHciNfc_IDMgmt.h>
49 #include <phHciNfc_LinkMgmt.h>
50 #include <phHciNfc_DevMgmt.h>
51 #include <phHciNfc_PollingLoop.h>
52 #include <phHciNfc_RFReader.h>
53 #include <phHciNfc_RFReaderA.h>
54 #include <phHciNfc_Emulation.h>
55 #ifdef ENABLE_P2P
56 #include <phHciNfc_NfcIPMgmt.h>
57 #endif
58 #include <phHciNfc_SWP.h>
59 #include <phHciNfc_WI.h>
60 #include <phOsalNfc.h>
61
62 /*
63 ################################################################################
64 ****************************** Macro Definitions *******************************
65 ################################################################################
66 */
67
68 /* Address Definitions for HAL Configuration */
69 #define NFC_ADDRESS_HAL_CONF 0x9FD0U
70
71
72 /*
73 ################################################################################
74 ********************** Structure/Enumeration Definitions ***********************
75 ################################################################################
76 */
77
78
79 #ifdef VALIDATE_FSM
80
81 typedef struct phHciNfc_sFsm
82 {
83 phHciNfc_eState_t from_state;
84 phHciNfc_eState_t to_state;
85 uint8_t valid;
86 }phHciNfc_sFsm_t;
87
88 static phHciNfc_sFsm_t phHciNfc_Valid_Fsm[] = {
89 {hciState_Reset, hciState_Initialise , TRUE},
90 /* {hciState_Reset, hciState_Config, FALSE}, */
91 {hciState_Initialise, hciState_Config, TRUE},
92 {hciState_Initialise, hciState_Release, TRUE},
93 {hciState_Config, hciState_Connect, TRUE},
94 {hciState_Config, hciState_Release, TRUE},
95 {hciState_Connect, hciState_Activate, TRUE},
96 {hciState_Connect, hciState_Transact, TRUE},
97 {hciState_Connect, hciState_Disconnect, TRUE},
98 {hciState_Disconnect, hciState_Config, TRUE},
99 /* {hciState_Disconnect, hciState_Release, TRUE}, */
100 {hciState_Reset, hciState_Initialise, TRUE},
101 };
102
103 #endif
104
105
106 /*
107 ################################################################################
108 ************************* Function Prototype Declaration ***********************
109 ################################################################################
110 */
111
112
113 static
114 NFCSTATUS
115 phHciNfc_Config_Sequence(
116 phHciNfc_sContext_t *psHciContext,
117 void *pHwRef
118 );
119
120
121 /**
122 * \ingroup grp_hci_nfc
123 *
124 * The phHciNfc_Connect_Sequence function sequence selects the
125 * discovered target for performing the transaction.
126 *
127 * \param[in] psHciContext psHciContext is the context of
128 * the HCI Layer.
129 * \param[in] pHwRef pHwRef is the Information of
130 * the Device Interface Link .
131 *
132 * \retval NFCSTATUS_SUCCESS HCI target selection sequence successful.
133 * \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
134 * could not be interpreted properly.
135 * \retval Other errors Other related errors
136 *
137 */
138
139 static
140 NFCSTATUS
141 phHciNfc_Transact_Sequence(
142 phHciNfc_sContext_t *psHciContext,
143 void *pHwRef
144 );
145
146 /**
147 * \ingroup grp_hci_nfc
148 *
149 * The phHciNfc_Info_Sequence function sequence selects the
150 * discovered target for performing the transaction.
151 *
152 * \param[in] psHciContext psHciContext is the context of
153 * the HCI Layer.
154 * \param[in] pHwRef pHwRef is the Information of
155 * the Device Interface Link .
156 *
157 * \retval NFCSTATUS_SUCCESS HCI target selection sequence successful.
158 * \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
159 * could not be interpreted properly.
160 * \retval Other errors Other related errors
161 *
162 */
163
164 static
165 NFCSTATUS
166 phHciNfc_Info_Sequence(
167 phHciNfc_sContext_t *psHciContext,
168 void *pHwRef
169 );
170
171 static
172 NFCSTATUS
173 phHciNfc_Test_Sequence(
174 phHciNfc_sContext_t *psHciContext,
175 void *pHwRef,
176 NFCSTATUS test_status,
177 uint8_t *pdata,
178 uint8_t length
179 );
180
181 #ifdef HCI_FSM_RESET
182
183 static
184 void
185 phHciNfc_FSM_Reset(
186 phHciNfc_sContext_t *psHciContext
187 );
188
189 #endif
190
191 static
192 NFCSTATUS
193 phHciNfc_IO_Sequence(
194 phHciNfc_sContext_t *psHciContext,
195 void *pHwRef,
196 NFCSTATUS test_status,
197 uint8_t *pdata,
198 uint8_t length
199 );
200
201 static
202 NFCSTATUS
203 phHciNfc_Pending_Sequence(
204 phHciNfc_sContext_t *psHciContext,
205 void *pHwRef
206 );
207
208
209 /*
210 ################################################################################
211 ***************************** Function Definitions *****************************
212 ################################################################################
213 */
214
215 NFCSTATUS
phHciNfc_FSM_Validate(phHciNfc_sContext_t * psHciContext,phHciNfc_eState_t state,uint8_t validate_type)216 phHciNfc_FSM_Validate(
217 phHciNfc_sContext_t *psHciContext,
218 phHciNfc_eState_t state,
219 uint8_t validate_type
220 )
221 {
222 NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
223 phHciNfc_eState_t cur_state = (phHciNfc_eState_t)
224 psHciContext->hci_state.cur_state;
225
226 switch(validate_type)
227 {
228 case NFC_FSM_CURRENT:
229 {
230 if( cur_state == (uint8_t) state )
231 {
232 status = NFCSTATUS_SUCCESS;
233 }
234 break;
235 }
236 case NFC_FSM_NEXT:
237 {
238 phHciNfc_eState_t next_state = state;
239 switch (cur_state)
240 {
241 case hciState_Reset:
242 {
243 switch(next_state)
244 {
245 /* Specifies the Starting of the init Sequence */
246 case hciState_Initialise:
247 /* Initialise to Perform Test on
248 the Antenna/SWP Link */
249 case hciState_Test:
250 {
251 status = NFCSTATUS_SUCCESS;
252 break;
253 }
254 default:
255 break;
256 }
257 break;
258 }
259 case hciState_Initialise:
260 {
261 switch(next_state)
262 {
263 /* Discovery Resume after connect failure */
264 case hciState_Initialise:
265 /* Configuring the Discovery/Emulation */
266 case hciState_Config:
267 /* Configuring the Memory */
268 case hciState_IO:
269 /* Occurence of the Tag Discovered Event */
270 case hciState_Select:
271 /* Occurence of the Target Activated Event */
272 case hciState_Listen:
273 /* Specifies the Starting of the Release Sequence */
274 case hciState_Release:
275 {
276 status = NFCSTATUS_SUCCESS;
277 break;
278 }
279 default:
280 break;
281 }
282 break;
283 }
284 case hciState_Test:
285 {
286 if ((hciState_Test == next_state )
287 || (hciState_IO == next_state)
288 || (hciState_Release == next_state))
289 {
290 /* Next Test/Reset Sequence */
291 status = NFCSTATUS_SUCCESS;
292 }
293 break;
294 }
295 case hciState_Select:
296 {
297 switch(next_state)
298 {
299 /* Restart the Wheel */
300 case hciState_Initialise:
301 /* Select the next Tag in the Field or
302 * already Selected Tag Again
303 */
304 /* Configuring the Memory */
305 case hciState_IO:
306 case hciState_Select:
307 /* Configuring the Discovery/Emulation */
308 case hciState_Config:
309 /* Re-Activate the Target or
310 * Discover the next target
311 */
312 case hciState_Reactivate:
313 /* Connect the Discovered Target */
314 case hciState_Connect:
315 /* Specifies the Starting of the Release Sequence */
316 case hciState_Release:
317 {
318 status = NFCSTATUS_SUCCESS;
319 break;
320 }
321 default:
322 break;
323 }
324 break;
325 }
326 case hciState_Connect:
327 {
328 switch(next_state)
329 {
330 /* Disabling the Tag Discovery */
331 case hciState_Initialise:
332 /* Configuring the Discovery/Emulation */
333 /* This should not be allowed if the target
334 * is connected.
335 */
336 /* Configuring the Memory */
337 case hciState_IO:
338 case hciState_Config:
339 /* Re-Activate the Target or
340 * Discover the next target
341 */
342 case hciState_Reactivate:
343 /* Intermediate Transceive State */
344 case hciState_Transact:
345 /* Intermediate Presence Check State */
346 case hciState_Presence:
347 /* Disconnect the Target Connected */
348 case hciState_Disconnect:
349 /* Specifies the Starting of the Release Sequence */
350 case hciState_Release:
351 {
352 status = NFCSTATUS_SUCCESS;
353 break;
354 }
355 default:
356 break;
357 }
358 break;
359 }
360 case hciState_Listen:
361 {
362 switch(next_state)
363 {
364 /* Releasing from the Emulation/Target Mode */
365 case hciState_Initialise:
366 /* Occurence of the Tag Discovered Event
367 * after the Disconnect Operation
368 */
369 case hciState_Select:
370 /* Configuring the Memory */
371 case hciState_IO:
372 /* Configuring the Discovery/Emulation */
373 case hciState_Config:
374 /* Intermediate Transceive State */
375 case hciState_Transact:
376 /* Specifies the Starting of the Release Sequence */
377 case hciState_Release:
378 {
379 status = NFCSTATUS_SUCCESS;
380 break;
381 }
382 default:
383 break;
384 }
385 break;
386 }
387 case hciState_Reactivate:
388 {
389 switch(next_state)
390 {
391 /* Restart/Discovery after the Target is removed
392 * after Reactivation.
393 */
394 /* case hciState_Initialise: */
395 /* Re-Connect the Re-Activated Target */
396 case hciState_Connect:
397 /* Configuring the Memory */
398 case hciState_IO:
399 /* Configuring the Discovery/Emulation */
400 case hciState_Config:
401 /* Specifies the Starting of the Release Sequence */
402 case hciState_Release:
403 {
404 status = NFCSTATUS_SUCCESS;
405 break;
406 }
407 default:
408 break;
409 }
410 break;
411 }
412 case hciState_Disconnect:
413 {
414 switch(next_state)
415 {
416 /* Discovery Resume after connect failure
417 after the disconnect */
418 case hciState_Initialise:
419 /* Configuring the Memory */
420 case hciState_IO:
421 /* Configuring the Discovery/Emulation */
422 case hciState_Config:
423 /* Occurence of the Tag Discovered Event
424 * after the Disconnect Operation
425 */
426 case hciState_Select:
427 /* Occurence of the Target Activated Event */
428 case hciState_Listen:
429 /* Specifies the Starting of the Release Sequence */
430 case hciState_Release:
431 {
432 status = NFCSTATUS_SUCCESS;
433 break;
434 }
435 default:
436 {
437 break;
438 }
439 }
440 break;
441 }
442 #ifdef USE_M5
443 case hciState_Presence:
444 case hciState_Transact:
445 case hciState_Release:
446 {
447 break;
448 }
449 #endif
450 /* case phHciNfc_Unknown: */
451 default:
452 {
453 /* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); */
454 break;
455 }
456 } /* End of State Validation Switch */
457 if( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
458 {
459 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
460 }
461 break;
462 }
463 default:
464 {
465 HCI_DEBUG("State Validate Type:%x is Unknown/Incorrect \n",
466 validate_type);
467 break;
468 }
469 }
470 return status;
471 }
472
473 NFCSTATUS
phHciNfc_FSM_Update(phHciNfc_sContext_t * psHciContext,phHciNfc_eState_t next_state)474 phHciNfc_FSM_Update(
475 phHciNfc_sContext_t *psHciContext,
476 phHciNfc_eState_t next_state
477 )
478 {
479 NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
480
481 HCI_DEBUG(" HCI: Current State --> %02u \n",
482 psHciContext->hci_state.cur_state );
483 HCI_DEBUG(" HCI: Transition Before FSM Update --> %02u \n",
484 psHciContext->hci_state.transition );
485 HCI_DEBUG(" HCI: Next State Before FSM Update --> %02u \n",
486 psHciContext->hci_state.next_state );
487
488 status = phHciNfc_FSM_Validate(psHciContext, next_state, NFC_FSM_NEXT );
489 if(NFCSTATUS_SUCCESS == status)
490 {
491 psHciContext->hci_state.next_state = (uint8_t) next_state;
492 psHciContext->hci_state.transition = NFC_FSM_IN_PROGRESS;
493 psHciContext->response_pending = FALSE;
494 HCI_DEBUG(" HCI: Next State After FSM Update --> %02u \n",
495 psHciContext->hci_state.next_state );
496 }
497 else
498 {
499 HCI_DEBUG(" HCI: FSM - Invalid next state --> %02u \n",
500 next_state );
501 }
502
503 return status;
504 }
505
506
507 NFCSTATUS
phHciNfc_FSM_Complete(phHciNfc_sContext_t * psHciContext)508 phHciNfc_FSM_Complete(
509 phHciNfc_sContext_t *psHciContext
510 )
511 {
512 NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
513
514 HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);
515
516 HCI_DEBUG(" HCI: Transition Before FSM Complete --> %02u \n",
517 psHciContext->hci_state.transition );
518
519 HCI_DEBUG(" HCI: Current State Before FSM Complete --> %02u \n",
520 psHciContext->hci_state.cur_state );
521
522 HCI_DEBUG(" HCI: Next State Before FSM Complete --> %02u \n",
523 psHciContext->hci_state.next_state );
524
525 if( (NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition)
526 )
527 {
528 psHciContext->hci_state.cur_state =
529 psHciContext->hci_state.next_state ;
530 psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
531 psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
532 /* Reset the HCI Sequence */
533 psHciContext->response_pending = FALSE;
534 psHciContext->hci_seq = HCI_INVALID_SEQ;
535 status = NFCSTATUS_SUCCESS;
536 }
537
538 HCI_DEBUG(" HCI: Current State After FSM Complete --> %02u \n",
539 psHciContext->hci_state.cur_state );
540
541 return status;
542 }
543
544 void
phHciNfc_FSM_Rollback(phHciNfc_sContext_t * psHciContext)545 phHciNfc_FSM_Rollback(
546 phHciNfc_sContext_t *psHciContext
547 )
548 {
549
550 HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);
551
552 HCI_DEBUG(" HCI: Transition Before FSM Rollback --> %02u \n",
553 psHciContext->hci_state.transition );
554
555 HCI_DEBUG(" HCI: Current State Before FSM Rollback --> %02u \n",
556 psHciContext->hci_state.cur_state );
557
558 HCI_DEBUG(" HCI: Next State Before FSM Rollback --> %02u \n",
559 psHciContext->hci_state.next_state );
560
561 if( (NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition)
562 )
563 {
564 psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
565 psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
566 /* Reset the HCI Sequence */
567 psHciContext->hci_seq = HCI_INVALID_SEQ;
568 psHciContext->response_pending = FALSE;
569 }
570 }
571
572 #ifdef HCI_FSM_RESET
573 static
574 void
phHciNfc_FSM_Reset(phHciNfc_sContext_t * psHciContext)575 phHciNfc_FSM_Reset(
576 phHciNfc_sContext_t *psHciContext
577 )
578 {
579
580 if( (hciState_Reset != psHciContext->hci_state.cur_state )
581 )
582 {
583 psHciContext->hci_state.cur_state = (uint8_t) hciState_Initialise ;
584 psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
585 psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
586 /* Reset the HCI Sequence */
587 psHciContext->hci_seq = HCI_INVALID_SEQ;
588 }
589
590 }
591 #endif
592
593
594
595 static
596 NFCSTATUS
phHciNfc_Pending_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)597 phHciNfc_Pending_Sequence(
598 phHciNfc_sContext_t *psHciContext,
599 void *pHwRef
600 )
601 {
602 NFCSTATUS status = NFCSTATUS_SUCCESS;
603
604 PHNFC_UNUSED_VARIABLE(status);
605
606 HCI_DEBUG("HCI: psHciContext->target_release --> %s \n",
607 (psHciContext->target_release)?"TRUE":"FALSE");
608 if(TRUE == psHciContext->target_release)
609 {
610 #ifdef SW_RELEASE_TARGET
611 status = phHciNfc_ReaderMgmt_Deselect(
612 psHciContext, pHwRef, phHal_eISO14443_A_PICC, TRUE);
613 if(NFCSTATUS_PENDING == status )
614 {
615 psHciContext->target_release = FALSE ;
616 }
617 }
618 else
619 {
620 status = psHciContext->error_status;
621 #else
622 psHciContext->target_release = FALSE ;
623 #endif
624 }
625
626 return status;
627 }
628
629
630 void
phHciNfc_Error_Sequence(void * psContext,void * pHwRef,NFCSTATUS error_status,void * pdata,uint8_t length)631 phHciNfc_Error_Sequence(
632 void *psContext,
633 void *pHwRef,
634 NFCSTATUS error_status,
635 void *pdata,
636 uint8_t length
637 )
638 {
639 NFCSTATUS status = NFCSTATUS_SUCCESS;
640 phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;
641
642 PHNFC_UNUSED_VARIABLE(status);
643
644 HCI_DEBUG("HCI: In Function: %s \n",
645 __FUNCTION__);
646
647 HCI_DEBUG ("HCI : Error Status : %04X\n", error_status);
648
649 HCI_DEBUG(" HCI: Current HCI State --> %02u \n",
650 psHciContext->hci_state.cur_state );
651 HCI_DEBUG(" HCI: Next HCI State --> %02u \n",
652 psHciContext->hci_state.next_state );
653
654
655 if ( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
656 {
657 switch(psHciContext->hci_state.next_state)
658 {
659 case hciState_Initialise:
660 {
661 if (hciState_Reset == psHciContext->hci_state.cur_state)
662 {
663 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
664
665 phHciNfc_Release_Lower( psHciContext, pHwRef );
666 /* Release all the resources and
667 * Notify the Receive Error Scenario to the Upper Layer
668 */
669 comp_info.status = error_status ;
670 phHciNfc_Release_Notify (psHciContext, pHwRef,
671 NFC_NOTIFY_INIT_FAILED, &comp_info);
672 }
673 else if (hciState_Config == psHciContext->hci_state.cur_state)
674 {
675 /* Notify the Poll/Emulation Configure failure to the upper layer */
676
677 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
678
679 comp_info.status = error_status ;
680
681 psHciContext->error_status = error_status;
682 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
683 /* Rollback the FSM as the Poll/Emulation configuration Failed */
684 phHciNfc_FSM_Rollback(psHciContext);
685 psHciContext->error_status = NFCSTATUS_SUCCESS;
686 phHciNfc_Notify(psHciContext->p_upper_notify,
687 psHciContext->p_upper_context, pHwRef,
688 NFC_NOTIFY_CONFIG_ERROR, &comp_info);
689 }
690 else
691 {
692
693 /* Notify the Poll Configure failure to the upper layer */
694 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
695
696
697 psHciContext->error_status = error_status;
698 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
699 /* Rollback the FSM as the Poll Disable Failed */
700 phHciNfc_FSM_Rollback(psHciContext);
701 comp_info.status = error_status ;
702 psHciContext->error_status = NFCSTATUS_SUCCESS;
703 phHciNfc_Notify(psHciContext->p_upper_notify,
704 psHciContext->p_upper_context, pHwRef,
705 NFC_NOTIFY_ERROR, &comp_info);
706 }
707 break;
708 }
709 case hciState_Test:
710 {
711 status = phHciNfc_Test_Sequence( psHciContext, pHwRef , error_status,
712 (uint8_t *)pdata, length );
713 break;
714 }
715 case hciState_IO:
716 {
717 status = phHciNfc_IO_Sequence( psHciContext, pHwRef , error_status,
718 (uint8_t *)pdata, length );
719 break;
720 }
721 case hciState_Config:
722 {
723 /* Notify the Configure failure to the upper layer */
724 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
725
726 psHciContext->error_status = error_status;
727 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
728 /* Rollback the FSM as the Poll Failed */
729 phHciNfc_FSM_Rollback(psHciContext);
730 comp_info.status = psHciContext->error_status ;
731 psHciContext->error_status = NFCSTATUS_SUCCESS;
732 phHciNfc_Notify(psHciContext->p_upper_notify,
733 psHciContext->p_upper_context, pHwRef,
734 NFC_NOTIFY_CONFIG_ERROR, &comp_info);
735 break;
736 }
737 case hciState_Select:
738 {
739 /* Notify the Configure failure to the upper layer */
740 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
741
742 /* Rollback the FSM as the Target Discovery Failed */
743 phHciNfc_FSM_Rollback(psHciContext);
744 status = phHciNfc_ReaderMgmt_Update_Sequence(
745 psHciContext, INFO_SEQ );
746 comp_info.status = error_status ;
747 phHciNfc_Notify(psHciContext->p_upper_notify,
748 psHciContext->p_upper_context, pHwRef,
749 NFC_NOTIFY_DISCOVERY_ERROR, &comp_info);
750
751 #if 0
752 /* Polling Wheel will be restarted by the upper layer
753 * to Rediscover again */
754 if(NFCSTATUS_SUCCESS == status)
755 {
756 status = phHciNfc_ReaderMgmt_Deselect(
757 psHciContext, pHwRef, phHal_eISO14443_A_PICC, FALSE);
758 }
759 phHciNfc_FSM_Rollback(psHciContext);
760 #endif
761 break;
762 }
763 case hciState_Transact:
764 /* Notify the Transceive failure to the upper layer */
765 {
766 phNfc_sTransactionInfo_t transact_info={FALSE,0,NULL,NULL,0};
767
768 /* Rollback the FSM as the Transceive Failed */
769 phHciNfc_FSM_Rollback(psHciContext);
770 transact_info.status = error_status;
771 transact_info.buffer = NULL;
772 transact_info.length = FALSE;
773 psHciContext->p_xchg_info = NULL ;
774 phHciNfc_Notify(psHciContext->p_upper_notify,
775 psHciContext->p_upper_context, pHwRef,
776 NFC_NOTIFY_TRANSCEIVE_ERROR, &transact_info);
777 break;
778
779 }
780 case hciState_Connect:
781 {
782 /* Notify the General failure to the upper layer */
783 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
784
785 /* psHciContext->host_rf_type = phHal_eUnknown_DevType; */
786 status = phHciNfc_ReaderMgmt_Update_Sequence(
787 psHciContext, INFO_SEQ );
788 psHciContext->p_target_info = NULL;
789 psHciContext->hci_state.cur_state = hciState_Select;
790 phHciNfc_FSM_Rollback(psHciContext);
791 comp_info.status = error_status ;
792 phHciNfc_Notify(psHciContext->p_upper_notify,
793 psHciContext->p_upper_context, pHwRef,
794 NFC_NOTIFY_CONNECT_FAILED, &comp_info);
795 break;
796 }
797 case hciState_Reactivate:
798 {
799 /* Notify the General failure to the upper layer */
800 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
801
802 /* psHciContext->host_rf_type = phHal_eUnknown_DevType;
803 status = phHciNfc_ReaderMgmt_Update_Sequence(
804 psHciContext, INFO_SEQ );
805 psHciContext->p_target_info = NULL;
806 psHciContext->hci_state.cur_state = hciState_Select; */
807 phHciNfc_FSM_Rollback(psHciContext);
808 comp_info.status = error_status ;
809 phHciNfc_Notify(psHciContext->p_upper_notify,
810 psHciContext->p_upper_context, pHwRef,
811 NFC_NOTIFY_CONNECT_FAILED, &comp_info);
812 break;
813 }
814 case hciState_Presence:
815 {
816 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
817
818 /* Roll Back to Connect State as Presence Check is Complete */
819 phHciNfc_FSM_Rollback(psHciContext);
820
821 /* Initialisation Complete Notification to the Upper Layer */
822 comp_info.status = error_status;
823 phHciNfc_Notify(psHciContext->p_upper_notify,
824 psHciContext->p_upper_context, pHwRef,
825 NFC_NOTIFY_ERROR, &comp_info);
826 HCI_PRINT(" HCI Remote Target Removed from the Field. \n");
827 break;
828 }
829 /* Notify the Connect or Disconnect failure to the upper layer */
830 case hciState_Disconnect:
831 {
832 /* Notify the General failure to the upper layer */
833 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
834
835 phHciNfc_FSM_Rollback(psHciContext);
836 comp_info.status = error_status ;
837 phHciNfc_Notify(psHciContext->p_upper_notify,
838 psHciContext->p_upper_context, pHwRef,
839 NFC_NOTIFY_DISCONNECT_FAILED, &comp_info);
840 break;
841 }
842 case hciState_Release:
843 {
844 #ifdef NXP_HCI_SHUTDOWN_OVERRIDE
845 status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
846 #else
847 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
848
849 phHciNfc_Release_Lower( psHciContext, pHwRef );
850 /* Release all the resources and
851 * Notify the Receive Error Scenario to the Upper Layer
852 */
853 comp_info.status = error_status ;
854 phHciNfc_Release_Notify (psHciContext, pHwRef,
855 NFC_NOTIFY_DEINIT_FAILED, &comp_info);
856 #endif
857 break;
858 }
859 default:
860 {
861 /* Notify the General failure to the upper layer */
862 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
863
864 phHciNfc_FSM_Rollback(psHciContext);
865 comp_info.status = error_status ;
866 psHciContext->error_status = error_status;
867 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
868 if (NFCSTATUS_PENDING != status)
869 {
870 psHciContext->error_status = NFCSTATUS_SUCCESS;
871 phHciNfc_Notify(psHciContext->p_upper_notify,
872 psHciContext->p_upper_context, pHwRef,
873 NFC_NOTIFY_ERROR, &comp_info);
874 }
875 break;
876 }
877
878 } /* End of the Processing of HCI State*/
879 }
880 else
881 {
882 /* Notify the General failure to the upper layer */
883 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
884 phHciNfc_FSM_Rollback(psHciContext);
885 comp_info.status = error_status ;
886 /* Disable the Notification to the Upper Layer */
887 if(NFCSTATUS_BOARD_COMMUNICATION_ERROR
888 == PHNFCSTATUS(error_status))
889 {
890 phHciNfc_Notify(psHciContext->p_upper_notify,
891 psHciContext->p_upper_context, pHwRef,
892 NFC_NOTIFY_ERROR, &comp_info);
893 }
894 else
895 {
896 psHciContext->error_status = error_status;
897 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
898 if (NFCSTATUS_PENDING != status)
899 {
900 psHciContext->error_status = NFCSTATUS_SUCCESS;
901 }
902 }
903 }
904 return;
905 }
906
907
908
909 NFCSTATUS
phHciNfc_Resume_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)910 phHciNfc_Resume_Sequence(
911 phHciNfc_sContext_t *psHciContext,
912 void *pHwRef
913 )
914 {
915 NFCSTATUS status = NFCSTATUS_SUCCESS;
916
917 HCI_DEBUG("HCI: In Function: %s \n",
918 __FUNCTION__);
919
920 HCI_DEBUG(" HCI: Current HCI State --> %02u \n",
921 psHciContext->hci_state.cur_state );
922 HCI_DEBUG(" HCI: Next HCI State --> %02u \n",
923 psHciContext->hci_state.next_state );
924
925 switch(psHciContext->hci_state.next_state)
926 {
927 /* Process the Admin Gate Response based on the HCI State */
928 case hciState_Initialise:
929 {
930 switch (psHciContext->hci_state.cur_state)
931 {
932 /* Initialise State after Power on */
933 case hciState_Reset:
934 {
935 status = phHciNfc_Initialise_Sequence(psHciContext ,pHwRef);
936 break;
937 }
938 /* Initialise State after Power on */
939 case hciState_Config:
940 {
941 status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
942 break;
943 }
944 /* Discovery Resume after connect failure */
945 case hciState_Initialise:
946 case hciState_Select:
947 case hciState_Connect:
948 {
949 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
950
951 /* Update to the Intialise state as the discovery wheel is
952 * restarted.
953 */
954 status = phHciNfc_FSM_Complete(psHciContext);
955
956 psHciContext->host_rf_type = phHal_eUnknown_DevType;
957 psHciContext->p_target_info = NULL;
958 psHciContext->p_xchg_info = NULL;
959
960 /* Initialisation Complete Notification to the Upper Layer */
961 comp_info.status = status;
962 phHciNfc_Notify(psHciContext->p_upper_notify,
963 psHciContext->p_upper_context, pHwRef,
964 NFC_NOTIFY_POLL_RESTARTED , &comp_info);
965 HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
966 break;
967 }
968 default:
969 {
970 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
971 break;
972 }
973 }
974 break;
975 }
976 case hciState_Release:
977 {
978 status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
979 break;
980 }
981 case hciState_Config:
982 {
983 status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
984 break;
985 }
986 case hciState_Listen:
987 case hciState_Select:
988 {
989 status = phHciNfc_Info_Sequence( psHciContext, pHwRef );
990 break;
991 }
992 case hciState_Reactivate:
993 case hciState_Connect:
994 {
995 status = phHciNfc_Connect_Sequence( psHciContext, pHwRef );
996 break;
997 }
998 case hciState_Transact:
999 {
1000 status = phHciNfc_Transact_Sequence(
1001 psHciContext, pHwRef );
1002 break;
1003 }
1004 case hciState_Presence:
1005 {
1006 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
1007
1008 /* Roll Back to Connect State as Presence Check is Complete */
1009 phHciNfc_FSM_Rollback(psHciContext);
1010
1011 /* Initialisation Complete Notification to the Upper Layer */
1012 comp_info.status = NFCSTATUS_SUCCESS;
1013 phHciNfc_Notify(psHciContext->p_upper_notify,
1014 psHciContext->p_upper_context, pHwRef,
1015 NFC_NOTIFY_TARGET_PRESENT , &comp_info);
1016 HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
1017 break;
1018 }
1019 case hciState_Disconnect:
1020 {
1021 status = phHciNfc_Disconnect_Sequence( psHciContext, pHwRef );
1022 break;
1023 }
1024 case hciState_Test:
1025 {
1026 status = phHciNfc_Test_Sequence( psHciContext, pHwRef , status, NULL, 0 );
1027 break;
1028 }
1029 case hciState_IO:
1030 {
1031 status = phHciNfc_IO_Sequence( psHciContext, pHwRef , status, NULL, 0 );
1032 break;
1033 }
1034 case hciState_Unknown:
1035 {
1036 break;
1037 }
1038 default:
1039 {
1040 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
1041 break;
1042 }
1043 } /* End of the Processing of HCI State*/
1044
1045 return status;
1046 }
1047
1048
1049 NFCSTATUS
phHciNfc_Initialise_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1050 phHciNfc_Initialise_Sequence(
1051 phHciNfc_sContext_t *psHciContext,
1052 void *pHwRef
1053 )
1054 {
1055 NFCSTATUS status = NFCSTATUS_SUCCESS;
1056 static uint8_t config = 0;
1057
1058 PHNFC_UNUSED_VARIABLE(config);
1059
1060 switch(psHciContext->hci_seq)
1061 {
1062 case ADMIN_INIT_SEQ:
1063 {
1064 status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
1065 if(NFCSTATUS_SUCCESS == status)
1066 {
1067 #ifdef ESTABLISH_SESSION
1068 if( hciMode_Session == psHciContext->hci_mode)
1069 {
1070 /* TODO: Initialise Link Management
1071 Gate Resources */
1072 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1073 PHNFC_UNUSED_VARIABLE(info_status);
1074 info_status = phHciNfc_IDMgmt_Update_Sequence(
1075 psHciContext, INFO_SEQ );
1076
1077 if(NFCSTATUS_SUCCESS == info_status)
1078 {
1079 psHciContext->hci_seq = PL_STOP_SEQ;
1080 }
1081 else
1082 {
1083 psHciContext->hci_seq = HCI_END_SEQ;
1084 status = PHNFCSTVAL(CID_NFC_HCI,
1085 NFCSTATUS_INVALID_HCI_SEQUENCE);
1086 }
1087 }
1088 else
1089 #endif
1090 {
1091 psHciContext->hci_seq = LINK_MGMT_INIT_SEQ;
1092 }
1093 }
1094 break;
1095 }
1096 case LINK_MGMT_INIT_SEQ:
1097 {
1098 status = phHciNfc_LinkMgmt_Initialise( psHciContext,pHwRef );
1099 if(NFCSTATUS_SUCCESS == status)
1100 {
1101 psHciContext->hci_seq = IDENTITY_INIT_SEQ;
1102 }
1103 break;
1104 }
1105 case IDENTITY_INIT_SEQ:
1106 {
1107 status = phHciNfc_IDMgmt_Initialise( psHciContext,pHwRef );
1108 if(NFCSTATUS_SUCCESS == status)
1109 {
1110 psHciContext->hci_seq = DEV_INIT_SEQ;
1111 }
1112 break;
1113 }
1114 case DEV_INIT_SEQ:
1115 {
1116 status = phHciNfc_DevMgmt_Initialise( psHciContext,pHwRef );
1117 if(NFCSTATUS_SUCCESS == status)
1118 {
1119 if (HCI_SELF_TEST != psHciContext->init_mode)
1120 {
1121 psHciContext->hci_seq = PL_INIT_SEQ;
1122 }
1123 else
1124 {
1125 #if defined( ESTABLISH_SESSION )
1126 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1127 PHNFC_UNUSED_VARIABLE(info_status);
1128 info_status = phHciNfc_IDMgmt_Update_Sequence(
1129 psHciContext, INFO_SEQ );
1130
1131 if(NFCSTATUS_SUCCESS == info_status)
1132 {
1133 #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1134 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1135 #else
1136 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
1137 #endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
1138 }
1139 else
1140 {
1141 psHciContext->hci_seq = HCI_END_SEQ;
1142 status = PHNFCSTVAL(CID_NFC_HCI,
1143 NFCSTATUS_INVALID_HCI_SEQUENCE);
1144 }
1145 #elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1146 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1147 #else
1148 psHciContext->hci_seq = HCI_END_SEQ;
1149 #endif /* #ifdef ESTABLISH_SESSION */
1150 }
1151
1152 }
1153 break;
1154 }
1155 case PL_INIT_SEQ:
1156 {
1157 status = phHciNfc_PollLoop_Initialise( psHciContext,pHwRef );
1158 if(NFCSTATUS_SUCCESS == status)
1159 {
1160 NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
1161 PHNFC_UNUSED_VARIABLE(reset_status);
1162 reset_status = phHciNfc_ReaderMgmt_Update_Sequence(
1163 psHciContext, RESET_SEQ );
1164 psHciContext->hci_seq = READER_MGMT_INIT_SEQ;
1165 }
1166 break;
1167 }
1168 case READER_MGMT_INIT_SEQ:
1169 {
1170 status = phHciNfc_ReaderMgmt_Initialise( psHciContext,pHwRef );
1171 if(NFCSTATUS_SUCCESS == status)
1172 {
1173 NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
1174 PHNFC_UNUSED_VARIABLE(reset_status);
1175 reset_status = phHciNfc_EmuMgmt_Update_Seq(
1176 psHciContext, RESET_SEQ );
1177 psHciContext->hci_seq = EMULATION_INIT_SEQ;
1178 }
1179 break;
1180 }
1181 case EMULATION_INIT_SEQ:
1182 {
1183 status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
1184 if(NFCSTATUS_SUCCESS == status)
1185 {
1186 #if defined( ESTABLISH_SESSION )
1187 psHciContext->hci_seq = ADMIN_SESSION_SEQ;
1188 #elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1189 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1190 #else
1191 psHciContext->hci_seq = HCI_END_SEQ;
1192 #endif
1193 }
1194 break;
1195 }
1196 #ifdef ESTABLISH_SESSION
1197 case ADMIN_SESSION_SEQ:
1198 {
1199 status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
1200 if(NFCSTATUS_SUCCESS == status)
1201 {
1202 #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1203 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1204 #else
1205 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
1206 #endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
1207 }
1208 break;
1209 }
1210 case PL_STOP_SEQ:
1211 {
1212 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1213 psHciContext, pHwRef );
1214 if(NFCSTATUS_SUCCESS == status)
1215 {
1216 #if defined( SW_AUTO_ACTIVATION )
1217 psHciContext->hci_seq = READER_SW_AUTO_SEQ;
1218 #elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1219 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1220 #else
1221 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
1222 #endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
1223 }
1224 break;
1225 }
1226 #ifdef SW_AUTO_ACTIVATION
1227 case READER_SW_AUTO_SEQ:
1228 {
1229 uint8_t activate_enable = FALSE;
1230 uint8_t rdr_enable = TRUE;
1231
1232 status = phHciNfc_ReaderA_Update_Info(
1233 psHciContext, HCI_READER_A_ENABLE,
1234 &rdr_enable);
1235 if(status == NFCSTATUS_SUCCESS)
1236 {
1237 status = phHciNfc_ReaderA_Auto_Activate( psHciContext,
1238 pHwRef, activate_enable );
1239 if(status == NFCSTATUS_SUCCESS)
1240 {
1241 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
1242 }
1243 }
1244 break;
1245 }
1246 #endif
1247 /* fall through */
1248 case IDENTITY_INFO_SEQ:
1249 {
1250 status = phHciNfc_IDMgmt_Info_Sequence( psHciContext,pHwRef );
1251 if(NFCSTATUS_SUCCESS == status)
1252 {
1253 if ((HCI_SELF_TEST != psHciContext->init_mode)
1254 /* && ( TRUE == ((phHal_sHwReference_t *)pHwRef)->se_detect ) */
1255 && (HCI_CUSTOM_INIT != psHciContext->init_mode)
1256 && (HCI_NFC_DEVICE_TEST != psHciContext->init_mode))
1257 {
1258 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1259 PHNFC_UNUSED_VARIABLE(info_status);
1260 info_status = phHciNfc_EmuMgmt_Update_Seq(
1261 psHciContext, INFO_SEQ );
1262
1263 if(NFCSTATUS_SUCCESS == info_status)
1264 {
1265 psHciContext->hci_seq = EMULATION_SWP_SEQ;
1266 }
1267 }
1268 else
1269 {
1270 psHciContext->hci_seq = HCI_END_SEQ;
1271 }
1272 }
1273 break;
1274 }
1275 case EMULATION_SWP_SEQ:
1276 {
1277 status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
1278 if(NFCSTATUS_SUCCESS == status)
1279 {
1280 psHciContext->hci_seq = HCI_END_SEQ;
1281 }
1282 break;
1283 }
1284 #endif /* #ifdef ESTABLISH_SESSION */
1285
1286 #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1287 case DEV_HAL_INFO_SEQ:
1288 {
1289 static uint8_t mem_index = 0;
1290 status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
1291 (NFC_ADDRESS_HAL_CONF + mem_index),
1292 (psHciContext->hal_mem_info + mem_index));
1293 if(NFCSTATUS_PENDING == status)
1294 {
1295 mem_index++;
1296 if (NXP_HAL_MEM_INFO_SIZE <= mem_index )
1297 {
1298 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1299 PHNFC_UNUSED_VARIABLE(info_status);
1300 info_status = phHciNfc_IDMgmt_Update_Sequence(
1301 psHciContext, INFO_SEQ );
1302 mem_index = 0;
1303 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
1304 /* psHciContext->hci_seq =
1305 (HCI_SELF_TEST != psHciContext->init_mode)?
1306 IDENTITY_INFO_SEQ : HCI_END_SEQ; */
1307 }
1308 }
1309 break;
1310 }
1311 #endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
1312 case HCI_END_SEQ:
1313 {
1314 phHal_sMemInfo_t *p_mem_info =
1315 (phHal_sMemInfo_t *) ( psHciContext->hal_mem_info );
1316 if (
1317 (HCI_SELF_TEST == psHciContext->init_mode )
1318 || (HCI_NFC_DEVICE_TEST == psHciContext->init_mode )
1319 )
1320 {
1321 psHciContext->hci_state.next_state
1322 = (uint8_t) hciState_Test;
1323 }
1324 status = phHciNfc_FSM_Complete ( psHciContext );
1325 #ifdef UICC_CONNECTIVITY_PATCH
1326 phHciNfc_Uicc_Connectivity( psHciContext, pHwRef );
1327 #endif /* #ifdef UICC_CONNECTIVITY_PATCH */
1328
1329 #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1330 if(NXP_FW_UPLOAD_SUCCESS != p_mem_info->fw_magic )
1331 {
1332 status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FAILED );
1333 }
1334 #endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
1335
1336 /* Initialisation Complete Notification to the Upper Layer */
1337 if(NFCSTATUS_SUCCESS == status)
1338 {
1339 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
1340
1341 comp_info.status = status;
1342 phHciNfc_Notify(psHciContext->p_upper_notify,
1343 psHciContext->p_upper_context, pHwRef,
1344 NFC_NOTIFY_INIT_COMPLETED, &comp_info);
1345 HCI_PRINT("HCI Initialisation Completed \n");
1346 }
1347 else
1348 {
1349 pphNfcIF_Notification_CB_t p_upper_notify = psHciContext->p_upper_notify;
1350 void *pcontext = psHciContext->p_upper_context;
1351 phNfc_sCompletionInfo_t comp_info;
1352
1353
1354 phHciNfc_Release_Lower( psHciContext, pHwRef );
1355 phHciNfc_Release_Resources( &psHciContext );
1356 /* Notify the Failure to the Upper Layer */
1357 comp_info.status = status;
1358 phHciNfc_Notify( p_upper_notify, pcontext, pHwRef,
1359 NFC_NOTIFY_INIT_FAILED, &comp_info);
1360 HCI_PRINT("HCI FSM Initialisation Error \n");
1361 }
1362 break;
1363 }
1364 default:
1365 break;
1366 }
1367
1368 return status;
1369 }
1370
1371
1372 NFCSTATUS
phHciNfc_Release_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1373 phHciNfc_Release_Sequence(
1374 phHciNfc_sContext_t *psHciContext,
1375 void *pHwRef
1376 )
1377 {
1378 NFCSTATUS status = NFCSTATUS_SUCCESS;
1379
1380 switch(psHciContext->hci_seq)
1381 {
1382 case PL_STOP_SEQ:
1383 {
1384 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1385 psHciContext, pHwRef );
1386 if(NFCSTATUS_SUCCESS == status)
1387 {
1388 (void)phHciNfc_EmuMgmt_Update_Seq(
1389 psHciContext, REL_SEQ );
1390 psHciContext->hci_seq = EMULATION_REL_SEQ;
1391 status = NFCSTATUS_PENDING;
1392 }
1393 break;
1394 }
1395 case EMULATION_REL_SEQ:
1396 {
1397 status = phHciNfc_EmuMgmt_Release( psHciContext,pHwRef );
1398 if(NFCSTATUS_SUCCESS == status)
1399 {
1400 (void)phHciNfc_DevMgmt_Update_Sequence(
1401 psHciContext, REL_SEQ );
1402 psHciContext->hci_seq = ADMIN_REL_SEQ;
1403 status = NFCSTATUS_PENDING;
1404 }
1405 break;
1406 }
1407 case DEV_REL_SEQ:
1408 {
1409 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1410 PHNFC_UNUSED_VARIABLE(info_status);
1411 info_status = phHciNfc_DevMgmt_Update_Sequence(
1412 psHciContext, REL_SEQ );
1413 status = phHciNfc_DevMgmt_Release( psHciContext, pHwRef );
1414 if(NFCSTATUS_SUCCESS == status)
1415 {
1416 psHciContext->hci_seq = HCI_END_SEQ;
1417 status = NFCSTATUS_PENDING;
1418 }
1419 break;
1420 }
1421 case READER_MGMT_REL_SEQ:
1422 {
1423 status = phHciNfc_ReaderMgmt_Release( psHciContext,pHwRef );
1424 if(NFCSTATUS_SUCCESS == status)
1425 {
1426 psHciContext->hci_seq = PL_REL_SEQ;
1427 status = NFCSTATUS_PENDING;
1428 }
1429 break;
1430 }
1431 case PL_REL_SEQ:
1432 {
1433 status = phHciNfc_PollLoop_Release( psHciContext,pHwRef );
1434 if(NFCSTATUS_SUCCESS == status)
1435 {
1436 psHciContext->hci_seq = IDENTITY_REL_SEQ;
1437 status = NFCSTATUS_PENDING;
1438 }
1439 break;
1440 }
1441 case IDENTITY_REL_SEQ:
1442 {
1443 status = phHciNfc_IDMgmt_Release( psHciContext,pHwRef );
1444 if(NFCSTATUS_SUCCESS == status)
1445 {
1446 psHciContext->hci_seq = LINK_MGMT_REL_SEQ;
1447 status = NFCSTATUS_PENDING;
1448 }
1449 break;
1450 }
1451 case LINK_MGMT_REL_SEQ:
1452 {
1453 status = phHciNfc_LinkMgmt_Release( psHciContext,pHwRef );
1454 if(NFCSTATUS_SUCCESS == status)
1455 {
1456 psHciContext->hci_seq = ADMIN_REL_SEQ;
1457 status = NFCSTATUS_PENDING;
1458 }
1459 break;
1460 }
1461 case ADMIN_REL_SEQ:
1462 {
1463 /* Admin Management Release Sequence */
1464 status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_TerminalHostID );
1465 if(NFCSTATUS_SUCCESS == status)
1466 {
1467 psHciContext->hci_seq = DEV_REL_SEQ;
1468 status = NFCSTATUS_PENDING;
1469 }
1470 break;
1471 }
1472 case HCI_END_SEQ:
1473 {
1474 pphNfcIF_Notification_CB_t p_upper_notify =
1475 psHciContext->p_upper_notify;
1476 phNfc_sLowerIF_t *plower_if =
1477 &(psHciContext->lower_interface);
1478 void *pcontext =
1479 psHciContext->p_upper_context;
1480 phNfc_sCompletionInfo_t comp_info;
1481
1482
1483 status = plower_if->release((void *)plower_if->pcontext,
1484 (void *)pHwRef);
1485
1486 phHciNfc_Release_Resources( &psHciContext );
1487 /* De-Initialisation Complete Notification to the Upper Layer */
1488 comp_info.status = status;
1489 phHciNfc_Notify(p_upper_notify, pcontext, pHwRef,
1490 NFC_NOTIFY_DEINIT_COMPLETED, &comp_info);
1491
1492 HCI_PRINT("HCI Release Completed \n");
1493 break;
1494 }
1495 default:
1496 {
1497 /* psHciContext->hci_seq = HCI_END_SEQ; */
1498 break;
1499 }
1500 }
1501
1502 return status;
1503 }
1504
1505
1506 static
1507 NFCSTATUS
phHciNfc_Config_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1508 phHciNfc_Config_Sequence(
1509 phHciNfc_sContext_t *psHciContext,
1510 void *pHwRef
1511 )
1512 {
1513 NFCSTATUS status = NFCSTATUS_SUCCESS;
1514 phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
1515
1516 switch(psHciContext->config_type)
1517 {
1518 case POLL_LOOP_CFG:
1519 {
1520 status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef );
1521 break;
1522 }
1523 case SMX_WI_MODE:
1524 {
1525 status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef );
1526 break;
1527 }
1528 #ifdef ENABLE_P2P
1529 case NFC_GENERAL_CFG:
1530 {
1531 if(TARGET_GENERAL_SEQ == psHciContext->hci_seq)
1532 {
1533 status = phHciNfc_NfcIP_SetATRInfo( psHciContext,
1534 pHwRef, NFCIP_TARGET,
1535 psHciContext->p_config_params);
1536 if( NFCSTATUS_PENDING != status )
1537 {
1538 /* Roll Back the State Machine to its Original State */
1539 phHciNfc_FSM_Rollback ( psHciContext );
1540 }
1541 else
1542 {
1543 psHciContext->hci_seq = HCI_END_SEQ;
1544 }
1545 }
1546 else
1547 {
1548 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
1549 if (NFCSTATUS_PENDING != status)
1550 {
1551 /* Roll Back to its Current State as Configuration is Complete */
1552 phHciNfc_FSM_Rollback(psHciContext);
1553
1554 HCI_PRINT(" NFC-IP(P2P) Configuration Completed. \n");
1555 comp_info.status = status;
1556 psHciContext->error_status = NFCSTATUS_SUCCESS;
1557 phHciNfc_Notify(psHciContext->p_upper_notify,
1558 psHciContext->p_upper_context, pHwRef,
1559 NFC_NOTIFY_CONFIG_SUCCESS , &comp_info);
1560 }
1561 }
1562 break;
1563 }
1564 #endif
1565 case SWP_PROTECT_CFG:
1566 case SWP_EVT_CFG:
1567 case SMX_WI_CFG:
1568 {
1569 /* Roll Back to its Current State as Configuration is Complete */
1570 phHciNfc_FSM_Rollback(psHciContext);
1571
1572 HCI_DEBUG(" %s Configuration Completed. \n",
1573 ((SMX_WI_CFG == psHciContext->config_type)?
1574 "SmartMX" : "SWP Event/Protection"));
1575
1576 comp_info.status = status;
1577 phHciNfc_Notify(psHciContext->p_upper_notify,
1578 psHciContext->p_upper_context, pHwRef,
1579 NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
1580 break;
1581 }
1582 case NFC_TARGET_CFG:
1583 {
1584 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1585 break;
1586 }
1587 case UICC_SWP_CFG:
1588 #if 0
1589 {
1590 phHal_sEmulationCfg_t *p_emulation_cfg =
1591 (phHal_sEmulationCfg_t * )
1592 psHciContext->p_config_params;
1593 if (NULL != p_emulation_cfg)
1594 {
1595 phHal_sUiccEmuCfg_t *uicc_config =
1596 &p_emulation_cfg->config.uiccEmuCfg;
1597 if( TRUE == uicc_config->enableUicc )
1598 {
1599 status = phHciNfc_Uicc_Connect_Status(psHciContext,pHwRef);
1600 if( NFCSTATUS_PENDING == status )
1601 {
1602 break;
1603 } /* Or Else Fall through to notify the above layer */
1604 }
1605 }
1606 }
1607 #endif
1608 /* fall through */
1609 case NFC_CE_A_CFG:
1610 case NFC_CE_B_CFG:
1611 {
1612 status = phHciNfc_EmulationCfg_Sequence( psHciContext, pHwRef );
1613 break;
1614 }
1615 default:
1616 {
1617 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
1618 break;
1619 }
1620 }
1621
1622 return status;
1623 }
1624
1625
1626 NFCSTATUS
phHciNfc_PollLoop_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1627 phHciNfc_PollLoop_Sequence(
1628 phHciNfc_sContext_t *psHciContext,
1629 void *pHwRef
1630 )
1631 {
1632 NFCSTATUS status = NFCSTATUS_SUCCESS;
1633 phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
1634 psHciContext->p_config_params;
1635 if (NULL != p_poll_config)
1636 {
1637 uint8_t speed =
1638 p_poll_config->NfcIP_Mode;
1639 switch(psHciContext->hci_seq)
1640 {
1641 case PL_DURATION_SEQ:
1642 {
1643 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1644 (uint8_t)PL_DURATION , NULL);
1645 if(NFCSTATUS_SUCCESS == status)
1646 {
1647 #if defined (ENABLE_P2P) && defined (TARGET_SPEED)
1648 psHciContext->hci_seq = TARGET_SPEED_SEQ;
1649 #elif defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1650 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1651 #elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1652 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1653 #else
1654 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1655 #endif
1656
1657 status = NFCSTATUS_PENDING;
1658 }
1659 break;
1660 }
1661 #if defined (ENABLE_P2P) && defined (TARGET_SPEED)
1662 case TARGET_SPEED_SEQ:
1663 {
1664 #define NFCIP_ACTIVE_SHIFT 0x03U
1665 #define NFCIP_PASSIVE_MASK 0x07U
1666 uint8_t mode = ( NXP_NFCIP_ACTIVE_DEFAULT << NFCIP_ACTIVE_SHIFT ) |
1667 ( DEFAULT_NFCIP_TARGET_MODE_SUPPORT & NFCIP_PASSIVE_MASK );
1668 status =
1669 phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_TARGET,
1670 (uint8_t) mode );
1671 if(NFCSTATUS_PENDING == status)
1672 {
1673 #if defined (INITIATOR_SPEED)
1674 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1675 #elif defined (NFCIP_TGT_DISABLE_CFG)
1676 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1677 #else
1678 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1679 #endif
1680 status = NFCSTATUS_PENDING;
1681 }
1682 break;
1683 }
1684 #endif
1685 #if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1686 case INITIATOR_SPEED_SEQ:
1687 {
1688 status =
1689 phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_INITIATOR,
1690 (uint8_t) (speed & DEFAULT_NFCIP_INITIATOR_MODE_SUPPORT));
1691 if(NFCSTATUS_PENDING == status)
1692 {
1693 #if defined (NFCIP_TGT_DISABLE_CFG)
1694 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1695 #else
1696 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1697 #endif
1698 status = NFCSTATUS_PENDING;
1699 }
1700 break;
1701 }
1702 #endif
1703 #if defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1704 case PL_TGT_DISABLE_SEQ:
1705 {
1706 /* Configure the Polling Loop Target Disable Parameter */
1707 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1708 (uint8_t)PL_DISABLE_TARGET, &p_poll_config->NfcIP_Tgt_Disable );
1709 if(NFCSTATUS_SUCCESS == status)
1710 {
1711 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1712 status = NFCSTATUS_PENDING;
1713 }
1714 break;
1715 }
1716 #endif
1717 case PL_CONFIG_PHASE_SEQ:
1718 {
1719 phHal_sPollDevInfo_t *p_poll_info =
1720 &(p_poll_config->PollDevInfo.PollCfgInfo);
1721
1722 p_poll_info->EnableIso14443A =
1723 ( (p_poll_info->EnableIso14443A)
1724 || ( speed & (uint8_t)phHal_ePassive106 )
1725 );
1726 p_poll_info->EnableFelica212 =
1727 ( (p_poll_info->EnableFelica212)
1728 || ( speed & (uint8_t)phHal_ePassive212 )
1729 );
1730 p_poll_info->EnableFelica424 =
1731 ( (p_poll_info->EnableFelica424)
1732 || ( speed & (uint8_t)phHal_ePassive424 )
1733 );
1734 /* Configure the Polling Loop Gate Parameters */
1735 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1736 (uint8_t)PL_RD_PHASES, NULL );
1737 if(NFCSTATUS_SUCCESS == status)
1738 {
1739 if(((~(PL_RD_PHASES_DISABLE)) &
1740 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1741 {
1742 psHciContext->hci_seq = READER_ENABLE_SEQ;
1743 }
1744 else
1745 {
1746 /* psHciContext->hci_seq = READER_DISABLE_SEQ; */
1747 psHciContext->hci_seq = HCI_END_SEQ;
1748 }
1749 status = NFCSTATUS_PENDING;
1750 }
1751 break;
1752 }
1753 case READER_ENABLE_SEQ:
1754 {
1755 status =
1756 phHciNfc_ReaderMgmt_Enable_Discovery(
1757 psHciContext, pHwRef );
1758 if(NFCSTATUS_SUCCESS == status)
1759 {
1760 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
1761 psHciContext->hci_seq = HCI_END_SEQ;
1762 status = NFCSTATUS_PENDING;
1763 }
1764 break;
1765 }
1766 case READER_DISABLE_SEQ:
1767 {
1768 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1769 psHciContext, pHwRef );
1770
1771 if(NFCSTATUS_SUCCESS == status)
1772 {
1773 if((~(PL_RD_PHASES_DISABLE) &
1774 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1775 {
1776 psHciContext->hci_seq = PL_DURATION_SEQ;
1777 }
1778 else
1779 {
1780 #if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1781 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1782 #elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1783 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1784 #else
1785 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1786 #endif
1787 /* psHciContext->hci_seq = HCI_END_SEQ; */
1788 }
1789 status = NFCSTATUS_PENDING;
1790 }
1791 break;
1792 }
1793 case HCI_END_SEQ:
1794 {
1795 phNfc_sCompletionInfo_t comp_info;
1796 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
1797 if (NFCSTATUS_PENDING != status)
1798 {
1799 /* status = phHciNfc_FSM_Complete ( psHciContext );*/
1800 phHciNfc_FSM_Rollback ( psHciContext );
1801 /* Poll Configuration Notification to the Upper Layer */
1802 if((~(PL_RD_PHASES_DISABLE) &
1803 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1804 {
1805 comp_info.status = status;
1806 phHciNfc_Notify(psHciContext->p_upper_notify,
1807 psHciContext->p_upper_context, pHwRef,
1808 NFC_NOTIFY_POLL_ENABLED, &comp_info);
1809 }
1810 else
1811 {
1812 comp_info.status = status;
1813 phHciNfc_Notify(psHciContext->p_upper_notify,
1814 psHciContext->p_upper_context, pHwRef,
1815 NFC_NOTIFY_POLL_DISABLED, &comp_info);
1816 }
1817 HCI_PRINT("HCI Discovery Configuration Completed \n");
1818 }
1819 break;
1820 }
1821 default:
1822 {
1823 /* psHciContext->hci_seq = HCI_END_SEQ; */
1824 break;
1825 }
1826 }/* End of the Poll Sequence Switch */
1827 }/* End of the Poll Config info Check */
1828
1829 return status;
1830 }
1831
1832
1833 NFCSTATUS
phHciNfc_EmulationCfg_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1834 phHciNfc_EmulationCfg_Sequence(
1835 phHciNfc_sContext_t *psHciContext,
1836 void *pHwRef
1837 )
1838 {
1839 NFCSTATUS status = NFCSTATUS_SUCCESS;
1840 static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
1841 #if defined(HOST_EMULATION)
1842 phHciNfc_GateID_t ce_gate = phHciNfc_UnknownGate;
1843 #endif /* #ifdef HOST_EMULATION */
1844 phHal_sEmulationCfg_t *p_emulation_cfg = (phHal_sEmulationCfg_t * )
1845 psHciContext->p_config_params;
1846 #ifdef UICC_SESSION_RESET
1847 uint8_t uicc_clear_pipes = FALSE;
1848 #endif
1849
1850
1851 if (NULL != p_emulation_cfg)
1852 {
1853 #if defined(HOST_EMULATION)
1854 if(NFC_HOST_CE_A_EMULATION == p_emulation_cfg->emuType)
1855 {
1856 psHciContext->config_type = NFC_CE_A_CFG;
1857 if (NULL == psHciContext->p_ce_a_info)
1858 {
1859 ce_gate = phHciNfc_CETypeAGate;
1860 }
1861 }
1862 else if (NFC_HOST_CE_B_EMULATION == p_emulation_cfg->emuType)
1863 {
1864 psHciContext->config_type = NFC_CE_B_CFG;
1865 if (NULL == psHciContext->p_ce_b_info)
1866 {
1867 ce_gate = phHciNfc_CETypeBGate;
1868 }
1869 }
1870 #ifdef UICC_SESSION_RESET
1871 else if ((NFC_UICC_EMULATION == p_emulation_cfg->emuType)
1872 &&(FALSE == p_emulation_cfg->config.uiccEmuCfg.enableUicc)
1873 )
1874 {
1875 uicc_clear_pipes = TRUE;
1876 }
1877 #endif
1878 else
1879 {
1880 ;
1881 }
1882 #endif /* #ifdef HOST_EMULATION */
1883
1884 switch(psHciContext->hci_seq)
1885 {
1886 #if defined(HOST_EMULATION)
1887 case ADMIN_CE_SEQ:
1888 {
1889 if(phHciNfc_UnknownGate != ce_gate)
1890 {
1891 status = phHciNfc_Admin_CE_Init(psHciContext, pHwRef, ce_gate);
1892 }
1893 else
1894 {
1895 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
1896 }
1897
1898 if(NFCSTATUS_SUCCESS == status)
1899 {
1900 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
1901 /* psHciContext->hci_seq = HCI_END_SEQ; */
1902 status = NFCSTATUS_PENDING;
1903 }
1904 break;
1905 }
1906 #endif
1907 case EMULATION_CONFIG_SEQ:
1908 {
1909 status = phHciNfc_Emulation_Cfg(psHciContext, pHwRef,
1910 psHciContext->config_type);
1911 if(NFCSTATUS_SUCCESS == status)
1912 {
1913 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
1914 #ifdef UICC_SESSION_RESET
1915 if(UICC_SWP_CFG == psHciContext->config_type)
1916 {
1917 psHciContext->hci_seq = ADMIN_REL_SEQ;
1918 }
1919 else
1920 #endif /* UICC_SESSION_RESET */
1921 {
1922 psHciContext->hci_seq = HCI_END_SEQ;
1923 }
1924 status = NFCSTATUS_PENDING;
1925 }
1926 break;
1927 }
1928 #ifdef UICC_SESSION_RESET
1929 case ADMIN_REL_SEQ:
1930 {
1931 if (TRUE == uicc_clear_pipes)
1932 {
1933 /* Admin Management UICC Release Sequence */
1934 status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_UICCHostID );
1935 if(NFCSTATUS_SUCCESS == status)
1936 {
1937 psHciContext->hci_seq = HCI_END_SEQ;
1938 if (UICC_SWP_CFG == psHciContext->config_type)
1939 {
1940 (void)phHciNfc_SWP_Update_Sequence(psHciContext,
1941 CONFIG_SEQ );
1942 }
1943 status = NFCSTATUS_PENDING;
1944 }
1945 break;
1946 }
1947 }
1948 #endif /* UICC_SESSION_RESET */
1949 /* fall through */
1950 case HCI_END_SEQ:
1951 {
1952 phHciNfc_FSM_Rollback(psHciContext);
1953
1954 HCI_PRINT(" Emulation Configuration Completed. \n");
1955
1956 comp_info.status = status;
1957 phHciNfc_Notify(psHciContext->p_upper_notify,
1958 psHciContext->p_upper_context, pHwRef,
1959 NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
1960 break;
1961 }
1962 default:
1963 {
1964 /* psHciContext->hci_seq = HCI_END_SEQ; */
1965 break;
1966 }
1967 }
1968 /*
1969 NFC_CE_A_CFG;
1970 NFC_CE_B_CFG; */
1971
1972 }/* End of the Emulation Config info Check */
1973
1974 return status;
1975 }
1976
1977
1978 NFCSTATUS
phHciNfc_SmartMx_Mode_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)1979 phHciNfc_SmartMx_Mode_Sequence(
1980 phHciNfc_sContext_t *psHciContext,
1981 void *pHwRef
1982 )
1983 {
1984 NFCSTATUS status = NFCSTATUS_SUCCESS;
1985 phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
1986 psHciContext->p_config_params;
1987 phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
1988 if (NULL != p_poll_config)
1989 {
1990 switch(psHciContext->hci_seq)
1991 {
1992 case READER_DISABLE_SEQ:
1993 {
1994 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1995 psHciContext, pHwRef );
1996 if(NFCSTATUS_SUCCESS == status)
1997 {
1998 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
1999 /* psHciContext->hci_seq = HCI_END_SEQ; */
2000 status = NFCSTATUS_PENDING;
2001 }
2002 break;
2003 }
2004 case EMULATION_CONFIG_SEQ:
2005 {
2006 status = phHciNfc_WI_Configure_Mode(
2007 psHciContext, pHwRef,psHciContext->smx_mode );
2008 if(NFCSTATUS_SUCCESS == status)
2009 {
2010 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
2011 /* psHciContext->hci_seq = HCI_END_SEQ; */
2012 status = NFCSTATUS_PENDING;
2013 }
2014 break;
2015 }
2016 case PL_CONFIG_PHASE_SEQ:
2017 {
2018 /* Configure the Polling Loop Gate Parameters */
2019 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
2020 (uint8_t)PL_RD_PHASES, NULL );
2021 if(NFCSTATUS_SUCCESS == status)
2022 {
2023 psHciContext->hci_seq = READER_ENABLE_SEQ;
2024 status = NFCSTATUS_PENDING;
2025 }
2026 break;
2027 }
2028 case READER_ENABLE_SEQ:
2029 {
2030 status =
2031 phHciNfc_ReaderMgmt_Enable_Discovery(
2032 psHciContext, pHwRef );
2033 if(NFCSTATUS_SUCCESS == status)
2034 {
2035 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
2036 psHciContext->hci_seq = HCI_END_SEQ;
2037 status = NFCSTATUS_PENDING;
2038 }
2039 break;
2040 }
2041 case HCI_END_SEQ:
2042 {
2043 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
2044 if (NFCSTATUS_PENDING != status)
2045 {
2046 /* status = phHciNfc_FSM_Complete ( psHciContext );*/
2047 phHciNfc_FSM_Rollback ( psHciContext );
2048 if( hciState_Disconnect == psHciContext->hci_state.cur_state)
2049 {
2050 psHciContext->host_rf_type = phHal_eUnknown_DevType;
2051 psHciContext->p_target_info = NULL;
2052 psHciContext->p_xchg_info = NULL;
2053 }
2054 /* Poll Configuration Notification to the Upper Layer */
2055 if((~(PL_RD_PHASES_DISABLE) &
2056 p_poll_config->PollDevInfo.PollEnabled)!= 0)
2057 {
2058 comp_info.status = status;
2059 phHciNfc_Notify(psHciContext->p_upper_notify,
2060 psHciContext->p_upper_context, pHwRef,
2061 NFC_NOTIFY_POLL_ENABLED, &comp_info);
2062 }
2063 else
2064 {
2065 comp_info.status = status;
2066 phHciNfc_Notify(psHciContext->p_upper_notify,
2067 psHciContext->p_upper_context, pHwRef,
2068 NFC_NOTIFY_POLL_DISABLED, &comp_info);
2069 }
2070 HCI_PRINT("HCI Discovery Configuration Completed \n");
2071 }
2072 break;
2073 }
2074 default:
2075 {
2076 /* psHciContext->hci_seq = HCI_END_SEQ; */
2077 break;
2078 }
2079 }/* End of the Poll Sequence Switch */
2080 }/* End of the Poll Config info Check */
2081
2082 return status;
2083 }
2084
2085
2086 NFCSTATUS
phHciNfc_Connect_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)2087 phHciNfc_Connect_Sequence(
2088 phHciNfc_sContext_t *psHciContext,
2089 void *pHwRef
2090 )
2091 {
2092 NFCSTATUS status = NFCSTATUS_SUCCESS;
2093 static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
2094 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
2095
2096 if( NULL != psHciContext->p_target_info )
2097 {
2098
2099 target_type = psHciContext->p_target_info->RemDevType;
2100 switch(psHciContext->hci_seq)
2101 {
2102 case READER_REACTIVATE_SEQ:
2103 {
2104 /* Complete the Reactivate Sequence and notify the HAL */
2105 status = phHciNfc_FSM_Complete ( psHciContext );
2106 /* Reactivate Complete Notification to the Upper Layer */
2107 if(NFCSTATUS_SUCCESS == status)
2108 {
2109 comp_info.status = status;
2110 phHciNfc_Notify(psHciContext->p_upper_notify,
2111 psHciContext->p_upper_context, pHwRef,
2112 NFC_NOTIFY_TARGET_REACTIVATED , &comp_info);
2113 HCI_PRINT(" HCI Remote Target Reactivated. \n");
2114 }
2115 else
2116 {
2117 comp_info.status = status;
2118 phHciNfc_FSM_Rollback ( psHciContext );
2119 phHciNfc_Notify(psHciContext->p_upper_notify,
2120 psHciContext->p_upper_context, pHwRef,
2121 NFC_NOTIFY_ERROR , &comp_info);
2122 HCI_PRINT("HCI FSM Invalid Selection State \n");
2123 HCI_PRINT("HCI Remote Target Reactivation Failed \n");
2124 }
2125 break;
2126 }
2127 case READER_SELECT_SEQ:
2128 {
2129 /* If the Target is Mifare then it should fall through */
2130 if(( phHal_eMifare_PICC != target_type )
2131 &&(phHal_eISO14443_3A_PICC != target_type)
2132 #ifdef TYPE_B
2133 && ( phHal_eISO14443_B_PICC != target_type )
2134 && ( phHal_eISO14443_4B_PICC != target_type )
2135 #endif
2136 #ifdef TYPE_FELICA
2137 && ( phHal_eFelica_PICC != target_type )
2138 #endif
2139 #ifdef TYPE_JEWEL
2140 && ( phHal_eJewel_PICC != target_type )
2141 #endif /* #ifdef TYPE_JEWEL */
2142 #ifdef TYPE_ISO15693
2143 && ( phHal_eISO15693_PICC != target_type )
2144 #endif /* #ifdef TYPE_ISO15693 */
2145
2146 )
2147 {
2148 status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
2149 if(NFCSTATUS_SUCCESS == status)
2150 {
2151 psHciContext->hci_seq = HCI_END_SEQ;
2152 status = NFCSTATUS_PENDING;
2153 }
2154 break;
2155 }
2156 }
2157 /* fall through */
2158 case HCI_END_SEQ:
2159 {
2160 /* Complete the Connect Sequence and notify the HAL */
2161 status = phHciNfc_FSM_Complete ( psHciContext );
2162 /* Connection Complete Notification to the Upper Layer */
2163 if(NFCSTATUS_SUCCESS == status)
2164 {
2165 /* Invalidate the previously polled RF Reader Type */
2166 /* psHciContext->host_rf_type = phHal_eInvalidRFType;*/
2167 comp_info.status = status;
2168 phHciNfc_Notify(psHciContext->p_upper_notify,
2169 psHciContext->p_upper_context, pHwRef,
2170 NFC_NOTIFY_TARGET_CONNECTED , &comp_info);
2171 HCI_PRINT(" HCI Remote Target Selected for Transaction. \n");
2172 }
2173 else
2174 {
2175 comp_info.status = status;
2176 /* phHciNfc_FSM_Rollback ( psHciContext ); */
2177 phHciNfc_Notify(psHciContext->p_upper_notify,
2178 psHciContext->p_upper_context, pHwRef,
2179 NFC_NOTIFY_ERROR , &comp_info);
2180 HCI_PRINT("HCI FSM Invalid Selection State \n");
2181 HCI_PRINT("HCI Remote Target Selection Failed \n");
2182 }
2183 break;
2184 }
2185 default:
2186 {
2187 HCI_PRINT("\t Invalid HCI Connect Sequence \n");
2188 /* psHciContext->hci_seq = HCI_END_SEQ; */
2189 break;
2190 }
2191 }/* End of the Connect Sequence Switch */
2192 }
2193
2194 return status;
2195 }
2196
2197
2198 NFCSTATUS
phHciNfc_Disconnect_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)2199 phHciNfc_Disconnect_Sequence(
2200 phHciNfc_sContext_t *psHciContext,
2201 void *pHwRef
2202 )
2203 {
2204 NFCSTATUS status = NFCSTATUS_SUCCESS;
2205 static phNfc_sCompletionInfo_t comp_info = {FALSE, 0 , NULL};
2206 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
2207 uint8_t re_poll = 0;
2208
2209 if( NULL != psHciContext->p_target_info )
2210 {
2211
2212 target_type = psHciContext->p_target_info->RemDevType;
2213 switch(psHciContext->hci_seq)
2214 {
2215 case READER_UICC_DISPATCH_SEQ:
2216 {
2217 status = phHciNfc_ReaderMgmt_UICC_Dispatch(
2218 psHciContext, pHwRef, target_type );
2219 psHciContext->hci_seq = READER_DESELECT_SEQ;
2220 if(NFCSTATUS_PENDING == status)
2221 {
2222 break;
2223 }
2224 }
2225 /* fall through */
2226 case READER_DESELECT_SEQ:
2227 {
2228 re_poll = (uint8_t) ( NULL != psHciContext->p_config_params )?
2229 *((uint8_t *)psHciContext->p_config_params):FALSE;
2230 status = phHciNfc_ReaderMgmt_Deselect(
2231 psHciContext, pHwRef, target_type, re_poll);
2232 if(NFCSTATUS_PENDING == status)
2233 {
2234 psHciContext->hci_seq = HCI_END_SEQ;
2235 psHciContext->p_config_params = NULL;
2236 }
2237 break;
2238 }
2239 case HCI_END_SEQ:
2240 {
2241 /* Complete the Disconnect Sequence and notify the HAL */
2242 status = phHciNfc_FSM_Complete ( psHciContext );
2243 /* Disconnect Notification to the Upper Layer */
2244 if(NFCSTATUS_SUCCESS == status)
2245 {
2246 /* Invalidate the previously polled RF Reader Type */
2247 psHciContext->host_rf_type = phHal_eUnknown_DevType;
2248 psHciContext->p_target_info = NULL;
2249 psHciContext->p_xchg_info = NULL;
2250 comp_info.status = status;
2251 phHciNfc_Notify(psHciContext->p_upper_notify,
2252 psHciContext->p_upper_context, pHwRef,
2253 NFC_NOTIFY_TARGET_DISCONNECTED , &comp_info);
2254 HCI_PRINT(" HCI Remote Target De-Selected. \n");
2255 }
2256 else
2257 {
2258 comp_info.status = status;
2259 /* phHciNfc_FSM_Rollback ( psHciContext ); */
2260 phHciNfc_Notify(psHciContext->p_upper_notify,
2261 psHciContext->p_upper_context, pHwRef,
2262 NFC_NOTIFY_ERROR , &comp_info);
2263 HCI_PRINT("HCI FSM Invalid De-Selection State \n");
2264 HCI_PRINT("HCI Remote Target De-Selection Failed \n");
2265 }
2266
2267 break;
2268 }
2269 default:
2270 {
2271 HCI_PRINT("\t Invalid HCI Connect Sequence \n");
2272 /* psHciContext->hci_seq = HCI_END_SEQ; */
2273 break;
2274 }
2275 }/* End of the Connect Sequence Switch */
2276 }
2277
2278 return status;
2279 }
2280
2281
2282 static
2283 NFCSTATUS
phHciNfc_Transact_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)2284 phHciNfc_Transact_Sequence(
2285 phHciNfc_sContext_t *psHciContext,
2286 void *pHwRef
2287 )
2288 {
2289 static phNfc_sTransactionInfo_t transact_info = {FALSE,0,NULL,NULL,0};
2290
2291 pphNfcIF_Notification_CB_t p_upper_notify = psHciContext->p_upper_notify;
2292 void *pcontext = psHciContext->p_upper_context;
2293 uint8_t transact_result = NFC_NOTIFY_ERROR;
2294
2295 /* Roll Back to Connect State as Transceive is Complete */
2296 phHciNfc_FSM_Rollback(psHciContext);
2297
2298 switch (psHciContext->host_rf_type)
2299 {
2300 case phHal_eISO14443_A_PCD:
2301 #ifdef TYPE_B
2302 case phHal_eISO14443_B_PCD:
2303 #endif
2304 case phHal_eISO14443_BPrime_PCD:
2305 #ifdef TYPE_FELICA
2306 case phHal_eFelica_PCD:
2307 #endif
2308 #ifdef TYPE_ISO15693
2309 case phHal_eISO15693_PCD:
2310 #endif
2311 {
2312 if(ZERO != psHciContext->rx_index)
2313 {
2314 transact_info.status = NFCSTATUS_SUCCESS;
2315 transact_info.buffer =
2316 &psHciContext->recv_buffer[psHciContext->rx_index];
2317 transact_info.length =
2318 psHciContext->rx_total - psHciContext->rx_index;
2319 transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
2320 }
2321 else
2322 {
2323 transact_info.status = NFCSTATUS_FAILED;
2324 transact_result = NFC_NOTIFY_TRANSCEIVE_ERROR;
2325 }
2326 HCI_PRINT(" HCI Transceive operation Completed. \n");
2327 psHciContext->p_xchg_info = NULL ;
2328 break;
2329 }
2330 #ifdef TYPE_JEWEL
2331 /* fall through */
2332 case phHal_eJewel_PCD:
2333 #endif
2334 {
2335 transact_info.status = NFCSTATUS_SUCCESS;
2336 transact_info.buffer =
2337 &psHciContext->recv_buffer[psHciContext->rx_index];
2338 transact_info.length =
2339 psHciContext->rx_total - psHciContext->rx_index;
2340 transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
2341 HCI_PRINT(" HCI Transceive operation Completed. \n");
2342 psHciContext->p_xchg_info = NULL ;
2343 break;
2344 }
2345 #if defined(ENABLE_P2P)
2346 case phHal_eNfcIP1_Initiator:
2347 case phHal_eNfcIP1_Target:
2348 #endif
2349 {
2350 HCI_PRINT(" HCI Send operation Completed. \n");
2351 transact_info.status = NFCSTATUS_SUCCESS;
2352 transact_result = NFC_NOTIFY_SEND_COMPLETED;
2353 break;
2354 }
2355 case phHal_eUnknown_DevType:
2356 default:
2357 {
2358 transact_info.status =
2359 PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2360 break;
2361 }
2362
2363 }
2364 /* Notify the Transceive Completion to the Upper layer */
2365 phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
2366 transact_result, &transact_info);
2367
2368 return (NFCSTATUS)NFCSTATUS_SUCCESS;
2369 }
2370
2371 static
2372 NFCSTATUS
phHciNfc_Info_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)2373 phHciNfc_Info_Sequence(
2374 phHciNfc_sContext_t *psHciContext,
2375 void *pHwRef
2376 )
2377 {
2378 NFCSTATUS status = NFCSTATUS_SUCCESS;
2379
2380 HCI_DEBUG(" HCI: Info Sequence Entry --> Reader Type : %02X \n",
2381 psHciContext->host_rf_type);
2382 switch (psHciContext->host_rf_type)
2383 {
2384 case phHal_eISO14443_A_PCD:
2385 #ifdef TYPE_B
2386 case phHal_eISO14443_B_PCD:
2387 #endif
2388 case phHal_eISO14443_BPrime_PCD:
2389 #ifdef TYPE_FELICA
2390 case phHal_eFelica_PCD:
2391 #endif
2392 #ifdef TYPE_JEWEL
2393 case phHal_eJewel_PCD:
2394 #endif
2395 #ifdef TYPE_ISO15693
2396 case phHal_eISO15693_PCD:
2397 #endif
2398 {
2399 /* To update the select sequence to retrieve
2400 * the target information using the reader type.
2401 */
2402 status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
2403 break;
2404 }
2405 #if defined(ENABLE_P2P)
2406 case phHal_eNfcIP1_Initiator:
2407 case phHal_eNfcIP1_Target:
2408 {
2409 status = phHciNfc_NfcIP_Info_Sequence( psHciContext, pHwRef );
2410 break;
2411 }
2412 #endif
2413 case phHal_eUnknown_DevType:
2414 default:
2415 {
2416 status =
2417 PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2418 break;
2419 }
2420
2421 }
2422 return status;
2423 }
2424
2425 static
2426 NFCSTATUS
phHciNfc_Test_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef,NFCSTATUS test_status,uint8_t * pdata,uint8_t length)2427 phHciNfc_Test_Sequence(
2428 phHciNfc_sContext_t *psHciContext,
2429 void *pHwRef,
2430 NFCSTATUS test_status,
2431 uint8_t *pdata,
2432 uint8_t length
2433 )
2434 {
2435 NFCSTATUS status = NFCSTATUS_SUCCESS;
2436 static phNfc_sCompletionInfo_t comp_info = {0};
2437 static phNfc_sData_t test_result= {NULL,0};
2438
2439 /* Complete the Test Sequence and notify the HAL */
2440 status = phHciNfc_FSM_Complete ( psHciContext );
2441 /* Test Results to the Upper Layer */
2442 if(NFCSTATUS_SUCCESS == status)
2443 {
2444 comp_info.status = test_status;
2445 if ( (NULL != pdata) && (length >= HCP_HEADER_LEN) )
2446 {
2447 test_result.buffer = ( pdata + HCP_HEADER_LEN);
2448 test_result.length = length - HCP_HEADER_LEN;
2449 }
2450 else
2451 {
2452 status = phHciNfc_DevMgmt_Get_Test_Result(
2453 psHciContext, &test_result );
2454 }
2455 comp_info.info = &test_result;
2456 phHciNfc_Notify(psHciContext->p_upper_notify,
2457 psHciContext->p_upper_context, pHwRef,
2458 NFC_NOTIFY_RESULT , &comp_info);
2459 HCI_DEBUG(" HCI System Test Completed : Status = %u\n", test_status);
2460 }
2461 else
2462 {
2463 comp_info.status = status;
2464 phHciNfc_FSM_Rollback ( psHciContext );
2465 phHciNfc_Notify(psHciContext->p_upper_notify,
2466 psHciContext->p_upper_context, pHwRef,
2467 NFC_NOTIFY_ERROR , &comp_info);
2468 HCI_PRINT("HCI FSM Invalid Test State \n");
2469 }
2470
2471 return status;
2472 }
2473
2474 static
2475 NFCSTATUS
phHciNfc_IO_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef,NFCSTATUS io_status,uint8_t * pdata,uint8_t length)2476 phHciNfc_IO_Sequence(
2477 phHciNfc_sContext_t *psHciContext,
2478 void *pHwRef,
2479 NFCSTATUS io_status,
2480 uint8_t *pdata,
2481 uint8_t length
2482 )
2483 {
2484 NFCSTATUS status = NFCSTATUS_SUCCESS;
2485 static phNfc_sCompletionInfo_t comp_info = {0};
2486
2487 /* To remove "warning (VS 4100) : unreferenced formal parameter" */
2488 PHNFC_UNUSED_VARIABLE(pdata);
2489 PHNFC_UNUSED_VARIABLE(length);
2490 /* Complete the Test Sequence and notify the HAL */
2491 phHciNfc_FSM_Rollback ( psHciContext );
2492 /* Test Results to the Upper Layer */
2493 comp_info.status = io_status;
2494 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
2495 if(NFCSTATUS_SUCCESS == io_status)
2496 {
2497 phHciNfc_Notify(psHciContext->p_upper_notify,
2498 psHciContext->p_upper_context, pHwRef,
2499 NFC_IO_SUCCESS , &comp_info);
2500 HCI_PRINT(" HCI System IO Successful. \n");
2501 }
2502 else
2503 {
2504 phHciNfc_Notify(psHciContext->p_upper_notify,
2505 psHciContext->p_upper_context, pHwRef,
2506 NFC_IO_ERROR , &comp_info);
2507 HCI_PRINT("HCI IO Error \n");
2508 }
2509 return status;
2510 }
2511
2512
2513
2514 #ifdef OTHER_TAGS
2515
2516 NFCSTATUS
phHciNfc_Activate_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef)2517 phHciNfc_Activate_Sequence(
2518 phHciNfc_sContext_t *psHciContext,
2519 void *pHwRef
2520 )
2521 {
2522 NFCSTATUS status = NFCSTATUS_SUCCESS;
2523
2524 return status;
2525 }
2526
2527
2528 #endif
2529
2530
2531