/*
* 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 phDnldNfc.c *
* \brief Download Mgmt Interface Source for the Firmware Download. *
* *
* *
* Project: NFC-FRI-1.1 *
* *
* $Date: Thu Sep 9 14:58:05 2010 $ *
* $Author: ing04880 $ *
* $Revision: 1.32 $ *
* $Aliases: $
* *
* =========================================================================== *
*/
/*
################################################################################
***************************** Header File Inclusion ****************************
################################################################################
*/
#include <stdlib.h>
#include <phNfcConfig.h>
#include <phNfcCompId.h>
#include <phNfcIoctlCode.h>
#include <phDnldNfc.h>
#include <phOsalNfc.h>
#include <phOsalNfc_Timer.h>
#include <phDal4Nfc.h>
/*
################################################################################
****************************** Macro Definitions *******************************
################################################################################
*/
#ifndef STATIC
#define STATIC static
#endif
#if defined (DNLD_SUMMARY) && !defined (DNLD_TRACE)
#define DNLD_TRACE
#endif
/* #if defined(PHDBG_INFO) && defined (PHDBG_CRITICAL_ERROR) */
#if defined(DNLD_TRACE)
extern char phOsalNfc_DbgTraceBuffer[];
#define MAX_TRACE_BUFFER 0x0410
#define Trace_buffer phOsalNfc_DbgTraceBuffer
/* #define DNLD_PRINT( str ) phOsalNfc_DbgTrace(str) */
#define DNLD_PRINT( str ) phOsalNfc_DbgString(str)
#define DNLD_DEBUG(str, arg) \
{ \
snprintf(Trace_buffer,MAX_TRACE_BUFFER,str,arg); \
phOsalNfc_DbgString(Trace_buffer); \
}
#define DNLD_PRINT_BUFFER(msg,buf,len) \
{ \
snprintf(Trace_buffer,MAX_TRACE_BUFFER,"\n\t %s:",msg); \
phOsalNfc_DbgString(Trace_buffer); \
phOsalNfc_DbgTrace(buf,len); \
phOsalNfc_DbgString("\r"); \
}
#else
#define DNLD_PRINT( str )
#define DNLD_DEBUG(str, arg)
#define DNLD_PRINT_BUFFER(msg,buf,len)
#endif
#define DO_DELAY(period) { unsigned i=0; for(;i<period;i++); }
#define PHDNLD_DNLD_DELAY 0x1000U
#define PHDNLD_MAX_PACKET 0x0200U /* Max Total Packet Size is 512 */
#define PHDNLD_DATA_SIZE ((PHDNLD_MAX_PACKET)- 8U) /* 0x01F8U */
/* Max Data Size is 504 */
#define PHDNLD_MIN_PACKET 0x03U /* Minimum Packet Size is 3*/
#define DNLD_DEFAULT_RESPONSE_TIMEOUT 0x4000U
#define NXP_FW_MIN_TX_RX_LEN 0x0AU
#if defined( NXP_FW_MAX_TX_RX_LEN ) && \
( NXP_FW_MAX_TX_RX_LEN > NXP_FW_MIN_TX_RX_LEN )
#define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN
#elif !defined( NXP_FW_MAX_TX_RX_LEN )
/* To specify the Maximum TX/RX Len */
#define NXP_FW_MAX_TX_RX_LEN 0x200
#define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN
#else
#define PHDNLD_FW_TX_RX_LEN NXP_FW_MIN_TX_RX_LEN
#endif
#define PHDNLD_FRAME_LEN_SIZE 0x02U
#define PHDNLD_ADDR_SIZE 0x03U
#define PHDNLD_DATA_LEN_SIZE 0x02U
#define PHDNLD_FRAME_DATA_OFFSET 0x03U
#define DNLD_SM_UNLOCK_MASK 0x01U
#define DNLD_TRIM_MASK 0x02U
#define DNLD_RESET_MASK 0x04U
#define DNLD_VERIFY_MASK 0x08U
#define DNLD_CRITICAL_MASK 0x10U
#define NXP_NFC_IMAG_FW_MAX 0x05U
#define PHDNLD_FW_PATCH_SEC 0x5FU
#define PHDNLD_PAGE_SIZE 0x80U /* Page Size Configured for 64 Bytes */
#define FW_MAX_SECTION 0x15U /* Max Number of Sections */
#define DNLD_CRC16_SIZE 0x02U
#define DNLD_CRC32_SIZE 0x04U
#define DNLD_CFG_PG_ADDR 0x00008000U
#define DNLD_FW_CODE_ADDR 0x00800000U
#define DNLD_PATCH_CODE_ADDR 0x00018800U
#define DNLD_PATCH_TABLE_ADDR 0x00008200U
/* Raw Command to pass the Data in Download Mode */
#define PHDNLD_CMD_RAW 0x00U
/* Command to Reset the Device in Download Mode */
#define PHDNLD_CMD_RESET 0x01U
/* Command to Read from the Address specified in Download Mode */
#define PHDNLD_CMD_READ 0x07U
#define PHDNLD_CMD_READ_LEN 0x0005U
/* Command to write to the Address specified in Download Mode */
#define PHDNLD_CMD_WRITE 0x08U
#define PHDNLD_CMD_SEC_WRITE 0x0CU
#define PHDNLD_CMD_WRITE_MIN_LEN 0x0005U
#define PHDNLD_CMD_WRITE_MAX_LEN PHDNLD_DATA_SIZE
/* Command to verify the data written */
#define PHDNLD_CMD_CHECK 0x06U
#define PHDNLD_CMD_CHECK_LEN 0x0007U
/* Command to Lock the */
#define PHDNLD_CMD_LOCK 0x40U
#define PHDNLD_CMD_LOCK_LEN 0x0002U
/* Command to set the Host Interface properties */
#define PHDNLD_CMD_SET_HIF 0x09U
/* Command to Activate the Patches Updated */
#define PHDNLD_CMD_ACTIVATE_PATCH 0x0AU
/* Command to verify the Integrity of the data written */
#define PHDNLD_CMD_CHECK_INTEGRITY 0x0BU
/* Command to verify the Integrity of the data written */
#define PHDNLD_CMD_ENCAPSULATE 0x0DU
#define CHECK_INTEGRITY_RESP_CRC16_LEN 0x03U
#define CHECK_INTEGRITY_RESP_CRC32_LEN 0x05U
#define CHECK_INTEGRITY_RESP_COMP_LEN 0x10U
/* Success Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_SUCCESS 0x00U
/* Timeout Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_TIMEOUT 0x01U
/* CRC Error Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_CRC_ERROR 0x02U
/* Access Denied Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_ACCESS_DENIED 0x08U
/* PROTOCOL Error Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_PROTOCOL_ERROR 0x0BU
/* Invalid parameter Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_INVALID_PARAMETER 0x11U
/* Command Not Supported Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_CMD_NOT_SUPPORTED 0x13U
/* Length parameter error Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_INVALID_LENGTH 0x18U
/* Checksum Error Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_CHKSUM_ERROR 0x19U
/* Version already uptodate Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_VERSION_UPTODATE 0x1DU
/* Memory operation error during the processing of
the Command Frame in the Download Mode */
#define PHDNLD_RESP_MEMORY_UPDATE_ERROR 0x20U
/* The Chaining of the Command Frame was Successful in the Download Mode */
#define PHDNLD_RESP_CHAINING_SUCCESS 0x21U
/* The Command is not allowed anymore in the Download Mode */
#define PHDNLD_RESP_CMD_NOT_ALLOWED 0xE0U
/* The Error during the Chaining the Command Frame in the Download Mode */
#define PHDNLD_RESP_CHAINING_ERROR 0xE6U
/* Write Error Response to a Command Sent in the Download Mode */
#define PHDNLD_RESP_WRITE_ERROR 0x74U
#define PNDNLD_WORD_LEN 0x04U
#define NXP_MAX_DNLD_RETRY 0x02U
#define NXP_MAX_SECTION_WRITE 0x05U
#define NXP_PATCH_VER_INDEX 0x05U
/*
################################################################################
******************** Enumeration and Structure Definition **********************
################################################################################
*/
typedef enum phDnldNfc_eSeqType{
DNLD_SEQ_RESET = 0x00U,
DNLD_SEQ_INIT,
DNLD_SEQ_RAW,
DNLD_SEQ_LOCK,
DNLD_SEQ_UNLOCK,
DNLD_SEQ_UPDATE,
DNLD_SEQ_ROLLBACK,
DNLD_SEQ_COMPLETE
} phDnldNfc_eSeqType_t;
typedef enum phDnldNfc_eState
{
phDnld_Reset_State = 0x00,
phDnld_Unlock_State,
phDnld_Upgrade_State,
phDnld_Verify_State,
phDnld_Complete_State,
phDnld_Invalid_State
}phDnldNfc_eState_t;
typedef enum phDnldNfc_eSeq
{
phDnld_Reset_Seq = 0x00,
phDnld_Activate_Patch,
phDnld_Deactivate_Patch,
phDnld_Update_Patch,
phDnld_Update_Patchtable,
phDnld_Lock_System,
phDnld_Unlock_System,
phDnld_Upgrade_Section,
phDnld_Verify_Integrity,
phDnld_Verify_Section,
phDnld_Complete_Seq,
phDnld_Raw_Upgrade,
phDnld_Invalid_Seq
}phDnldNfc_eSeq_t;
typedef enum phDnldNfc_eChkCrc{
CHK_INTEGRITY_CONFIG_PAGE_CRC = 0x00U,
CHK_INTEGRITY_PATCH_TABLE_CRC = 0x01U,
CHK_INTEGRITY_FLASH_CODE_CRC = 0x02U,
CHK_INTEGRITY_PATCH_CODE_CRC = 0x03U,
CHK_INTEGRITY_COMPLETE_CRC = 0xFFU
} phDnldNfc_eChkCrc_t;
typedef struct hw_comp_tbl
{
uint8_t hw_version[3];
uint8_t compatibility;
}hw_comp_tbl_t;
typedef struct img_data_hdr
{
/* Image Identification */
uint32_t img_id;
/* Offset of the Data from the header */
uint8_t img_data_offset;
/* Number of fimware images available in the img_data */
uint8_t no_of_fw_img;
/* Fimware image Padding in the img_data */
uint8_t fw_img_pad[2];
/* HW Compatiblity table for the set of the Hardwares */
hw_comp_tbl_t comp_tbl;
/* This data consists of the firmware images required to download */
}img_data_hdr_t;
typedef struct fw_data_hdr
{
/* The data offset from the firmware header.
* Just in case if in future we require to
* add some more information.
*/
uint8_t fw_hdr_len;
/* Total size of all the sections which needs to be updated */
uint8_t no_of_sections;
uint8_t hw_comp_no;
uint8_t fw_patch;
uint32_t fw_version;
}fw_data_hdr_t;
/* This data consists all the sections that needs to be downloaded */
typedef struct section_hdr
{
uint8_t section_hdr_len;
uint8_t section_mem_type;
uint8_t section_checksum;
uint8_t section_conf;
uint32_t section_address;
uint32_t section_length;
}section_hdr_t;
typedef struct section_info
{
section_hdr_t *p_sec_hdr;
uint8_t *p_trim_data;
/* The section data consist of the Firmware binary required
* to be loaded to the particular address.
*/
uint8_t *p_sec_data;
/* The Section checksum to verify the integrity of the section
* data.
*/
uint8_t *p_sec_chksum;
/** \internal Index used to refer and process the
* Firmware Section Data */
volatile uint32_t section_offset;
/** \internal Section Read Sequence */
volatile uint8_t section_read;
/** \internal Section Write Sequence */
volatile uint8_t section_write;
/** \internal TRIM Write Sequence */
volatile uint8_t trim_write;
volatile uint8_t sec_verify_retry;
}section_info_t;
typedef struct phDnldNfc_sParam
{
uint8_t data_addr[PHDNLD_ADDR_SIZE];
uint8_t data_len[PHDNLD_DATA_LEN_SIZE];
uint8_t data_packet[PHDNLD_DATA_SIZE];
}phDnldNfc_sParam_t;
typedef struct phDnldNfc_sDataHdr
{
uint8_t frame_type;
uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
}phDnldNfc_sData_Hdr_t;
typedef struct phDnldNfc_sRawHdr
{
uint8_t frame_type;
uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
}phDnldNfc_sRawHdr_t;
typedef struct phDnldNfc_sRawDataHdr
{
uint8_t data_addr[PHDNLD_ADDR_SIZE];
uint8_t data_len[PHDNLD_DATA_LEN_SIZE];
}phDnldNfc_sRawDataHdr_t;
typedef struct phDnldNfc_sChkCrc16_Resp
{
uint8_t Chk_status;
uint8_t Chk_Crc16[2];
}phDnldNfc_sChkCrc16_Resp_t;
typedef struct phDnldNfc_sChkCrc32_Resp
{
uint8_t Chk_status;
uint8_t Chk_Crc32[4];
}phDnldNfc_sChkCrc32_Resp_t;
typedef struct phDnldNfc_sChkCrcComplete
{
phDnldNfc_sChkCrc16_Resp_t config_page;
phDnldNfc_sChkCrc16_Resp_t patch_table;
phDnldNfc_sChkCrc32_Resp_t flash_code;
phDnldNfc_sChkCrc32_Resp_t patch_code;
}phDnldNfc_sChkCrcComplete_t;
typedef struct phDnldNfc_sData
{
uint8_t frame_type;
uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
union param
{
phDnldNfc_sParam_t data_param;
uint8_t response_data[PHDNLD_MAX_PACKET];
uint8_t cmd_param;
}param_info;
}phDnldNfc_sData_t;
#ifdef NXP_NFC_MULTIPLE_FW
typedef struct phDnldNfc_sFwImageInfo
{
/** \internal Data Pointer to the Firmware header section of the Firmware */
fw_data_hdr_t *p_fw_hdr;
/** \internal Buffer pointer to store the Firmware Section Data */
section_info_t *p_fw_sec;
/** \internal Buffer pointer to store the Firmware Raw Data */
uint8_t *p_fw_raw;
}phDnldNfc_sFwImageInfo_t;
#endif /* #ifdef NXP_NFC_MULTIPLE_FW */
typedef struct phDnldNfc_TxInfo
{
uint8_t *transmit_frame;
uint16_t tx_offset;
/** \internal Remaining amount of data to be sent */
uint16_t tx_len;
uint16_t tx_total;
/** \internal Chain information for the data to be sent */
uint8_t tx_chain;
}phDnldNfc_TxInfo_t;
typedef struct phDnldNfc_RxInfo
{
/** \internal Total length of the received buffer */
uint16_t rx_total;
/** \internal Chain information of the received buffer */
uint16_t rx_chain;
/** \internal Remaining Data information to be read to complete the
* Data Information.
*/
uint16_t rx_remain;
/** \internal Buffer to Send the Raw Data Frame */
uint8_t raw_buffer_data[PHDNLD_MAX_PACKET
+ PHDNLD_PAGE_SIZE];
}phDnldNfc_RxInfo_t;
typedef struct phDnldNfc_sContext
{
/** \internal Structure to store the lower interface operations */
phNfc_sLowerIF_t lower_interface;
phNfc_sData_t *p_fw_version;
/** \internal Pointer to the Hardware Reference Sturcture */
phHal_sHwReference_t *p_hw_ref;
/** \internal Pointer to the upper layer notification callback function */
pphNfcIF_Notification_CB_t p_upper_notify;
/** \internal Pointer to the upper layer context */
void *p_upper_context;
/** \internal Timer ID for the Download Abort */
uint32_t timer_id;
/** \internal Internal Download for the Download Abort */
uint32_t dnld_timeout;
/** \internal Data Pointer to the Image header section of the Firmware */
img_data_hdr_t *p_img_hdr;
#ifdef NXP_NFC_MULTIPLE_FW
/** \internal Data Pointer to the Firmware Image Information */
phDnldNfc_sFwImageInfo_t *p_img_info;
#endif /* #ifdef NXP_NFC_MULTIPLE_FW */
/** \internal Data Pointer to the Firmware header section of the Firmware */
fw_data_hdr_t *p_fw_hdr;
/** \internal Buffer pointer to store the Firmware Data */
section_info_t *p_fw_sec;
/** \internal Buffer pointer to store the Firmware Raw Data */
uint8_t *p_fw_raw;
/** \internal Previous Download Size */
uint32_t prev_dnld_size;
/** \internal Single Data Block to download the Firmware */
uint8_t dnld_data[PHDNLD_MAX_PACKET
+ PHDNLD_PAGE_SIZE];
/** \internal Index used to refer and process the Download Data */
volatile uint32_t dnld_index;
/** \internal Response Data to process the response */
phDnldNfc_sData_t dnld_resp;
/** \internal Previously downloaded data stored
* to compare the written data */
phNfc_sData_t dnld_store;
/** \internal Previously downloaded trimmed data stored
* to compare the written data */
phNfc_sData_t trim_store;
uint8_t *p_resp_buffer;
phDnldNfc_sChkCrcComplete_t chk_integrity_crc;
phDnldNfc_eChkCrc_t chk_integrity_param;
#define NXP_FW_SW_VMID_TRIM
#ifdef NXP_FW_SW_VMID_TRIM
#define NXP_FW_VMID_TRIM_CHK_ADDR 0x0000813DU
#define NXP_FW_VMID_CARD_MODE_ADDR 0x00009931U
#define NXP_FW_VMID_RD_MODE_ADDR 0x00009981U
uint8_t vmid_trim_update;
#endif /* #ifdef NXP_FW_SW_VMID_TRIM */
uint8_t cur_frame_info;
uint8_t raw_mode_upgrade;
uint8_t *p_patch_table_crc;
uint8_t *p_flash_code_crc;
uint8_t *p_patch_code_crc;
uint16_t resp_length;
/** \internal Current FW Section in Process */
volatile uint8_t section_index;
/** \internal Previous Command sent */
volatile uint8_t prev_cmd;
uint8_t dnld_retry;
/** \internal Current Download State */
volatile uint8_t cur_dnld_state;
/** \internal Next Download State */
volatile uint8_t next_dnld_state;
/** \internal Current step in Download Sequence */
volatile uint8_t cur_dnld_seq;
/** \internal Next step in Download Sequence */
volatile uint8_t next_dnld_seq;
/* \internal Data Transmit information */
phDnldNfc_TxInfo_t tx_info;
/* \internal Data Receive information */
phDnldNfc_RxInfo_t rx_info;
}phDnldNfc_sContext_t;
/*
################################################################################
******************** Global and Static Variables Definition ********************
################################################################################
*/
#ifndef NFC_TIMER_CONTEXT
static phDnldNfc_sContext_t *gpphDnldContext = NULL;
#endif
#ifdef NXP_FW_DNLD_CHECK_PHASE
#define NXP_FW_DNLD_COMPLETE_PHASE 0x00U
#define NXP_FW_DNLD_SYSTEM_PHASE 0x01U
#define NXP_FW_DNLD_CFG_PHASE 0x02U
#define NXP_FW_DNLD_DATA_PHASE 0x03U
#define NXP_FW_DNLD_RAW_PHASE 0x04U
#define NXP_FW_DNLD_INVALID_PHASE 0xFFU
static uint8_t gphDnldPhase = NXP_FW_DNLD_COMPLETE_PHASE;
#endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */
/**/
/*
*************************** Static Function Declaration **************************
*/
STATIC
NFCSTATUS
phDnldNfc_Send_Command(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
uint8_t cmd,
void *params,
uint16_t param_length
);
static
NFCSTATUS
phDnldNfc_Process_FW(
phDnldNfc_sContext_t *psDnldContext,
phHal_sHwReference_t *pHwRef
#ifdef NXP_FW_PARAM
,
uint8_t *nxp_nfc_fw,
uint32_t fw_length
#endif
);
STATIC
void
phDnldNfc_Send_Complete (
void *psContext,
void *pHwRef,
phNfc_sTransactionInfo_t *pInfo
);
STATIC
void
phDnldNfc_Receive_Complete (
void *psContext,
void *pHwRef,
phNfc_sTransactionInfo_t *pInfo
);
STATIC
NFCSTATUS
phDnldNfc_Process_Response(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
);
static
NFCSTATUS
phDnldNfc_Resume(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
);
static
NFCSTATUS
phDnldNfc_Resume_Write(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef
);
static
NFCSTATUS
phDnldNfc_Process_Write(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
section_info_t *p_sec_info,
uint32_t *p_sec_offset
);
static
NFCSTATUS
phDnldNfc_Sequence(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
);
static
NFCSTATUS
phDnldNfc_Upgrade_Sequence(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
);
STATIC
NFCSTATUS
phDnldNfc_Receive(
void *psContext,
void *pHwRef,
uint8_t *pdata,
uint16_t length
);
STATIC
NFCSTATUS
phDnldNfc_Send (
void *psContext,
void *pHwRef,
uint8_t *pdata,
uint16_t length
);
STATIC
NFCSTATUS
phDnldNfc_Set_Seq(
phDnldNfc_sContext_t *psDnldContext,
phDnldNfc_eSeqType_t seq_type
);
static
void
phDnldNfc_Notify(
pphNfcIF_Notification_CB_t p_upper_notify,
void *p_upper_context,
void *pHwRef,
uint8_t type,
void *pInfo
);
STATIC
NFCSTATUS
phDnldNfc_Allocate_Resource (
void **ppBuffer,
uint16_t size
);
STATIC
void
phDnldNfc_Release_Resources (
phDnldNfc_sContext_t **ppsDnldContext
);
STATIC
void
phDnldNfc_Release_Lower(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef
);
static
NFCSTATUS
phDnldNfc_Read(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
section_info_t *p_sec_info
);
STATIC
void
phDnldNfc_Abort (
uint32_t abort_id
#ifdef NFC_TIMER_CONTEXT
, void *dnld_cntxt
#endif
);
#ifdef DNLD_CRC_CALC
static
void
phDnldNfc_UpdateCrc16(
uint8_t crcByte,
uint16_t *pCrc
);
STATIC
uint16_t
phDnldNfc_ComputeCrc16(
uint8_t *pData,
uint16_t length
);
/*
*************************** Function Definitions **************************
*/
#define CRC32_POLYNOMIAL 0xEDB88320L
static uint32_t CRC32Table[0x100];
void BuildCRCTable()
{
unsigned long crc;
uint8_t i = 0, j = 0;
for ( i = 0; i <= 0xFF ; i++ )
{
crc = i;
for ( j = 8 ; j> 0; j-- )
{
if ( crc & 1 )
{
crc = ( crc>> 1 ) ^ CRC32_POLYNOMIAL;
}
else
{
crc>>= 1;
}
}
CRC32Table[ i ] = crc;
}
}
/*
* This routine calculates the CRC for a block of data using the
* table lookup method. It accepts an original value for the crc,
* and returns the updated value.
*/
uint32_t CalculateCRC32( void *buffer , uint32_t count, uint32_t crc )
{
uint8_t *p;
uint32_t temp1;
uint32_t temp2;
p = (uint8_t *) buffer;
while ( count-- != 0 ) {
temp1 = ( crc>> 8 ) & 0x00FFFFFFL;
temp2 = CRC32Table[ ( (int) crc ^ *p++ ) & 0xff ];
crc = temp1 ^ temp2;
}
return( crc );
}
static
void
phDnldNfc_UpdateCrc16(
uint8_t crcByte,
uint16_t *pCrc
)
{
crcByte = (crcByte ^ (uint8_t)((*pCrc) & 0x00FF));
crcByte = (crcByte ^ (uint8_t)(crcByte << 4));
*pCrc = (*pCrc >> 8) ^ ((uint16_t)crcByte << 8) ^
((uint16_t)crcByte << 3) ^
((uint16_t)crcByte >> 4);
}
STATIC
uint16_t
phDnldNfc_ComputeCrc16(
uint8_t *pData,
uint16_t length
)
{
uint8_t crc_byte = 0;
uint16_t index = 0;
uint16_t crc = 0;
#ifdef CRC_A
crc = 0x6363; /* ITU-V.41 */
#else
crc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
#endif /* #ifdef CRC_A */
do
{
crc_byte = pData[index];
phDnldNfc_UpdateCrc16(crc_byte, &crc);
index++;
} while (index < length);
#ifndef INVERT_CRC
crc = ~crc; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
#endif /* #ifndef INVERT_CRC */
/* *pCrc1 = (uint8_t) (crc & BYTE_MASK);
*pCrc2 = (uint8_t) ((crc >> 8) & BYTE_MASK); */
return crc ;
}
#endif /* #ifdef DNLD_CRC_CALC */
/*!
* \brief Allocation of the Download Interface resources.
*
* This function releases and frees all the resources used by Download Mode
* Feature.
*/
STATIC
NFCSTATUS
phDnldNfc_Allocate_Resource (
void **ppBuffer,
uint16_t size
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
*ppBuffer = (void *) phOsalNfc_GetMemory(size);
if( *ppBuffer != NULL )
{
(void )memset(((void *)*ppBuffer), 0,
size);
}
else
{
*ppBuffer = NULL;
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
return status;
}
/*!
* \brief Release of the Download Interface resources.
*
* This function releases and frees all the resources used by Download layer.
*/
STATIC
void
phDnldNfc_Release_Resources (
phDnldNfc_sContext_t **ppsDnldContext
)
{
if(NULL != (*ppsDnldContext)->p_resp_buffer)
{
phOsalNfc_FreeMemory((*ppsDnldContext)->p_resp_buffer);
(*ppsDnldContext)->p_resp_buffer = NULL;
}
if(NULL != (*ppsDnldContext)->dnld_store.buffer)
{
phOsalNfc_FreeMemory((*ppsDnldContext)->dnld_store.buffer);
(*ppsDnldContext)->dnld_store.buffer = NULL;
(*ppsDnldContext)->dnld_store.length = 0;
}
if(NULL != (*ppsDnldContext)->trim_store.buffer)
{
phOsalNfc_FreeMemory((*ppsDnldContext)->trim_store.buffer);
(*ppsDnldContext)->trim_store.buffer = NULL;
(*ppsDnldContext)->trim_store.length = 0;
}
if(NULL != (*ppsDnldContext)->p_fw_sec)
{
phOsalNfc_FreeMemory((*ppsDnldContext)->p_fw_sec);
(*ppsDnldContext)->p_fw_sec = NULL;
}
if ( NXP_INVALID_TIMER_ID != (*ppsDnldContext)->timer_id )
{
phOsalNfc_Timer_Stop((*ppsDnldContext)->timer_id );
phOsalNfc_Timer_Delete((*ppsDnldContext)->timer_id );
(*ppsDnldContext)->timer_id = NXP_INVALID_TIMER_ID;
}
phOsalNfc_FreeMemory((*ppsDnldContext));
(*ppsDnldContext) = NULL;
return ;
}
STATIC
void
phDnldNfc_Release_Lower(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef
)
{
phNfc_sLowerIF_t *plower_if =
&(psDnldContext->lower_interface);
NFCSTATUS status = NFCSTATUS_SUCCESS;
PHNFC_UNUSED_VARIABLE(status);
if(NULL != plower_if->release)
{
#ifdef DNLD_LOWER_RELEASE
status = plower_if->release((void *)plower_if->pcontext,
(void *)pHwRef);
#else
PHNFC_UNUSED_VARIABLE(pHwRef);
#endif
(void)memset((void *)plower_if,
0, sizeof(phNfc_sLowerIF_t));
DNLD_DEBUG(" FW_DNLD: Releasing the Lower Layer Resources: Status = %02X\n"
,status);
}
return;
}
static
void
phDnldNfc_Notify(
pphNfcIF_Notification_CB_t p_upper_notify,
void *p_upper_context,
void *pHwRef,
uint8_t type,
void *pInfo
)
{
if( ( NULL != p_upper_notify) )
{
/* Notify the to the Upper Layer */
(p_upper_notify)(p_upper_context, pHwRef, type, pInfo);
}
}
STATIC
NFCSTATUS
phDnldNfc_Set_Seq(
phDnldNfc_sContext_t *psDnldContext,
phDnldNfc_eSeqType_t seq_type
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
static uint8_t prev_temp_state = 0;
static uint8_t prev_temp_seq =
(uint8_t) phDnld_Activate_Patch;
switch(seq_type)
{
case DNLD_SEQ_RESET:
case DNLD_SEQ_INIT:
{
psDnldContext->cur_dnld_state =
(uint8_t) phDnld_Reset_State;
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Upgrade_State;
psDnldContext->cur_dnld_seq =
(uint8_t)phDnld_Upgrade_Section;
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq;
break;
}
case DNLD_SEQ_RAW:
{
psDnldContext->cur_dnld_state =
(uint8_t) phDnld_Reset_State;
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Upgrade_State;
psDnldContext->cur_dnld_seq =
(uint8_t)phDnld_Raw_Upgrade;
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq;
break;
}
case DNLD_SEQ_UNLOCK:
{
psDnldContext->cur_dnld_state =
(uint8_t) phDnld_Reset_State;
#ifdef NXP_FW_DNLD_CHECK_PHASE
if( NXP_FW_DNLD_SYSTEM_PHASE < gphDnldPhase )
{
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Upgrade_State;
psDnldContext->cur_dnld_seq =
(uint8_t)phDnld_Upgrade_Section;
}
else
#endif /* NXP_FW_DNLD_CHECK_PHASE */
{
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Unlock_State;
psDnldContext->cur_dnld_seq =
(uint8_t) phDnld_Activate_Patch;
}
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq;
break;
}
case DNLD_SEQ_LOCK:
{
psDnldContext->cur_dnld_state =
(uint8_t) phDnld_Reset_State;
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Reset_State;
psDnldContext->cur_dnld_seq =
(uint8_t) phDnld_Lock_System;
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq;
break;
}
case DNLD_SEQ_UPDATE:
{
prev_temp_state = (uint8_t) psDnldContext->cur_dnld_state;
psDnldContext->cur_dnld_state =
psDnldContext->next_dnld_state;
/* psDnldContext->next_dnld_state =
(uint8_t)phDnld_Invalid_State ; */
prev_temp_seq = (uint8_t) psDnldContext->cur_dnld_seq;
psDnldContext->cur_dnld_seq =
psDnldContext->next_dnld_seq;
break;
}
case DNLD_SEQ_ROLLBACK:
{
psDnldContext->cur_dnld_seq = (uint8_t) prev_temp_seq;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Invalid_Seq ;
prev_temp_seq = 0;
psDnldContext->cur_dnld_state = (uint8_t) prev_temp_state;
/* psDnldContext->next_dnld_state =
(uint8_t)phDnld_Invalid_State ; */
prev_temp_state = 0;
break;
}
case DNLD_SEQ_COMPLETE:
{
psDnldContext->cur_dnld_state =
(uint8_t) phDnld_Reset_State;
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Verify_State;
psDnldContext->cur_dnld_seq =
(uint8_t) phDnld_Verify_Integrity;
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq ;
break;
}
default:
{
break;
}
}
return status;
}
/*!
* \brief Sends the data the corresponding peripheral device.
*
* This function sends the Download data to the connected NFC Pheripheral device
*/
STATIC
NFCSTATUS
phDnldNfc_Send (
void *psContext,
void *pHwRef,
uint8_t *pdata,
uint16_t length
)
{
phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext;
NFCSTATUS status = NFCSTATUS_SUCCESS;
phNfc_sLowerIF_t *plower_if = &(psDnldContext->lower_interface);
if( (NULL != plower_if)
&& (NULL != plower_if->send)
)
{
#ifndef DNLD_SUMMARY
DNLD_PRINT_BUFFER("Send Buffer",pdata,length);
#endif
status = plower_if->send((void *)plower_if->pcontext,
(void *)pHwRef, pdata, length);
#if defined(FW_DOWNLOAD_TIMER) && \
(FW_DOWNLOAD_TIMER == 2)
if (
(NFCSTATUS_PENDING == status)
&& ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
)
{
psDnldContext->dnld_timeout = NXP_DNLD_COMPLETE_TIMEOUT;
if ( psDnldContext->dnld_timeout
< DNLD_DEFAULT_RESPONSE_TIMEOUT)
{
psDnldContext->dnld_timeout
= DNLD_DEFAULT_RESPONSE_TIMEOUT;
}
/* Start the Download Timer */
phOsalNfc_Timer_Start( psDnldContext->timer_id,
psDnldContext->dnld_timeout,
(ppCallBck_t) phDnldNfc_Abort
#ifdef NFC_TIMER_CONTEXT
, (void *) psDnldContext
#endif
);
DNLD_DEBUG(" DNLD : Timer %X Started ", psDnldContext->timer_id);
DNLD_DEBUG(" \t\t With %U Timeout \n", psDnldContext->dnld_timeout);
}
#endif /* (NXP_NFC_DNLD_TIMER == 1) */
}
return status;
}
/*!
* \brief Receives the Download Mode Response from the corresponding peripheral device.
*
* This function receives the Download Command Response to the connected NFC
* Pheripheral device.
*/
STATIC
NFCSTATUS
phDnldNfc_Receive(
void *psContext,
void *pHwRef,
uint8_t *pdata,
uint16_t length
)
{
phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext;
phNfc_sLowerIF_t *plower_if = NULL ;
NFCSTATUS status = NFCSTATUS_SUCCESS;
if(NULL == psDnldContext )
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
else
{
plower_if = &(psDnldContext->lower_interface);
if( (NULL != plower_if)
&& (NULL != plower_if->receive)
)
{
status = plower_if->receive((void *)plower_if->pcontext,
(void *)pHwRef, pdata, length);
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Read(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
section_info_t *p_sec_info
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
phDnldNfc_sParam_t *p_data_param =
&p_dnld_data->param_info.data_param;
uint32_t read_addr = (p_sec_info->p_sec_hdr->section_address
+ p_sec_info->section_offset);
static unsigned sec_type = 0;
uint8_t i = 0;
uint16_t read_size = 0 ;
sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
if( ( FALSE == p_sec_info->section_read )
&& ((sec_type & DNLD_TRIM_MASK))
&& (FALSE == p_sec_info->trim_write) )
{
read_size = (uint16_t) p_sec_info->p_sec_hdr->section_length;
DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size);
}
else
{
if (( FALSE == p_sec_info->section_read )
&& ((sec_type & DNLD_VERIFY_MASK))
)
{
read_size = (uint16_t)(psDnldContext->prev_dnld_size );
DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size);
}
else if( ( TRUE == p_sec_info->section_read )
&& ( TRUE == p_sec_info->section_write )
)
{
/*Already Read the Data Hence Ignore the Read */
DNLD_DEBUG(" FW_DNLD: Already Read, Read Ignored, read_size = %X \n", read_size);
}
else
{
/* Ignore the Read */
DNLD_DEBUG(" FW_DNLD: Section Read Status = %X \n", p_sec_info->section_read);
DNLD_DEBUG(" FW_DNLD: Section Write Status = %X \n", p_sec_info->section_write);
DNLD_DEBUG(" FW_DNLD: No Read Required, Read_size = %X \n", read_size);
}
}
if (read_size != 0)
{
read_size = (uint16_t)((PHDNLD_DATA_SIZE >= read_size)?
read_size: PHDNLD_DATA_SIZE);
p_dnld_data->frame_length[i] = (uint8_t)0;
/* Update the LSB of the Data and the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)((read_addr >>
(BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK);
p_data_param->data_len[i] = (uint8_t)((read_size >>
BYTE_SIZE) & BYTE_MASK);
i++;
p_dnld_data->frame_length[i] = (uint8_t)
( PHDNLD_CMD_READ_LEN & BYTE_MASK);
/* Update the 2nd byte of the Data and the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)((read_addr >>
BYTE_SIZE) & BYTE_MASK);
p_data_param->data_len[i] = (uint8_t) (read_size & BYTE_MASK);
i++;
/* Update the 3rd byte of the the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)(read_addr & BYTE_MASK);
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_READ, NULL , 0 );
if ( NFCSTATUS_PENDING == status )
{
p_sec_info->section_read = TRUE ;
psDnldContext->next_dnld_state = phDnld_Upgrade_State;
DNLD_DEBUG(" FW_DNLD: Memory Read at Address %X : ", read_addr);
DNLD_DEBUG(" of Size %X \n", read_size);
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Process_Write(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
section_info_t *p_sec_info,
uint32_t *p_sec_offset
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
phDnldNfc_sParam_t *dnld_data =
&p_dnld_data->param_info.data_param;
uint8_t *p_sm_trim_data = (uint8_t *)psDnldContext->
dnld_resp.param_info.response_data;
uint32_t dnld_addr = 0;
#ifdef NXP_FW_SW_VMID_TRIM
uint32_t trim_addr = 0;
#endif /* #ifdef NXP_FW_SW_VMID_TRIM */
static unsigned sec_type = 0;
uint8_t i = 0;
uint16_t dnld_size = 0;
int cmp_val = 0x00;
sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
status = phDnldNfc_Read(psDnldContext, pHwRef, p_sec_info);
if( NFCSTATUS_PENDING != status )
{
if( (TRUE == p_sec_info->trim_write)
&& (TRUE == p_sec_info->section_read)
&& ((sec_type & DNLD_VERIFY_MASK))
)
{
if(NULL != psDnldContext->trim_store.buffer)
{
uint32_t trim_cmp_size = psDnldContext->prev_dnld_size;
if( p_sec_info->p_sec_hdr->section_address
< (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
{
trim_cmp_size = trim_cmp_size - 2;
}
/* Below Comparison fails due to the checksum */
cmp_val = phOsalNfc_MemCompare(
psDnldContext->trim_store.buffer,
&psDnldContext->dnld_resp.
param_info.response_data[0]
,trim_cmp_size);
DNLD_DEBUG(" FW_DNLD: %X Bytes Trim Write Complete ",
psDnldContext->prev_dnld_size);
DNLD_DEBUG(" Comparison Status %X\n", cmp_val);
}
p_sec_info->trim_write = FALSE;
DNLD_DEBUG(" FW_DNLD: TRIMMED %X Bytes Write Complete\n", psDnldContext->prev_dnld_size);
}
else
{
if((NULL != psDnldContext->dnld_store.buffer)
&& ((sec_type & DNLD_VERIFY_MASK))
&& (TRUE == p_sec_info->section_write)
&& (TRUE == p_sec_info->section_read)
)
{
cmp_val = phOsalNfc_MemCompare(
psDnldContext->dnld_store.buffer,
&psDnldContext->dnld_resp.
param_info.response_data[0]
,psDnldContext->dnld_store.length);
p_sec_info->section_read = FALSE;
p_sec_info->section_write = FALSE;
DNLD_DEBUG(" FW_DNLD: %X Bytes Write Complete ",
psDnldContext->dnld_store.length);
DNLD_DEBUG(" Comparison Status %X\n", cmp_val);
}
else
{
if(( TRUE == p_sec_info->section_write)
&& ( FALSE == p_sec_info->section_read)
)
{
p_sec_info->section_write = FALSE;
}
}
/* p_sec_info->section_read = FALSE; */
}
if (( 0 == psDnldContext->dnld_retry )
&& (0 == cmp_val)
)
{
p_sec_info->sec_verify_retry = 0;
p_sec_info->section_offset = p_sec_info->section_offset +
psDnldContext->prev_dnld_size;
psDnldContext->prev_dnld_size = 0;
DNLD_DEBUG(" FW_DNLD: Memory Write Retry - %X \n",
psDnldContext->dnld_retry);
}
else
{
p_sec_info->sec_verify_retry++;
DNLD_DEBUG(" FW_DNLD: Memory Verification Failed, Retry = %X \n",
p_sec_info->sec_verify_retry);
}
if( p_sec_info->sec_verify_retry < NXP_MAX_SECTION_WRITE )
{
dnld_addr = (p_sec_info->p_sec_hdr->section_address + *p_sec_offset);
dnld_size = (uint16_t)(p_sec_info->p_sec_hdr->section_length
- *p_sec_offset);
}
else
{
status = NFCSTATUS_FAILED;
DNLD_DEBUG(" FW_DNLD: Memory Verification - Maximum Limit, Retry = %X \n",
p_sec_info->sec_verify_retry);
}
}
if (dnld_size != 0)
{
dnld_size = (uint16_t)((PHDNLD_DATA_SIZE >= dnld_size)?
dnld_size: PHDNLD_DATA_SIZE);
/* Update the LSB of the Data and the Address Parameter*/
dnld_data->data_addr[i] = (uint8_t)((dnld_addr >>
(BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK);
dnld_data->data_len[i] = (uint8_t)((dnld_size >> BYTE_SIZE)
& BYTE_MASK);
p_dnld_data->frame_length[i] = (uint8_t)
(((dnld_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE)
& BYTE_MASK);
i++;
/* Update the 2nd byte of the Data and the Address Parameter*/
dnld_data->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE)
& BYTE_MASK);
dnld_data->data_len[i] = (uint8_t) (dnld_size & BYTE_MASK);
p_dnld_data->frame_length[i] = (uint8_t) ((dnld_size +
PHDNLD_CMD_WRITE_MIN_LEN) & BYTE_MASK);
i++;
/* Update the 3rd byte of the the Address Parameter*/
dnld_data->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK);
(void)memcpy( dnld_data->data_packet,
(p_sec_info->p_sec_data + *p_sec_offset), dnld_size );
if( ((sec_type & DNLD_TRIM_MASK))
&& (p_sec_info->sec_verify_retry != 0)
&& (NULL != psDnldContext->trim_store.buffer)
)
{
(void)memcpy( dnld_data->data_packet,
psDnldContext->trim_store.buffer, dnld_size );
}
else if(((sec_type & DNLD_TRIM_MASK))
&& ( TRUE == p_sec_info->section_read )
)
{
for(i = 0; i < *(p_sec_info->p_trim_data);i++)
{
#ifdef NXP_FW_SW_VMID_TRIM
/*
if(bit 0 of 0x813D is equal to 1) then
Do not overwrite 0x9931 / 0x9981 during download
else
@0x9931 = 0x79 // card Mode
@0x9981 = 0x79 // Reader Mode
*/
trim_addr = p_sec_info->p_sec_hdr->section_address
+ p_sec_info->p_trim_data[i+1];
if (NXP_FW_VMID_TRIM_CHK_ADDR == trim_addr)
{
psDnldContext->vmid_trim_update =
p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
}
if((NXP_FW_VMID_CARD_MODE_ADDR == trim_addr)
|| (NXP_FW_VMID_RD_MODE_ADDR == trim_addr))
{
if (TRUE == psDnldContext->vmid_trim_update)
{
dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] =
p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
}
}
else
#endif
{
dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] =
p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
}
}
if(NULL != psDnldContext->trim_store.buffer)
{
phOsalNfc_FreeMemory(psDnldContext->trim_store.buffer);
psDnldContext->trim_store.buffer = NULL;
psDnldContext->trim_store.length = 0;
}
#if 1
(void)
phDnldNfc_Allocate_Resource((void **)
&(psDnldContext->trim_store.buffer),dnld_size);
#else
psDnldContext->trim_store.buffer =
(uint8_t *) phOsalNfc_GetMemory(dnld_size);
#endif
if(NULL != psDnldContext->trim_store.buffer)
{
(void )memset((void *)psDnldContext->trim_store.buffer,0,
dnld_size);
(void)memcpy( psDnldContext->trim_store.buffer,
dnld_data->data_packet, dnld_size );
psDnldContext->trim_store.length = dnld_size;
DNLD_DEBUG(" FW_DNLD: Write with Trimming at Address %X ", dnld_addr );
DNLD_DEBUG(" of Size %X and ", dnld_size );
DNLD_DEBUG(" with %X Trimming Values \n", *(p_sec_info->p_trim_data) );
}
}
else
{
if(NULL != psDnldContext->dnld_store.buffer)
{
phOsalNfc_FreeMemory(psDnldContext->dnld_store.buffer);
psDnldContext->dnld_store.buffer = NULL;
psDnldContext->dnld_store.length = 0;
}
#if 1
(void)
phDnldNfc_Allocate_Resource((void **)
&(psDnldContext->dnld_store.buffer),dnld_size);
#else
psDnldContext->dnld_store.buffer =
(uint8_t *) phOsalNfc_GetMemory(dnld_size);
#endif
if(NULL != psDnldContext->dnld_store.buffer)
{
(void )memset((void *)psDnldContext->dnld_store.buffer,0,
dnld_size);
(void)memcpy( psDnldContext->dnld_store.buffer,
dnld_data->data_packet, dnld_size );
psDnldContext->dnld_store.length = dnld_size;
DNLD_DEBUG(" FW_DNLD: Memory Write at Address %X ", dnld_addr );
DNLD_DEBUG(" of Size %X ", dnld_size );
}
}
if(PHDNLD_FW_PATCH_SEC != psDnldContext->p_fw_hdr->fw_patch)
{
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_WRITE, NULL , 0 );
}
else
{
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_SEC_WRITE, NULL , 0 );
}
DNLD_DEBUG(" FW_DNLD: Memory Write Status = %X \n", status);
if ( NFCSTATUS_PENDING == status )
{
psDnldContext->prev_dnld_size = dnld_size;
cmp_val = 0x00;
if((sec_type & DNLD_TRIM_MASK))
{
p_sec_info->trim_write = TRUE;
DNLD_DEBUG(" FW_DNLD: Bytes Downloaded (Trimming Values) = %X Bytes \n",
dnld_size);
}
else
{
p_sec_info->section_write = TRUE;
DNLD_DEBUG(" FW_DNLD: Bytes Downloaded = %X : ",
(*p_sec_offset + dnld_size));
DNLD_DEBUG(" Bytes Remaining = %X \n",
(p_sec_info->p_sec_hdr->section_length -
(*p_sec_offset + dnld_size)));
}
p_sec_info->section_read = FALSE;
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Resume_Write(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint8_t sec_index = psDnldContext->section_index;
section_info_t *p_sec_info = (psDnldContext->p_fw_sec + sec_index);
while((sec_index < psDnldContext->p_fw_hdr->no_of_sections)
&& (NFCSTATUS_SUCCESS == status )
)
{
status = phDnldNfc_Process_Write(psDnldContext, pHwRef,
p_sec_info, (uint32_t *)&(p_sec_info->section_offset));
if (NFCSTATUS_SUCCESS == status)
{
unsigned sec_type = 0;
sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
p_sec_info->section_offset = 0;
p_sec_info->section_read = FALSE;
p_sec_info->section_write = FALSE;
p_sec_info->trim_write = FALSE;
DNLD_DEBUG(" FW_DNLD: Section %02X Download Complete\n", sec_index);
if((sec_type & DNLD_RESET_MASK))
{
DNLD_DEBUG(" FW_DNLD: Reset After Section %02X Download \n", sec_index);
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_RESET , NULL, 0 );
}
DNLD_PRINT("*******************************************\n\n");
sec_index++;
#ifdef NXP_FW_DNLD_CHECK_PHASE
if( p_sec_info->p_sec_hdr->section_address
< (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
{
gphDnldPhase = NXP_FW_DNLD_DATA_PHASE;
}
p_sec_info = (psDnldContext->p_fw_sec + sec_index);
if( (sec_index < psDnldContext->p_fw_hdr->no_of_sections)
&& ( p_sec_info->p_sec_hdr->section_address
< (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
)
{
if( NXP_FW_DNLD_CFG_PHASE >= gphDnldPhase )
{
gphDnldPhase = NXP_FW_DNLD_CFG_PHASE;
}
else
{
sec_index++;
p_sec_info = (psDnldContext->p_fw_sec + sec_index);
}
}
#else
p_sec_info = (psDnldContext->p_fw_sec + sec_index);
#endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */
psDnldContext->section_index = sec_index;
/* psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State; */
}
}
if (NFCSTATUS_PENDING == status)
{
psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State;
}
else if (NFCSTATUS_SUCCESS == status)
{
/* Reset the PN544 Device */
psDnldContext->next_dnld_state = (uint8_t) phDnld_Complete_State;
}
else
{
}
return status;
}
#define NXP_DNLD_SM_UNLOCK_ADDR 0x008002U
#if !defined (ES_HW_VER)
#define ES_HW_VER 32
#endif
#if (ES_HW_VER <= 30)
#define NXP_DNLD_PATCH_ADDR 0x01AFFFU
#else
#define NXP_DNLD_PATCH_ADDR 0x01A1E0U
#endif
#if (ES_HW_VER <= 30)
#define NXP_DNLD_PATCH_TABLE_ADDR 0x008107U
#else
#define NXP_DNLD_PATCH_TABLE_ADDR 0x00825AU
#endif
static
NFCSTATUS
phDnldNfc_Sequence(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint32_t dnld_addr = 0;
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
phDnldNfc_sParam_t *p_data_param =
& p_dnld_data->param_info.data_param;
uint8_t *p_data = NULL;
static uint32_t patch_size = 0;
#if (ES_HW_VER == 32)
static uint8_t patch_table[] = {0xA0, 0xA1, 0xE0, 0x80, 0xA9, 0x6C };
static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5,
0xD0, 0xFC, 0xA5, 0x02, 0x80, 0xA9, 0x75};
#elif (ES_HW_VER == 31)
static uint8_t patch_table[] = {0xA0, 0xAF, 0xE0, 0x80, 0x78, 0x84 };
static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5,
0xD0, 0xFC, 0xD0, 0xE0, 0xA5, 0x02, 0x80, 0x78, 0x8D};
#elif (ES_HW_VER == 30)
static uint8_t patch_table[] = {0x80, 0x91, 0x51, 0xA0, 0xAF,
0xFF, 0x80, 0x91, 0x5A};
static uint8_t patch_data[] = {0x22};
#endif
static uint8_t unlock_data[] = {0x00, 0x00};
static uint8_t lock_data[] = {0x0C, 0x00};
uint8_t i = 0;
PHNFC_UNUSED_VARIABLE(pdata);
PHNFC_UNUSED_VARIABLE(length);
switch(psDnldContext->cur_dnld_seq)
{
case phDnld_Reset_Seq:
{
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_RESET , NULL , 0 );
/* status = (NFCSTATUS_PENDING == status)? NFCSTATUS_SUCCESS:
status; */
DNLD_DEBUG(" FW_DNLD: Reset Seq.. Status = %X \n", status);
break;
}
case phDnld_Activate_Patch:
{
uint8_t patch_activate = 0x01;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Update_Patch;
#ifdef NXP_FW_DNLD_CHECK_PHASE
gphDnldPhase = NXP_FW_DNLD_SYSTEM_PHASE;
#endif /* NXP_FW_DNLD_CHECK_PHASE */
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) );
DNLD_PRINT(" FW_DNLD: Activate the Patch Update .... \n");
break;
}
case phDnld_Deactivate_Patch:
{
uint8_t patch_activate = 0x00;
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Reset_State;
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) );
DNLD_PRINT(" FW_DNLD: Deactivate the Patch Update .... \n");
break;
}
case phDnld_Update_Patch:
{
dnld_addr = NXP_DNLD_PATCH_ADDR;
patch_size = sizeof(patch_data) ;
p_data = patch_data;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Update_Patchtable;
DNLD_PRINT(" FW_DNLD: Patch Update Seq.... \n");
break;
}
case phDnld_Update_Patchtable:
{
dnld_addr = NXP_DNLD_PATCH_TABLE_ADDR;
patch_size = sizeof(patch_table) ;
p_data = patch_table;
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Reset_State;
DNLD_PRINT(" FW_DNLD: Patch Table Update Seq.... \n");
break;
}
case phDnld_Unlock_System:
{
dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR;
patch_size = sizeof(unlock_data) ;
p_data = unlock_data;
#define NXP_FW_PATCH_DISABLE
#ifdef NXP_FW_PATCH_DISABLE
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Deactivate_Patch;
#else
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Reset_State;
#endif
DNLD_PRINT(" FW_DNLD: System Memory Unlock Seq.... \n");
break;
}
case phDnld_Lock_System:
{
dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR;
patch_size = sizeof(lock_data) ;
p_data = lock_data;
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Reset_State;
DNLD_PRINT(" FW_DNLD: System Memory Lock Seq.... \n");
break;
}
case phDnld_Upgrade_Section:
{
status = phDnldNfc_Resume_Write(
psDnldContext, pHwRef );
break;
}
case phDnld_Verify_Integrity:
{
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Reset_State;
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_CHECK_INTEGRITY , NULL, 0 );
DNLD_PRINT(" FW_DNLD: System Memory Integrity Check Sequence.... \n");
break;
}
case phDnld_Verify_Section:
{
break;
}
default:
{
break;
}
}
if( NFCSTATUS_SUCCESS == status)
{
/* Update the LSB of the Data and the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)((dnld_addr >>
(BYTE_SIZE + BYTE_SIZE))
& BYTE_MASK);
p_data_param->data_len[i] = (uint8_t)((patch_size >> BYTE_SIZE)
& BYTE_MASK);
p_dnld_data->frame_length[i] = (uint8_t)
(((patch_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE)
& BYTE_MASK);
i++;
/* Update the 2nd byte of the Data and the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE)
& BYTE_MASK);
p_data_param->data_len[i] = (uint8_t) (patch_size & BYTE_MASK);
p_dnld_data->frame_length[i] = (uint8_t)
((patch_size + PHDNLD_CMD_WRITE_MIN_LEN)
& BYTE_MASK);
i++;
/* Update the 3rd byte of the the Address Parameter*/
p_data_param->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK);
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_WRITE,(void *)p_data , (uint8_t)patch_size );
if (NFCSTATUS_PENDING != status)
{
status = phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_ROLLBACK);
}
}
return status;
}
#define FRAME_HEADER_LEN 0x03U
static
void
phDnldNfc_Tx_Reset(phDnldNfc_sContext_t *psDnldContext)
{
psDnldContext->tx_info.transmit_frame = NULL;
psDnldContext->tx_info.tx_total = 0x00;
psDnldContext->tx_info.tx_offset = 0x00;
psDnldContext->tx_info.tx_len = 0x00;
psDnldContext->tx_info.tx_chain = FALSE;
}
STATIC
bool_t
phDnldNfc_Extract_Chunks(
uint8_t *frame_data,
uint16_t frame_offset,
uint16_t frame_length,
uint16_t max_frame ,
uint16_t *chunk_length
);
STATIC
bool_t
phDnldNfc_Extract_Chunks(
uint8_t *frame_data,
uint16_t frame_offset,
uint16_t frame_length,
uint16_t max_frame ,
uint16_t *chunk_length
)
{
bool_t chunk_present = FALSE;
if( 0 == frame_offset)
{
if( max_frame >= (frame_length
- frame_offset))
{
*chunk_length = (frame_length - frame_offset);
}
else
{
*chunk_length = max_frame
- FRAME_HEADER_LEN;
chunk_present = TRUE;
}
}
else
{
if( max_frame >= (frame_length
- frame_offset))
{
*chunk_length = (frame_length - frame_offset);
}
else
{
*chunk_length = max_frame
- FRAME_HEADER_LEN;
chunk_present = TRUE;
}
}
return chunk_present;
}
STATIC
NFCSTATUS
phDnldNfc_Send_Raw(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
uint8_t *raw_frame,
uint16_t frame_offset,
uint16_t frame_length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_sRawHdr_t *raw_frame_hdr = ( phDnldNfc_sRawHdr_t * ) raw_frame;
switch(raw_frame_hdr->frame_type)
{
case PHDNLD_CMD_RESET:
{
break;
}
case PHDNLD_CMD_READ:
{
/* TODO: To Update the length and the buffer to receive data */
break;
}
case PHDNLD_CMD_WRITE:
{
phDnldNfc_sRawDataHdr_t *raw_data_hdr =
( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN);
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_SEC_WRITE:
{
uint16_t tx_length = 0x00;
uint16_t frame_offset =
psDnldContext->tx_info.tx_offset;
uint16_t chain =
psDnldContext->tx_info.tx_chain;
chain =
phDnldNfc_Extract_Chunks(
raw_frame,
frame_offset,
frame_length,
PHDNLD_FW_TX_RX_LEN,
&tx_length
);
if( TRUE == chain )
{
status = phDnldNfc_Send_Command( psDnldContext,
pHwRef, PHDNLD_CMD_ENCAPSULATE,
(raw_frame + frame_offset),
tx_length);
if(NFCSTATUS_PENDING == status)
{
psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
/* TODO: Update for the Chaining */
psDnldContext->tx_info.tx_offset += tx_length;
psDnldContext->tx_info.tx_chain = chain;
}
}
else if (0 != frame_offset)
{
status = phDnldNfc_Send_Command( psDnldContext,
pHwRef, PHDNLD_CMD_ENCAPSULATE,
(raw_frame + frame_offset),
tx_length);
if(NFCSTATUS_PENDING == status)
{
psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
/* TODO: Update for the Chaining */
psDnldContext->prev_dnld_size = frame_length;
phDnldNfc_Tx_Reset(psDnldContext);
}
}
else
{
phDnldNfc_sRawDataHdr_t *raw_data_hdr =
( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN);
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
}
break;
}
case PHDNLD_CMD_CHECK:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_SET_HIF:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_ACTIVATE_PATCH:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_CHECK_INTEGRITY:
{
uint8_t integrity_param =
*(raw_frame + FRAME_HEADER_LEN);
switch(integrity_param)
{
case CHK_INTEGRITY_CONFIG_PAGE_CRC:
case CHK_INTEGRITY_PATCH_TABLE_CRC:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_CRC16_LEN;
break;
}
case CHK_INTEGRITY_FLASH_CODE_CRC:
case CHK_INTEGRITY_PATCH_CODE_CRC:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_CRC32_LEN;
break;
}
case CHK_INTEGRITY_COMPLETE_CRC:
default:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_COMP_LEN;
break;
}
}
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED);
break;
}
}
if (NFCSTATUS_SUCCESS == status)
{
status = phDnldNfc_Send( psDnldContext, pHwRef ,
raw_frame, frame_length);
if(NFCSTATUS_PENDING == status)
{
psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
/* TODO: Update for the Chaining */
psDnldContext->prev_dnld_size = frame_length;
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Frame_Complete(phDnldNfc_sContext_t *psDnldContext)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_sData_Hdr_t *p_dnld_raw = NULL;
uint32_t dnld_index = psDnldContext->dnld_index;
uint8_t *p_raw_sec_hdr = NULL;
uint16_t tx_length = 0x00;
dnld_index = dnld_index + psDnldContext->prev_dnld_size;
p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
dnld_index = dnld_index + *p_raw_sec_hdr;
p_dnld_raw = (phDnldNfc_sData_Hdr_t *) (psDnldContext->p_fw_raw +
psDnldContext->dnld_index);
tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
p_dnld_raw->frame_length[1]);
tx_length = tx_length + PHDNLD_MIN_PACKET;
return status;
}
static
NFCSTATUS
phDnldNfc_Raw_Write(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint32_t dnld_index = psDnldContext->dnld_index;
uint32_t tx_length = 0;
uint8_t *p_raw_sec_hdr = NULL;
uint8_t dnld_flag = FALSE;
uint8_t skip_frame = FALSE;
if(NULL != psDnldContext->p_fw_raw)
{
if( (TRUE != psDnldContext->tx_info.tx_chain)
&& (0x00 == psDnldContext->dnld_retry)
)
{
dnld_index = dnld_index + psDnldContext->prev_dnld_size;
p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
dnld_index = dnld_index + *p_raw_sec_hdr;
}
else
{
phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *)
(psDnldContext->p_fw_raw +
psDnldContext->dnld_index);
tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
p_dnld_raw->frame_length[1]);
tx_length = tx_length + PHDNLD_MIN_PACKET;
status = phDnldNfc_Send_Raw( psDnldContext, pHwRef,
(uint8_t *)(p_dnld_raw),
psDnldContext->tx_info.tx_offset,
(uint16_t)tx_length);
}
#define PHDNLD_MAJOR_OFFSET 0x04U
#define PHDNLD_MINOR_OFFSET 0x05U
#define PHDNLD_PHASE_OFFSET 0x06U
#define PHDNLD_FRAMETYPE_OFFSET 0x07U
#define PHDNLD_NO_OPERATION 0x00U
#define PHDNLD_NORMAL_OPERATION 0x10U
#define PHDNLD_ADVANCED_OPERATION 0x20U
#define PHDNLD_SETUP_OPERATION 0x40U
#define PHDNLD_RECOVER_OPERATION 0x80U
#define PHDNLD_COMPLETE_OPERATION 0xF0U
#define PHDNLD_TERMINATE_TYPE 0x0EU
#define PHDNLD_MARKER_MASK 0x0FU
while((NFCSTATUS_SUCCESS == status )
&& (FALSE == dnld_flag)
)
{
phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *)
(psDnldContext->p_fw_raw + dnld_index);
uint8_t frame_type = *(p_raw_sec_hdr + PHDNLD_FRAMETYPE_OFFSET);
tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
p_dnld_raw->frame_length[1]);
tx_length = tx_length + PHDNLD_MIN_PACKET;
skip_frame = FALSE;
if( (0x00 == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET))
|| (0xFF == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET))
|| !( psDnldContext->raw_mode_upgrade
& (frame_type & (~PHDNLD_MARKER_MASK)) )
)
{
dnld_index = dnld_index + tx_length;
p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
dnld_index = dnld_index + *p_raw_sec_hdr;
skip_frame = TRUE;
}
if (PHDNLD_TERMINATE_TYPE ==
(frame_type & PHDNLD_MARKER_MASK))
{
if(TRUE != skip_frame)
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade &
~(frame_type & ~PHDNLD_MARKER_MASK)) ;
}
if(PHDNLD_NO_OPERATION ==
psDnldContext->raw_mode_upgrade)
{
dnld_flag = TRUE;
}
}
else
{
}
if((FALSE == skip_frame)
&& (FALSE == dnld_flag)
)
{
status = phDnldNfc_Send_Raw( psDnldContext, pHwRef,
(uint8_t *)(p_dnld_raw),
psDnldContext->tx_info.tx_offset,
(uint16_t)tx_length);
}
if( NFCSTATUS_PENDING == status )
{
psDnldContext->dnld_index = dnld_index;
psDnldContext->cur_frame_info= frame_type;
}
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Upgrade_Sequence(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
PHNFC_UNUSED_VARIABLE(pdata);
PHNFC_UNUSED_VARIABLE(length);
if(phDnld_Raw_Upgrade == psDnldContext->cur_dnld_seq)
{
status = phDnldNfc_Raw_Write( psDnldContext, pHwRef );
}
else
{
status = phDnldNfc_Resume_Write( psDnldContext, pHwRef );
}
return status;
}
static
NFCSTATUS
phDnldNfc_Resume(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_eState_t dnld_next_state = (phDnldNfc_eState_t)
psDnldContext->cur_dnld_state;
phNfc_sCompletionInfo_t comp_info = {0};
switch( dnld_next_state )
{
case phDnld_Reset_State:
{
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_RESET , NULL, 0 );
switch( psDnldContext->cur_dnld_seq )
{
case phDnld_Update_Patchtable:
{
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Unlock_State;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Unlock_System;
break;
}
#ifdef NXP_FW_PATCH_DISABLE
case phDnld_Deactivate_Patch:
#else
case phDnld_Unlock_System:
#endif
{
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Upgrade_State;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Upgrade_Section;
#ifdef NXP_FW_DNLD_CHECK_PHASE
gphDnldPhase = NXP_FW_DNLD_CFG_PHASE;
#endif /* NXP_FW_DNLD_CHECK_PHASE */
break;
}
case phDnld_Lock_System:
{
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Verify_State;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Verify_Integrity;
#else
/* (void ) memset( (void *) &psDnldContext->chk_integrity_crc,
0, sizeof(psDnldContext->chk_integrity_crc)); */
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Complete_State;
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
break;
}
case phDnld_Verify_Integrity:
{
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Complete_State;
break;
}
default:
{
status = (NFCSTATUS_PENDING == status)?
NFCSTATUS_SUCCESS: status;
break;
}
}
break;
}
case phDnld_Unlock_State:
{
status = phDnldNfc_Sequence( psDnldContext, pHwRef,
pdata, length);
break;
}
case phDnld_Upgrade_State:
{
status = phDnldNfc_Upgrade_Sequence( psDnldContext, pHwRef,
pdata, length);
if ((NFCSTATUS_SUCCESS == status )
&& (phDnld_Complete_State == psDnldContext->next_dnld_state))
{
#if 0
psDnldContext->cur_dnld_seq =
(uint8_t)phDnld_Lock_System;
psDnldContext->next_dnld_seq =
psDnldContext->cur_dnld_seq;
#endif
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
psDnldContext->next_dnld_state =
(uint8_t)phDnld_Verify_State;
psDnldContext->next_dnld_seq =
(uint8_t)phDnld_Verify_Integrity;
psDnldContext->cur_dnld_seq =
psDnldContext->next_dnld_seq;
status = phDnldNfc_Sequence( psDnldContext,
pHwRef, pdata, length);
#else
/* (void ) memset( (void *) &psDnldContext->chk_integrity_crc,
0, sizeof(psDnldContext->chk_integrity_crc)); */
psDnldContext->next_dnld_state =
(uint8_t) phDnld_Complete_State;
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
}
break;
}
case phDnld_Verify_State:
{
status = phDnldNfc_Sequence( psDnldContext,
pHwRef, pdata, length);
break;
}
case phDnld_Complete_State:
{
uint8_t integrity_chk = 0xA5;
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
uint8_t verify_crc = 0x96;
if ( (NULL != psDnldContext->p_flash_code_crc)
&& (NULL != psDnldContext->p_patch_code_crc)
&& (NULL != psDnldContext->p_patch_table_crc)
)
{
uint8_t crc_i = 0;
uint16_t patch_table_crc = 0;
uint32_t flash_code_crc = 0;
uint32_t patch_code_crc = 0;
for (crc_i = 0; crc_i < DNLD_CRC32_SIZE; crc_i++ )
{
if (crc_i < DNLD_CRC16_SIZE )
{
patch_table_crc = patch_table_crc
| psDnldContext->chk_integrity_crc.patch_table.Chk_Crc16[crc_i]
<< (crc_i * BYTE_SIZE) ;
}
flash_code_crc = flash_code_crc
| psDnldContext->chk_integrity_crc.flash_code.Chk_Crc32[crc_i]
<< (crc_i * BYTE_SIZE) ;
patch_code_crc = patch_code_crc
| psDnldContext->chk_integrity_crc.patch_code.Chk_Crc32[crc_i]
<< (crc_i * BYTE_SIZE) ;
}
verify_crc =(uint8_t)( (*((uint32_t *) psDnldContext->p_flash_code_crc)) !=
flash_code_crc );
verify_crc |=(uint8_t)( (*((uint32_t *) psDnldContext->p_patch_code_crc)) !=
patch_code_crc );
verify_crc |=(uint8_t)( (*((uint16_t *) psDnldContext->p_patch_table_crc)) !=
patch_table_crc );
}
else
{
DNLD_PRINT(" FW_DNLD: Flash, Patch code and Patch Table CRC ");
DNLD_PRINT(" Not Available in the Firmware \n");
}
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
integrity_chk = psDnldContext->chk_integrity_crc.config_page.Chk_status +
psDnldContext->chk_integrity_crc.patch_table.Chk_status +
psDnldContext->chk_integrity_crc.flash_code.Chk_status +
psDnldContext->chk_integrity_crc.patch_code.Chk_status;
if ( ( 0 != integrity_chk )
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
|| ( 0 != verify_crc )
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
)
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED);
}
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED);
break;
}
}
if (NFCSTATUS_PENDING == status)
{
/* Write/Receive is still pending */
}
else
{
pphNfcIF_Notification_CB_t p_upper_notify =
psDnldContext->p_upper_notify;
void *p_upper_context =
psDnldContext->p_upper_context;
DNLD_DEBUG(" FW_DNLD: Resume Termination Status = %X \n", status);
comp_info.status = status;
(void) phDal4Nfc_Unregister(
psDnldContext->lower_interface.pcontext, pHwRef);
phDnldNfc_Release_Lower(psDnldContext, pHwRef);
phDnldNfc_Release_Resources(&psDnldContext);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
/* Notify the Error/Success Scenario to the upper layer */
phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, (uint8_t)
((NFCSTATUS_SUCCESS == comp_info.status )? NFC_IO_SUCCESS: NFC_IO_ERROR),
&comp_info );
}
return status;
}
STATIC
NFCSTATUS
phDnldNfc_Process_Response(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
void *pdata,
uint16_t length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
phDnldNfc_sData_Hdr_t *resp_data =
(phDnldNfc_sData_Hdr_t *) pdata;
PHNFC_UNUSED_VARIABLE(pHwRef);
DNLD_DEBUG(" FW_DNLD: Receive Length = %X \n", length );
if(( psDnldContext->rx_info.rx_total == 0 )
&& (PHDNLD_MIN_PACKET <= length)
)
{
psDnldContext->rx_info.rx_total =
((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)|
resp_data->frame_length[1];
if( psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET == length )
{
DNLD_DEBUG(" FW_DNLD: Success Memory Read = %X \n",
psDnldContext->rx_info.rx_total);
#ifndef DNLD_SUMMARY
/* DNLD_PRINT_BUFFER("Receive Buffer",pdata,length); */
#endif
}
else
{
/* status = phDnldNfc_Receive( psDnldContext, pHwRef,
psDnldContext->p_resp_buffer,
(uint8_t)((psDnldContext->rx_info.rx_total <= PHDNLD_MAX_PACKET)?
psDnldContext->rx_info.rx_total: PHDNLD_MAX_PACKET) ); */
DNLD_PRINT(" FW_DNLD: Invalid Receive length ");
DNLD_DEBUG(": Length Expected = %X \n",
(psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET));
status = PHNFCSTVAL( CID_NFC_DNLD,
NFCSTATUS_INVALID_RECEIVE_LENGTH );
}
}
else
{
/*TODO:*/
psDnldContext->rx_info.rx_total = 0 ;
status = PHNFCSTVAL( CID_NFC_DNLD,
NFCSTATUS_INVALID_RECEIVE_LENGTH );
}
return status;
}
STATIC
void
phDnldNfc_Receive_Complete (
void *psContext,
void *pHwRef,
phNfc_sTransactionInfo_t *pInfo
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS ;
void *pdata = NULL ;
phDnldNfc_sData_Hdr_t *resp_data = NULL;
uint16_t length = 0 ;
phNfc_sCompletionInfo_t comp_info = {0};
DNLD_PRINT("\n FW_DNLD: Receive Response .... ");
if ( (NULL != psContext)
&& (NULL != pInfo)
&& (NULL != pHwRef)
)
{
phDnldNfc_sContext_t *psDnldContext =
(phDnldNfc_sContext_t *)psContext;
status = pInfo->status ;
length = pInfo->length ;
pdata = pInfo->buffer;
if(status != NFCSTATUS_SUCCESS)
{
DNLD_DEBUG(" Failed. Status = %02X\n",status);
/* Handle the Error Scenario */
}
else if (NULL == pdata)
{
DNLD_DEBUG(" Failed. No data received. pdata = %02X\n",pdata);
/* Handle the Error Scenario */
status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_FAILED );
}
else if ((0 == length)
|| (PHDNLD_MIN_PACKET > length ))
{
DNLD_DEBUG(" Receive Response Length = %u .... \n",length);
/* Handle the Error Scenario */
#ifndef HAL_SW_DNLD_RLEN
status = PHNFCSTVAL( CID_NFC_DNLD,
NFCSTATUS_INVALID_RECEIVE_LENGTH );
#endif
}
else
{
#if defined(FW_DOWNLOAD_TIMER) && \
(FW_DOWNLOAD_TIMER == 2)
if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
{
phOsalNfc_Timer_Stop( psDnldContext->timer_id );
}
#endif
#ifndef DNLD_SUMMARY
DNLD_PRINT_BUFFER("Receive Buffer",pdata,length);
#endif
DNLD_DEBUG(" Receive Response Length = %X. \n", length);
resp_data = (phDnldNfc_sData_Hdr_t *) pdata;
switch(resp_data->frame_type)
{
case PHDNLD_RESP_SUCCESS:
{
uint16_t resp_length =
((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)|
resp_data->frame_length[1];
switch ( psDnldContext->prev_cmd )
{
case PHDNLD_CMD_READ :
{
if( PHDNLD_NO_OPERATION
== psDnldContext->raw_mode_upgrade)
{
status = phDnldNfc_Process_Response(
psDnldContext, pHwRef, pdata , length);
if (NFCSTATUS_SUCCESS != status)
{
/* psDnldContext->dnld_retry++; */
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
/* psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY */
}
}
else
{
}
break;
}
case PHDNLD_CMD_CHECK_INTEGRITY :
{
if( PHDNLD_NO_OPERATION
== psDnldContext->raw_mode_upgrade)
{
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
phDnldNfc_sChkCrcComplete_t *p_dnld_crc_all =
&psDnldContext->chk_integrity_crc;
switch(psDnldContext->chk_integrity_param)
{
case CHK_INTEGRITY_CONFIG_PAGE_CRC:
{
(void)memcpy(&p_dnld_crc_all->config_page,
(((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
break;
}
case CHK_INTEGRITY_PATCH_TABLE_CRC:
{
(void)memcpy(&p_dnld_crc_all->patch_table,
(((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
break;
}
case CHK_INTEGRITY_FLASH_CODE_CRC:
{
(void)memcpy(&p_dnld_crc_all->flash_code,
(((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
break;
}
case CHK_INTEGRITY_PATCH_CODE_CRC:
{
(void)memcpy(&p_dnld_crc_all->patch_code,
(((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
break;
}
case CHK_INTEGRITY_COMPLETE_CRC:
{
(void)memcpy(p_dnld_crc_all,
(((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
DNLD_DEBUG(" FW_DNLD: Check Integrity Complete Structure Size = %X \n",
sizeof(psDnldContext->chk_integrity_crc));
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_FEATURE_NOT_SUPPORTED);
break;
}
}
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
}
else
{
psDnldContext->raw_mode_upgrade =
(PHDNLD_SETUP_OPERATION | PHDNLD_ADVANCED_OPERATION);
/* psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade &
( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); */
}
break;
}
case PHDNLD_CMD_WRITE:
{
psDnldContext->dnld_retry = 0;
break;
}
case PHDNLD_CMD_SEC_WRITE:
{
psDnldContext->dnld_retry = 0;
break;
}
case PHDNLD_CMD_ACTIVATE_PATCH:
case PHDNLD_CMD_CHECK:
default:
{
if( PHDNLD_NO_OPERATION
== psDnldContext->raw_mode_upgrade)
{
if( ( (PHDNLD_MIN_PACKET > length)
|| ( 0 != resp_length) )
)
{
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
status = PHNFCSTVAL( CID_NFC_DNLD,
NFCSTATUS_INVALID_RECEIVE_LENGTH );
}
else
{
psDnldContext->dnld_retry = 0;
}
}
else
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade & ~PHDNLD_RECOVER_OPERATION);
}
break;
}
} /* End of the Previous Command Switch Case */
break;
}/* Case PHDNLD_RESP_SUCCESS*/
case PHDNLD_RESP_TIMEOUT:
case PHDNLD_RESP_CRC_ERROR:
case PHDNLD_RESP_WRITE_ERROR:
{
if(psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY )
{
psDnldContext->dnld_retry++;
}
status = PHNFCSTVAL(CID_NFC_DNLD,
resp_data->frame_type);
break;
}
/* fall through */
case PHDNLD_RESP_ACCESS_DENIED:
case PHDNLD_RESP_INVALID_PARAMETER:
case PHDNLD_RESP_INVALID_LENGTH:
/* Initial Frame Checksum */
case PHDNLD_RESP_CHKSUM_ERROR:
case PHDNLD_RESP_MEMORY_UPDATE_ERROR:
{
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
status = PHNFCSTVAL(CID_NFC_DNLD,
resp_data->frame_type);
break;
}
case PHDNLD_RESP_PROTOCOL_ERROR:
{
if(( PHDNLD_NO_OPERATION
== psDnldContext->raw_mode_upgrade)
|| ( PHDNLD_ADVANCED_OPERATION
== psDnldContext->raw_mode_upgrade)
)
{
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_INVALID_FORMAT);
}
else if( (PHDNLD_NORMAL_OPERATION
& psDnldContext->raw_mode_upgrade)
)
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION);
}
else if ( PHDNLD_RECOVER_OPERATION
& psDnldContext->raw_mode_upgrade )
{
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_INVALID_FORMAT);
}
else
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade &
~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
}
break;
}
case PHDNLD_RESP_VERSION_UPTODATE:
{
/* TODO: to make sure that the Advance Frames are sent to get
* the updated status */
if ( PHDNLD_ADVANCED_OPERATION
== psDnldContext->raw_mode_upgrade)
{
status = ( CID_NFC_DNLD << BYTE_SIZE ) ;
}
else if ( PHDNLD_NO_OPERATION
!= psDnldContext->raw_mode_upgrade)
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade &
~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
}
else
{
}
break;
}
case PHDNLD_RESP_CMD_NOT_SUPPORTED:
{
if ( PHDNLD_NO_OPERATION
== psDnldContext->raw_mode_upgrade)
{
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
else if ( PHDNLD_ADVANCED_OPERATION
== psDnldContext->raw_mode_upgrade)
{
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_FEATURE_NOT_SUPPORTED);
}
#if 0
else if( (PHDNLD_NORMAL_OPERATION
& psDnldContext->raw_mode_upgrade)
)
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION);
}
else if ( PHDNLD_SETUP_OPERATION
& psDnldContext->raw_mode_upgrade )
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade & ~PHDNLD_SETUP_OPERATION);
}
#endif
else
{
psDnldContext->raw_mode_upgrade =
(psDnldContext->raw_mode_upgrade &
~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
}
break;
}
/* The Chaining of the Command Frame
was Successful in the Download Mode */
case PHDNLD_RESP_CHAINING_SUCCESS:
{
/* TODO: Handle the Corner Case Scenarios
* the updated status */
psDnldContext->dnld_retry = 0x00;
break;
}
/* The Error during the Chaining the Command Frame in the Download Mode */
case PHDNLD_RESP_CHAINING_ERROR:
{
/* TODO: Restart the Chunk in Corner Case
* the updated status */
psDnldContext->dnld_retry++;
phDnldNfc_Tx_Reset(psDnldContext);
break;
}
/* The Command is not allowed anymore in the Download Mode */
case PHDNLD_RESP_CMD_NOT_ALLOWED:
default:
{
psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_NOT_ALLOWED);
break;
}
} /* End of the Response Frame Type Switch */
if (NFCSTATUS_PENDING != status)
{
if ((NFCSTATUS_SUCCESS != status) &&
(psDnldContext->dnld_retry >= NXP_MAX_DNLD_RETRY))
{
pphNfcIF_Notification_CB_t p_upper_notify =
psDnldContext->p_upper_notify;
void *p_upper_context =
psDnldContext->p_upper_context;
comp_info.status = status;
DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
status = phDal4Nfc_Unregister(
psDnldContext->lower_interface.pcontext, pHwRef);
phDnldNfc_Release_Lower(psDnldContext, pHwRef);
phDnldNfc_Release_Resources(&psDnldContext);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
/* Notify the Error/Success Scenario to the upper layer */
phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
(uint8_t) NFC_IO_ERROR, &comp_info );
}
else if ( (NFCSTATUS_SUCCESS != status) &&
(NFCSTATUS_SUCCESS == PHNFCSTATUS(status))
)
{
pphNfcIF_Notification_CB_t p_upper_notify =
psDnldContext->p_upper_notify;
void *p_upper_context =
psDnldContext->p_upper_context;
comp_info.status = NFCSTATUS_SUCCESS;
DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
status = phDal4Nfc_Unregister(
psDnldContext->lower_interface.pcontext, pHwRef);
phDnldNfc_Release_Lower(psDnldContext, pHwRef);
phDnldNfc_Release_Resources(&psDnldContext);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
/* Notify the Error/Success Scenario to the upper layer */
phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
(uint8_t) NFC_IO_SUCCESS, &comp_info );
}
else if (NFCSTATUS_FEATURE_NOT_SUPPORTED == PHNFCSTATUS(status))
{
pphNfcIF_Notification_CB_t p_upper_notify =
psDnldContext->p_upper_notify;
void *p_upper_context =
psDnldContext->p_upper_context;
comp_info.status = status;
DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
status = phDal4Nfc_Unregister(
psDnldContext->lower_interface.pcontext, pHwRef);
phDnldNfc_Release_Lower(psDnldContext, pHwRef);
phDnldNfc_Release_Resources(&psDnldContext);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
/* Notify the Error/Success Scenario to the upper layer */
phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
(uint8_t) NFC_IO_SUCCESS, &comp_info );
}
else
{
/* DNLD_PRINT(" FW_DNLD: Successful.\n"); */
psDnldContext->resp_length = /* PHDNLD_MIN_PACKET */ 0 ;
status = phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_UPDATE);
status = phDnldNfc_Resume( psDnldContext,
pHwRef, pdata, length );
}
}
} /* End of status != Success */
}
}
STATIC
void
phDnldNfc_Send_Complete (
void *psContext,
void *pHwRef,
phNfc_sTransactionInfo_t *pInfo
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS ;
uint16_t length = 0;
DNLD_PRINT(" FW_DNLD: Send Data .... ");
if ( (NULL != psContext)
&& (NULL != pInfo)
&& (NULL != pHwRef)
)
{
phDnldNfc_sContext_t *psDnldContext =
(phDnldNfc_sContext_t *)psContext;
status = pInfo->status ;
length = pInfo->length ;
if(status != NFCSTATUS_SUCCESS)
{
DNLD_DEBUG(" Failed. Status = %02X\n",status);
/* Handle the Error Scenario */
}
else
{
DNLD_PRINT(" Successful.\n");
(void)memset((void *)&psDnldContext->dnld_data, 0,
sizeof(psDnldContext->dnld_data));
if ((PHDNLD_CMD_SET_HIF != psDnldContext->prev_cmd)
&& (PHDNLD_CMD_RESET != psDnldContext->prev_cmd))
{
psDnldContext->rx_info.rx_total = 0;
status = phDnldNfc_Receive( psDnldContext, pHwRef,
(uint8_t *)(&psDnldContext->dnld_resp),
psDnldContext->resp_length);
}
else
{
psDnldContext->resp_length = 0;
psDnldContext->dnld_retry = 0;
if( PHDNLD_CMD_RESET == psDnldContext->prev_cmd )
{
DO_DELAY(PHDNLD_DNLD_DELAY);
}
#if defined(FW_DOWNLOAD_TIMER) && \
(FW_DOWNLOAD_TIMER == 2)
if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
{
phOsalNfc_Timer_Stop( psDnldContext->timer_id );
}
#endif
status = phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_UPDATE);
}
if(NFCSTATUS_SUCCESS == status )
{
status = phDnldNfc_Resume( psDnldContext, pHwRef, NULL, length);
}
} /* End of status != Success */
} /* End of Context != NULL */
}
STATIC
NFCSTATUS
phDnldNfc_Send_Command(
phDnldNfc_sContext_t *psDnldContext,
void *pHwRef,
uint8_t cmd,
void *params,
uint16_t param_length
)
{
NFCSTATUS status = NFCSTATUS_SUCCESS;
uint16_t tx_length = 0;
uint16_t rx_length = 0;
uint8_t **pp_resp_data = &psDnldContext->p_resp_buffer;
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
switch(cmd)
{
case PHDNLD_CMD_RESET:
{
(void)memset((void *)&psDnldContext->dnld_data, 0,
sizeof(psDnldContext->dnld_data));
break;
}
case PHDNLD_CMD_READ:
{
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */
&p_dnld_data->param_info.data_param;
tx_length = PHDNLD_CMD_READ_LEN;
if (NULL != *pp_resp_data)
{
phOsalNfc_FreeMemory(*pp_resp_data);
*pp_resp_data = NULL;
}
rx_length = (uint16_t) (((uint16_t)param_info->data_len[0]
<< BYTE_SIZE) + param_info->data_len[1]);
psDnldContext->resp_length =
(( rx_length + PHDNLD_MIN_PACKET ));
(void)phDnldNfc_Allocate_Resource( (void **) pp_resp_data,
rx_length);
break;
}
case PHDNLD_CMD_WRITE:
case PHDNLD_CMD_SEC_WRITE:
{
phDnldNfc_sData_t *p_dnld_data =
(phDnldNfc_sData_t *)psDnldContext->dnld_data;
phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */
&p_dnld_data->param_info.data_param;
tx_length = (uint16_t) (((uint16_t)param_info->data_len[0]
<< BYTE_SIZE) + param_info->data_len[1]
+ PHDNLD_CMD_WRITE_MIN_LEN );
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
if ((0 != param_length) && (NULL != params))
{
(void)memcpy(param_info->data_packet, params, param_length);
}
break;
}
case PHDNLD_CMD_CHECK:
{
tx_length = PHDNLD_CMD_CHECK_LEN;
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_ENCAPSULATE:
{
uint8_t i = 0x00;
if ((0 != param_length) && (NULL != params))
{
p_dnld_data->frame_type =
PHDNLD_CMD_ENCAPSULATE;
(void)memcpy((void *)( ((uint8_t *)p_dnld_data)
+ PHDNLD_FRAME_DATA_OFFSET)
, params, param_length);
tx_length = param_length;
p_dnld_data->frame_length[i++] =
(uint8_t)(tx_length >> BYTE_SIZE);
p_dnld_data->frame_length[i] =
(uint8_t)( tx_length & BYTE_MASK );
tx_length += PHDNLD_FRAME_DATA_OFFSET;
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
status = phDnldNfc_Send( psDnldContext, pHwRef ,
(uint8_t *)p_dnld_data, tx_length);
}
else
{
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_NOT_ALLOWED);
}
break;
}
case PHDNLD_CMD_SET_HIF:
{
tx_length++;
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
break;
}
case PHDNLD_CMD_ACTIVATE_PATCH:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET;
if ((NULL != params) && ( param_length > 0 ))
{
p_dnld_data->param_info.cmd_param =
(*(uint8_t *)params);
tx_length = param_length;
}
else
{
p_dnld_data->param_info.cmd_param = FALSE;
tx_length++;
}
break;
}
case PHDNLD_CMD_CHECK_INTEGRITY:
{
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
if ((NULL != params) && ( param_length > 0 ))
{
psDnldContext->chk_integrity_param =
(phDnldNfc_eChkCrc_t)(*(uint8_t *)params);
tx_length = param_length ;
}
else
{
psDnldContext->chk_integrity_param = CHK_INTEGRITY_COMPLETE_CRC;
tx_length++;
}
p_dnld_data->param_info.cmd_param =
(uint8_t) psDnldContext->chk_integrity_param;
switch(psDnldContext->chk_integrity_param)
{
case CHK_INTEGRITY_CONFIG_PAGE_CRC:
case CHK_INTEGRITY_PATCH_TABLE_CRC:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_CRC16_LEN;
break;
}
case CHK_INTEGRITY_FLASH_CODE_CRC:
case CHK_INTEGRITY_PATCH_CODE_CRC:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_CRC32_LEN;
break;
}
case CHK_INTEGRITY_COMPLETE_CRC:
default:
{
psDnldContext->resp_length = PHDNLD_MIN_PACKET
+ CHECK_INTEGRITY_RESP_COMP_LEN;
break;
}
}
#else
tx_length++;
p_dnld_data->param_info.cmd_param =
(uint8_t) CHK_INTEGRITY_COMPLETE_CRC;
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
break;
}
default:
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED);
break;
}
}
if (NFCSTATUS_SUCCESS == status)
{
uint8_t i = 0;
p_dnld_data->frame_type = cmd;
p_dnld_data->frame_length[i++] =
(uint8_t)(tx_length >> BYTE_SIZE);
p_dnld_data->frame_length[i] =
(uint8_t)( tx_length & BYTE_MASK );
tx_length = tx_length + PHDNLD_MIN_PACKET;
status = phDnldNfc_Send( psDnldContext, pHwRef ,
(uint8_t *)p_dnld_data, tx_length);
if(NFCSTATUS_PENDING == status)
{
psDnldContext->prev_cmd = cmd;
}
}
return status;
}
static
NFCSTATUS
phDnldNfc_Check_FW(
phHal_sHwReference_t *pHwRef,
fw_data_hdr_t *cur_fw_hdr
)
{
NFCSTATUS status = NFCSTATUS_FAILED;
if ( !pHwRef->device_info.fw_version )
{
/* Override the Firmware Version Check and upgrade*/;
DNLD_PRINT(" FW_DNLD_CHK: Forceful Upgrade of the Firmware .... Required \n");
status = NFCSTATUS_SUCCESS;
}
else if ( (pHwRef->device_info.fw_version >> (BYTE_SIZE * 2))
!= ( cur_fw_hdr->fw_version >> (BYTE_SIZE * 2) ))
{
/* Check for the Compatible Romlib Version for the Hardware */
DNLD_PRINT(" FW_DNLD: IC Hardware Version Mismatch.. \n");
status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED );
}
else if (( pHwRef->device_info.fw_version < cur_fw_hdr->fw_version )
)
{
/* TODO: Firmware Version Check and upgrade*/
DNLD_PRINT(" FW_DNLD: Older Firmware Upgrading to newerone.... \n");
status = NFCSTATUS_SUCCESS;
}
#ifdef NXP_FW_CHK_LATEST
else if (( pHwRef->device_info.fw_version > cur_fw_hdr->fw_version )
)
{
DNLD_PRINT(" FW_DNLD: Newer than the Stored One .... \n");
status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED );
}
#endif /* NXP_FW_CHK_LATEST */
else
{
DNLD_PRINT(" FW_DNLD: Already Updated .... \n");
status = ( CID_NFC_DNLD << BYTE_SIZE ) ;
}
return status;
}
static
NFCSTATUS
phDnldNfc_Process_FW(
phDnldNfc_sContext_t *psDnldContext,
phHal_sHwReference_t *pHwRef
#ifdef NXP_FW_PARAM
,uint8_t *nxp_nfc_fw
,uint32_t nxp_fw_len
#endif
)
{
NFCSTATUS status = NFCSTATUS_FAILED;
section_info_t *p_cur_sec = NULL;
static unsigned sec_type;
uint32_t fw_index = 0;
#ifdef NXP_NFC_MULTIPLE_FW
phDnldNfc_sFwImageInfo_t *p_cur_fw = NULL;
#endif /* #ifdef NXP_NFC_MULTIPLE_FW */
fw_data_hdr_t *cur_fw_hdr = NULL;
uint8_t sec_index = 0;
uint8_t i = 0;
psDnldContext->p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw;
#ifdef NXP_NFC_MULTIPLE_FW
/* TODO: Create a memory of pointers to store all the Firmwares */
if( (NXP_NFC_IMAG_FW_MAX > psDnldContext->p_img_hdr->no_of_fw_img)
&& (0 != psDnldContext->p_img_hdr->no_of_fw_img)
)
{
( void )phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_img_info,
(psDnldContext->p_img_hdr->no_of_fw_img * sizeof(phDnldNfc_sFwImageInfo_t)));
if(NULL != psDnldContext->p_img_info)
{
p_cur_fw = psDnldContext->p_img_info;
}
}
#endif /* #ifdef NXP_NFC_MULTIPLE_FW */
fw_index = sizeof (img_data_hdr_t);
for ( i=0; i < psDnldContext->p_img_hdr->no_of_fw_img; i++ )
{
psDnldContext->p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index );
#ifdef NXP_NFC_MULTIPLE_FW
if(NULL != p_cur_fw)
{
( p_cur_fw + i)->p_fw_hdr = psDnldContext->p_fw_hdr;
}
#endif /* #ifdef NXP_NFC_MULTIPLE_FW */
cur_fw_hdr = psDnldContext->p_fw_hdr;
fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN);
status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr);
}
if ( ( NFCSTATUS_SUCCESS == status )
#if defined (NXP_FW_INTEGRITY_VERIFY)
|| (NFCSTATUS_SUCCESS == PHNFCSTATUS(status) )
#endif /* !defined (NXP_FW_INTEGRITY_VERIFY) */
)
{
if( (BYTE_MASK > cur_fw_hdr->no_of_sections)
&& (0 != cur_fw_hdr->no_of_sections)
)
{
(void) phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_fw_sec,
(cur_fw_hdr->no_of_sections * sizeof(section_info_t)));
if(NULL != psDnldContext->p_fw_sec)
{
DNLD_DEBUG(" FW_DNLD: FW Index : %x \n",
fw_index );
DNLD_DEBUG(" FW_DNLD: No of Sections : %x \n\n",
cur_fw_hdr->no_of_sections);
for(sec_index = 0; sec_index
< cur_fw_hdr->no_of_sections; sec_index++ )
{
p_cur_sec = ((section_info_t *)
(psDnldContext->p_fw_sec + sec_index ));
p_cur_sec->p_sec_hdr = (section_hdr_t *)
(nxp_nfc_fw + fw_index);
DNLD_DEBUG(" FW_DNLD: Section %x \n", sec_index);
DNLD_DEBUG(" FW_DNLD: Section Header Len : %x ",
p_cur_sec->p_sec_hdr->section_hdr_len);
DNLD_DEBUG(" Section Address : %x ",
p_cur_sec->p_sec_hdr->section_address);
DNLD_DEBUG(" Section Length : %x ",
p_cur_sec->p_sec_hdr->section_length);
DNLD_DEBUG(" Section Memory Type : %x \n",
p_cur_sec->p_sec_hdr->section_mem_type);
sec_type = (unsigned int)p_cur_sec->p_sec_hdr->section_mem_type;
if((sec_type & DNLD_TRIM_MASK))
{
p_cur_sec->p_trim_data = (uint8_t *)
(nxp_nfc_fw + fw_index + sizeof(section_hdr_t));
}
else
{
p_cur_sec->p_trim_data = NULL;
}
if (0 == sec_index)
{
if ((sec_type & DNLD_SM_UNLOCK_MASK))
{
(void)phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_UNLOCK);
}
else
{
(void)phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_INIT);
}
}
p_cur_sec->section_read = FALSE;
p_cur_sec->section_offset = 0;
p_cur_sec->p_sec_data = ((uint8_t *) nxp_nfc_fw) + fw_index +
(p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN);
fw_index = fw_index +
(p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN)
+ p_cur_sec->p_sec_hdr->section_length;
if( 0 != p_cur_sec->p_sec_hdr->section_checksum )
{
DNLD_DEBUG(" FW_DNLD: Section checksum : %x \n",
p_cur_sec->p_sec_hdr->section_checksum );
p_cur_sec->p_sec_chksum = ( uint8_t *)(nxp_nfc_fw + fw_index);
fw_index = fw_index +
p_cur_sec->p_sec_hdr->section_checksum;
}
DNLD_DEBUG(" FW_DNLD: FW Index : %x \n", fw_index );
#if (NXP_FW_INTEGRITY_CHK >= 0x01)
switch( p_cur_sec->p_sec_hdr->section_address )
{
case DNLD_FW_CODE_ADDR:
{
psDnldContext->p_flash_code_crc =
p_cur_sec->p_sec_data
+ p_cur_sec->p_sec_hdr->section_length
- DNLD_CRC32_SIZE;
break;
}
case DNLD_PATCH_CODE_ADDR:
{
psDnldContext->p_patch_code_crc =
p_cur_sec->p_sec_data
+ p_cur_sec->p_sec_hdr->section_length
- DNLD_CRC32_SIZE;
break;
}
case DNLD_PATCH_TABLE_ADDR:
{
psDnldContext->p_patch_table_crc =
p_cur_sec->p_sec_data
+ p_cur_sec->p_sec_hdr->section_length
- DNLD_CRC16_SIZE;
break;
}
default:
{
break;
}
} /* End of Address Switch */
#endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
} /* End of For Loop */
} /* End of the Null Check */
else
{
status = PHNFCSTVAL(CID_NFC_DNLD,
NFCSTATUS_INSUFFICIENT_RESOURCES);
}
}
else if (
(0 == cur_fw_hdr->no_of_sections)
&& (PHDNLD_FW_PATCH_SEC == cur_fw_hdr->fw_patch)
)
{
psDnldContext->p_fw_raw = (uint8_t *)(nxp_nfc_fw + fw_index);
psDnldContext->raw_mode_upgrade = PHDNLD_COMPLETE_OPERATION;
(void)phDnldNfc_Set_Seq(psDnldContext,
DNLD_SEQ_RAW);
}
else
{
DNLD_PRINT("********* Empty Section and Firmware ******************\n\n");
}
DNLD_PRINT("*******************************************\n\n");
}
return status;
}
#if !defined (NXP_FW_INTEGRITY_VERIFY)
NFCSTATUS
phDnldNfc_Run_Check(
phHal_sHwReference_t *pHwRef
#ifdef NXP_FW_PARAM
,uint8_t *nxp_nfc_fw
uint32_t fw_length
#endif
)
{
NFCSTATUS status = NFCSTATUS_FAILED;
uint32_t fw_index = 0;
img_data_hdr_t *p_img_hdr = NULL;
fw_data_hdr_t *p_fw_hdr = NULL;
fw_data_hdr_t *cur_fw_hdr = NULL;
uint8_t i = 0;
p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw;
fw_index = sizeof (img_data_hdr_t);
for ( i=0; i < p_img_hdr->no_of_fw_img; i++ )
{
p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index );
/* TODO: Create a memory of pointers to store all the Firmwares */
cur_fw_hdr = p_fw_hdr;
fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN);
status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr);
}
return status;
}
#endif /* #if !defined (NXP_FW_INTEGRITY_VERIFY) */
STATIC
void
phDnldNfc_Abort (
uint32_t abort_id
#ifdef NFC_TIMER_CONTEXT
, void *dnld_cntxt
#endif
)
{
phNfc_sCompletionInfo_t comp_info = {0};
phDnldNfc_sContext_t *p_dnld_context = NULL;
#ifdef NFC_TIMER_CONTEXT
p_dnld_context = (phDnldNfc_sContext_t *)dnld_cntxt;
#else
p_dnld_context = gpphDnldContext;
#endif
if ( ( NULL != p_dnld_context)
&& (abort_id == p_dnld_context->timer_id ))
{
pphNfcIF_Notification_CB_t p_upper_notify =
p_dnld_context->p_upper_notify;
void *p_upper_context =
p_dnld_context->p_upper_context;
phHal_sHwReference_t *pHwRef = p_dnld_context->p_hw_ref;
(void)phDal4Nfc_Unregister(
p_dnld_context->lower_interface.pcontext, pHwRef );
phDnldNfc_Release_Lower(p_dnld_context, pHwRef);
phDnldNfc_Release_Resources(&p_dnld_context);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = p_dnld_context;
#endif
/* Notify the Error/Success Scenario to the upper layer */
DNLD_DEBUG(" FW_DNLD: FW_DNLD Aborted with %x Timer Timeout \n",
abort_id);
comp_info.status = NFCSTATUS_FAILED ;
phDnldNfc_Notify( p_upper_notify, p_upper_context,
pHwRef, (uint8_t) NFC_IO_ERROR, &comp_info );
}
return ;
}
NFCSTATUS
phDnldNfc_Upgrade (
phHal_sHwReference_t *pHwRef,
#ifdef NXP_FW_PARAM
uint8_t type,
uint8_t *nxp_nfc_fw,
uint32_t fw_length,
#endif
pphNfcIF_Notification_CB_t upgrade_complete,
void *context
)
{
phDnldNfc_sContext_t *psDnldContext = NULL;
phNfcIF_sReference_t dnldReference = { NULL };
phNfcIF_sCallBack_t if_callback = { NULL, NULL, NULL, NULL };
phNfc_sLowerIF_t *plower_if = NULL;
NFCSTATUS status = NFCSTATUS_SUCCESS;
section_info_t *p_cur_sec = NULL;
unsigned sec_type = 0;
if( (NULL == pHwRef)
)
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
}
else
{
DNLD_PRINT(" FW_DNLD: Starting the FW Upgrade Sequence .... \n");
(void)
phDnldNfc_Allocate_Resource((void **)
&psDnldContext,sizeof(phDnldNfc_sContext_t));
if(psDnldContext != NULL)
{
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
psDnldContext->p_hw_ref = pHwRef;
psDnldContext->timer_id = NXP_INVALID_TIMER_ID;
DNLD_PRINT(" FW_DNLD: Initialisation in Progress.... \n");
if_callback.pif_ctxt = psDnldContext ;
if_callback.send_complete = &phDnldNfc_Send_Complete;
if_callback.receive_complete= &phDnldNfc_Receive_Complete;
/* if_callback.notify = &phDnldNfc_Notify_Event; */
plower_if = dnldReference.plower_if = &(psDnldContext->lower_interface);
status = phDal4Nfc_Register(&dnldReference, if_callback,
NULL);
DNLD_DEBUG(" FW_DNLD: Lower Layer Register, Status = %02X\n",status);
if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init))
{
/* psDnldContext->p_config_params = pHwConfig ; */
status = plower_if->init((void *)plower_if->pcontext,
(void *)pHwRef);
DNLD_DEBUG(" FW_DNLD: Lower Layer Initialisation, Status = %02X\n",status);
}
else
{
/* TODO: Handle Initialisation in the Invalid State */
}
/* The Lower layer Initialisation successful */
if (NFCSTATUS_SUCCESS == status)
{
psDnldContext->p_upper_notify = upgrade_complete;
psDnldContext->p_upper_context = context;
status = phDnldNfc_Process_FW( psDnldContext, pHwRef
#ifdef NXP_FW_PARAM
,*nxp_nfc_fw , fw_length
#endif
);
if (NFCSTATUS_SUCCESS == status)
{
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_RESET , NULL , 0 );
if (NFCSTATUS_PENDING == status)
{
DNLD_PRINT("\n FW_DNLD: Initial Reset .... \n");
#if defined(FW_DOWNLOAD_TIMER)
psDnldContext->timer_id = phOsalNfc_Timer_Create( );
#if (FW_DOWNLOAD_TIMER < 2)
phOsalNfc_Timer_Start( psDnldContext->timer_id,
NXP_DNLD_COMPLETE_TIMEOUT,
(ppCallBck_t) phDnldNfc_Abort
#ifdef NFC_TIMER_CONTEXT
, (void *) psDnldContext
#endif
);
#endif /* #if (FW_DOWNLOAD_TIMER < 2) */
#endif /* #if defined(FW_DOWNLOAD_TIMER) */
}
}
else if (NFCSTATUS_SUCCESS == PHNFCSTATUS(status))
{
#if defined (NXP_FW_INTEGRITY_VERIFY)
/*
* To check for the integrity if the firmware is already
* Upgraded.
*/
status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
PHDNLD_CMD_RESET , NULL , 0 );
if (NFCSTATUS_PENDING == status)
{
DNLD_PRINT("\n FW_DNLD: Integrity Reset .... \n");
(void)phDnldNfc_Set_Seq(psDnldContext, DNLD_SEQ_COMPLETE);
status = PHNFCSTVAL( CID_NFC_DNLD,
NFCSTATUS_PENDING );
#if defined(FW_DOWNLOAD_TIMER)
psDnldContext->timer_id = phOsalNfc_Timer_Create( );
#if (FW_DOWNLOAD_TIMER < 2)
phOsalNfc_Timer_Start( psDnldContext->timer_id,
NXP_DNLD_COMPLETE_TIMEOUT,
(ppCallBck_t) phDnldNfc_Abort
#ifdef NFC_TIMER_CONTEXT
, (void *) psDnldContext
#endif
);
#endif /* #if (FW_DOWNLOAD_TIMER < 2) */
#endif /* #if defined(FW_DOWNLOAD_TIMER) */
}
#else
status = NFCSTATUS_SUCCESS;
#endif /* #if defined (NXP_FW_INTEGRITY_VERIFY) */
}
else
{
DNLD_PRINT(" FW_DNLD Initialisation in Failed \n");
}
}
if (NFCSTATUS_PENDING != PHNFCSTATUS(status))
{
(void)phDal4Nfc_Unregister(
psDnldContext->lower_interface.pcontext, pHwRef);
phDnldNfc_Release_Lower(psDnldContext, pHwRef);
phDnldNfc_Release_Resources(&psDnldContext);
#ifndef NFC_TIMER_CONTEXT
gpphDnldContext = psDnldContext;
#endif
}
} /* End of Status Check for Memory */
else
{
status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INSUFFICIENT_RESOURCES);
DNLD_PRINT(" FW_DNLD: Memory Allocation of Context Failed\n");
}
}
return status;
}