Gitiles
Code Review Sign In
review.blissroms.org / platform_external_libnfc-nxp / refs/heads/o8.0-rebase / . / src / phHciNfc_Sequence.c
blob: 6d0bf13fb5baa33d4750a3dc88287c6040b33b78 [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* *
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
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]68/* Address Definitions for HAL Configuration */
69#define NFC_ADDRESS_HAL_CONF 0x9FD0U
70
71
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]72/*
73################################################################################
74********************** Structure/Enumeration Definitions ***********************
75################################################################################
76*/
77
78
79#ifdef VALIDATE_FSM
80
81typedef 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
88static 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
113static
114NFCSTATUS
115phHciNfc_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
139static
140NFCSTATUS
141phHciNfc_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
164static
165NFCSTATUS
166phHciNfc_Info_Sequence(
167 phHciNfc_sContext_t *psHciContext,
168 void *pHwRef
169 );
170
171static
172NFCSTATUS
173phHciNfc_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
183static
184void
185phHciNfc_FSM_Reset(
186 phHciNfc_sContext_t *psHciContext
187 );
188
189#endif
190
191static
192NFCSTATUS
193phHciNfc_IO_Sequence(
194 phHciNfc_sContext_t *psHciContext,
195 void *pHwRef,
196 NFCSTATUS test_status,
197 uint8_t *pdata,
198 uint8_t length
199 );
200
201static
202NFCSTATUS
203phHciNfc_Pending_Sequence(
204 phHciNfc_sContext_t *psHciContext,
205 void *pHwRef
206 );
207
208
209/*
210################################################################################
211***************************** Function Definitions *****************************
212################################################################################
213*/
214
215NFCSTATUS
216phHciNfc_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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]250 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]251 status = NFCSTATUS_SUCCESS;
252 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]253 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]275 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]276 status = NFCSTATUS_SUCCESS;
277 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]278 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]317 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]318 status = NFCSTATUS_SUCCESS;
319 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]320 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]351 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]352 status = NFCSTATUS_SUCCESS;
353 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]354 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]378 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]379 status = NFCSTATUS_SUCCESS;
380 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]381 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]403 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]404 status = NFCSTATUS_SUCCESS;
405 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]406 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]431 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]432 status = NFCSTATUS_SUCCESS;
433 break;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]434 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]435 default:
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]436 {
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]437 break;
438 }
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]439 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Martijn Coenen42f5b412013-04-25 17:27:48 -0700[diff] [blame]459 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_BUSY);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
473NFCSTATUS
474phHciNfc_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
507NFCSTATUS
508phHciNfc_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
544void
545phHciNfc_FSM_Rollback(
546 phHciNfc_sContext_t *psHciContext
547 )
548{
549
Nick Pelly34ff48f2011-06-27 09:01:51 -0700[diff] [blame]550 HCI_DEBUG("HCI: %s: transition=%02u, cur_state=%02u, next_state=%02u\n",
551 __func__,
552 psHciContext->hci_state.transition,
553 psHciContext->hci_state.cur_state,
554 psHciContext->hci_state.next_state);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]555
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]556
Nick Pelly34ff48f2011-06-27 09:01:51 -0700[diff] [blame]557
558
559
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
573static
574void
575phHciNfc_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
595static
596NFCSTATUS
597phHciNfc_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
630void
631phHciNfc_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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]663 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]677 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]694 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
695
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]724 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]740 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]766 phNfc_sTransactionInfo_t transact_info={FALSE,0,NULL,NULL,0};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]783 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]800 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]816 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]833 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]847 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]862 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]883 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
909NFCSTATUS
910phHciNfc_Resume_Sequence(
911 phHciNfc_sContext_t *psHciContext,
912 void *pHwRef
913 )
914{
915 NFCSTATUS status = NFCSTATUS_SUCCESS;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]916
Nick Pelly34ff48f2011-06-27 09:01:51 -0700[diff] [blame]917 HCI_DEBUG("HCI: %s: cur_state=%02u, next_state=%02u",
918 __FUNCTION__,
919 psHciContext->hci_state.cur_state,
920 psHciContext->hci_state.next_state);
921
922
923
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]949 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1006 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
1049NFCSTATUS
1050phHciNfc_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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1125#if defined( ESTABLISH_SESSION )
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1133#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1134 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1135#else
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1136 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1137#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1138 }
1139 else
1140 {
1141 psHciContext->hci_seq = HCI_END_SEQ;
1142 status = PHNFCSTVAL(CID_NFC_HCI,
1143 NFCSTATUS_INVALID_HCI_SEQUENCE);
1144 }
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1145#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1146 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1147#else
1148 psHciContext->hci_seq = HCI_END_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1149#endif /* #ifdef ESTABLISH_SESSION */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1186#if defined( ESTABLISH_SESSION )
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1187 psHciContext->hci_seq = ADMIN_SESSION_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1188#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1189 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1202#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1203 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
1204#else
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1205 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1206#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1216#if defined( SW_AUTO_ACTIVATION )
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1217 psHciContext->hci_seq = READER_SW_AUTO_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1218#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
1219 psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1220#else
1221 psHciContext->hci_seq = IDENTITY_INFO_SEQ;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1222#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 ) */
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1255 && (HCI_CUSTOM_INIT != psHciContext->init_mode)
1256 && (HCI_NFC_DEVICE_TEST != psHciContext->init_mode))
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 }
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]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 ) */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1312 case HCI_END_SEQ:
1313 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]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 )
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]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
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1336 /* Initialisation Complete Notification to the Upper Layer */
1337 if(NFCSTATUS_SUCCESS == status)
1338 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1339 phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
1372NFCSTATUS
1373phHciNfc_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 {
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1409 NFCSTATUS info_status = NFCSTATUS_SUCCESS;
1410 PHNFC_UNUSED_VARIABLE(info_status);
1411 info_status = phHciNfc_DevMgmt_Update_Sequence(
1412 psHciContext, REL_SEQ );
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
1506static
1507NFCSTATUS
1508phHciNfc_Config_Sequence(
1509 phHciNfc_sContext_t *psHciContext,
1510 void *pHwRef
1511 )
1512{
1513 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1514 phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
1626NFCSTATUS
1627phHciNfc_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;
Martijn Coenen20b7bd52012-01-31 22:13:33 -0800[diff] [blame]1639 uint8_t targetSpeed =
1640 p_poll_config->NfcIP_Target_Mode;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1641 switch(psHciContext->hci_seq)
1642 {
1643 case PL_DURATION_SEQ:
1644 {
1645 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1646 (uint8_t)PL_DURATION , NULL);
1647 if(NFCSTATUS_SUCCESS == status)
1648 {
1649#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
1650 psHciContext->hci_seq = TARGET_SPEED_SEQ;
1651#elif defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1652 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1653#elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1654 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1655#else
1656 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1657#endif
1658
1659 status = NFCSTATUS_PENDING;
1660 }
1661 break;
1662 }
1663#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
1664 case TARGET_SPEED_SEQ:
1665 {
1666#define NFCIP_ACTIVE_SHIFT 0x03U
1667#define NFCIP_PASSIVE_MASK 0x07U
Martijn Coenen20b7bd52012-01-31 22:13:33 -0800[diff] [blame]1668 uint8_t mode = targetSpeed;
Martijn Coenen25aa1292012-03-16 13:15:23 -0700[diff] [blame]1669 HCI_DEBUG("Setting target mode to 0x%02X", mode);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1670 status =
1671 phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_TARGET,
1672 (uint8_t) mode );
1673 if(NFCSTATUS_PENDING == status)
1674 {
1675#if defined (INITIATOR_SPEED)
1676 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1677#elif defined (NFCIP_TGT_DISABLE_CFG)
1678 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1679#else
1680 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1681#endif
1682 status = NFCSTATUS_PENDING;
1683 }
1684 break;
1685 }
1686#endif
1687#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1688 case INITIATOR_SPEED_SEQ:
1689 {
Martijn Coenen25aa1292012-03-16 13:15:23 -0700[diff] [blame]1690 HCI_DEBUG("Setting initiator mode to 0x%02X", speed);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1691 status =
1692 phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_INITIATOR,
Nick Pelly00c98d52011-03-18 11:27:49 -0700[diff] [blame]1693 (uint8_t) (speed & DEFAULT_NFCIP_INITIATOR_MODE_SUPPORT));
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1694 if(NFCSTATUS_PENDING == status)
1695 {
1696#if defined (NFCIP_TGT_DISABLE_CFG)
1697 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1698#else
1699 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1700#endif
1701 status = NFCSTATUS_PENDING;
1702 }
1703 break;
1704 }
1705#endif
1706#if defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1707 case PL_TGT_DISABLE_SEQ:
1708 {
1709 /* Configure the Polling Loop Target Disable Parameter */
1710 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1711 (uint8_t)PL_DISABLE_TARGET, &p_poll_config->NfcIP_Tgt_Disable );
1712 if(NFCSTATUS_SUCCESS == status)
1713 {
1714 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1715 status = NFCSTATUS_PENDING;
1716 }
1717 break;
1718 }
1719#endif
1720 case PL_CONFIG_PHASE_SEQ:
1721 {
1722 phHal_sPollDevInfo_t *p_poll_info =
1723 &(p_poll_config->PollDevInfo.PollCfgInfo);
1724
1725 p_poll_info->EnableIso14443A =
1726 ( (p_poll_info->EnableIso14443A)
1727 || ( speed & (uint8_t)phHal_ePassive106 )
1728 );
1729 p_poll_info->EnableFelica212 =
1730 ( (p_poll_info->EnableFelica212)
1731 || ( speed & (uint8_t)phHal_ePassive212 )
1732 );
1733 p_poll_info->EnableFelica424 =
1734 ( (p_poll_info->EnableFelica424)
1735 || ( speed & (uint8_t)phHal_ePassive424 )
1736 );
1737 /* Configure the Polling Loop Gate Parameters */
1738 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
1739 (uint8_t)PL_RD_PHASES, NULL );
1740 if(NFCSTATUS_SUCCESS == status)
1741 {
1742 if(((~(PL_RD_PHASES_DISABLE)) &
1743 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1744 {
1745 psHciContext->hci_seq = READER_ENABLE_SEQ;
1746 }
1747 else
1748 {
1749 /* psHciContext->hci_seq = READER_DISABLE_SEQ; */
1750 psHciContext->hci_seq = HCI_END_SEQ;
1751 }
1752 status = NFCSTATUS_PENDING;
1753 }
1754 break;
1755 }
1756 case READER_ENABLE_SEQ:
1757 {
1758 status =
1759 phHciNfc_ReaderMgmt_Enable_Discovery(
1760 psHciContext, pHwRef );
1761 if(NFCSTATUS_SUCCESS == status)
1762 {
1763 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
1764 psHciContext->hci_seq = HCI_END_SEQ;
1765 status = NFCSTATUS_PENDING;
1766 }
1767 break;
1768 }
1769 case READER_DISABLE_SEQ:
1770 {
1771 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1772 psHciContext, pHwRef );
1773
1774 if(NFCSTATUS_SUCCESS == status)
1775 {
1776 if((~(PL_RD_PHASES_DISABLE) &
1777 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1778 {
1779 psHciContext->hci_seq = PL_DURATION_SEQ;
1780 }
1781 else
1782 {
1783#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
1784 psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
1785#elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
1786 psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
1787#else
1788 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
1789#endif
1790 /* psHciContext->hci_seq = HCI_END_SEQ; */
1791 }
1792 status = NFCSTATUS_PENDING;
1793 }
1794 break;
1795 }
1796 case HCI_END_SEQ:
1797 {
1798 phNfc_sCompletionInfo_t comp_info;
1799 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
1800 if (NFCSTATUS_PENDING != status)
1801 {
1802 /* status = phHciNfc_FSM_Complete ( psHciContext );*/
1803 phHciNfc_FSM_Rollback ( psHciContext );
1804 /* Poll Configuration Notification to the Upper Layer */
1805 if((~(PL_RD_PHASES_DISABLE) &
1806 p_poll_config->PollDevInfo.PollEnabled)!= 0)
1807 {
1808 comp_info.status = status;
1809 phHciNfc_Notify(psHciContext->p_upper_notify,
1810 psHciContext->p_upper_context, pHwRef,
1811 NFC_NOTIFY_POLL_ENABLED, &comp_info);
1812 }
1813 else
1814 {
1815 comp_info.status = status;
1816 phHciNfc_Notify(psHciContext->p_upper_notify,
1817 psHciContext->p_upper_context, pHwRef,
1818 NFC_NOTIFY_POLL_DISABLED, &comp_info);
1819 }
1820 HCI_PRINT("HCI Discovery Configuration Completed \n");
1821 }
1822 break;
1823 }
1824 default:
1825 {
1826 /* psHciContext->hci_seq = HCI_END_SEQ; */
1827 break;
1828 }
1829 }/* End of the Poll Sequence Switch */
1830 }/* End of the Poll Config info Check */
1831
1832 return status;
1833}
1834
1835
1836NFCSTATUS
1837phHciNfc_EmulationCfg_Sequence(
1838 phHciNfc_sContext_t *psHciContext,
1839 void *pHwRef
1840 )
1841{
1842 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1843 static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1844#if defined(HOST_EMULATION)
1845 phHciNfc_GateID_t ce_gate = phHciNfc_UnknownGate;
1846#endif /* #ifdef HOST_EMULATION */
1847 phHal_sEmulationCfg_t *p_emulation_cfg = (phHal_sEmulationCfg_t * )
1848 psHciContext->p_config_params;
1849#ifdef UICC_SESSION_RESET
1850 uint8_t uicc_clear_pipes = FALSE;
1851#endif
1852
1853
1854 if (NULL != p_emulation_cfg)
1855 {
1856#if defined(HOST_EMULATION)
1857 if(NFC_HOST_CE_A_EMULATION == p_emulation_cfg->emuType)
1858 {
1859 psHciContext->config_type = NFC_CE_A_CFG;
1860 if (NULL == psHciContext->p_ce_a_info)
1861 {
1862 ce_gate = phHciNfc_CETypeAGate;
1863 }
1864 }
1865 else if (NFC_HOST_CE_B_EMULATION == p_emulation_cfg->emuType)
1866 {
1867 psHciContext->config_type = NFC_CE_B_CFG;
1868 if (NULL == psHciContext->p_ce_b_info)
1869 {
1870 ce_gate = phHciNfc_CETypeBGate;
1871 }
1872 }
1873#ifdef UICC_SESSION_RESET
1874 else if ((NFC_UICC_EMULATION == p_emulation_cfg->emuType)
1875 &&(FALSE == p_emulation_cfg->config.uiccEmuCfg.enableUicc)
1876 )
1877 {
1878 uicc_clear_pipes = TRUE;
1879 }
1880#endif
1881 else
1882 {
1883 ;
1884 }
1885#endif /* #ifdef HOST_EMULATION */
1886
1887 switch(psHciContext->hci_seq)
1888 {
1889#if defined(HOST_EMULATION)
1890 case ADMIN_CE_SEQ:
1891 {
1892 if(phHciNfc_UnknownGate != ce_gate)
1893 {
1894 status = phHciNfc_Admin_CE_Init(psHciContext, pHwRef, ce_gate);
1895 }
1896 else
1897 {
1898 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
1899 }
1900
1901 if(NFCSTATUS_SUCCESS == status)
1902 {
1903 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
1904 /* psHciContext->hci_seq = HCI_END_SEQ; */
1905 status = NFCSTATUS_PENDING;
1906 }
1907 break;
1908 }
1909#endif
1910 case EMULATION_CONFIG_SEQ:
1911 {
1912 status = phHciNfc_Emulation_Cfg(psHciContext, pHwRef,
1913 psHciContext->config_type);
1914 if(NFCSTATUS_SUCCESS == status)
1915 {
1916 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
1917#ifdef UICC_SESSION_RESET
1918 if(UICC_SWP_CFG == psHciContext->config_type)
1919 {
1920 psHciContext->hci_seq = ADMIN_REL_SEQ;
1921 }
1922 else
1923#endif /* UICC_SESSION_RESET */
1924 {
1925 psHciContext->hci_seq = HCI_END_SEQ;
1926 }
1927 status = NFCSTATUS_PENDING;
1928 }
1929 break;
1930 }
1931#ifdef UICC_SESSION_RESET
1932 case ADMIN_REL_SEQ:
1933 {
1934 if (TRUE == uicc_clear_pipes)
1935 {
1936 /* Admin Management UICC Release Sequence */
1937 status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_UICCHostID );
1938 if(NFCSTATUS_SUCCESS == status)
1939 {
1940 psHciContext->hci_seq = HCI_END_SEQ;
1941 if (UICC_SWP_CFG == psHciContext->config_type)
1942 {
1943 (void)phHciNfc_SWP_Update_Sequence(psHciContext,
1944 CONFIG_SEQ );
1945 }
1946 status = NFCSTATUS_PENDING;
1947 }
1948 break;
1949 }
1950 }
1951#endif /* UICC_SESSION_RESET */
1952 /* fall through */
1953 case HCI_END_SEQ:
1954 {
1955 phHciNfc_FSM_Rollback(psHciContext);
1956
1957 HCI_PRINT(" Emulation Configuration Completed. \n");
1958
1959 comp_info.status = status;
1960 phHciNfc_Notify(psHciContext->p_upper_notify,
1961 psHciContext->p_upper_context, pHwRef,
1962 NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
1963 break;
1964 }
1965 default:
1966 {
1967 /* psHciContext->hci_seq = HCI_END_SEQ; */
1968 break;
1969 }
1970 }
1971 /*
1972 NFC_CE_A_CFG;
1973 NFC_CE_B_CFG; */
1974
1975 }/* End of the Emulation Config info Check */
1976
1977 return status;
1978}
1979
1980
1981NFCSTATUS
1982phHciNfc_SmartMx_Mode_Sequence(
1983 phHciNfc_sContext_t *psHciContext,
1984 void *pHwRef
1985 )
1986{
1987 NFCSTATUS status = NFCSTATUS_SUCCESS;
1988 phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
1989 psHciContext->p_config_params;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]1990 phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1991 if (NULL != p_poll_config)
1992 {
1993 switch(psHciContext->hci_seq)
1994 {
1995 case READER_DISABLE_SEQ:
1996 {
1997 status = phHciNfc_ReaderMgmt_Disable_Discovery(
1998 psHciContext, pHwRef );
1999 if(NFCSTATUS_SUCCESS == status)
2000 {
2001 psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
2002 /* psHciContext->hci_seq = HCI_END_SEQ; */
2003 status = NFCSTATUS_PENDING;
2004 }
2005 break;
2006 }
2007 case EMULATION_CONFIG_SEQ:
2008 {
2009 status = phHciNfc_WI_Configure_Mode(
2010 psHciContext, pHwRef,psHciContext->smx_mode );
2011 if(NFCSTATUS_SUCCESS == status)
2012 {
2013 psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
2014 /* psHciContext->hci_seq = HCI_END_SEQ; */
2015 status = NFCSTATUS_PENDING;
2016 }
2017 break;
2018 }
2019 case PL_CONFIG_PHASE_SEQ:
2020 {
2021 /* Configure the Polling Loop Gate Parameters */
2022 status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
2023 (uint8_t)PL_RD_PHASES, NULL );
2024 if(NFCSTATUS_SUCCESS == status)
2025 {
2026 psHciContext->hci_seq = READER_ENABLE_SEQ;
2027 status = NFCSTATUS_PENDING;
2028 }
2029 break;
2030 }
2031 case READER_ENABLE_SEQ:
2032 {
2033 status =
2034 phHciNfc_ReaderMgmt_Enable_Discovery(
2035 psHciContext, pHwRef );
2036 if(NFCSTATUS_SUCCESS == status)
2037 {
2038 /* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
2039 psHciContext->hci_seq = HCI_END_SEQ;
2040 status = NFCSTATUS_PENDING;
2041 }
2042 break;
2043 }
2044 case HCI_END_SEQ:
2045 {
2046 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
2047 if (NFCSTATUS_PENDING != status)
2048 {
2049 /* status = phHciNfc_FSM_Complete ( psHciContext );*/
2050 phHciNfc_FSM_Rollback ( psHciContext );
2051 if( hciState_Disconnect == psHciContext->hci_state.cur_state)
2052 {
2053 psHciContext->host_rf_type = phHal_eUnknown_DevType;
2054 psHciContext->p_target_info = NULL;
2055 psHciContext->p_xchg_info = NULL;
2056 }
2057 /* Poll Configuration Notification to the Upper Layer */
2058 if((~(PL_RD_PHASES_DISABLE) &
2059 p_poll_config->PollDevInfo.PollEnabled)!= 0)
2060 {
2061 comp_info.status = status;
2062 phHciNfc_Notify(psHciContext->p_upper_notify,
2063 psHciContext->p_upper_context, pHwRef,
2064 NFC_NOTIFY_POLL_ENABLED, &comp_info);
2065 }
2066 else
2067 {
2068 comp_info.status = status;
2069 phHciNfc_Notify(psHciContext->p_upper_notify,
2070 psHciContext->p_upper_context, pHwRef,
2071 NFC_NOTIFY_POLL_DISABLED, &comp_info);
2072 }
2073 HCI_PRINT("HCI Discovery Configuration Completed \n");
2074 }
2075 break;
2076 }
2077 default:
2078 {
2079 /* psHciContext->hci_seq = HCI_END_SEQ; */
2080 break;
2081 }
2082 }/* End of the Poll Sequence Switch */
2083 }/* End of the Poll Config info Check */
2084
2085 return status;
2086}
2087
2088
2089NFCSTATUS
2090phHciNfc_Connect_Sequence(
2091 phHciNfc_sContext_t *psHciContext,
2092 void *pHwRef
2093 )
2094{
2095 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2096 static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2097 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
2098
2099 if( NULL != psHciContext->p_target_info )
2100 {
2101
2102 target_type = psHciContext->p_target_info->RemDevType;
2103 switch(psHciContext->hci_seq)
2104 {
2105 case READER_REACTIVATE_SEQ:
2106 {
2107 /* Complete the Reactivate Sequence and notify the HAL */
2108 status = phHciNfc_FSM_Complete ( psHciContext );
2109 /* Reactivate Complete Notification to the Upper Layer */
2110 if(NFCSTATUS_SUCCESS == status)
2111 {
2112 comp_info.status = status;
2113 phHciNfc_Notify(psHciContext->p_upper_notify,
2114 psHciContext->p_upper_context, pHwRef,
2115 NFC_NOTIFY_TARGET_REACTIVATED , &comp_info);
2116 HCI_PRINT(" HCI Remote Target Reactivated. \n");
2117 }
2118 else
2119 {
2120 comp_info.status = status;
2121 phHciNfc_FSM_Rollback ( psHciContext );
2122 phHciNfc_Notify(psHciContext->p_upper_notify,
2123 psHciContext->p_upper_context, pHwRef,
2124 NFC_NOTIFY_ERROR , &comp_info);
2125 HCI_PRINT("HCI FSM Invalid Selection State \n");
2126 HCI_PRINT("HCI Remote Target Reactivation Failed \n");
2127 }
2128 break;
2129 }
2130 case READER_SELECT_SEQ:
2131 {
2132 /* If the Target is Mifare then it should fall through */
2133 if(( phHal_eMifare_PICC != target_type )
2134 &&(phHal_eISO14443_3A_PICC != target_type)
2135#ifdef TYPE_B
2136 && ( phHal_eISO14443_B_PICC != target_type )
2137 && ( phHal_eISO14443_4B_PICC != target_type )
2138#endif
2139#ifdef TYPE_FELICA
2140 && ( phHal_eFelica_PICC != target_type )
2141#endif
2142#ifdef TYPE_JEWEL
2143 && ( phHal_eJewel_PICC != target_type )
2144#endif /* #ifdef TYPE_JEWEL */
2145#ifdef TYPE_ISO15693
2146 && ( phHal_eISO15693_PICC != target_type )
2147#endif /* #ifdef TYPE_ISO15693 */
2148
2149 )
2150 {
2151 status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
2152 if(NFCSTATUS_SUCCESS == status)
2153 {
2154 psHciContext->hci_seq = HCI_END_SEQ;
2155 status = NFCSTATUS_PENDING;
2156 }
2157 break;
2158 }
2159 }
2160 /* fall through */
2161 case HCI_END_SEQ:
2162 {
2163 /* Complete the Connect Sequence and notify the HAL */
2164 status = phHciNfc_FSM_Complete ( psHciContext );
2165 /* Connection Complete Notification to the Upper Layer */
2166 if(NFCSTATUS_SUCCESS == status)
2167 {
2168 /* Invalidate the previously polled RF Reader Type */
2169 /* psHciContext->host_rf_type = phHal_eInvalidRFType;*/
2170 comp_info.status = status;
2171 phHciNfc_Notify(psHciContext->p_upper_notify,
2172 psHciContext->p_upper_context, pHwRef,
2173 NFC_NOTIFY_TARGET_CONNECTED , &comp_info);
2174 HCI_PRINT(" HCI Remote Target Selected for Transaction. \n");
2175 }
2176 else
2177 {
2178 comp_info.status = status;
2179 /* phHciNfc_FSM_Rollback ( psHciContext ); */
2180 phHciNfc_Notify(psHciContext->p_upper_notify,
2181 psHciContext->p_upper_context, pHwRef,
2182 NFC_NOTIFY_ERROR , &comp_info);
2183 HCI_PRINT("HCI FSM Invalid Selection State \n");
2184 HCI_PRINT("HCI Remote Target Selection Failed \n");
2185 }
2186 break;
2187 }
2188 default:
2189 {
2190 HCI_PRINT("\t Invalid HCI Connect Sequence \n");
2191 /* psHciContext->hci_seq = HCI_END_SEQ; */
2192 break;
2193 }
2194 }/* End of the Connect Sequence Switch */
2195 }
2196
2197 return status;
2198}
2199
2200
2201NFCSTATUS
2202phHciNfc_Disconnect_Sequence(
2203 phHciNfc_sContext_t *psHciContext,
2204 void *pHwRef
2205 )
2206{
2207 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2208 static phNfc_sCompletionInfo_t comp_info = {FALSE, 0 , NULL};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2209 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
2210 uint8_t re_poll = 0;
2211
2212 if( NULL != psHciContext->p_target_info )
2213 {
2214
2215 target_type = psHciContext->p_target_info->RemDevType;
2216 switch(psHciContext->hci_seq)
2217 {
2218 case READER_UICC_DISPATCH_SEQ:
2219 {
2220 status = phHciNfc_ReaderMgmt_UICC_Dispatch(
2221 psHciContext, pHwRef, target_type );
2222 psHciContext->hci_seq = READER_DESELECT_SEQ;
2223 if(NFCSTATUS_PENDING == status)
2224 {
2225 break;
2226 }
2227 }
2228 /* fall through */
2229 case READER_DESELECT_SEQ:
2230 {
2231 re_poll = (uint8_t) ( NULL != psHciContext->p_config_params )?
2232 *((uint8_t *)psHciContext->p_config_params):FALSE;
2233 status = phHciNfc_ReaderMgmt_Deselect(
2234 psHciContext, pHwRef, target_type, re_poll);
2235 if(NFCSTATUS_PENDING == status)
2236 {
2237 psHciContext->hci_seq = HCI_END_SEQ;
2238 psHciContext->p_config_params = NULL;
2239 }
2240 break;
2241 }
2242 case HCI_END_SEQ:
2243 {
2244 /* Complete the Disconnect Sequence and notify the HAL */
2245 status = phHciNfc_FSM_Complete ( psHciContext );
2246 /* Disconnect Notification to the Upper Layer */
2247 if(NFCSTATUS_SUCCESS == status)
2248 {
2249 /* Invalidate the previously polled RF Reader Type */
2250 psHciContext->host_rf_type = phHal_eUnknown_DevType;
2251 psHciContext->p_target_info = NULL;
2252 psHciContext->p_xchg_info = NULL;
2253 comp_info.status = status;
2254 phHciNfc_Notify(psHciContext->p_upper_notify,
2255 psHciContext->p_upper_context, pHwRef,
2256 NFC_NOTIFY_TARGET_DISCONNECTED , &comp_info);
2257 HCI_PRINT(" HCI Remote Target De-Selected. \n");
2258 }
2259 else
2260 {
2261 comp_info.status = status;
2262 /* phHciNfc_FSM_Rollback ( psHciContext ); */
2263 phHciNfc_Notify(psHciContext->p_upper_notify,
2264 psHciContext->p_upper_context, pHwRef,
2265 NFC_NOTIFY_ERROR , &comp_info);
2266 HCI_PRINT("HCI FSM Invalid De-Selection State \n");
2267 HCI_PRINT("HCI Remote Target De-Selection Failed \n");
2268 }
2269
2270 break;
2271 }
2272 default:
2273 {
2274 HCI_PRINT("\t Invalid HCI Connect Sequence \n");
2275 /* psHciContext->hci_seq = HCI_END_SEQ; */
2276 break;
2277 }
2278 }/* End of the Connect Sequence Switch */
2279 }
2280
2281 return status;
2282}
2283
2284
2285static
2286NFCSTATUS
2287phHciNfc_Transact_Sequence(
2288 phHciNfc_sContext_t *psHciContext,
2289 void *pHwRef
2290 )
2291{
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2292 static phNfc_sTransactionInfo_t transact_info = {FALSE,0,NULL,NULL,0};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2293
2294 pphNfcIF_Notification_CB_t p_upper_notify = psHciContext->p_upper_notify;
2295 void *pcontext = psHciContext->p_upper_context;
2296 uint8_t transact_result = NFC_NOTIFY_ERROR;
2297
2298 /* Roll Back to Connect State as Transceive is Complete */
2299 phHciNfc_FSM_Rollback(psHciContext);
2300
2301 switch (psHciContext->host_rf_type)
2302 {
2303 case phHal_eISO14443_A_PCD:
2304#ifdef TYPE_B
2305 case phHal_eISO14443_B_PCD:
2306#endif
2307 case phHal_eISO14443_BPrime_PCD:
2308#ifdef TYPE_FELICA
2309 case phHal_eFelica_PCD:
2310#endif
2311#ifdef TYPE_ISO15693
2312 case phHal_eISO15693_PCD:
2313#endif
2314 {
2315 if(ZERO != psHciContext->rx_index)
2316 {
2317 transact_info.status = NFCSTATUS_SUCCESS;
2318 transact_info.buffer =
2319 &psHciContext->recv_buffer[psHciContext->rx_index];
2320 transact_info.length =
2321 psHciContext->rx_total - psHciContext->rx_index;
2322 transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
2323 }
2324 else
2325 {
2326 transact_info.status = NFCSTATUS_FAILED;
2327 transact_result = NFC_NOTIFY_TRANSCEIVE_ERROR;
2328 }
2329 HCI_PRINT(" HCI Transceive operation Completed. \n");
2330 psHciContext->p_xchg_info = NULL ;
2331 break;
2332 }
2333#ifdef TYPE_JEWEL
2334 /* fall through */
2335 case phHal_eJewel_PCD:
2336#endif
2337 {
2338 transact_info.status = NFCSTATUS_SUCCESS;
2339 transact_info.buffer =
2340 &psHciContext->recv_buffer[psHciContext->rx_index];
2341 transact_info.length =
2342 psHciContext->rx_total - psHciContext->rx_index;
2343 transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
2344 HCI_PRINT(" HCI Transceive operation Completed. \n");
2345 psHciContext->p_xchg_info = NULL ;
2346 break;
2347 }
2348#if defined(ENABLE_P2P)
2349 case phHal_eNfcIP1_Initiator:
2350 case phHal_eNfcIP1_Target:
2351#endif
2352 {
2353 HCI_PRINT(" HCI Send operation Completed. \n");
2354 transact_info.status = NFCSTATUS_SUCCESS;
2355 transact_result = NFC_NOTIFY_SEND_COMPLETED;
2356 break;
2357 }
2358 case phHal_eUnknown_DevType:
2359 default:
2360 {
2361 transact_info.status =
2362 PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2363 break;
2364 }
2365
2366 }
2367 /* Notify the Transceive Completion to the Upper layer */
2368 phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
2369 transact_result, &transact_info);
2370
2371 return (NFCSTATUS)NFCSTATUS_SUCCESS;
2372}
2373
2374static
2375NFCSTATUS
2376phHciNfc_Info_Sequence(
2377 phHciNfc_sContext_t *psHciContext,
2378 void *pHwRef
2379 )
2380{
2381 NFCSTATUS status = NFCSTATUS_SUCCESS;
2382
2383 HCI_DEBUG(" HCI: Info Sequence Entry --> Reader Type : %02X \n",
2384 psHciContext->host_rf_type);
2385 switch (psHciContext->host_rf_type)
2386 {
2387 case phHal_eISO14443_A_PCD:
2388#ifdef TYPE_B
2389 case phHal_eISO14443_B_PCD:
2390#endif
2391 case phHal_eISO14443_BPrime_PCD:
2392#ifdef TYPE_FELICA
2393 case phHal_eFelica_PCD:
2394#endif
2395#ifdef TYPE_JEWEL
2396 case phHal_eJewel_PCD:
2397#endif
2398#ifdef TYPE_ISO15693
2399 case phHal_eISO15693_PCD:
2400#endif
2401 {
2402 /* To update the select sequence to retrieve
2403 * the target information using the reader type.
2404 */
2405 status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
2406 break;
2407 }
2408#if defined(ENABLE_P2P)
2409 case phHal_eNfcIP1_Initiator:
2410 case phHal_eNfcIP1_Target:
2411 {
2412 status = phHciNfc_NfcIP_Info_Sequence( psHciContext, pHwRef );
2413 break;
2414 }
2415#endif
2416 case phHal_eUnknown_DevType:
2417 default:
2418 {
2419 status =
2420 PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2421 break;
2422 }
2423
2424 }
2425 return status;
2426}
2427
2428static
2429NFCSTATUS
2430phHciNfc_Test_Sequence(
2431 phHciNfc_sContext_t *psHciContext,
2432 void *pHwRef,
2433 NFCSTATUS test_status,
2434 uint8_t *pdata,
2435 uint8_t length
2436 )
2437{
2438 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2439 static phNfc_sCompletionInfo_t comp_info = {0};
2440 static phNfc_sData_t test_result= {NULL,0};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2441
2442 /* Complete the Test Sequence and notify the HAL */
2443 status = phHciNfc_FSM_Complete ( psHciContext );
2444 /* Test Results to the Upper Layer */
2445 if(NFCSTATUS_SUCCESS == status)
2446 {
2447 comp_info.status = test_status;
2448 if ( (NULL != pdata) && (length >= HCP_HEADER_LEN) )
2449 {
2450 test_result.buffer = ( pdata + HCP_HEADER_LEN);
2451 test_result.length = length - HCP_HEADER_LEN;
2452 }
2453 else
2454 {
2455 status = phHciNfc_DevMgmt_Get_Test_Result(
2456 psHciContext, &test_result );
2457 }
2458 comp_info.info = &test_result;
2459 phHciNfc_Notify(psHciContext->p_upper_notify,
2460 psHciContext->p_upper_context, pHwRef,
2461 NFC_NOTIFY_RESULT , &comp_info);
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2462 HCI_DEBUG(" HCI System Test Completed : Status = %u\n", test_status);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2463 }
2464 else
2465 {
2466 comp_info.status = status;
2467 phHciNfc_FSM_Rollback ( psHciContext );
2468 phHciNfc_Notify(psHciContext->p_upper_notify,
2469 psHciContext->p_upper_context, pHwRef,
2470 NFC_NOTIFY_ERROR , &comp_info);
2471 HCI_PRINT("HCI FSM Invalid Test State \n");
2472 }
2473
2474 return status;
2475}
2476
2477static
2478NFCSTATUS
2479phHciNfc_IO_Sequence(
2480 phHciNfc_sContext_t *psHciContext,
2481 void *pHwRef,
2482 NFCSTATUS io_status,
2483 uint8_t *pdata,
2484 uint8_t length
2485 )
2486{
2487 NFCSTATUS status = NFCSTATUS_SUCCESS;
Rob von Behren6dd94832011-09-16 15:05:25 -0700[diff] [blame]2488 static phNfc_sCompletionInfo_t comp_info = {0};
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2489
2490 /* To remove "warning (VS 4100) : unreferenced formal parameter" */
2491 PHNFC_UNUSED_VARIABLE(pdata);
2492 PHNFC_UNUSED_VARIABLE(length);
2493 /* Complete the Test Sequence and notify the HAL */
2494 phHciNfc_FSM_Rollback ( psHciContext );
2495 /* Test Results to the Upper Layer */
2496 comp_info.status = io_status;
2497 status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
2498 if(NFCSTATUS_SUCCESS == io_status)
2499 {
2500 phHciNfc_Notify(psHciContext->p_upper_notify,
2501 psHciContext->p_upper_context, pHwRef,
2502 NFC_IO_SUCCESS , &comp_info);
2503 HCI_PRINT(" HCI System IO Successful. \n");
2504 }
2505 else
2506 {
2507 phHciNfc_Notify(psHciContext->p_upper_notify,
2508 psHciContext->p_upper_context, pHwRef,
2509 NFC_IO_ERROR , &comp_info);
2510 HCI_PRINT("HCI IO Error \n");
2511 }
2512 return status;
2513}
2514
2515
2516
2517#ifdef OTHER_TAGS
2518
2519NFCSTATUS
2520phHciNfc_Activate_Sequence(
2521 phHciNfc_sContext_t *psHciContext,
2522 void *pHwRef
2523 )
2524{
2525 NFCSTATUS status = NFCSTATUS_SUCCESS;
2526
2527 return status;
2528}
2529
2530
2531#endif
2532
2533