/*
* Copyright (C) 2012-2014 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.
*/
#include <phTmlNfc.h>
#include <phDnldNfc.h>
#include <phNxpNciHal_Dnld.h>
#include <phNxpNciHal_utils.h>
#include <phNxpLog.h>
#include <phNxpConfig.h>
/* Macro */
#define PHLIBNFC_IOCTL_DNLD_MAX_ATTEMPTS 3
#define PHLIBNFC_IOCTL_DNLD_GETVERLEN (0x0BU)
#define PHLIBNFC_IOCTL_DNLD_GETVERLEN_MRA2_1 (0x09U)
#define PHLIBNFC_DNLD_MEM_READ (0xECU)
#define PHLIBNFC_DNLD_MEM_WRITE (0xEDU)
#define PHLIBNFC_DNLD_READ_LOG (0xEEU)
#define NFC_MEM_READ (0xD0U)
#define NFC_MEM_WRITE (0xD1U)
#define NFC_FW_DOWNLOAD (0x09F7U)
/* External global variable to get FW version */
extern uint16_t wFwVer;
extern uint16_t wMwVer;
#if(NFC_NXP_CHIP_TYPE != PN547C2)
extern uint8_t gRecFWDwnld;
#endif
/* RF Configuration structure */
typedef struct phLibNfc_IoctlSetRfConfig
{
uint8_t bNumOfParams; /* Number of Rf configurable parameters to be set */
uint8_t *pInputBuffer; /* Buffer containing Rf configurable parameters */
uint8_t bSetSysPmuFlag; /* Flag to decide wether to set SystemPmu or no from the first byte */
}phLibNfc_IoctlSetRfConfig;
/* Structure to hold information from EEPROM */
typedef struct phLibNfc_EELogParams
{
uint16_t wCurrMwVer; /* Holds current MW version on the chip */
uint16_t wCurrFwVer; /* Holds current FW version on the chip */
uint16_t wNumDnldTrig; /* Total number of times dnld has been attempted */
uint16_t wNumDnldSuccess; /* Total number of times dnld has been successful */
uint16_t wNumDnldFail; /* Total number of times dnld has Failed */
uint16_t wDnldFailCnt; /* holds the number of times dnld has failed,will be reset on success */
bool_t bConfig; /* Flag to be set in dnld mode after successful dnld,to be reset in NCI Mode
after setting the NCI configuration */
} phLibNfc_EELogParams_t;
/* FW download module context structure */
typedef struct
{
bool_t bDnldEepromWrite; /* Flag to indicate eeprom write request*/
bool_t bSkipSeq; /* Flag to indicate FW download sequence to be skipped or not */
bool_t bSkipReset; /* Flag to indicate Reset cmd to be skipped or not in FW download sequence */
bool_t bSkipForce; /* Flag to indicate Force cmd to be skipped or not in FW recovery sequence */
bool_t bPrevSessnOpen; /* Flag to indicate previous download session is open or not */
bool_t bLibNfcCtxtMem; /* flag to indicate if mem was allocated for gpphLibNfc_Context */
bool_t bDnldInitiated; /* Flag to indicate if fw upgrade was initiated */
bool_t bSendNciCmd; /* Flag to indicate if NCI cmd to be sent or not,after PKU */
uint8_t bChipVer; /* holds the hw chip version */
bool_t bDnldRecovery; /* Flag to indicate if dnld recovery sequence needs to be triggered */
bool_t bForceDnld; /* Flag to indicate if forced download option is enabled */
bool_t bRetryDnld; /* Flag to indicate retry download after successful recovery complete */
uint8_t bDnldAttempts; /* Holds the count of no. of dnld attempts made.max 3 */
uint16_t IoctlCode; /* Ioctl code*/
bool_t bDnldAttemptFailed; /* Flag to indicate last download attempt failed */
NFCSTATUS bLastStatus; /* Holds the actual download write attempt status */
phLibNfc_EELogParams_t tLogParams; /* holds the params that could be logged to reserved EE address */
uint8_t bClkSrcVal; /* Holds the System clock source read from config file */
uint8_t bClkFreqVal; /* Holds the System clock frequency read from config file */
} phNxpNciHal_fw_Ioctl_Cntx_t;
/* Global variables used in this file only*/
static phNxpNciHal_fw_Ioctl_Cntx_t gphNxpNciHal_fw_IoctlCtx;
/* Local function prototype */
static NFCSTATUS
phNxpNciHal_fw_dnld_reset(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_reset_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_force(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_force_cb(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_normal_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_normal(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_get_version_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_get_version(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_get_sessn_state_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_get_sessn_state(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_log_read_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_log_read(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_write_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_write(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_chk_integrity_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_chk_integrity(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_log_cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_log(void* pContext, NFCSTATUS status, void* pInfo);
static void
phNxpNciHal_fw_dnld_send_ncicmd_Cb(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_send_ncicmd(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_recover(void* pContext, NFCSTATUS status, void* pInfo);
static NFCSTATUS
phNxpNciHal_fw_dnld_complete(void* pContext, NFCSTATUS status, void* pInfo);
/** Internal function to verify Crc Status byte received during CheckIntegrity */
static NFCSTATUS
phLibNfc_VerifyCrcStatus(uint8_t bCrcStatus);
static void phNxpNciHal_fw_dnld_recover_cb(void* pContext, NFCSTATUS status,
void* pInfo);
static NFCSTATUS phNxpNciHal_fw_seq_handler(NFCSTATUS (*seq_handler[])(void* pContext, NFCSTATUS status, void* pInfo));
/* Array of pointers to start fw download seq */
static NFCSTATUS (*phNxpNciHal_dwnld_seqhandler[])(
void* pContext, NFCSTATUS status, void* pInfo) = {
#if(NFC_NXP_CHIP_TYPE == PN547C2)
phNxpNciHal_fw_dnld_normal,
phNxpNciHal_fw_dnld_normal,
#endif
phNxpNciHal_fw_dnld_get_sessn_state,
phNxpNciHal_fw_dnld_get_version,
phNxpNciHal_fw_dnld_log_read,
phNxpNciHal_fw_dnld_write,
phNxpNciHal_fw_dnld_get_sessn_state,
phNxpNciHal_fw_dnld_get_version,
phNxpNciHal_fw_dnld_log,
phNxpNciHal_fw_dnld_chk_integrity,
NULL
};
#if(NFC_NXP_CHIP_TYPE != PN547C2)
/* Array of pointers to start dummy fw download seq */
static NFCSTATUS (*phNxpNciHal_dummy_rec_dwnld_seqhandler[])(
void* pContext, NFCSTATUS status, void* pInfo) = {
phNxpNciHal_fw_dnld_normal,
phNxpNciHal_fw_dnld_normal,
phNxpNciHal_fw_dnld_get_sessn_state,
phNxpNciHal_fw_dnld_get_version,
phNxpNciHal_fw_dnld_log_read,
phNxpNciHal_fw_dnld_write,
NULL
};
#endif
/* Download Recovery Sequence */
static NFCSTATUS (*phNxpNciHal_dwnld_rec_seqhandler[])(
void* pContext, NFCSTATUS status, void* pInfo) = {
phNxpNciHal_fw_dnld_reset,
phNxpNciHal_fw_dnld_force,
phNxpNciHal_fw_dnld_recover,
phNxpNciHal_fw_dnld_send_ncicmd,
NULL
};
/* Download Log Sequence */
static NFCSTATUS (*phNxpNciHal_dwnld_log_seqhandler[])(
void* pContext, NFCSTATUS status, void* pInfo) = {
phNxpNciHal_fw_dnld_log,
NULL
};
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_reset_cb
**
** Description Download Reset callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_reset_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
UNUSED(pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_reset_cb - Request Successful");
}
else
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset_cb - Request Failed!!");
}
p_cb_data->status = status;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_reset
**
** Description Download Reset
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_reset(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if((TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq)) || (TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipReset)))
{
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipReset))
{
(gphNxpNciHal_fw_IoctlCtx.bSkipReset) = FALSE;
}
return NFCSTATUS_SUCCESS;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset Create dnld_cb_data failed");
return NFCSTATUS_FAILED;
}
wStatus = phDnldNfc_Reset((pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_reset_cb, (void*) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phDnldNfc_Reset failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_normal_cb
**
** Description Download Normal callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_normal_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
UNUSED(pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_normal_cb - Request Successful");
}
else
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_normal_cb - Request Failed!!");
/* In this fail scenario trick the sequence handler to call next recover sequence */
status = NFCSTATUS_SUCCESS;
}
p_cb_data->status = status;
SEM_POST(p_cb_data);
usleep(1000 * 10);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_force_cb
**
** Description Download Force callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_force_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
UNUSED(pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D("phLibNfc_DnldForceCb - Request Successful");
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = TRUE;
(gphNxpNciHal_fw_IoctlCtx.bSkipReset) = TRUE;
}
else
{
/* In this fail scenario trick the sequence handler to call next recover sequence */
status = NFCSTATUS_SUCCESS;
NXPLOG_FWDNLD_E("phLibNfc_DnldForceCb - Request Failed!!");
}
p_cb_data->status = status;
SEM_POST(p_cb_data);
usleep(1000 * 10);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_normal
**
** Description Download Normal
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_normal(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t bClkVal[2];
phDnldNfc_Buff_t tData;
phNxpNciHal_Sem_t cb_data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipForce))
{
return NFCSTATUS_SUCCESS;
}
else
{
/*
bClkVal[0] = NXP_SYS_CLK_SRC_SEL;
bClkVal[1] = NXP_SYS_CLK_FREQ_SEL;
*/
bClkVal[0] = gphNxpNciHal_fw_IoctlCtx.bClkSrcVal;
bClkVal[1] = gphNxpNciHal_fw_IoctlCtx.bClkFreqVal;
(tData.pBuff) = bClkVal;
(tData.wLen) = sizeof(bClkVal);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldRecovery))
{
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts)++;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset Create dnld_cb_data failed");
return NFCSTATUS_FAILED;
}
wStatus = phDnldNfc_Force(&tData,(pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_normal_cb, (void*) &cb_data);
if(NFCSTATUS_PENDING != wStatus)
{
NXPLOG_FWDNLD_E("phDnldNfc_Normal failed");
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
goto clean_and_return;
}
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_normal semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_normal cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_force
**
** Description Download Force
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_force(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
uint8_t bClkVal[2];
phDnldNfc_Buff_t tData;
phNxpNciHal_Sem_t cb_data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipForce))
{
return NFCSTATUS_SUCCESS;
}
else
{
/*
bClkVal[0] = NXP_SYS_CLK_SRC_SEL;
bClkVal[1] = NXP_SYS_CLK_FREQ_SEL;
*/
bClkVal[0] = gphNxpNciHal_fw_IoctlCtx.bClkSrcVal;
bClkVal[1] = gphNxpNciHal_fw_IoctlCtx.bClkFreqVal;
(tData.pBuff) = bClkVal;
(tData.wLen) = sizeof(bClkVal);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldRecovery))
{
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts)++;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_reset Create dnld_cb_data failed");
return NFCSTATUS_FAILED;
}
wStatus = phDnldNfc_Force(&tData,(pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_force_cb, (void*) &cb_data);
if(NFCSTATUS_PENDING != wStatus)
{
NXPLOG_FWDNLD_E("phDnldNfc_Force failed");
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
goto clean_and_return;
}
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_force semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_force cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_get_version_cb
**
** Description Download Get version callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_get_version_cb(void* pContext,
NFCSTATUS status, void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
pphDnldNfc_Buff_t pRespBuff;
uint16_t wFwVern = 0;
uint16_t wMwVern = 0;
uint8_t bHwVer = 0;
uint8_t bExpectedLen = 0;
uint8_t bNewVer[2];
uint8_t bCurrVer[2];
if ((NFCSTATUS_SUCCESS == wStatus) && (NULL != pInfo))
{
NXPLOG_FWDNLD_D ("phNxpNciHal_fw_dnld_get_version_cb - Request Successful");
pRespBuff = (pphDnldNfc_Buff_t) pInfo;
if ((0 != pRespBuff->wLen) && (NULL != pRespBuff->pBuff))
{
bHwVer = (pRespBuff->pBuff[0]);
bHwVer &= 0x0F; /* 0x0F is the mask to extract chip version */
if ((PHDNLDNFC_HWVER_MRA2_1 == bHwVer) || (PHDNLDNFC_HWVER_MRA2_2 == bHwVer)
#if(NFC_NXP_CHIP_TYPE == PN551)
|| (PHDNLDNFC_HWVER_PN551_MRA1_0 == bHwVer)
#elif(NFC_NXP_CHIP_TYPE == PN548C2)
|| (PHDNLDNFC_HWVER_PN548AD_MRA1_0 == bHwVer)
#endif
)
{
bExpectedLen = PHLIBNFC_IOCTL_DNLD_GETVERLEN_MRA2_1;
(gphNxpNciHal_fw_IoctlCtx.bChipVer) = bHwVer;
}
else if ((bHwVer >= PHDNLDNFC_HWVER_MRA1_0) && (bHwVer
<= PHDNLDNFC_HWVER_MRA2_0))
{
bExpectedLen = PHLIBNFC_IOCTL_DNLD_GETVERLEN;
(gphNxpNciHal_fw_IoctlCtx.bChipVer) = bHwVer;
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version_cb - Invalid ChipVersion!!");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version_cb - Version Resp Buff Invalid...\n");
}
if ((NFCSTATUS_SUCCESS == wStatus) && (bExpectedLen == pRespBuff->wLen)
&& (NULL != pRespBuff->pBuff))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_get_version_cb - Valid Version Resp Buff!!...\n");
/* Validate version details to confirm if continue with the next sequence of Operations. */
memcpy(bCurrVer, &(pRespBuff->pBuff[bExpectedLen - 2]),
sizeof(bCurrVer));
wFwVern = wFwVer;
wMwVern = wMwVer;
memcpy(bNewVer,&wFwVern,sizeof(bNewVer));
/* check if the ROM code version and FW Major version is valid for the chip*/
/* ES2.2 Rom Version - 0x7 and Valid FW Major Version - 0x1 */
if ((pRespBuff->pBuff[1] == 0x07) &&(bNewVer[1] !=0x01))
{
NXPLOG_FWDNLD_E("C1 FW on C2 chip is not allowed - FW Major Version!= 1 on ES2.2");
wStatus = NFCSTATUS_NOT_ALLOWED;
}
/* Major Version number check */
else if((FALSE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated)) && (bNewVer[1] < bCurrVer[1]))
{
NXPLOG_FWDNLD_E("Version Check Failed - MajorVerNum Mismatch\n");
wStatus = NFCSTATUS_NOT_ALLOWED;
}
/* Minor Version number check - before download.*/
else if((FALSE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated)) && ((bNewVer[0] == bCurrVer[0]) &&
(bNewVer[1] == bCurrVer[1])))
{
wStatus = NFCSTATUS_SUCCESS;
#if (PH_LIBNFC_ENABLE_FORCE_DOWNLOAD == 0)
NXPLOG_FWDNLD_D("Version Already UpToDate!!\n");
(gphNxpNciHal_fw_IoctlCtx.bSkipSeq) = TRUE;
#else
(gphNxpNciHal_fw_IoctlCtx.bForceDnld) = TRUE;
#endif
}
/* Minor Version number check - after download
* after download, we should get the same version information.*/
else if ((TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated)) && ((bNewVer[0] != bCurrVer[0]) ||
(bNewVer[1] != bCurrVer[1])))
{
NXPLOG_FWDNLD_E("Version Not Updated After Download!!\n");
wStatus = NFCSTATUS_FAILED;
}
else
{
NXPLOG_FWDNLD_D("Version Check Successful\n");
/* Store the Mw & Fw Version for updating in EEPROM Log Area after successful download */
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated))
{
NXPLOG_FWDNLD_W("Updating Fw & Mw Versions..");
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wCurrMwVer) = wMwVern;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wCurrFwVer) = wFwVern;
}
}
}
else
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version_cb - Version Resp Buff Invalid...\n");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version_cb - Request Failed!!");
}
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_get_version
**
** Description Download Get version
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_get_version(void* pContext,
NFCSTATUS status, void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
static uint8_t bGetVerRes[11];
phDnldNfc_Buff_t tDnldBuff;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if((TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq)) ||
(TRUE == (gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen)))
{
return NFCSTATUS_SUCCESS;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version cb_data creation failed");
return NFCSTATUS_FAILED;
}
tDnldBuff.pBuff = bGetVerRes;
tDnldBuff.wLen = sizeof(bGetVerRes);
wStatus = phDnldNfc_GetVersion(&tDnldBuff,
(pphDnldNfc_RspCb_t) &phNxpNciHal_fw_dnld_get_version_cb,
(void*) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_get_sessn_state_cb
**
** Description Download Get session state callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_get_sessn_state_cb(void* pContext,
NFCSTATUS status, void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
pphDnldNfc_Buff_t pRespBuff;
if ((NFCSTATUS_SUCCESS == wStatus) && (NULL != pInfo))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_get_sessn_state_cb - Request Successful");
pRespBuff = (pphDnldNfc_Buff_t) pInfo;
if ((3 == (pRespBuff->wLen)) && (NULL != (pRespBuff->pBuff)))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_get_sessn_state_cb - Valid Session State Resp Buff!!...");
if (phDnldNfc_LCOper == pRespBuff->pBuff[2])
{
if (PHLIBNFC_FWDNLD_SESSNOPEN == pRespBuff->pBuff[0])
{
NXPLOG_FWDNLD_E("Prev Fw Upgrade Session still Open..");
(gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen) = TRUE;
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated))
{
NXPLOG_FWDNLD_D("Session still Open after Prev Fw Upgrade attempt!!");
if((gphNxpNciHal_fw_IoctlCtx.bDnldAttempts) < PHLIBNFC_IOCTL_DNLD_MAX_ATTEMPTS)
{
NXPLOG_FWDNLD_W("Setting Dnld Retry ..");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = TRUE;
}
else
{
NXPLOG_FWDNLD_E("Max Dnld Retry Counts Exceeded!!");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
}
wStatus = NFCSTATUS_FAILED;
}
}
else
{
gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen = FALSE;
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("NFCC not in Operational State..Fw Upgrade not allowed!!");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_sessn_state_cb - Session State Resp Buff Invalid...");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_sessn_state_cb - Request Failed!!");
}
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_get_sessn_state
**
** Description Download Get session state
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_get_sessn_state(void* pContext,
NFCSTATUS status, void* pInfo)
{
phDnldNfc_Buff_t tDnldBuff;
static uint8_t bGSnStateRes[3];
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if (TRUE == gphNxpNciHal_fw_IoctlCtx.bSkipSeq)
{
return NFCSTATUS_SUCCESS;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_get_version cb_data creation failed");
return NFCSTATUS_FAILED;
}
tDnldBuff.pBuff = bGSnStateRes;
tDnldBuff.wLen = sizeof(bGSnStateRes);
wStatus = phDnldNfc_GetSessionState(&tDnldBuff,
&phNxpNciHal_fw_dnld_get_sessn_state_cb, (void *) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phDnldNfc_GetSessionState failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phDnldNfc_GetSessionState semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phDnldNfc_GetSessionState cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_log_read_cb
**
** Description Download Logread callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_log_read_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
if((NFCSTATUS_SUCCESS == status) && (NULL != pInfo))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_log_read_cb - Request Successful");
}
else
{
status = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_read_cb - Request Failed!!");
}
p_cb_data->status = status;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_log_read
**
** Description Download Log Read
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_log_read(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
phDnldNfc_Buff_t Data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if((((TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq)) || (TRUE == (gphNxpNciHal_fw_IoctlCtx.bForceDnld))) &&
(FALSE == (gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen))) || (((TRUE == (gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen))) &&
(TRUE == (gphNxpNciHal_fw_IoctlCtx.bRetryDnld))))
{
return NFCSTATUS_SUCCESS;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_read cb_data creation failed");
return NFCSTATUS_FAILED;
}
(Data.pBuff) = (void *)&(gphNxpNciHal_fw_IoctlCtx.tLogParams);
(Data.wLen) = sizeof(phLibNfc_EELogParams_t);
wStatus = phDnldNfc_ReadLog(&Data,
(pphDnldNfc_RspCb_t) &phNxpNciHal_fw_dnld_log_read_cb,
(void *) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_read failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_read semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_read cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_write_cb
**
** Description Download Write callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_write_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
UNUSED(pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_write_cb - Request Successful");
(gphNxpNciHal_fw_IoctlCtx.bDnldEepromWrite) = FALSE;
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated))
{
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wNumDnldSuccess) += 1;
if((gphNxpNciHal_fw_IoctlCtx.tLogParams.wDnldFailCnt) > 0)
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_write_cb - Resetting DnldFailCnt");
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wDnldFailCnt) = 0;
}
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.tLogParams.bConfig))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_write_cb - Setting bConfig for use by NCI mode");
(gphNxpNciHal_fw_IoctlCtx.tLogParams.bConfig) = TRUE;
}
}
/* Reset the previously set DnldAttemptFailed flag */
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldAttemptFailed))
{
(gphNxpNciHal_fw_IoctlCtx.bDnldAttemptFailed) = FALSE;
}
}
else
{
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated))
{
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wNumDnldFail) += 1;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wDnldFailCnt) += 1;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.bConfig) = FALSE;
}
if(NFCSTATUS_WRITE_FAILED == status)
{
(gphNxpNciHal_fw_IoctlCtx.bSkipSeq) = TRUE;
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = TRUE;
}
//status = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_write_cb - Request Failed!!");
}
p_cb_data->status = status;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_write
**
** Description Download Write
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_write(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
UNUSED(pContext);
UNUSED(status);
UNUSED(pInfo);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bRetryDnld))
{
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
}
if((TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq))
&& (FALSE == (gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen)))
{
return NFCSTATUS_SUCCESS;
}
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_write cb_data creation failed");
return NFCSTATUS_FAILED;
}
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.bForceDnld))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_write - Incrementing NumDnldTrig..");
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = TRUE;
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts)++;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wNumDnldTrig) += 1;
}
wStatus = phDnldNfc_Write(FALSE, NULL,
(pphDnldNfc_RspCb_t) &phNxpNciHal_fw_dnld_write_cb,
(void *) &cb_data);
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.bForceDnld))
{
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_write failed");
wStatus = NFCSTATUS_FAILED;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wNumDnldFail) += 1;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.wDnldFailCnt) += 1;
(gphNxpNciHal_fw_IoctlCtx.tLogParams.bConfig) = FALSE;
goto clean_and_return;
}
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_write semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_write cb failed");
wStatus = cb_data.status;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_chk_integrity_cb
**
** Description Download Check Integrity callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_chk_integrity_cb(void* pContext,
NFCSTATUS status, void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
pphDnldNfc_Buff_t pRespBuff;
//uint8_t bUserDataCrc[4];
if ((NFCSTATUS_SUCCESS == wStatus) && (NULL != pInfo))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_chk_integrity_cb - Request Successful");
pRespBuff = (pphDnldNfc_Buff_t) pInfo;
if ((31 == (pRespBuff->wLen)) && (NULL != (pRespBuff->pBuff)))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_chk_integrity_cb - Valid Resp Buff!!...\n");
wStatus = phLibNfc_VerifyCrcStatus(pRespBuff->pBuff[0]);
/*
memcpy(bUserDataCrc, &(pRespBuff->pBuff[27]),
sizeof(bUserDataCrc));*/
}
else
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity_cb - Resp Buff Invalid...\n");
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity_cb - Request Failed!!");
}
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_chk_integrity
**
** Description Download Check Integrity
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_chk_integrity(void* pContext,
NFCSTATUS status, void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
phDnldNfc_Buff_t tDnldBuff;
static uint8_t bChkIntgRes[31];
UNUSED(pInfo);
UNUSED(pContext);
UNUSED(status);
if(TRUE == gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen)
{
NXPLOG_FWDNLD_D("Previous Upload session is open..Cannot issue ChkIntegrity Cmd!!");
return NFCSTATUS_SUCCESS;
}
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq))
{
return NFCSTATUS_SUCCESS;
}
else if(TRUE == gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen)
{
NXPLOG_FWDNLD_E("Previous Upload session is open..Cannot issue ChkIntegrity Cmd!!");
return NFCSTATUS_SUCCESS;
}
tDnldBuff.pBuff = bChkIntgRes;
tDnldBuff.wLen = sizeof(bChkIntgRes);
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity cb_data creation failed");
return NFCSTATUS_FAILED;
}
wStatus = phDnldNfc_CheckIntegrity((gphNxpNciHal_fw_IoctlCtx.bChipVer),
&tDnldBuff, &phNxpNciHal_fw_dnld_chk_integrity_cb,
(void *) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_chk_integrity cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_recover
**
** Description Download Recover
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_recover(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
UNUSED(pInfo);
UNUSED(status);
UNUSED(pContext);
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldRecovery))
{
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_recover cb_data creation failed");
return NFCSTATUS_FAILED;
}
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts)++;
/* resetting this flag to avoid cyclic issuance of recovery sequence in case of failure */
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
wStatus = phDnldNfc_Write(TRUE,NULL,(pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_recover_cb, (void*) &cb_data);
if(NFCSTATUS_PENDING != wStatus)
{
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_recover semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_recover cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
}
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_recover_cb
**
** Description Download Recover callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_recover_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
UNUSED(pContext);
UNUSED(pInfo);
if(NFCSTATUS_SUCCESS == wStatus)
{
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.bSkipForce))
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_recoverCb - Request Successful");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = TRUE;
}
else
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_recoverCb - Production key update Request Successful");
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = TRUE;
}
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_recoverCb - Request Failed!!");
}
/* resetting this flag to avoid cyclic issuance of recovery sequence in case of failure */
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
/* reset previously set SkipForce */
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_send_ncicmd_cb
**
** Description Download Send NCI Command callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_send_ncicmd_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
pphDnldNfc_Buff_t pRespBuff;
UNUSED(pContext);
if(NFCSTATUS_SUCCESS == wStatus)
{
NXPLOG_FWDNLD_D("phNxpNciHal_fw_dnld_send_ncicmdCb - Request Successful");
pRespBuff = (pphDnldNfc_Buff_t)pInfo;
if((0 != (pRespBuff->wLen)) && (NULL != (pRespBuff->pBuff)))
{
if(0 == (pRespBuff->pBuff[3]))
{
NXPLOG_FWDNLD_D("Successful Response received for Nci Reset Cmd");
}
else
{
NXPLOG_FWDNLD_E("Nci Reset Request Failed!!");
}
}
else
{
NXPLOG_FWDNLD_E("Invalid Response received for Nci Reset Request!!");
}
/* Call Tml Ioctl to enable download mode */
wStatus = phTmlNfc_IoCtl(phTmlNfc_e_EnableDownloadMode);
if(NFCSTATUS_SUCCESS == wStatus)
{
NXPLOG_FWDNLD_D("Switched Successfully to dnld mode..");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = TRUE;
}
else
{
NXPLOG_FWDNLD_E("Switching back to dnld mode Failed!!");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
wStatus = NFCSTATUS_FAILED;
}
}
else
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_send_ncicmdCb - Request Failed!!");
}
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = FALSE;
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_send_ncicmd
**
** Description Download Send NCI Command
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_send_ncicmd(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
static uint8_t bNciCmd[4] = {0x20,0x00,0x01,0x00}; /* Nci Reset Cmd with KeepConfig option */
static uint8_t bNciResp[6];
phDnldNfc_Buff_t tsData;
phDnldNfc_Buff_t trData;
phNxpNciHal_Sem_t cb_data;
UNUSED(pInfo);
UNUSED(status);
UNUSED(pContext);
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.bSendNciCmd))
{
return NFCSTATUS_SUCCESS;
}
else
{
/* Call Tml Ioctl to enable/restore normal mode */
wStatus = phTmlNfc_IoCtl(phTmlNfc_e_EnableNormalMode);
if(NFCSTATUS_SUCCESS != wStatus)
{
NXPLOG_FWDNLD_E("Switching to NormalMode Failed!!");
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = FALSE;
}
else
{
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_send_ncicmd cb_data creation failed");
return NFCSTATUS_FAILED;
}
(tsData.pBuff) = bNciCmd;
(tsData.wLen) = sizeof(bNciCmd);
(trData.pBuff) = bNciResp;
(trData.wLen) = sizeof(bNciResp);
wStatus = phDnldNfc_RawReq(&tsData,&trData,
(pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_send_ncicmd_cb, (void*) &cb_data);
if(NFCSTATUS_PENDING != wStatus)
{
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_send_ncicmd semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_send_ncicmd cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
}
}
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_log_cb
**
** Description Download Log callback
**
** Returns None
**
*******************************************************************************/
static void phNxpNciHal_fw_dnld_log_cb(void* pContext, NFCSTATUS status,
void* pInfo)
{
phNxpNciHal_Sem_t *p_cb_data = (phNxpNciHal_Sem_t*) pContext;
NFCSTATUS wStatus = status;
UNUSED(pContext);
UNUSED(pInfo);
if(NFCSTATUS_SUCCESS == wStatus)
{
NXPLOG_FWDNLD_D("phLibNfc_DnldLogCb - Request Successful");
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
}
else
{
wStatus = NFCSTATUS_FAILED;
NXPLOG_FWDNLD_E("phLibNfc_DnldLogCb - Request Failed!!");
}
p_cb_data->status = wStatus;
SEM_POST(p_cb_data);
return;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_log
**
** Description Download Log
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_log(void* pContext, NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
phNxpNciHal_Sem_t cb_data;
phDnldNfc_Buff_t tData;
UNUSED(pInfo);
UNUSED(status);
UNUSED(pContext);
if(((TRUE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq)) ||
(TRUE == (gphNxpNciHal_fw_IoctlCtx.bForceDnld))) &&
(FALSE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated)))
{
return NFCSTATUS_SUCCESS;
}
else
{
if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log cb_data creation failed");
return NFCSTATUS_FAILED;
}
(tData.pBuff) = (void *)&(gphNxpNciHal_fw_IoctlCtx.tLogParams);
(tData.wLen) = sizeof(gphNxpNciHal_fw_IoctlCtx.tLogParams);
wStatus = phDnldNfc_Log(&tData,(pphDnldNfc_RspCb_t)&phNxpNciHal_fw_dnld_log_cb, (void*) &cb_data);
if (wStatus != NFCSTATUS_PENDING)
{
NXPLOG_FWDNLD_E("phDnldNfc_Log failed");
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
/* Wait for callback response */
if (SEM_WAIT(cb_data))
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log semaphore error");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
if (cb_data.status != NFCSTATUS_SUCCESS)
{
NXPLOG_FWDNLD_E("phNxpNciHal_fw_dnld_log_cb failed");
wStatus = NFCSTATUS_FAILED;
goto clean_and_return;
}
wStatus = NFCSTATUS_SUCCESS;
clean_and_return:
phNxpNciHal_cleanup_cb_data(&cb_data);
return wStatus;
}
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_seq_handler
**
** Description Sequence Handler
**
** Returns NFCSTATUS_SUCCESS if sequence completed uninterrupted
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_seq_handler(NFCSTATUS (*seq_handler[])(void* pContext, NFCSTATUS status, void* pInfo))
{
char *pContext = "FW-Download";
int16_t seq_counter = 0;
phDnldNfc_Buff_t pInfo;
NFCSTATUS status = NFCSTATUS_FAILED;
status = phTmlNfc_ReadAbort();
if(NFCSTATUS_SUCCESS != status)
{
NXPLOG_FWDNLD_E("Tml Read Abort failed!!");
return status;
}
while(seq_handler[seq_counter] != NULL )
{
status = NFCSTATUS_FAILED;
status = (seq_handler[seq_counter])(pContext, status, &pInfo );
if(NFCSTATUS_SUCCESS != status)
{
NXPLOG_FWDNLD_E(" phNxpNciHal_fw_seq_handler : FAILED");
break;
}
seq_counter++;
}
return status;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_dnld_complete
**
** Description Download Sequence Complete
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
static NFCSTATUS phNxpNciHal_fw_dnld_complete(void* pContext,NFCSTATUS status,
void* pInfo)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
NFCSTATUS fStatus = status;
UNUSED(pInfo);
UNUSED(pContext);
if(NFCSTATUS_WRITE_FAILED == status)
{
if((gphNxpNciHal_fw_IoctlCtx.bDnldAttempts) < PHLIBNFC_IOCTL_DNLD_MAX_ATTEMPTS)
{
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = TRUE;
}
else
{
NXPLOG_FWDNLD_E("Max Dnld Retry Counts Exceeded!!");
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
}
}
else if(NFCSTATUS_REJECTED == status)
{
if((gphNxpNciHal_fw_IoctlCtx.bDnldAttempts) < PHLIBNFC_IOCTL_DNLD_MAX_ATTEMPTS)
{
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = TRUE;
/* in case of signature error we need to try recover sequence directly bypassing the force cmd */
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = TRUE;
}
else
{
NXPLOG_FWDNLD_E("Max Dnld Retry Counts Exceeded!!");
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
}
}
if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldInitiated))
{
(gphNxpNciHal_fw_IoctlCtx.bLastStatus) = status;
(gphNxpNciHal_fw_IoctlCtx.bDnldAttemptFailed) = TRUE;
NXPLOG_FWDNLD_E("Invoking Pending Download Log Sequence..");
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
/* Perform the Logging sequence */
wStatus = phNxpNciHal_fw_seq_handler(phNxpNciHal_dwnld_log_seqhandler);
if (NFCSTATUS_SUCCESS != gphNxpNciHal_fw_IoctlCtx.bLastStatus)
{
/* update the previous Download Write status to upper layer and not the status of Log command */
wStatus = gphNxpNciHal_fw_IoctlCtx.bLastStatus;
NXPLOG_FWDNLD_E ("phNxpNciHal_fw_dnld_complete: Last Download Write Status before Log command bLastStatus = 0x%x", gphNxpNciHal_fw_IoctlCtx.bLastStatus);
}
status = phNxpNciHal_fw_dnld_complete(pContext, wStatus, &pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D(" phNxpNciHal_fw_dnld_complete : SUCCESS");
}
else
{
NXPLOG_FWDNLD_E(" phNxpNciHal_fw_dnld_complete : FAILED");
}
}
else if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bDnldRecovery))
{
NXPLOG_FWDNLD_E("Invoking Download Recovery Sequence..");
if(NFCSTATUS_SUCCESS == wStatus)
{
/* Perform the download Recovery sequence */
wStatus = phNxpNciHal_fw_seq_handler(phNxpNciHal_dwnld_rec_seqhandler);
status = phNxpNciHal_fw_dnld_complete(pContext, wStatus, &pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D(" phNxpNciHal_fw_dnld_complete : SUCCESS");
}
else
{
NXPLOG_FWDNLD_E(" phNxpNciHal_fw_dnld_complete : FAILED");
}
}
}
else if(TRUE == (gphNxpNciHal_fw_IoctlCtx.bRetryDnld))
{
(gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bForceDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipSeq) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = FALSE;
/* Perform the download sequence ... after successful recover attempt */
wStatus = phNxpNciHal_fw_seq_handler(phNxpNciHal_dwnld_seqhandler);
status = phNxpNciHal_fw_dnld_complete(pContext, wStatus, &pInfo);
if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D(" phNxpNciHal_fw_dnld_complete : SUCCESS");
}
else
{
NXPLOG_FWDNLD_E(" phNxpNciHal_fw_dnld_complete : FAILED");
}
}
else
{
NXPLOG_FWDNLD_D ("phNxpNciHal_fw_dnld_complete: Download Status = 0x%x", status);
if(FALSE == (gphNxpNciHal_fw_IoctlCtx.bSkipSeq))
{
if(NFCSTATUS_SUCCESS == status)
{
if(NFC_FW_DOWNLOAD == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Fw Download success.. ");
}
else if(PHLIBNFC_DNLD_MEM_READ == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Read Request success.. ");
}
else if(PHLIBNFC_DNLD_MEM_WRITE == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Write Request success.. ");
}
else if(PHLIBNFC_DNLD_READ_LOG == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("ReadLog Request success.. ");
}
else
{
NXPLOG_FWDNLD_E("Invalid Request!!");
}
}
else
{
if(NFC_FW_DOWNLOAD == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Fw Download Failed!!");
}
else if(NFC_MEM_READ == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Read Request Failed!!");
}
else if(NFC_MEM_WRITE == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("Write Request Failed!!");
}
else if(PHLIBNFC_DNLD_READ_LOG == gphNxpNciHal_fw_IoctlCtx.IoctlCode)
{
NXPLOG_FWDNLD_E("ReadLog Request Failed!!");
}
else
{
NXPLOG_FWDNLD_E("Invalid Request!!");
}
}
}
if(FALSE == gphNxpNciHal_fw_IoctlCtx.bSendNciCmd)
{
/* Call Tml Ioctl to enable/restore normal mode */
wStatus = phTmlNfc_IoCtl(phTmlNfc_e_EnableNormalMode);
if(NFCSTATUS_SUCCESS != wStatus)
{
NXPLOG_FWDNLD_E("Switching to NormalMode Failed!!");
}
else
{
wStatus = fStatus;
}
}
(gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bChipVer) = 0;
(gphNxpNciHal_fw_IoctlCtx.bSkipSeq) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bForceDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipReset) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts) = 0;
if(FALSE == gphNxpNciHal_fw_IoctlCtx.bDnldAttemptFailed)
{
}
else
{
NXPLOG_FWDNLD_E("Returning Download Failed Status to Caller!!");
(gphNxpNciHal_fw_IoctlCtx.bLastStatus) = NFCSTATUS_SUCCESS;
(gphNxpNciHal_fw_IoctlCtx.bDnldAttemptFailed) = FALSE;
}
phDnldNfc_CloseFwLibHandle();
}
return wStatus;
}
/*******************************************************************************
**
** Function phNxpNciHal_fw_download_seq
**
** Description Download Sequence
**
** Returns NFCSTATUS_SUCCESS if success
**
*******************************************************************************/
NFCSTATUS phNxpNciHal_fw_download_seq(uint8_t bClkSrcVal, uint8_t bClkFreqVal)
{
NFCSTATUS status = NFCSTATUS_FAILED;
phDnldNfc_Buff_t pInfo;
char *pContext = "FW-Download";
/* reset the global flags */
gphNxpNciHal_fw_IoctlCtx.IoctlCode = NFC_FW_DOWNLOAD;
(gphNxpNciHal_fw_IoctlCtx.bPrevSessnOpen) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldInitiated) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bChipVer) = 0;
(gphNxpNciHal_fw_IoctlCtx.bSkipSeq) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bForceDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldRecovery) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bRetryDnld) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipReset) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSkipForce) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bSendNciCmd) = FALSE;
(gphNxpNciHal_fw_IoctlCtx.bDnldAttempts) = 0;
(gphNxpNciHal_fw_IoctlCtx.bClkSrcVal) = bClkSrcVal;
(gphNxpNciHal_fw_IoctlCtx.bClkFreqVal) = bClkFreqVal;
/* Get firmware version */
if (NFCSTATUS_SUCCESS == phDnldNfc_InitImgInfo())
{
NXPLOG_FWDNLD_D("phDnldNfc_InitImgInfo:SUCCESS");
#if(NFC_NXP_CHIP_TYPE != PN547C2)
if (gRecFWDwnld == TRUE)
{
status = phNxpNciHal_fw_seq_handler (phNxpNciHal_dummy_rec_dwnld_seqhandler);
}
else
#endif
{
status = phNxpNciHal_fw_seq_handler (phNxpNciHal_dwnld_seqhandler);
}
}
else
{
NXPLOG_FWDNLD_E("phDnldNfc_InitImgInfo: FAILED");
}
/* Chage to normal mode */
status = phNxpNciHal_fw_dnld_complete(pContext, status, &pInfo);
/*if (NFCSTATUS_SUCCESS == status)
{
NXPLOG_FWDNLD_D(" phNxpNciHal_fw_dnld_complete : SUCCESS");
}
else
{
NXPLOG_FWDNLD_E(" phNxpNciHal_fw_dnld_complete : FAILED");
}*/
return status;
}
static
NFCSTATUS
phLibNfc_VerifyCrcStatus(uint8_t bCrcStatus)
{
#if(NFC_NXP_CHIP_TYPE == PN551)
uint8_t bBitPos = 1;
uint8_t bShiftVal = 2;
#else
uint8_t bBitPos = 0;
uint8_t bShiftVal = 1;
#endif
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
while(bBitPos < 7)
{
if(!(bCrcStatus & bShiftVal))
{
switch(bBitPos)
{
case 0:
{
NXPLOG_FWDNLD_E("User Data Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 1:
{
NXPLOG_FWDNLD_E("Trim Data Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 2:
{
NXPLOG_FWDNLD_E("Protected Data Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 3:
{
NXPLOG_FWDNLD_E("Patch Code Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 4:
{
NXPLOG_FWDNLD_E("Function Code Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 5:
{
NXPLOG_FWDNLD_E("Patch Table Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
case 6:
{
NXPLOG_FWDNLD_E("Function Table Crc is NOT OK!!");
wStatus = NFCSTATUS_FAILED;
break;
}
default:
{
break;
}
}
}
bShiftVal <<= 1;
++bBitPos;
}
return wStatus;
}