2533 lines
90 KiB
C
2533 lines
90 KiB
C
/*
|
|
* Copyright (C) 2010 NXP Semiconductors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
|
|
/*!
|
|
* =========================================================================== *
|
|
* *
|
|
* *
|
|
* \file phHciNfc_Sequence.c *
|
|
* \brief State Machine Implementation for the HCI Management and *
|
|
* and the Function Sequence for a particular State *
|
|
* *
|
|
* *
|
|
* Project: NFC-FRI-1.1 *
|
|
* *
|
|
* $Date: Tue Jun 8 09:33:46 2010 $ *
|
|
* $Author: ing04880 $ *
|
|
* $Revision: 1.85 $ *
|
|
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
|
|
* *
|
|
* =========================================================================== *
|
|
*/
|
|
|
|
/*
|
|
################################################################################
|
|
***************************** Header File Inclusion ****************************
|
|
################################################################################
|
|
*/
|
|
|
|
#include <phNfcCompId.h>
|
|
#include <phNfcConfig.h>
|
|
#include <phHciNfc.h>
|
|
#include <phHciNfc_Sequence.h>
|
|
#include <phHciNfc_AdminMgmt.h>
|
|
#include <phHciNfc_IDMgmt.h>
|
|
#include <phHciNfc_LinkMgmt.h>
|
|
#include <phHciNfc_DevMgmt.h>
|
|
#include <phHciNfc_PollingLoop.h>
|
|
#include <phHciNfc_RFReader.h>
|
|
#include <phHciNfc_RFReaderA.h>
|
|
#include <phHciNfc_Emulation.h>
|
|
#ifdef ENABLE_P2P
|
|
#include <phHciNfc_NfcIPMgmt.h>
|
|
#endif
|
|
#include <phHciNfc_SWP.h>
|
|
#include <phHciNfc_WI.h>
|
|
#include <phOsalNfc.h>
|
|
|
|
/*
|
|
################################################################################
|
|
****************************** Macro Definitions *******************************
|
|
################################################################################
|
|
*/
|
|
|
|
/* Address Definitions for HAL Configuration */
|
|
#define NFC_ADDRESS_HAL_CONF 0x9FD0U
|
|
|
|
|
|
/*
|
|
################################################################################
|
|
********************** Structure/Enumeration Definitions ***********************
|
|
################################################################################
|
|
*/
|
|
|
|
|
|
#ifdef VALIDATE_FSM
|
|
|
|
typedef struct phHciNfc_sFsm
|
|
{
|
|
phHciNfc_eState_t from_state;
|
|
phHciNfc_eState_t to_state;
|
|
uint8_t valid;
|
|
}phHciNfc_sFsm_t;
|
|
|
|
static phHciNfc_sFsm_t phHciNfc_Valid_Fsm[] = {
|
|
{hciState_Reset, hciState_Initialise , TRUE},
|
|
/* {hciState_Reset, hciState_Config, FALSE}, */
|
|
{hciState_Initialise, hciState_Config, TRUE},
|
|
{hciState_Initialise, hciState_Release, TRUE},
|
|
{hciState_Config, hciState_Connect, TRUE},
|
|
{hciState_Config, hciState_Release, TRUE},
|
|
{hciState_Connect, hciState_Activate, TRUE},
|
|
{hciState_Connect, hciState_Transact, TRUE},
|
|
{hciState_Connect, hciState_Disconnect, TRUE},
|
|
{hciState_Disconnect, hciState_Config, TRUE},
|
|
/* {hciState_Disconnect, hciState_Release, TRUE}, */
|
|
{hciState_Reset, hciState_Initialise, TRUE},
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
################################################################################
|
|
************************* Function Prototype Declaration ***********************
|
|
################################################################################
|
|
*/
|
|
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Config_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
);
|
|
|
|
|
|
/**
|
|
* \ingroup grp_hci_nfc
|
|
*
|
|
* The phHciNfc_Connect_Sequence function sequence selects the
|
|
* discovered target for performing the transaction.
|
|
*
|
|
* \param[in] psHciContext psHciContext is the context of
|
|
* the HCI Layer.
|
|
* \param[in] pHwRef pHwRef is the Information of
|
|
* the Device Interface Link .
|
|
*
|
|
* \retval NFCSTATUS_SUCCESS HCI target selection sequence successful.
|
|
* \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
|
|
* could not be interpreted properly.
|
|
* \retval Other errors Other related errors
|
|
*
|
|
*/
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Transact_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
);
|
|
|
|
/**
|
|
* \ingroup grp_hci_nfc
|
|
*
|
|
* The phHciNfc_Info_Sequence function sequence selects the
|
|
* discovered target for performing the transaction.
|
|
*
|
|
* \param[in] psHciContext psHciContext is the context of
|
|
* the HCI Layer.
|
|
* \param[in] pHwRef pHwRef is the Information of
|
|
* the Device Interface Link .
|
|
*
|
|
* \retval NFCSTATUS_SUCCESS HCI target selection sequence successful.
|
|
* \retval NFCSTATUS_INVALID_PARAMETER One or more of the supplied parameters
|
|
* could not be interpreted properly.
|
|
* \retval Other errors Other related errors
|
|
*
|
|
*/
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Info_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Test_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
NFCSTATUS test_status,
|
|
uint8_t *pdata,
|
|
uint8_t length
|
|
);
|
|
|
|
#ifdef HCI_FSM_RESET
|
|
|
|
static
|
|
void
|
|
phHciNfc_FSM_Reset(
|
|
phHciNfc_sContext_t *psHciContext
|
|
);
|
|
|
|
#endif
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_IO_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
NFCSTATUS test_status,
|
|
uint8_t *pdata,
|
|
uint8_t length
|
|
);
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Pending_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
);
|
|
|
|
|
|
/*
|
|
################################################################################
|
|
***************************** Function Definitions *****************************
|
|
################################################################################
|
|
*/
|
|
|
|
NFCSTATUS
|
|
phHciNfc_FSM_Validate(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
phHciNfc_eState_t state,
|
|
uint8_t validate_type
|
|
)
|
|
{
|
|
NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
|
|
phHciNfc_eState_t cur_state = (phHciNfc_eState_t)
|
|
psHciContext->hci_state.cur_state;
|
|
|
|
switch(validate_type)
|
|
{
|
|
case NFC_FSM_CURRENT:
|
|
{
|
|
if( cur_state == (uint8_t) state )
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
case NFC_FSM_NEXT:
|
|
{
|
|
phHciNfc_eState_t next_state = state;
|
|
switch (cur_state)
|
|
{
|
|
case hciState_Reset:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Specifies the Starting of the init Sequence */
|
|
case hciState_Initialise:
|
|
/* Initialise to Perform Test on
|
|
the Antenna/SWP Link */
|
|
case hciState_Test:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Initialise:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Discovery Resume after connect failure */
|
|
case hciState_Initialise:
|
|
/* Configuring the Discovery/Emulation */
|
|
case hciState_Config:
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
/* Occurence of the Tag Discovered Event */
|
|
case hciState_Select:
|
|
/* Occurence of the Target Activated Event */
|
|
case hciState_Listen:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Test:
|
|
{
|
|
if ((hciState_Test == next_state )
|
|
|| (hciState_IO == next_state)
|
|
|| (hciState_Release == next_state))
|
|
{
|
|
/* Next Test/Reset Sequence */
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Select:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Restart the Wheel */
|
|
case hciState_Initialise:
|
|
/* Select the next Tag in the Field or
|
|
* already Selected Tag Again
|
|
*/
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
case hciState_Select:
|
|
/* Configuring the Discovery/Emulation */
|
|
case hciState_Config:
|
|
/* Re-Activate the Target or
|
|
* Discover the next target
|
|
*/
|
|
case hciState_Reactivate:
|
|
/* Connect the Discovered Target */
|
|
case hciState_Connect:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Connect:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Disabling the Tag Discovery */
|
|
case hciState_Initialise:
|
|
/* Configuring the Discovery/Emulation */
|
|
/* This should not be allowed if the target
|
|
* is connected.
|
|
*/
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
case hciState_Config:
|
|
/* Re-Activate the Target or
|
|
* Discover the next target
|
|
*/
|
|
case hciState_Reactivate:
|
|
/* Intermediate Transceive State */
|
|
case hciState_Transact:
|
|
/* Intermediate Presence Check State */
|
|
case hciState_Presence:
|
|
/* Disconnect the Target Connected */
|
|
case hciState_Disconnect:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Listen:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Releasing from the Emulation/Target Mode */
|
|
case hciState_Initialise:
|
|
/* Occurence of the Tag Discovered Event
|
|
* after the Disconnect Operation
|
|
*/
|
|
case hciState_Select:
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
/* Configuring the Discovery/Emulation */
|
|
case hciState_Config:
|
|
/* Intermediate Transceive State */
|
|
case hciState_Transact:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Reactivate:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Restart/Discovery after the Target is removed
|
|
* after Reactivation.
|
|
*/
|
|
/* case hciState_Initialise: */
|
|
/* Re-Connect the Re-Activated Target */
|
|
case hciState_Connect:
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
/* Configuring the Discovery/Emulation */
|
|
case hciState_Config:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Disconnect:
|
|
{
|
|
switch(next_state)
|
|
{
|
|
/* Discovery Resume after connect failure
|
|
after the disconnect */
|
|
case hciState_Initialise:
|
|
/* Configuring the Memory */
|
|
case hciState_IO:
|
|
/* Configuring the Discovery/Emulation */
|
|
case hciState_Config:
|
|
/* Occurence of the Tag Discovered Event
|
|
* after the Disconnect Operation
|
|
*/
|
|
case hciState_Select:
|
|
/* Occurence of the Target Activated Event */
|
|
case hciState_Listen:
|
|
/* Specifies the Starting of the Release Sequence */
|
|
case hciState_Release:
|
|
{
|
|
status = NFCSTATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#ifdef USE_M5
|
|
case hciState_Presence:
|
|
case hciState_Transact:
|
|
case hciState_Release:
|
|
{
|
|
break;
|
|
}
|
|
#endif
|
|
/* case phHciNfc_Unknown: */
|
|
default:
|
|
{
|
|
/* status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE); */
|
|
break;
|
|
}
|
|
} /* End of State Validation Switch */
|
|
if( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_BUSY);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
HCI_DEBUG("State Validate Type:%x is Unknown/Incorrect \n",
|
|
validate_type);
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NFCSTATUS
|
|
phHciNfc_FSM_Update(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
phHciNfc_eState_t next_state
|
|
)
|
|
{
|
|
NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
|
|
|
|
HCI_DEBUG(" HCI: Current State --> %02u \n",
|
|
psHciContext->hci_state.cur_state );
|
|
HCI_DEBUG(" HCI: Transition Before FSM Update --> %02u \n",
|
|
psHciContext->hci_state.transition );
|
|
HCI_DEBUG(" HCI: Next State Before FSM Update --> %02u \n",
|
|
psHciContext->hci_state.next_state );
|
|
|
|
status = phHciNfc_FSM_Validate(psHciContext, next_state, NFC_FSM_NEXT );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_state.next_state = (uint8_t) next_state;
|
|
psHciContext->hci_state.transition = NFC_FSM_IN_PROGRESS;
|
|
psHciContext->response_pending = FALSE;
|
|
HCI_DEBUG(" HCI: Next State After FSM Update --> %02u \n",
|
|
psHciContext->hci_state.next_state );
|
|
}
|
|
else
|
|
{
|
|
HCI_DEBUG(" HCI: FSM - Invalid next state --> %02u \n",
|
|
next_state );
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_FSM_Complete(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
NFCSTATUS status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
|
|
|
|
HCI_DEBUG("HCI: In Function: %s \n", __FUNCTION__);
|
|
|
|
HCI_DEBUG(" HCI: Transition Before FSM Complete --> %02u \n",
|
|
psHciContext->hci_state.transition );
|
|
|
|
HCI_DEBUG(" HCI: Current State Before FSM Complete --> %02u \n",
|
|
psHciContext->hci_state.cur_state );
|
|
|
|
HCI_DEBUG(" HCI: Next State Before FSM Complete --> %02u \n",
|
|
psHciContext->hci_state.next_state );
|
|
|
|
if( (NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition)
|
|
)
|
|
{
|
|
psHciContext->hci_state.cur_state =
|
|
psHciContext->hci_state.next_state ;
|
|
psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
|
|
psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
|
|
/* Reset the HCI Sequence */
|
|
psHciContext->response_pending = FALSE;
|
|
psHciContext->hci_seq = HCI_INVALID_SEQ;
|
|
status = NFCSTATUS_SUCCESS;
|
|
}
|
|
|
|
HCI_DEBUG(" HCI: Current State After FSM Complete --> %02u \n",
|
|
psHciContext->hci_state.cur_state );
|
|
|
|
return status;
|
|
}
|
|
|
|
void
|
|
phHciNfc_FSM_Rollback(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
|
|
HCI_DEBUG("HCI: %s: transition=%02u, cur_state=%02u, next_state=%02u\n",
|
|
__func__,
|
|
psHciContext->hci_state.transition,
|
|
psHciContext->hci_state.cur_state,
|
|
psHciContext->hci_state.next_state);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( (NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition)
|
|
)
|
|
{
|
|
psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
|
|
psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
|
|
/* Reset the HCI Sequence */
|
|
psHciContext->hci_seq = HCI_INVALID_SEQ;
|
|
psHciContext->response_pending = FALSE;
|
|
}
|
|
}
|
|
|
|
#ifdef HCI_FSM_RESET
|
|
static
|
|
void
|
|
phHciNfc_FSM_Reset(
|
|
phHciNfc_sContext_t *psHciContext
|
|
)
|
|
{
|
|
|
|
if( (hciState_Reset != psHciContext->hci_state.cur_state )
|
|
)
|
|
{
|
|
psHciContext->hci_state.cur_state = (uint8_t) hciState_Initialise ;
|
|
psHciContext->hci_state.transition = NFC_FSM_COMPLETE ;
|
|
psHciContext->hci_state.next_state = (uint8_t) hciState_Unknown ;
|
|
/* Reset the HCI Sequence */
|
|
psHciContext->hci_seq = HCI_INVALID_SEQ;
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Pending_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
PHNFC_UNUSED_VARIABLE(status);
|
|
|
|
HCI_DEBUG("HCI: psHciContext->target_release --> %s \n",
|
|
(psHciContext->target_release)?"TRUE":"FALSE");
|
|
if(TRUE == psHciContext->target_release)
|
|
{
|
|
#ifdef SW_RELEASE_TARGET
|
|
status = phHciNfc_ReaderMgmt_Deselect(
|
|
psHciContext, pHwRef, phHal_eISO14443_A_PICC, TRUE);
|
|
if(NFCSTATUS_PENDING == status )
|
|
{
|
|
psHciContext->target_release = FALSE ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = psHciContext->error_status;
|
|
#else
|
|
psHciContext->target_release = FALSE ;
|
|
#endif
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
void
|
|
phHciNfc_Error_Sequence(
|
|
void *psContext,
|
|
void *pHwRef,
|
|
NFCSTATUS error_status,
|
|
void *pdata,
|
|
uint8_t length
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_sContext_t *psHciContext = (phHciNfc_sContext_t *)psContext;
|
|
|
|
PHNFC_UNUSED_VARIABLE(status);
|
|
|
|
HCI_DEBUG("HCI: In Function: %s \n",
|
|
__FUNCTION__);
|
|
|
|
HCI_DEBUG ("HCI : Error Status : %04X\n", error_status);
|
|
|
|
HCI_DEBUG(" HCI: Current HCI State --> %02u \n",
|
|
psHciContext->hci_state.cur_state );
|
|
HCI_DEBUG(" HCI: Next HCI State --> %02u \n",
|
|
psHciContext->hci_state.next_state );
|
|
|
|
|
|
if ( NFC_FSM_IN_PROGRESS == psHciContext->hci_state.transition )
|
|
{
|
|
switch(psHciContext->hci_state.next_state)
|
|
{
|
|
case hciState_Initialise:
|
|
{
|
|
if (hciState_Reset == psHciContext->hci_state.cur_state)
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
phHciNfc_Release_Lower( psHciContext, pHwRef );
|
|
/* Release all the resources and
|
|
* Notify the Receive Error Scenario to the Upper Layer
|
|
*/
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Release_Notify (psHciContext, pHwRef,
|
|
NFC_NOTIFY_INIT_FAILED, &comp_info);
|
|
}
|
|
else if (hciState_Config == psHciContext->hci_state.cur_state)
|
|
{
|
|
/* Notify the Poll/Emulation Configure failure to the upper layer */
|
|
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
comp_info.status = error_status ;
|
|
|
|
psHciContext->error_status = error_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
/* Rollback the FSM as the Poll/Emulation configuration Failed */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONFIG_ERROR, &comp_info);
|
|
}
|
|
else
|
|
{
|
|
|
|
/* Notify the Poll Configure failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
|
|
psHciContext->error_status = error_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
/* Rollback the FSM as the Poll Disable Failed */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR, &comp_info);
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Test:
|
|
{
|
|
status = phHciNfc_Test_Sequence( psHciContext, pHwRef , error_status,
|
|
(uint8_t *)pdata, length );
|
|
break;
|
|
}
|
|
case hciState_IO:
|
|
{
|
|
status = phHciNfc_IO_Sequence( psHciContext, pHwRef , error_status,
|
|
(uint8_t *)pdata, length );
|
|
break;
|
|
}
|
|
case hciState_Config:
|
|
{
|
|
/* Notify the Configure failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
psHciContext->error_status = error_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
/* Rollback the FSM as the Poll Failed */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = psHciContext->error_status ;
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONFIG_ERROR, &comp_info);
|
|
break;
|
|
}
|
|
case hciState_Select:
|
|
{
|
|
/* Notify the Configure failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* Rollback the FSM as the Target Discovery Failed */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_DISCOVERY_ERROR, &comp_info);
|
|
|
|
#if 0
|
|
/* Polling Wheel will be restarted by the upper layer
|
|
* to Rediscover again */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Deselect(
|
|
psHciContext, pHwRef, phHal_eISO14443_A_PICC, FALSE);
|
|
}
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
#endif
|
|
break;
|
|
}
|
|
case hciState_Transact:
|
|
/* Notify the Transceive failure to the upper layer */
|
|
{
|
|
phNfc_sTransactionInfo_t transact_info={FALSE,0,NULL,NULL,0};
|
|
|
|
/* Rollback the FSM as the Transceive Failed */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
transact_info.status = error_status;
|
|
transact_info.buffer = NULL;
|
|
transact_info.length = FALSE;
|
|
psHciContext->p_xchg_info = NULL ;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_TRANSCEIVE_ERROR, &transact_info);
|
|
break;
|
|
|
|
}
|
|
case hciState_Connect:
|
|
{
|
|
/* Notify the General failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* psHciContext->host_rf_type = phHal_eUnknown_DevType; */
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
psHciContext->p_target_info = NULL;
|
|
psHciContext->hci_state.cur_state = hciState_Select;
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONNECT_FAILED, &comp_info);
|
|
break;
|
|
}
|
|
case hciState_Reactivate:
|
|
{
|
|
/* Notify the General failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* psHciContext->host_rf_type = phHal_eUnknown_DevType;
|
|
status = phHciNfc_ReaderMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
psHciContext->p_target_info = NULL;
|
|
psHciContext->hci_state.cur_state = hciState_Select; */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONNECT_FAILED, &comp_info);
|
|
break;
|
|
}
|
|
case hciState_Presence:
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* Roll Back to Connect State as Presence Check is Complete */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
/* Initialisation Complete Notification to the Upper Layer */
|
|
comp_info.status = error_status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR, &comp_info);
|
|
HCI_PRINT(" HCI Remote Target Removed from the Field. \n");
|
|
break;
|
|
}
|
|
/* Notify the Connect or Disconnect failure to the upper layer */
|
|
case hciState_Disconnect:
|
|
{
|
|
/* Notify the General failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_DISCONNECT_FAILED, &comp_info);
|
|
break;
|
|
}
|
|
case hciState_Release:
|
|
{
|
|
#ifdef NXP_HCI_SHUTDOWN_OVERRIDE
|
|
status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
|
|
#else
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
phHciNfc_Release_Lower( psHciContext, pHwRef );
|
|
/* Release all the resources and
|
|
* Notify the Receive Error Scenario to the Upper Layer
|
|
*/
|
|
comp_info.status = error_status ;
|
|
phHciNfc_Release_Notify (psHciContext, pHwRef,
|
|
NFC_NOTIFY_DEINIT_FAILED, &comp_info);
|
|
#endif
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* Notify the General failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
psHciContext->error_status = error_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if (NFCSTATUS_PENDING != status)
|
|
{
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR, &comp_info);
|
|
}
|
|
break;
|
|
}
|
|
|
|
} /* End of the Processing of HCI State*/
|
|
}
|
|
else
|
|
{
|
|
/* Notify the General failure to the upper layer */
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
comp_info.status = error_status ;
|
|
/* Disable the Notification to the Upper Layer */
|
|
if(NFCSTATUS_BOARD_COMMUNICATION_ERROR
|
|
== PHNFCSTATUS(error_status))
|
|
{
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR, &comp_info);
|
|
}
|
|
else
|
|
{
|
|
psHciContext->error_status = error_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if (NFCSTATUS_PENDING != status)
|
|
{
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Resume_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
HCI_DEBUG("HCI: %s: cur_state=%02u, next_state=%02u",
|
|
__FUNCTION__,
|
|
psHciContext->hci_state.cur_state,
|
|
psHciContext->hci_state.next_state);
|
|
|
|
|
|
|
|
|
|
switch(psHciContext->hci_state.next_state)
|
|
{
|
|
/* Process the Admin Gate Response based on the HCI State */
|
|
case hciState_Initialise:
|
|
{
|
|
switch (psHciContext->hci_state.cur_state)
|
|
{
|
|
/* Initialise State after Power on */
|
|
case hciState_Reset:
|
|
{
|
|
status = phHciNfc_Initialise_Sequence(psHciContext ,pHwRef);
|
|
break;
|
|
}
|
|
/* Initialise State after Power on */
|
|
case hciState_Config:
|
|
{
|
|
status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
|
|
break;
|
|
}
|
|
/* Discovery Resume after connect failure */
|
|
case hciState_Initialise:
|
|
case hciState_Select:
|
|
case hciState_Connect:
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* Update to the Intialise state as the discovery wheel is
|
|
* restarted.
|
|
*/
|
|
status = phHciNfc_FSM_Complete(psHciContext);
|
|
|
|
psHciContext->host_rf_type = phHal_eUnknown_DevType;
|
|
psHciContext->p_target_info = NULL;
|
|
psHciContext->p_xchg_info = NULL;
|
|
|
|
/* Initialisation Complete Notification to the Upper Layer */
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_POLL_RESTARTED , &comp_info);
|
|
HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case hciState_Release:
|
|
{
|
|
status = phHciNfc_Release_Sequence(psHciContext ,pHwRef);
|
|
break;
|
|
}
|
|
case hciState_Config:
|
|
{
|
|
status = phHciNfc_Config_Sequence(psHciContext ,pHwRef);
|
|
break;
|
|
}
|
|
case hciState_Listen:
|
|
case hciState_Select:
|
|
{
|
|
status = phHciNfc_Info_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
case hciState_Reactivate:
|
|
case hciState_Connect:
|
|
{
|
|
status = phHciNfc_Connect_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
case hciState_Transact:
|
|
{
|
|
status = phHciNfc_Transact_Sequence(
|
|
psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
case hciState_Presence:
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
/* Roll Back to Connect State as Presence Check is Complete */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
/* Initialisation Complete Notification to the Upper Layer */
|
|
comp_info.status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_TARGET_PRESENT , &comp_info);
|
|
HCI_PRINT(" HCI Remote Target Still Present in the Field. \n");
|
|
break;
|
|
}
|
|
case hciState_Disconnect:
|
|
{
|
|
status = phHciNfc_Disconnect_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
case hciState_Test:
|
|
{
|
|
status = phHciNfc_Test_Sequence( psHciContext, pHwRef , status, NULL, 0 );
|
|
break;
|
|
}
|
|
case hciState_IO:
|
|
{
|
|
status = phHciNfc_IO_Sequence( psHciContext, pHwRef , status, NULL, 0 );
|
|
break;
|
|
}
|
|
case hciState_Unknown:
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_STATE);
|
|
break;
|
|
}
|
|
} /* End of the Processing of HCI State*/
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Initialise_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static uint8_t config = 0;
|
|
|
|
PHNFC_UNUSED_VARIABLE(config);
|
|
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case ADMIN_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
#ifdef ESTABLISH_SESSION
|
|
if( hciMode_Session == psHciContext->hci_mode)
|
|
{
|
|
/* TODO: Initialise Link Management
|
|
Gate Resources */
|
|
NFCSTATUS info_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(info_status);
|
|
info_status = phHciNfc_IDMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
|
|
if(NFCSTATUS_SUCCESS == info_status)
|
|
{
|
|
psHciContext->hci_seq = PL_STOP_SEQ;
|
|
}
|
|
else
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
psHciContext->hci_seq = LINK_MGMT_INIT_SEQ;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case LINK_MGMT_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_LinkMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = IDENTITY_INIT_SEQ;
|
|
}
|
|
break;
|
|
}
|
|
case IDENTITY_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_IDMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = DEV_INIT_SEQ;
|
|
}
|
|
break;
|
|
}
|
|
case DEV_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_DevMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
if (HCI_SELF_TEST != psHciContext->init_mode)
|
|
{
|
|
psHciContext->hci_seq = PL_INIT_SEQ;
|
|
}
|
|
else
|
|
{
|
|
#if defined( ESTABLISH_SESSION )
|
|
NFCSTATUS info_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(info_status);
|
|
info_status = phHciNfc_IDMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
|
|
if(NFCSTATUS_SUCCESS == info_status)
|
|
{
|
|
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = IDENTITY_INFO_SEQ;
|
|
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
|
|
}
|
|
else
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = PHNFCSTVAL(CID_NFC_HCI,
|
|
NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
}
|
|
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
#endif /* #ifdef ESTABLISH_SESSION */
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
case PL_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_PollLoop_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(reset_status);
|
|
reset_status = phHciNfc_ReaderMgmt_Update_Sequence(
|
|
psHciContext, RESET_SEQ );
|
|
psHciContext->hci_seq = READER_MGMT_INIT_SEQ;
|
|
}
|
|
break;
|
|
}
|
|
case READER_MGMT_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
NFCSTATUS reset_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(reset_status);
|
|
reset_status = phHciNfc_EmuMgmt_Update_Seq(
|
|
psHciContext, RESET_SEQ );
|
|
psHciContext->hci_seq = EMULATION_INIT_SEQ;
|
|
}
|
|
break;
|
|
}
|
|
case EMULATION_INIT_SEQ:
|
|
{
|
|
status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
#if defined( ESTABLISH_SESSION )
|
|
psHciContext->hci_seq = ADMIN_SESSION_SEQ;
|
|
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
#endif
|
|
}
|
|
break;
|
|
}
|
|
#ifdef ESTABLISH_SESSION
|
|
case ADMIN_SESSION_SEQ:
|
|
{
|
|
status = phHciNfc_Admin_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = IDENTITY_INFO_SEQ;
|
|
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
|
|
}
|
|
break;
|
|
}
|
|
case PL_STOP_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Disable_Discovery(
|
|
psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
#if defined( SW_AUTO_ACTIVATION )
|
|
psHciContext->hci_seq = READER_SW_AUTO_SEQ;
|
|
#elif ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
psHciContext->hci_seq = DEV_HAL_INFO_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = IDENTITY_INFO_SEQ;
|
|
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
|
|
}
|
|
break;
|
|
}
|
|
#ifdef SW_AUTO_ACTIVATION
|
|
case READER_SW_AUTO_SEQ:
|
|
{
|
|
uint8_t activate_enable = FALSE;
|
|
uint8_t rdr_enable = TRUE;
|
|
|
|
status = phHciNfc_ReaderA_Update_Info(
|
|
psHciContext, HCI_READER_A_ENABLE,
|
|
&rdr_enable);
|
|
if(status == NFCSTATUS_SUCCESS)
|
|
{
|
|
status = phHciNfc_ReaderA_Auto_Activate( psHciContext,
|
|
pHwRef, activate_enable );
|
|
if(status == NFCSTATUS_SUCCESS)
|
|
{
|
|
psHciContext->hci_seq = IDENTITY_INFO_SEQ;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
/* fall through */
|
|
case IDENTITY_INFO_SEQ:
|
|
{
|
|
status = phHciNfc_IDMgmt_Info_Sequence( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
if ((HCI_SELF_TEST != psHciContext->init_mode)
|
|
/* && ( TRUE == ((phHal_sHwReference_t *)pHwRef)->se_detect ) */
|
|
&& (HCI_CUSTOM_INIT != psHciContext->init_mode)
|
|
&& (HCI_NFC_DEVICE_TEST != psHciContext->init_mode))
|
|
{
|
|
NFCSTATUS info_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(info_status);
|
|
info_status = phHciNfc_EmuMgmt_Update_Seq(
|
|
psHciContext, INFO_SEQ );
|
|
|
|
if(NFCSTATUS_SUCCESS == info_status)
|
|
{
|
|
psHciContext->hci_seq = EMULATION_SWP_SEQ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case EMULATION_SWP_SEQ:
|
|
{
|
|
status = phHciNfc_EmuMgmt_Initialise( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
}
|
|
break;
|
|
}
|
|
#endif /* #ifdef ESTABLISH_SESSION */
|
|
|
|
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
case DEV_HAL_INFO_SEQ:
|
|
{
|
|
static uint8_t mem_index = 0;
|
|
status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
|
|
(NFC_ADDRESS_HAL_CONF + mem_index),
|
|
(psHciContext->hal_mem_info + mem_index));
|
|
if(NFCSTATUS_PENDING == status)
|
|
{
|
|
mem_index++;
|
|
if (NXP_HAL_MEM_INFO_SIZE <= mem_index )
|
|
{
|
|
NFCSTATUS info_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(info_status);
|
|
info_status = phHciNfc_IDMgmt_Update_Sequence(
|
|
psHciContext, INFO_SEQ );
|
|
mem_index = 0;
|
|
psHciContext->hci_seq = IDENTITY_INFO_SEQ;
|
|
/* psHciContext->hci_seq =
|
|
(HCI_SELF_TEST != psHciContext->init_mode)?
|
|
IDENTITY_INFO_SEQ : HCI_END_SEQ; */
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
|
|
case HCI_END_SEQ:
|
|
{
|
|
phHal_sMemInfo_t *p_mem_info =
|
|
(phHal_sMemInfo_t *) ( psHciContext->hal_mem_info );
|
|
if (
|
|
(HCI_SELF_TEST == psHciContext->init_mode )
|
|
|| (HCI_NFC_DEVICE_TEST == psHciContext->init_mode )
|
|
)
|
|
{
|
|
psHciContext->hci_state.next_state
|
|
= (uint8_t) hciState_Test;
|
|
}
|
|
status = phHciNfc_FSM_Complete ( psHciContext );
|
|
#ifdef UICC_CONNECTIVITY_PATCH
|
|
phHciNfc_Uicc_Connectivity( psHciContext, pHwRef );
|
|
#endif /* #ifdef UICC_CONNECTIVITY_PATCH */
|
|
|
|
#if ( NXP_HAL_MEM_INFO_SIZE > 0x00U )
|
|
if(NXP_FW_UPLOAD_SUCCESS != p_mem_info->fw_magic )
|
|
{
|
|
status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FAILED );
|
|
}
|
|
#endif /* #if ( NXP_HAL_MEM_INFO_SIZE > 0x00U ) */
|
|
|
|
/* Initialisation Complete Notification to the Upper Layer */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info={FALSE,0, NULL};
|
|
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_INIT_COMPLETED, &comp_info);
|
|
HCI_PRINT("HCI Initialisation Completed \n");
|
|
}
|
|
else
|
|
{
|
|
pphNfcIF_Notification_CB_t p_upper_notify = psHciContext->p_upper_notify;
|
|
void *pcontext = psHciContext->p_upper_context;
|
|
phNfc_sCompletionInfo_t comp_info;
|
|
|
|
|
|
phHciNfc_Release_Lower( psHciContext, pHwRef );
|
|
phHciNfc_Release_Resources( &psHciContext );
|
|
/* Notify the Failure to the Upper Layer */
|
|
comp_info.status = status;
|
|
phHciNfc_Notify( p_upper_notify, pcontext, pHwRef,
|
|
NFC_NOTIFY_INIT_FAILED, &comp_info);
|
|
HCI_PRINT("HCI FSM Initialisation Error \n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Release_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case PL_STOP_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Disable_Discovery(
|
|
psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
(void)phHciNfc_EmuMgmt_Update_Seq(
|
|
psHciContext, REL_SEQ );
|
|
psHciContext->hci_seq = EMULATION_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case EMULATION_REL_SEQ:
|
|
{
|
|
status = phHciNfc_EmuMgmt_Release( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
(void)phHciNfc_DevMgmt_Update_Sequence(
|
|
psHciContext, REL_SEQ );
|
|
psHciContext->hci_seq = ADMIN_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case DEV_REL_SEQ:
|
|
{
|
|
NFCSTATUS info_status = NFCSTATUS_SUCCESS;
|
|
PHNFC_UNUSED_VARIABLE(info_status);
|
|
info_status = phHciNfc_DevMgmt_Update_Sequence(
|
|
psHciContext, REL_SEQ );
|
|
status = phHciNfc_DevMgmt_Release( psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case READER_MGMT_REL_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Release( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = PL_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case PL_REL_SEQ:
|
|
{
|
|
status = phHciNfc_PollLoop_Release( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = IDENTITY_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case IDENTITY_REL_SEQ:
|
|
{
|
|
status = phHciNfc_IDMgmt_Release( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = LINK_MGMT_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case LINK_MGMT_REL_SEQ:
|
|
{
|
|
status = phHciNfc_LinkMgmt_Release( psHciContext,pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = ADMIN_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case ADMIN_REL_SEQ:
|
|
{
|
|
/* Admin Management Release Sequence */
|
|
status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_TerminalHostID );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = DEV_REL_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case HCI_END_SEQ:
|
|
{
|
|
pphNfcIF_Notification_CB_t p_upper_notify =
|
|
psHciContext->p_upper_notify;
|
|
phNfc_sLowerIF_t *plower_if =
|
|
&(psHciContext->lower_interface);
|
|
void *pcontext =
|
|
psHciContext->p_upper_context;
|
|
phNfc_sCompletionInfo_t comp_info;
|
|
|
|
|
|
status = plower_if->release((void *)plower_if->pcontext,
|
|
(void *)pHwRef);
|
|
|
|
phHciNfc_Release_Resources( &psHciContext );
|
|
/* De-Initialisation Complete Notification to the Upper Layer */
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(p_upper_notify, pcontext, pHwRef,
|
|
NFC_NOTIFY_DEINIT_COMPLETED, &comp_info);
|
|
|
|
HCI_PRINT("HCI Release Completed \n");
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Config_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
|
|
|
|
switch(psHciContext->config_type)
|
|
{
|
|
case POLL_LOOP_CFG:
|
|
{
|
|
status = phHciNfc_PollLoop_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
case SMX_WI_MODE:
|
|
{
|
|
status = phHciNfc_SmartMx_Mode_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
#ifdef ENABLE_P2P
|
|
case NFC_GENERAL_CFG:
|
|
{
|
|
if(TARGET_GENERAL_SEQ == psHciContext->hci_seq)
|
|
{
|
|
status = phHciNfc_NfcIP_SetATRInfo( psHciContext,
|
|
pHwRef, NFCIP_TARGET,
|
|
psHciContext->p_config_params);
|
|
if( NFCSTATUS_PENDING != status )
|
|
{
|
|
/* Roll Back the State Machine to its Original State */
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
}
|
|
else
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if (NFCSTATUS_PENDING != status)
|
|
{
|
|
/* Roll Back to its Current State as Configuration is Complete */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
HCI_PRINT(" NFC-IP(P2P) Configuration Completed. \n");
|
|
comp_info.status = status;
|
|
psHciContext->error_status = NFCSTATUS_SUCCESS;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONFIG_SUCCESS , &comp_info);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
case SWP_PROTECT_CFG:
|
|
case SWP_EVT_CFG:
|
|
case SMX_WI_CFG:
|
|
{
|
|
/* Roll Back to its Current State as Configuration is Complete */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
HCI_DEBUG(" %s Configuration Completed. \n",
|
|
((SMX_WI_CFG == psHciContext->config_type)?
|
|
"SmartMX" : "SWP Event/Protection"));
|
|
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
|
|
break;
|
|
}
|
|
case NFC_TARGET_CFG:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
|
|
break;
|
|
}
|
|
case UICC_SWP_CFG:
|
|
#if 0
|
|
{
|
|
phHal_sEmulationCfg_t *p_emulation_cfg =
|
|
(phHal_sEmulationCfg_t * )
|
|
psHciContext->p_config_params;
|
|
if (NULL != p_emulation_cfg)
|
|
{
|
|
phHal_sUiccEmuCfg_t *uicc_config =
|
|
&p_emulation_cfg->config.uiccEmuCfg;
|
|
if( TRUE == uicc_config->enableUicc )
|
|
{
|
|
status = phHciNfc_Uicc_Connect_Status(psHciContext,pHwRef);
|
|
if( NFCSTATUS_PENDING == status )
|
|
{
|
|
break;
|
|
} /* Or Else Fall through to notify the above layer */
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
/* fall through */
|
|
case NFC_CE_A_CFG:
|
|
case NFC_CE_B_CFG:
|
|
{
|
|
status = phHciNfc_EmulationCfg_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_PollLoop_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
|
|
psHciContext->p_config_params;
|
|
if (NULL != p_poll_config)
|
|
{
|
|
uint8_t speed =
|
|
p_poll_config->NfcIP_Mode;
|
|
uint8_t targetSpeed =
|
|
p_poll_config->NfcIP_Target_Mode;
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case PL_DURATION_SEQ:
|
|
{
|
|
status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
|
|
(uint8_t)PL_DURATION , NULL);
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
|
|
psHciContext->hci_seq = TARGET_SPEED_SEQ;
|
|
#elif defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
|
|
psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
|
|
#elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
|
|
psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
#endif
|
|
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#if defined (ENABLE_P2P) && defined (TARGET_SPEED)
|
|
case TARGET_SPEED_SEQ:
|
|
{
|
|
#define NFCIP_ACTIVE_SHIFT 0x03U
|
|
#define NFCIP_PASSIVE_MASK 0x07U
|
|
uint8_t mode = targetSpeed;
|
|
HCI_DEBUG("Setting target mode to 0x%02X", mode);
|
|
status =
|
|
phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_TARGET,
|
|
(uint8_t) mode );
|
|
if(NFCSTATUS_PENDING == status)
|
|
{
|
|
#if defined (INITIATOR_SPEED)
|
|
psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
|
|
#elif defined (NFCIP_TGT_DISABLE_CFG)
|
|
psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
#endif
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
|
|
case INITIATOR_SPEED_SEQ:
|
|
{
|
|
HCI_DEBUG("Setting initiator mode to 0x%02X", speed);
|
|
status =
|
|
phHciNfc_NfcIP_SetMode( psHciContext, pHwRef, NFCIP_INITIATOR,
|
|
(uint8_t) (speed & DEFAULT_NFCIP_INITIATOR_MODE_SUPPORT));
|
|
if(NFCSTATUS_PENDING == status)
|
|
{
|
|
#if defined (NFCIP_TGT_DISABLE_CFG)
|
|
psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
#endif
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
#if defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
|
|
case PL_TGT_DISABLE_SEQ:
|
|
{
|
|
/* Configure the Polling Loop Target Disable Parameter */
|
|
status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
|
|
(uint8_t)PL_DISABLE_TARGET, &p_poll_config->NfcIP_Tgt_Disable );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
case PL_CONFIG_PHASE_SEQ:
|
|
{
|
|
phHal_sPollDevInfo_t *p_poll_info =
|
|
&(p_poll_config->PollDevInfo.PollCfgInfo);
|
|
|
|
p_poll_info->EnableIso14443A =
|
|
( (p_poll_info->EnableIso14443A)
|
|
|| ( speed & (uint8_t)phHal_ePassive106 )
|
|
);
|
|
p_poll_info->EnableFelica212 =
|
|
( (p_poll_info->EnableFelica212)
|
|
|| ( speed & (uint8_t)phHal_ePassive212 )
|
|
);
|
|
p_poll_info->EnableFelica424 =
|
|
( (p_poll_info->EnableFelica424)
|
|
|| ( speed & (uint8_t)phHal_ePassive424 )
|
|
);
|
|
/* Configure the Polling Loop Gate Parameters */
|
|
status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
|
|
(uint8_t)PL_RD_PHASES, NULL );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
if(((~(PL_RD_PHASES_DISABLE)) &
|
|
p_poll_config->PollDevInfo.PollEnabled)!= 0)
|
|
{
|
|
psHciContext->hci_seq = READER_ENABLE_SEQ;
|
|
}
|
|
else
|
|
{
|
|
/* psHciContext->hci_seq = READER_DISABLE_SEQ; */
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
}
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case READER_ENABLE_SEQ:
|
|
{
|
|
status =
|
|
phHciNfc_ReaderMgmt_Enable_Discovery(
|
|
psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
/* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case READER_DISABLE_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Disable_Discovery(
|
|
psHciContext, pHwRef );
|
|
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
if((~(PL_RD_PHASES_DISABLE) &
|
|
p_poll_config->PollDevInfo.PollEnabled)!= 0)
|
|
{
|
|
psHciContext->hci_seq = PL_DURATION_SEQ;
|
|
}
|
|
else
|
|
{
|
|
#if defined (ENABLE_P2P) && defined (INITIATOR_SPEED)
|
|
psHciContext->hci_seq = INITIATOR_SPEED_SEQ;
|
|
#elif defined (ENABLE_P2P) && defined (NFCIP_TGT_DISABLE_CFG)
|
|
psHciContext->hci_seq = PL_TGT_DISABLE_SEQ;
|
|
#else
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
#endif
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
}
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case HCI_END_SEQ:
|
|
{
|
|
phNfc_sCompletionInfo_t comp_info;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if (NFCSTATUS_PENDING != status)
|
|
{
|
|
/* status = phHciNfc_FSM_Complete ( psHciContext );*/
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
/* Poll Configuration Notification to the Upper Layer */
|
|
if((~(PL_RD_PHASES_DISABLE) &
|
|
p_poll_config->PollDevInfo.PollEnabled)!= 0)
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_POLL_ENABLED, &comp_info);
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_POLL_DISABLED, &comp_info);
|
|
}
|
|
HCI_PRINT("HCI Discovery Configuration Completed \n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}/* End of the Poll Sequence Switch */
|
|
}/* End of the Poll Config info Check */
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_EmulationCfg_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
|
|
#if defined(HOST_EMULATION)
|
|
phHciNfc_GateID_t ce_gate = phHciNfc_UnknownGate;
|
|
#endif /* #ifdef HOST_EMULATION */
|
|
phHal_sEmulationCfg_t *p_emulation_cfg = (phHal_sEmulationCfg_t * )
|
|
psHciContext->p_config_params;
|
|
#ifdef UICC_SESSION_RESET
|
|
uint8_t uicc_clear_pipes = FALSE;
|
|
#endif
|
|
|
|
|
|
if (NULL != p_emulation_cfg)
|
|
{
|
|
#if defined(HOST_EMULATION)
|
|
if(NFC_HOST_CE_A_EMULATION == p_emulation_cfg->emuType)
|
|
{
|
|
psHciContext->config_type = NFC_CE_A_CFG;
|
|
if (NULL == psHciContext->p_ce_a_info)
|
|
{
|
|
ce_gate = phHciNfc_CETypeAGate;
|
|
}
|
|
}
|
|
else if (NFC_HOST_CE_B_EMULATION == p_emulation_cfg->emuType)
|
|
{
|
|
psHciContext->config_type = NFC_CE_B_CFG;
|
|
if (NULL == psHciContext->p_ce_b_info)
|
|
{
|
|
ce_gate = phHciNfc_CETypeBGate;
|
|
}
|
|
}
|
|
#ifdef UICC_SESSION_RESET
|
|
else if ((NFC_UICC_EMULATION == p_emulation_cfg->emuType)
|
|
&&(FALSE == p_emulation_cfg->config.uiccEmuCfg.enableUicc)
|
|
)
|
|
{
|
|
uicc_clear_pipes = TRUE;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
;
|
|
}
|
|
#endif /* #ifdef HOST_EMULATION */
|
|
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
#if defined(HOST_EMULATION)
|
|
case ADMIN_CE_SEQ:
|
|
{
|
|
if(phHciNfc_UnknownGate != ce_gate)
|
|
{
|
|
status = phHciNfc_Admin_CE_Init(psHciContext, pHwRef, ce_gate);
|
|
}
|
|
else
|
|
{
|
|
status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
|
|
}
|
|
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
case EMULATION_CONFIG_SEQ:
|
|
{
|
|
status = phHciNfc_Emulation_Cfg(psHciContext, pHwRef,
|
|
psHciContext->config_type);
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
/* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
|
|
#ifdef UICC_SESSION_RESET
|
|
if(UICC_SWP_CFG == psHciContext->config_type)
|
|
{
|
|
psHciContext->hci_seq = ADMIN_REL_SEQ;
|
|
}
|
|
else
|
|
#endif /* UICC_SESSION_RESET */
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
}
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
#ifdef UICC_SESSION_RESET
|
|
case ADMIN_REL_SEQ:
|
|
{
|
|
if (TRUE == uicc_clear_pipes)
|
|
{
|
|
/* Admin Management UICC Release Sequence */
|
|
status = phHciNfc_Admin_Release( psHciContext,pHwRef, phHciNfc_UICCHostID );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
if (UICC_SWP_CFG == psHciContext->config_type)
|
|
{
|
|
(void)phHciNfc_SWP_Update_Sequence(psHciContext,
|
|
CONFIG_SEQ );
|
|
}
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif /* UICC_SESSION_RESET */
|
|
/* fall through */
|
|
case HCI_END_SEQ:
|
|
{
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
HCI_PRINT(" Emulation Configuration Completed. \n");
|
|
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_CONFIG_SUCCESS, &comp_info);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
NFC_CE_A_CFG;
|
|
NFC_CE_B_CFG; */
|
|
|
|
}/* End of the Emulation Config info Check */
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_SmartMx_Mode_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
|
|
psHciContext->p_config_params;
|
|
phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
|
|
if (NULL != p_poll_config)
|
|
{
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case READER_DISABLE_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Disable_Discovery(
|
|
psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = EMULATION_CONFIG_SEQ;
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case EMULATION_CONFIG_SEQ:
|
|
{
|
|
status = phHciNfc_WI_Configure_Mode(
|
|
psHciContext, pHwRef,psHciContext->smx_mode );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ;
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case PL_CONFIG_PHASE_SEQ:
|
|
{
|
|
/* Configure the Polling Loop Gate Parameters */
|
|
status = phHciNfc_PollLoop_Cfg( psHciContext, pHwRef,
|
|
(uint8_t)PL_RD_PHASES, NULL );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = READER_ENABLE_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case READER_ENABLE_SEQ:
|
|
{
|
|
status =
|
|
phHciNfc_ReaderMgmt_Enable_Discovery(
|
|
psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
/* psHciContext->hci_seq = PL_CONFIG_PHASE_SEQ; */
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
case HCI_END_SEQ:
|
|
{
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if (NFCSTATUS_PENDING != status)
|
|
{
|
|
/* status = phHciNfc_FSM_Complete ( psHciContext );*/
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
if( hciState_Disconnect == psHciContext->hci_state.cur_state)
|
|
{
|
|
psHciContext->host_rf_type = phHal_eUnknown_DevType;
|
|
psHciContext->p_target_info = NULL;
|
|
psHciContext->p_xchg_info = NULL;
|
|
}
|
|
/* Poll Configuration Notification to the Upper Layer */
|
|
if((~(PL_RD_PHASES_DISABLE) &
|
|
p_poll_config->PollDevInfo.PollEnabled)!= 0)
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_POLL_ENABLED, &comp_info);
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_POLL_DISABLED, &comp_info);
|
|
}
|
|
HCI_PRINT("HCI Discovery Configuration Completed \n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}/* End of the Poll Sequence Switch */
|
|
}/* End of the Poll Config info Check */
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Connect_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static phNfc_sCompletionInfo_t comp_info = {FALSE,0,NULL};
|
|
phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
|
|
|
|
if( NULL != psHciContext->p_target_info )
|
|
{
|
|
|
|
target_type = psHciContext->p_target_info->RemDevType;
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case READER_REACTIVATE_SEQ:
|
|
{
|
|
/* Complete the Reactivate Sequence and notify the HAL */
|
|
status = phHciNfc_FSM_Complete ( psHciContext );
|
|
/* Reactivate Complete Notification to the Upper Layer */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_TARGET_REACTIVATED , &comp_info);
|
|
HCI_PRINT(" HCI Remote Target Reactivated. \n");
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR , &comp_info);
|
|
HCI_PRINT("HCI FSM Invalid Selection State \n");
|
|
HCI_PRINT("HCI Remote Target Reactivation Failed \n");
|
|
}
|
|
break;
|
|
}
|
|
case READER_SELECT_SEQ:
|
|
{
|
|
/* If the Target is Mifare then it should fall through */
|
|
if(( phHal_eMifare_PICC != target_type )
|
|
&&(phHal_eISO14443_3A_PICC != target_type)
|
|
#ifdef TYPE_B
|
|
&& ( phHal_eISO14443_B_PICC != target_type )
|
|
&& ( phHal_eISO14443_4B_PICC != target_type )
|
|
#endif
|
|
#ifdef TYPE_FELICA
|
|
&& ( phHal_eFelica_PICC != target_type )
|
|
#endif
|
|
#ifdef TYPE_JEWEL
|
|
&& ( phHal_eJewel_PICC != target_type )
|
|
#endif /* #ifdef TYPE_JEWEL */
|
|
#ifdef TYPE_ISO15693
|
|
&& ( phHal_eISO15693_PICC != target_type )
|
|
#endif /* #ifdef TYPE_ISO15693 */
|
|
|
|
)
|
|
{
|
|
status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
status = NFCSTATUS_PENDING;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/* fall through */
|
|
case HCI_END_SEQ:
|
|
{
|
|
/* Complete the Connect Sequence and notify the HAL */
|
|
status = phHciNfc_FSM_Complete ( psHciContext );
|
|
/* Connection Complete Notification to the Upper Layer */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
/* Invalidate the previously polled RF Reader Type */
|
|
/* psHciContext->host_rf_type = phHal_eInvalidRFType;*/
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_TARGET_CONNECTED , &comp_info);
|
|
HCI_PRINT(" HCI Remote Target Selected for Transaction. \n");
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
/* phHciNfc_FSM_Rollback ( psHciContext ); */
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR , &comp_info);
|
|
HCI_PRINT("HCI FSM Invalid Selection State \n");
|
|
HCI_PRINT("HCI Remote Target Selection Failed \n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
HCI_PRINT("\t Invalid HCI Connect Sequence \n");
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}/* End of the Connect Sequence Switch */
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Disconnect_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static phNfc_sCompletionInfo_t comp_info = {FALSE, 0 , NULL};
|
|
phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
|
|
uint8_t re_poll = 0;
|
|
|
|
if( NULL != psHciContext->p_target_info )
|
|
{
|
|
|
|
target_type = psHciContext->p_target_info->RemDevType;
|
|
switch(psHciContext->hci_seq)
|
|
{
|
|
case READER_UICC_DISPATCH_SEQ:
|
|
{
|
|
status = phHciNfc_ReaderMgmt_UICC_Dispatch(
|
|
psHciContext, pHwRef, target_type );
|
|
psHciContext->hci_seq = READER_DESELECT_SEQ;
|
|
if(NFCSTATUS_PENDING == status)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
/* fall through */
|
|
case READER_DESELECT_SEQ:
|
|
{
|
|
re_poll = (uint8_t) ( NULL != psHciContext->p_config_params )?
|
|
*((uint8_t *)psHciContext->p_config_params):FALSE;
|
|
status = phHciNfc_ReaderMgmt_Deselect(
|
|
psHciContext, pHwRef, target_type, re_poll);
|
|
if(NFCSTATUS_PENDING == status)
|
|
{
|
|
psHciContext->hci_seq = HCI_END_SEQ;
|
|
psHciContext->p_config_params = NULL;
|
|
}
|
|
break;
|
|
}
|
|
case HCI_END_SEQ:
|
|
{
|
|
/* Complete the Disconnect Sequence and notify the HAL */
|
|
status = phHciNfc_FSM_Complete ( psHciContext );
|
|
/* Disconnect Notification to the Upper Layer */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
/* Invalidate the previously polled RF Reader Type */
|
|
psHciContext->host_rf_type = phHal_eUnknown_DevType;
|
|
psHciContext->p_target_info = NULL;
|
|
psHciContext->p_xchg_info = NULL;
|
|
comp_info.status = status;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_TARGET_DISCONNECTED , &comp_info);
|
|
HCI_PRINT(" HCI Remote Target De-Selected. \n");
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
/* phHciNfc_FSM_Rollback ( psHciContext ); */
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR , &comp_info);
|
|
HCI_PRINT("HCI FSM Invalid De-Selection State \n");
|
|
HCI_PRINT("HCI Remote Target De-Selection Failed \n");
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
HCI_PRINT("\t Invalid HCI Connect Sequence \n");
|
|
/* psHciContext->hci_seq = HCI_END_SEQ; */
|
|
break;
|
|
}
|
|
}/* End of the Connect Sequence Switch */
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Transact_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
static phNfc_sTransactionInfo_t transact_info = {FALSE,0,NULL,NULL,0};
|
|
|
|
pphNfcIF_Notification_CB_t p_upper_notify = psHciContext->p_upper_notify;
|
|
void *pcontext = psHciContext->p_upper_context;
|
|
uint8_t transact_result = NFC_NOTIFY_ERROR;
|
|
|
|
/* Roll Back to Connect State as Transceive is Complete */
|
|
phHciNfc_FSM_Rollback(psHciContext);
|
|
|
|
switch (psHciContext->host_rf_type)
|
|
{
|
|
case phHal_eISO14443_A_PCD:
|
|
#ifdef TYPE_B
|
|
case phHal_eISO14443_B_PCD:
|
|
#endif
|
|
case phHal_eISO14443_BPrime_PCD:
|
|
#ifdef TYPE_FELICA
|
|
case phHal_eFelica_PCD:
|
|
#endif
|
|
#ifdef TYPE_ISO15693
|
|
case phHal_eISO15693_PCD:
|
|
#endif
|
|
{
|
|
if(ZERO != psHciContext->rx_index)
|
|
{
|
|
transact_info.status = NFCSTATUS_SUCCESS;
|
|
transact_info.buffer =
|
|
&psHciContext->recv_buffer[psHciContext->rx_index];
|
|
transact_info.length =
|
|
psHciContext->rx_total - psHciContext->rx_index;
|
|
transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
|
|
}
|
|
else
|
|
{
|
|
transact_info.status = NFCSTATUS_FAILED;
|
|
transact_result = NFC_NOTIFY_TRANSCEIVE_ERROR;
|
|
}
|
|
HCI_PRINT(" HCI Transceive operation Completed. \n");
|
|
psHciContext->p_xchg_info = NULL ;
|
|
break;
|
|
}
|
|
#ifdef TYPE_JEWEL
|
|
/* fall through */
|
|
case phHal_eJewel_PCD:
|
|
#endif
|
|
{
|
|
transact_info.status = NFCSTATUS_SUCCESS;
|
|
transact_info.buffer =
|
|
&psHciContext->recv_buffer[psHciContext->rx_index];
|
|
transact_info.length =
|
|
psHciContext->rx_total - psHciContext->rx_index;
|
|
transact_result = NFC_NOTIFY_TRANSCEIVE_COMPLETED;
|
|
HCI_PRINT(" HCI Transceive operation Completed. \n");
|
|
psHciContext->p_xchg_info = NULL ;
|
|
break;
|
|
}
|
|
#if defined(ENABLE_P2P)
|
|
case phHal_eNfcIP1_Initiator:
|
|
case phHal_eNfcIP1_Target:
|
|
#endif
|
|
{
|
|
HCI_PRINT(" HCI Send operation Completed. \n");
|
|
transact_info.status = NFCSTATUS_SUCCESS;
|
|
transact_result = NFC_NOTIFY_SEND_COMPLETED;
|
|
break;
|
|
}
|
|
case phHal_eUnknown_DevType:
|
|
default:
|
|
{
|
|
transact_info.status =
|
|
PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
}
|
|
/* Notify the Transceive Completion to the Upper layer */
|
|
phHciNfc_Notify( p_upper_notify, pcontext , pHwRef,
|
|
transact_result, &transact_info);
|
|
|
|
return (NFCSTATUS)NFCSTATUS_SUCCESS;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Info_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
HCI_DEBUG(" HCI: Info Sequence Entry --> Reader Type : %02X \n",
|
|
psHciContext->host_rf_type);
|
|
switch (psHciContext->host_rf_type)
|
|
{
|
|
case phHal_eISO14443_A_PCD:
|
|
#ifdef TYPE_B
|
|
case phHal_eISO14443_B_PCD:
|
|
#endif
|
|
case phHal_eISO14443_BPrime_PCD:
|
|
#ifdef TYPE_FELICA
|
|
case phHal_eFelica_PCD:
|
|
#endif
|
|
#ifdef TYPE_JEWEL
|
|
case phHal_eJewel_PCD:
|
|
#endif
|
|
#ifdef TYPE_ISO15693
|
|
case phHal_eISO15693_PCD:
|
|
#endif
|
|
{
|
|
/* To update the select sequence to retrieve
|
|
* the target information using the reader type.
|
|
*/
|
|
status = phHciNfc_ReaderMgmt_Info_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
#if defined(ENABLE_P2P)
|
|
case phHal_eNfcIP1_Initiator:
|
|
case phHal_eNfcIP1_Target:
|
|
{
|
|
status = phHciNfc_NfcIP_Info_Sequence( psHciContext, pHwRef );
|
|
break;
|
|
}
|
|
#endif
|
|
case phHal_eUnknown_DevType:
|
|
default:
|
|
{
|
|
status =
|
|
PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_Test_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
NFCSTATUS test_status,
|
|
uint8_t *pdata,
|
|
uint8_t length
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static phNfc_sCompletionInfo_t comp_info = {0};
|
|
static phNfc_sData_t test_result= {NULL,0};
|
|
|
|
/* Complete the Test Sequence and notify the HAL */
|
|
status = phHciNfc_FSM_Complete ( psHciContext );
|
|
/* Test Results to the Upper Layer */
|
|
if(NFCSTATUS_SUCCESS == status)
|
|
{
|
|
comp_info.status = test_status;
|
|
if ( (NULL != pdata) && (length >= HCP_HEADER_LEN) )
|
|
{
|
|
test_result.buffer = ( pdata + HCP_HEADER_LEN);
|
|
test_result.length = length - HCP_HEADER_LEN;
|
|
}
|
|
else
|
|
{
|
|
status = phHciNfc_DevMgmt_Get_Test_Result(
|
|
psHciContext, &test_result );
|
|
}
|
|
comp_info.info = &test_result;
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_RESULT , &comp_info);
|
|
HCI_DEBUG(" HCI System Test Completed : Status = %u\n", test_status);
|
|
}
|
|
else
|
|
{
|
|
comp_info.status = status;
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_NOTIFY_ERROR , &comp_info);
|
|
HCI_PRINT("HCI FSM Invalid Test State \n");
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static
|
|
NFCSTATUS
|
|
phHciNfc_IO_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef,
|
|
NFCSTATUS io_status,
|
|
uint8_t *pdata,
|
|
uint8_t length
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
static phNfc_sCompletionInfo_t comp_info = {0};
|
|
|
|
/* To remove "warning (VS 4100) : unreferenced formal parameter" */
|
|
PHNFC_UNUSED_VARIABLE(pdata);
|
|
PHNFC_UNUSED_VARIABLE(length);
|
|
/* Complete the Test Sequence and notify the HAL */
|
|
phHciNfc_FSM_Rollback ( psHciContext );
|
|
/* Test Results to the Upper Layer */
|
|
comp_info.status = io_status;
|
|
status = phHciNfc_Pending_Sequence(psHciContext, pHwRef );
|
|
if(NFCSTATUS_SUCCESS == io_status)
|
|
{
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_IO_SUCCESS , &comp_info);
|
|
HCI_PRINT(" HCI System IO Successful. \n");
|
|
}
|
|
else
|
|
{
|
|
phHciNfc_Notify(psHciContext->p_upper_notify,
|
|
psHciContext->p_upper_context, pHwRef,
|
|
NFC_IO_ERROR , &comp_info);
|
|
HCI_PRINT("HCI IO Error \n");
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
#ifdef OTHER_TAGS
|
|
|
|
NFCSTATUS
|
|
phHciNfc_Activate_Sequence(
|
|
phHciNfc_sContext_t *psHciContext,
|
|
void *pHwRef
|
|
)
|
|
{
|
|
NFCSTATUS status = NFCSTATUS_SUCCESS;
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|