2 * Copyright (C) 2010 NXP Semiconductors
\r
4 * Licensed under the Apache License, Version 2.0 (the "License");
\r
5 * you may not use this file except in compliance with the License.
\r
6 * You may obtain a copy of the License at
\r
8 * http://www.apache.org/licenses/LICENSE-2.0
\r
10 * Unless required by applicable law or agreed to in writing, software
\r
11 * distributed under the License is distributed on an "AS IS" BASIS,
\r
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
13 * See the License for the specific language governing permissions and
\r
14 * limitations under the License.
\r
18 * =========================================================================== *
\r
21 * \file phDnldNfc.c *
\r
22 * \brief Download Mgmt Interface Source for the Firmware Download. *
\r
25 * Project: NFC-FRI-1.1 *
\r
27 * $Date: Tue Jun 28 14:25:44 2011 $ *
\r
28 * $Author: ing04880 $ *
\r
29 * $Revision: 1.33 $ *
\r
32 * =========================================================================== *
\r
37 ################################################################################
\r
38 ***************************** Header File Inclusion ****************************
\r
39 ################################################################################
\r
43 #include <phNfcConfig.h>
\r
44 #include <phNfcCompId.h>
\r
45 #include <phNfcIoctlCode.h>
\r
46 #include <phDnldNfc.h>
\r
47 #include <phOsalNfc.h>
\r
48 #include <phOsalNfc_Timer.h>
\r
49 #include <phDal4Nfc.h>
\r
50 #include <utils/Log.h>
\r
52 ################################################################################
\r
53 ****************************** Macro Definitions *******************************
\r
54 ################################################################################
\r
58 #define STATIC static
\r
61 #if defined (DNLD_SUMMARY) && !defined (DNLD_TRACE)
\r
65 /* #if defined(PHDBG_INFO) && defined (PHDBG_CRITICAL_ERROR) */
\r
66 #if defined(DNLD_TRACE)
\r
67 extern char phOsalNfc_DbgTraceBuffer[];
\r
69 #define MAX_TRACE_BUFFER 0x0410
\r
70 #define Trace_buffer phOsalNfc_DbgTraceBuffer
\r
71 /* #define DNLD_PRINT( str ) phOsalNfc_DbgTrace(str) */
\r
72 #define DNLD_PRINT( str ) phOsalNfc_DbgString(str)
\r
73 #define DNLD_DEBUG(str, arg) \
\r
75 snprintf(Trace_buffer,MAX_TRACE_BUFFER,str,arg); \
\r
76 phOsalNfc_DbgString(Trace_buffer); \
\r
78 #define DNLD_PRINT_BUFFER(msg,buf,len) \
\r
80 snprintf(Trace_buffer,MAX_TRACE_BUFFER,"\n\t %s:",msg); \
\r
81 phOsalNfc_DbgString(Trace_buffer); \
\r
82 phOsalNfc_DbgTrace(buf,len); \
\r
83 phOsalNfc_DbgString("\r"); \
\r
86 #define DNLD_PRINT( str )
\r
87 #define DNLD_DEBUG(str, arg)
\r
88 #define DNLD_PRINT_BUFFER(msg,buf,len)
\r
91 #define DO_DELAY(period) usleep(period)
\r
93 /* delay after SW reset cmd in ms, required on uart for XTAL stability */
\r
94 #define PHDNLD_DNLD_DELAY 5000
\r
95 //#define PHDNLD_MAX_PACKET 0x0200U /* Max Total Packet Size is 512 */
\r
96 #define PHDNLD_MAX_PACKET 32U /* Max Total Packet Size is 512 */
\r
97 #define PHDNLD_DATA_SIZE ((PHDNLD_MAX_PACKET)- 8U) /* 0x01F8U */
\r
98 /* Max Data Size is 504 */
\r
99 #define PHDNLD_MIN_PACKET 0x03U /* Minimum Packet Size is 3*/
\r
101 #define DNLD_DEFAULT_RESPONSE_TIMEOUT 0x4000U
\r
103 #define NXP_FW_MIN_TX_RX_LEN 0x0AU
\r
106 #if defined( NXP_FW_MAX_TX_RX_LEN ) && \
\r
107 ( NXP_FW_MAX_TX_RX_LEN > NXP_FW_MIN_TX_RX_LEN )
\r
109 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN
\r
111 #elif !defined( NXP_FW_MAX_TX_RX_LEN )
\r
113 /* To specify the Maximum TX/RX Len */
\r
114 #define NXP_FW_MAX_TX_RX_LEN 0x200
\r
115 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN
\r
119 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MIN_TX_RX_LEN
\r
123 #define PHDNLD_FRAME_LEN_SIZE 0x02U
\r
124 #define PHDNLD_ADDR_SIZE 0x03U
\r
125 #define PHDNLD_DATA_LEN_SIZE 0x02U
\r
126 #define PHDNLD_FRAME_DATA_OFFSET 0x03U
\r
128 #define DNLD_SM_UNLOCK_MASK 0x01U
\r
129 #define DNLD_TRIM_MASK 0x02U
\r
130 #define DNLD_RESET_MASK 0x04U
\r
131 #define DNLD_VERIFY_MASK 0x08U
\r
132 #define DNLD_CRITICAL_MASK 0x10U
\r
135 #define NXP_NFC_IMAG_FW_MAX 0x05U
\r
137 #define PHDNLD_FW_PATCH_SEC 0x5FU
\r
139 #define PHDNLD_PAGE_SIZE 0x80U /* Page Size Configured for 64 Bytes */
\r
141 #define FW_MAX_SECTION 0x15U /* Max Number of Sections */
\r
143 #define DNLD_CRC16_SIZE 0x02U
\r
145 #define DNLD_CRC32_SIZE 0x04U
\r
147 #define DNLD_CFG_PG_ADDR 0x00008000U
\r
148 #define DNLD_FW_CODE_ADDR 0x00800000U
\r
149 #define DNLD_PATCH_CODE_ADDR 0x00018800U
\r
150 #define DNLD_PATCH_TABLE_ADDR 0x00008200U
\r
153 /* Raw Command to pass the Data in Download Mode */
\r
154 #define PHDNLD_CMD_RAW 0x00U
\r
155 /* Command to Reset the Device in Download Mode */
\r
156 #define PHDNLD_CMD_RESET 0x01U
\r
157 /* Command to Read from the Address specified in Download Mode */
\r
158 #define PHDNLD_CMD_READ 0x07U
\r
159 #define PHDNLD_CMD_READ_LEN 0x0005U
\r
160 /* Command to write to the Address specified in Download Mode */
\r
161 #define PHDNLD_CMD_WRITE 0x08U
\r
162 #define PHDNLD_CMD_SEC_WRITE 0x0CU
\r
163 #define PHDNLD_CMD_WRITE_MIN_LEN 0x0005U
\r
164 #define PHDNLD_CMD_WRITE_MAX_LEN PHDNLD_DATA_SIZE
\r
165 /* Command to verify the data written */
\r
166 #define PHDNLD_CMD_CHECK 0x06U
\r
167 #define PHDNLD_CMD_CHECK_LEN 0x0007U
\r
169 /* Command to Lock the */
\r
170 #define PHDNLD_CMD_LOCK 0x40U
\r
171 #define PHDNLD_CMD_LOCK_LEN 0x0002U
\r
174 /* Command to set the Host Interface properties */
\r
175 #define PHDNLD_CMD_SET_HIF 0x09U
\r
177 /* Command to Activate the Patches Updated */
\r
178 #define PHDNLD_CMD_ACTIVATE_PATCH 0x0AU
\r
180 /* Command to verify the Integrity of the data written */
\r
181 #define PHDNLD_CMD_CHECK_INTEGRITY 0x0BU
\r
183 /* Command to verify the Integrity of the data written */
\r
184 #define PHDNLD_CMD_ENCAPSULATE 0x0DU
\r
186 #define CHECK_INTEGRITY_RESP_CRC16_LEN 0x03U
\r
187 #define CHECK_INTEGRITY_RESP_CRC32_LEN 0x05U
\r
188 #define CHECK_INTEGRITY_RESP_COMP_LEN 0x10U
\r
191 /* Success Response to a Command Sent in the Download Mode */
\r
192 #define PHDNLD_RESP_SUCCESS 0x00U
\r
193 /* Timeout Response to a Command Sent in the Download Mode */
\r
194 #define PHDNLD_RESP_TIMEOUT 0x01U
\r
195 /* CRC Error Response to a Command Sent in the Download Mode */
\r
196 #define PHDNLD_RESP_CRC_ERROR 0x02U
\r
197 /* Access Denied Response to a Command Sent in the Download Mode */
\r
198 #define PHDNLD_RESP_ACCESS_DENIED 0x08U
\r
199 /* PROTOCOL Error Response to a Command Sent in the Download Mode */
\r
200 #define PHDNLD_RESP_PROTOCOL_ERROR 0x0BU
\r
201 /* Invalid parameter Response to a Command Sent in the Download Mode */
\r
202 #define PHDNLD_RESP_INVALID_PARAMETER 0x11U
\r
203 /* Command Not Supported Response to a Command Sent in the Download Mode */
\r
204 #define PHDNLD_RESP_CMD_NOT_SUPPORTED 0x13U
\r
205 /* Length parameter error Response to a Command Sent in the Download Mode */
\r
206 #define PHDNLD_RESP_INVALID_LENGTH 0x18U
\r
207 /* Checksum Error Response to a Command Sent in the Download Mode */
\r
208 #define PHDNLD_RESP_CHKSUM_ERROR 0x19U
\r
209 /* Version already uptodate Response to a Command Sent in the Download Mode */
\r
210 #define PHDNLD_RESP_VERSION_UPTODATE 0x1DU
\r
211 /* Memory operation error during the processing of
\r
212 the Command Frame in the Download Mode */
\r
213 #define PHDNLD_RESP_MEMORY_UPDATE_ERROR 0x20U
\r
214 /* The Chaining of the Command Frame was Successful in the Download Mode */
\r
215 #define PHDNLD_RESP_CHAINING_SUCCESS 0x21U
\r
216 /* The Command is not allowed anymore in the Download Mode */
\r
217 #define PHDNLD_RESP_CMD_NOT_ALLOWED 0xE0U
\r
218 /* The Error during the Chaining the Command Frame in the Download Mode */
\r
219 #define PHDNLD_RESP_CHAINING_ERROR 0xE6U
\r
220 /* Write Error Response to a Command Sent in the Download Mode */
\r
221 #define PHDNLD_RESP_WRITE_ERROR 0x74U
\r
223 #define PNDNLD_WORD_LEN 0x04U
\r
225 #define NXP_MAX_DNLD_RETRY 0x02U
\r
227 #define NXP_MAX_SECTION_WRITE 0x05U
\r
229 #define NXP_PATCH_VER_INDEX 0x05U
\r
233 ################################################################################
\r
234 ******************** Enumeration and Structure Definition **********************
\r
235 ################################################################################
\r
238 typedef enum phDnldNfc_eSeqType{
\r
239 DNLD_SEQ_RESET = 0x00U,
\r
247 } phDnldNfc_eSeqType_t;
\r
249 typedef enum phDnldNfc_eState
\r
251 phDnld_Reset_State = 0x00,
\r
252 phDnld_Unlock_State,
\r
253 phDnld_Upgrade_State,
\r
254 phDnld_Verify_State,
\r
255 phDnld_Complete_State,
\r
256 phDnld_Invalid_State
\r
257 }phDnldNfc_eState_t;
\r
260 typedef enum phDnldNfc_eSeq
\r
262 phDnld_Reset_Seq = 0x00,
\r
263 phDnld_Activate_Patch,
\r
264 phDnld_Deactivate_Patch,
\r
265 phDnld_Update_Patch,
\r
266 phDnld_Update_Patchtable,
\r
267 phDnld_Lock_System,
\r
268 phDnld_Unlock_System,
\r
269 phDnld_Upgrade_Section,
\r
270 phDnld_Verify_Integrity,
\r
271 phDnld_Verify_Section,
\r
272 phDnld_Complete_Seq,
\r
273 phDnld_Raw_Upgrade,
\r
277 typedef enum phDnldNfc_eChkCrc{
\r
278 CHK_INTEGRITY_CONFIG_PAGE_CRC = 0x00U,
\r
279 CHK_INTEGRITY_PATCH_TABLE_CRC = 0x01U,
\r
280 CHK_INTEGRITY_FLASH_CODE_CRC = 0x02U,
\r
281 CHK_INTEGRITY_PATCH_CODE_CRC = 0x03U,
\r
282 CHK_INTEGRITY_COMPLETE_CRC = 0xFFU
\r
283 } phDnldNfc_eChkCrc_t;
\r
287 typedef struct hw_comp_tbl
\r
289 uint8_t hw_version[3];
\r
290 uint8_t compatibility;
\r
294 typedef struct img_data_hdr
\r
296 /* Image Identification */
\r
298 /* Offset of the Data from the header */
\r
299 uint8_t img_data_offset;
\r
300 /* Number of fimware images available in the img_data */
\r
301 uint8_t no_of_fw_img;
\r
302 /* Fimware image Padding in the img_data */
\r
303 uint8_t fw_img_pad[2];
\r
304 /* HW Compatiblity table for the set of the Hardwares */
\r
305 hw_comp_tbl_t comp_tbl;
\r
306 /* This data consists of the firmware images required to download */
\r
310 typedef struct fw_data_hdr
\r
312 /* The data offset from the firmware header.
\r
313 * Just in case if in future we require to
\r
314 * add some more information.
\r
316 uint8_t fw_hdr_len;
\r
317 /* Total size of all the sections which needs to be updated */
\r
318 uint8_t no_of_sections;
\r
319 uint8_t hw_comp_no;
\r
321 uint32_t fw_version;
\r
326 /* This data consists all the sections that needs to be downloaded */
\r
327 typedef struct section_hdr
\r
329 uint8_t section_hdr_len;
\r
330 uint8_t section_mem_type;
\r
331 uint8_t section_checksum;
\r
332 uint8_t section_conf;
\r
333 uint32_t section_address;
\r
334 uint32_t section_length;
\r
337 typedef struct section_info
\r
339 section_hdr_t *p_sec_hdr;
\r
340 uint8_t *p_trim_data;
\r
341 /* The section data consist of the Firmware binary required
\r
342 * to be loaded to the particular address.
\r
344 uint8_t *p_sec_data;
\r
345 /* The Section checksum to verify the integrity of the section
\r
348 uint8_t *p_sec_chksum;
\r
349 /** \internal Index used to refer and process the
\r
350 * Firmware Section Data */
\r
351 volatile uint32_t section_offset;
\r
353 /** \internal Section Read Sequence */
\r
354 volatile uint8_t section_read;
\r
356 /** \internal Section Write Sequence */
\r
357 volatile uint8_t section_write;
\r
359 /** \internal TRIM Write Sequence */
\r
360 volatile uint8_t trim_write;
\r
362 volatile uint8_t sec_verify_retry;
\r
367 typedef struct phDnldNfc_sParam
\r
369 uint8_t data_addr[PHDNLD_ADDR_SIZE];
\r
370 uint8_t data_len[PHDNLD_DATA_LEN_SIZE];
\r
371 uint8_t data_packet[PHDNLD_DATA_SIZE];
\r
372 }phDnldNfc_sParam_t;
\r
374 typedef struct phDnldNfc_sDataHdr
\r
376 uint8_t frame_type;
\r
377 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
\r
378 }phDnldNfc_sData_Hdr_t;
\r
380 typedef struct phDnldNfc_sRawHdr
\r
382 uint8_t frame_type;
\r
383 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
\r
384 }phDnldNfc_sRawHdr_t;
\r
386 typedef struct phDnldNfc_sRawDataHdr
\r
388 uint8_t data_addr[PHDNLD_ADDR_SIZE];
\r
389 uint8_t data_len[PHDNLD_DATA_LEN_SIZE];
\r
390 }phDnldNfc_sRawDataHdr_t;
\r
392 typedef struct phDnldNfc_sChkCrc16_Resp
\r
394 uint8_t Chk_status;
\r
395 uint8_t Chk_Crc16[2];
\r
397 }phDnldNfc_sChkCrc16_Resp_t;
\r
399 typedef struct phDnldNfc_sChkCrc32_Resp
\r
401 uint8_t Chk_status;
\r
402 uint8_t Chk_Crc32[4];
\r
404 }phDnldNfc_sChkCrc32_Resp_t;
\r
407 typedef struct phDnldNfc_sChkCrcComplete
\r
409 phDnldNfc_sChkCrc16_Resp_t config_page;
\r
410 phDnldNfc_sChkCrc16_Resp_t patch_table;
\r
411 phDnldNfc_sChkCrc32_Resp_t flash_code;
\r
412 phDnldNfc_sChkCrc32_Resp_t patch_code;
\r
413 }phDnldNfc_sChkCrcComplete_t;
\r
415 typedef struct phDnldNfc_sData
\r
417 uint8_t frame_type;
\r
418 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE];
\r
421 phDnldNfc_sParam_t data_param;
\r
422 uint8_t response_data[PHDNLD_MAX_PACKET];
\r
425 }phDnldNfc_sData_t;
\r
427 #ifdef NXP_NFC_MULTIPLE_FW
\r
429 typedef struct phDnldNfc_sFwImageInfo
\r
431 /** \internal Data Pointer to the Firmware header section of the Firmware */
\r
432 fw_data_hdr_t *p_fw_hdr;
\r
433 /** \internal Buffer pointer to store the Firmware Section Data */
\r
434 section_info_t *p_fw_sec;
\r
435 /** \internal Buffer pointer to store the Firmware Raw Data */
\r
437 }phDnldNfc_sFwImageInfo_t;
\r
439 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */
\r
442 typedef struct phDnldNfc_TxInfo
\r
444 uint8_t *transmit_frame;
\r
446 uint16_t tx_offset;
\r
448 /** \internal Remaining amount of data to be sent */
\r
453 /** \internal Chain information for the data to be sent */
\r
456 }phDnldNfc_TxInfo_t;
\r
459 typedef struct phDnldNfc_RxInfo
\r
461 /** \internal Total length of the received buffer */
\r
463 /** \internal Chain information of the received buffer */
\r
465 /** \internal Remaining Data information to be read to complete the
\r
466 * Data Information.
\r
468 uint16_t rx_remain;
\r
470 /** \internal Buffer to Send the Raw Data Frame */
\r
471 uint8_t raw_buffer_data[PHDNLD_MAX_PACKET
\r
472 + PHDNLD_PAGE_SIZE];
\r
473 }phDnldNfc_RxInfo_t;
\r
476 typedef struct phDnldNfc_sContext
\r
478 /** \internal Structure to store the lower interface operations */
\r
479 phNfc_sLowerIF_t lower_interface;
\r
481 phNfc_sData_t *p_fw_version;
\r
483 /** \internal Pointer to the Hardware Reference Sturcture */
\r
484 phHal_sHwReference_t *p_hw_ref;
\r
486 /** \internal Pointer to the upper layer notification callback function */
\r
487 pphNfcIF_Notification_CB_t p_upper_notify;
\r
488 /** \internal Pointer to the upper layer context */
\r
489 void *p_upper_context;
\r
491 /** \internal Timer ID for the Download Abort */
\r
493 /** \internal Internal Download for the Download Abort */
\r
494 uint32_t dnld_timeout;
\r
495 /** \internal Data Pointer to the Image header section of the Firmware */
\r
496 img_data_hdr_t *p_img_hdr;
\r
498 #ifdef NXP_NFC_MULTIPLE_FW
\r
499 /** \internal Data Pointer to the Firmware Image Information */
\r
500 phDnldNfc_sFwImageInfo_t *p_img_info;
\r
501 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */
\r
503 /** \internal Data Pointer to the Firmware header section of the Firmware */
\r
504 fw_data_hdr_t *p_fw_hdr;
\r
505 /** \internal Buffer pointer to store the Firmware Data */
\r
506 section_info_t *p_fw_sec;
\r
507 /** \internal Buffer pointer to store the Firmware Raw Data */
\r
510 /** \internal Previous Download Size */
\r
511 uint32_t prev_dnld_size;
\r
513 /** \internal Single Data Block to download the Firmware */
\r
514 uint8_t dnld_data[PHDNLD_MAX_PACKET
\r
515 + PHDNLD_PAGE_SIZE];
\r
516 /** \internal Index used to refer and process the Download Data */
\r
517 volatile uint32_t dnld_index;
\r
519 /** \internal Response Data to process the response */
\r
520 phDnldNfc_sData_t dnld_resp;
\r
522 /** \internal Previously downloaded data stored
\r
523 * to compare the written data */
\r
524 phNfc_sData_t dnld_store;
\r
526 /** \internal Previously downloaded trimmed data stored
\r
527 * to compare the written data */
\r
528 phNfc_sData_t trim_store;
\r
530 uint8_t *p_resp_buffer;
\r
532 phDnldNfc_sChkCrcComplete_t chk_integrity_crc;
\r
534 phDnldNfc_eChkCrc_t chk_integrity_param;
\r
536 #define NXP_FW_SW_VMID_TRIM
\r
537 #ifdef NXP_FW_SW_VMID_TRIM
\r
539 #define NXP_FW_VMID_TRIM_CHK_ADDR 0x0000813DU
\r
540 #define NXP_FW_VMID_CARD_MODE_ADDR 0x00009931U
\r
541 #define NXP_FW_VMID_RD_MODE_ADDR 0x00009981U
\r
543 uint8_t vmid_trim_update;
\r
544 #endif /* #ifdef NXP_FW_SW_VMID_TRIM */
\r
546 uint8_t cur_frame_info;
\r
548 uint8_t raw_mode_upgrade;
\r
550 uint8_t *p_patch_table_crc;
\r
552 uint8_t *p_flash_code_crc;
\r
554 uint8_t *p_patch_code_crc;
\r
556 uint16_t resp_length;
\r
558 /** \internal Current FW Section in Process */
\r
559 volatile uint8_t section_index;
\r
561 /** \internal Previous Command sent */
\r
562 volatile uint8_t prev_cmd;
\r
564 uint8_t dnld_retry;
\r
566 /** \internal Current Download State */
\r
567 volatile uint8_t cur_dnld_state;
\r
568 /** \internal Next Download State */
\r
569 volatile uint8_t next_dnld_state;
\r
571 /** \internal Current step in Download Sequence */
\r
572 volatile uint8_t cur_dnld_seq;
\r
573 /** \internal Next step in Download Sequence */
\r
574 volatile uint8_t next_dnld_seq;
\r
576 /* \internal Data Transmit information */
\r
577 phDnldNfc_TxInfo_t tx_info;
\r
579 /* \internal Data Receive information */
\r
580 phDnldNfc_RxInfo_t rx_info;
\r
583 }phDnldNfc_sContext_t;
\r
587 ################################################################################
\r
588 ******************** Global and Static Variables Definition ********************
\r
589 ################################################################################
\r
592 #ifndef NFC_TIMER_CONTEXT
\r
593 static phDnldNfc_sContext_t *gpphDnldContext = NULL;
\r
596 #ifdef NXP_FW_DNLD_CHECK_PHASE
\r
598 #define NXP_FW_DNLD_COMPLETE_PHASE 0x00U
\r
599 #define NXP_FW_DNLD_SYSTEM_PHASE 0x01U
\r
600 #define NXP_FW_DNLD_CFG_PHASE 0x02U
\r
601 #define NXP_FW_DNLD_DATA_PHASE 0x03U
\r
602 #define NXP_FW_DNLD_RAW_PHASE 0x04U
\r
603 #define NXP_FW_DNLD_INVALID_PHASE 0xFFU
\r
605 static uint8_t gphDnldPhase = NXP_FW_DNLD_COMPLETE_PHASE;
\r
607 #endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */
\r
612 *************************** Static Function Declaration **************************
\r
617 phDnldNfc_Send_Command(
\r
618 phDnldNfc_sContext_t *psDnldContext,
\r
622 uint16_t param_length
\r
627 phDnldNfc_Process_FW(
\r
628 phDnldNfc_sContext_t *psDnldContext,
\r
629 phHal_sHwReference_t *pHwRef
\r
630 #ifdef NXP_FW_PARAM
\r
632 uint8_t *nxp_nfc_fw,
\r
639 phDnldNfc_Send_Complete (
\r
642 phNfc_sTransactionInfo_t *pInfo
\r
647 phDnldNfc_Receive_Complete (
\r
650 phNfc_sTransactionInfo_t *pInfo
\r
655 phDnldNfc_Process_Response(
\r
656 phDnldNfc_sContext_t *psDnldContext,
\r
666 phDnldNfc_sContext_t *psDnldContext,
\r
674 phDnldNfc_Resume_Write(
\r
675 phDnldNfc_sContext_t *psDnldContext,
\r
681 phDnldNfc_Process_Write(
\r
682 phDnldNfc_sContext_t *psDnldContext,
\r
684 section_info_t *p_sec_info,
\r
685 uint32_t *p_sec_offset
\r
690 phDnldNfc_Sequence(
\r
691 phDnldNfc_sContext_t *psDnldContext,
\r
699 phDnldNfc_Upgrade_Sequence(
\r
700 phDnldNfc_sContext_t *psDnldContext,
\r
728 phDnldNfc_sContext_t *psDnldContext,
\r
729 phDnldNfc_eSeqType_t seq_type
\r
735 pphNfcIF_Notification_CB_t p_upper_notify,
\r
736 void *p_upper_context,
\r
744 phDnldNfc_Allocate_Resource (
\r
751 phDnldNfc_Release_Resources (
\r
752 phDnldNfc_sContext_t **ppsDnldContext
\r
757 phDnldNfc_Release_Lower(
\r
758 phDnldNfc_sContext_t *psDnldContext,
\r
766 phDnldNfc_sContext_t *psDnldContext,
\r
768 section_info_t *p_sec_info
\r
775 #ifdef NFC_TIMER_CONTEXT
\r
781 #ifdef DNLD_CRC_CALC
\r
785 phDnldNfc_UpdateCrc16(
\r
792 phDnldNfc_ComputeCrc16(
\r
799 *************************** Function Definitions **************************
\r
801 #define CRC32_POLYNOMIAL 0xEDB88320L
\r
803 static uint32_t CRC32Table[0x100];
\r
805 void BuildCRCTable()
\r
808 uint8_t i = 0, j = 0;
\r
810 for ( i = 0; i <= 0xFF ; i++ )
\r
813 for ( j = 8 ; j> 0; j-- )
\r
817 crc = ( crc>> 1 ) ^ CRC32_POLYNOMIAL;
\r
824 CRC32Table[ i ] = crc;
\r
829 * This routine calculates the CRC for a block of data using the
\r
830 * table lookup method. It accepts an original value for the crc,
\r
831 * and returns the updated value.
\r
834 uint32_t CalculateCRC32( void *buffer , uint32_t count, uint32_t crc )
\r
840 p = (uint8_t *) buffer;
\r
841 while ( count-- != 0 ) {
\r
842 temp1 = ( crc>> 8 ) & 0x00FFFFFFL;
\r
843 temp2 = CRC32Table[ ( (int) crc ^ *p++ ) & 0xff ];
\r
844 crc = temp1 ^ temp2;
\r
852 phDnldNfc_UpdateCrc16(
\r
857 crcByte = (crcByte ^ (uint8_t)((*pCrc) & 0x00FF));
\r
858 crcByte = (crcByte ^ (uint8_t)(crcByte << 4));
\r
859 *pCrc = (*pCrc >> 8) ^ ((uint16_t)crcByte << 8) ^
\r
860 ((uint16_t)crcByte << 3) ^
\r
861 ((uint16_t)crcByte >> 4);
\r
867 phDnldNfc_ComputeCrc16(
\r
872 uint8_t crc_byte = 0;
\r
873 uint16_t index = 0;
\r
877 crc = 0x6363; /* ITU-V.41 */
\r
879 crc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
\r
880 #endif /* #ifdef CRC_A */
\r
884 crc_byte = pData[index];
\r
885 phDnldNfc_UpdateCrc16(crc_byte, &crc);
\r
887 } while (index < length);
\r
890 crc = ~crc; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
\r
891 #endif /* #ifndef INVERT_CRC */
\r
893 /* *pCrc1 = (uint8_t) (crc & BYTE_MASK);
\r
894 *pCrc2 = (uint8_t) ((crc >> 8) & BYTE_MASK); */
\r
898 #endif /* #ifdef DNLD_CRC_CALC */
\r
902 * \brief Allocation of the Download Interface resources.
\r
904 * This function releases and frees all the resources used by Download Mode
\r
910 phDnldNfc_Allocate_Resource (
\r
915 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
917 *ppBuffer = (void *) phOsalNfc_GetMemory(size);
\r
918 if( *ppBuffer != NULL )
\r
920 (void )memset(((void *)*ppBuffer), 0,
\r
926 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
927 NFCSTATUS_INSUFFICIENT_RESOURCES);
\r
934 * \brief Release of the Download Interface resources.
\r
936 * This function releases and frees all the resources used by Download layer.
\r
941 phDnldNfc_Release_Resources (
\r
942 phDnldNfc_sContext_t **ppsDnldContext
\r
946 if(NULL != (*ppsDnldContext)->p_resp_buffer)
\r
948 phOsalNfc_FreeMemory((*ppsDnldContext)->p_resp_buffer);
\r
949 (*ppsDnldContext)->p_resp_buffer = NULL;
\r
951 if(NULL != (*ppsDnldContext)->dnld_store.buffer)
\r
953 phOsalNfc_FreeMemory((*ppsDnldContext)->dnld_store.buffer);
\r
954 (*ppsDnldContext)->dnld_store.buffer = NULL;
\r
955 (*ppsDnldContext)->dnld_store.length = 0;
\r
957 if(NULL != (*ppsDnldContext)->trim_store.buffer)
\r
959 phOsalNfc_FreeMemory((*ppsDnldContext)->trim_store.buffer);
\r
960 (*ppsDnldContext)->trim_store.buffer = NULL;
\r
961 (*ppsDnldContext)->trim_store.length = 0;
\r
963 if(NULL != (*ppsDnldContext)->p_fw_sec)
\r
965 phOsalNfc_FreeMemory((*ppsDnldContext)->p_fw_sec);
\r
966 (*ppsDnldContext)->p_fw_sec = NULL;
\r
968 if ( NXP_INVALID_TIMER_ID != (*ppsDnldContext)->timer_id )
\r
970 phOsalNfc_Timer_Stop((*ppsDnldContext)->timer_id );
\r
971 phOsalNfc_Timer_Delete((*ppsDnldContext)->timer_id );
\r
972 (*ppsDnldContext)->timer_id = NXP_INVALID_TIMER_ID;
\r
975 phOsalNfc_FreeMemory((*ppsDnldContext));
\r
976 (*ppsDnldContext) = NULL;
\r
984 phDnldNfc_Release_Lower(
\r
985 phDnldNfc_sContext_t *psDnldContext,
\r
989 phNfc_sLowerIF_t *plower_if =
\r
990 &(psDnldContext->lower_interface);
\r
991 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
993 PHNFC_UNUSED_VARIABLE(status);
\r
995 if(NULL != plower_if->release)
\r
997 #ifdef DNLD_LOWER_RELEASE
\r
998 status = plower_if->release((void *)plower_if->pcontext,
\r
1001 PHNFC_UNUSED_VARIABLE(pHwRef);
\r
1004 (void)memset((void *)plower_if,
\r
1005 0, sizeof(phNfc_sLowerIF_t));
\r
1006 DNLD_DEBUG(" FW_DNLD: Releasing the Lower Layer Resources: Status = %02X\n"
\r
1018 pphNfcIF_Notification_CB_t p_upper_notify,
\r
1019 void *p_upper_context,
\r
1025 if( ( NULL != p_upper_notify) )
\r
1027 /* Notify the to the Upper Layer */
\r
1028 (p_upper_notify)(p_upper_context, pHwRef, type, pInfo);
\r
1035 phDnldNfc_Set_Seq(
\r
1036 phDnldNfc_sContext_t *psDnldContext,
\r
1037 phDnldNfc_eSeqType_t seq_type
\r
1040 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1041 static uint8_t prev_temp_state = 0;
\r
1042 static uint8_t prev_temp_seq =
\r
1043 (uint8_t) phDnld_Activate_Patch;
\r
1047 case DNLD_SEQ_RESET:
\r
1048 case DNLD_SEQ_INIT:
\r
1050 psDnldContext->cur_dnld_state =
\r
1051 (uint8_t) phDnld_Reset_State;
\r
1052 psDnldContext->next_dnld_state =
\r
1053 (uint8_t)phDnld_Upgrade_State;
\r
1054 psDnldContext->cur_dnld_seq =
\r
1055 (uint8_t)phDnld_Upgrade_Section;
\r
1056 psDnldContext->next_dnld_seq =
\r
1057 psDnldContext->cur_dnld_seq;
\r
1060 case DNLD_SEQ_RAW:
\r
1062 psDnldContext->cur_dnld_state =
\r
1063 (uint8_t) phDnld_Reset_State;
\r
1064 psDnldContext->next_dnld_state =
\r
1065 (uint8_t)phDnld_Upgrade_State;
\r
1066 psDnldContext->cur_dnld_seq =
\r
1067 (uint8_t)phDnld_Raw_Upgrade;
\r
1068 psDnldContext->next_dnld_seq =
\r
1069 psDnldContext->cur_dnld_seq;
\r
1072 case DNLD_SEQ_UNLOCK:
\r
1074 psDnldContext->cur_dnld_state =
\r
1075 (uint8_t) phDnld_Reset_State;
\r
1077 #ifdef NXP_FW_DNLD_CHECK_PHASE
\r
1078 if( NXP_FW_DNLD_SYSTEM_PHASE < gphDnldPhase )
\r
1080 psDnldContext->next_dnld_state =
\r
1081 (uint8_t)phDnld_Upgrade_State;
\r
1082 psDnldContext->cur_dnld_seq =
\r
1083 (uint8_t)phDnld_Upgrade_Section;
\r
1086 #endif /* NXP_FW_DNLD_CHECK_PHASE */
\r
1088 psDnldContext->next_dnld_state =
\r
1089 (uint8_t) phDnld_Unlock_State;
\r
1090 psDnldContext->cur_dnld_seq =
\r
1091 (uint8_t) phDnld_Activate_Patch;
\r
1093 psDnldContext->next_dnld_seq =
\r
1094 psDnldContext->cur_dnld_seq;
\r
1097 case DNLD_SEQ_LOCK:
\r
1099 psDnldContext->cur_dnld_state =
\r
1100 (uint8_t) phDnld_Reset_State;
\r
1101 psDnldContext->next_dnld_state =
\r
1102 (uint8_t) phDnld_Reset_State;
\r
1103 psDnldContext->cur_dnld_seq =
\r
1104 (uint8_t) phDnld_Lock_System;
\r
1105 psDnldContext->next_dnld_seq =
\r
1106 psDnldContext->cur_dnld_seq;
\r
1109 case DNLD_SEQ_UPDATE:
\r
1111 prev_temp_state = (uint8_t) psDnldContext->cur_dnld_state;
\r
1112 psDnldContext->cur_dnld_state =
\r
1113 psDnldContext->next_dnld_state;
\r
1114 /* psDnldContext->next_dnld_state =
\r
1115 (uint8_t)phDnld_Invalid_State ; */
\r
1116 prev_temp_seq = (uint8_t) psDnldContext->cur_dnld_seq;
\r
1117 psDnldContext->cur_dnld_seq =
\r
1118 psDnldContext->next_dnld_seq;
\r
1121 case DNLD_SEQ_ROLLBACK:
\r
1123 psDnldContext->cur_dnld_seq = (uint8_t) prev_temp_seq;
\r
1124 psDnldContext->next_dnld_seq =
\r
1125 (uint8_t)phDnld_Invalid_Seq ;
\r
1126 prev_temp_seq = 0;
\r
1128 psDnldContext->cur_dnld_state = (uint8_t) prev_temp_state;
\r
1129 /* psDnldContext->next_dnld_state =
\r
1130 (uint8_t)phDnld_Invalid_State ; */
\r
1131 prev_temp_state = 0;
\r
1134 case DNLD_SEQ_COMPLETE:
\r
1136 psDnldContext->cur_dnld_state =
\r
1137 (uint8_t) phDnld_Reset_State;
\r
1138 psDnldContext->next_dnld_state =
\r
1139 (uint8_t) phDnld_Verify_State;
\r
1140 psDnldContext->cur_dnld_seq =
\r
1141 (uint8_t) phDnld_Verify_Integrity;
\r
1142 psDnldContext->next_dnld_seq =
\r
1143 psDnldContext->cur_dnld_seq ;
\r
1158 * \brief Sends the data the corresponding peripheral device.
\r
1160 * This function sends the Download data to the connected NFC Pheripheral device
\r
1173 phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext;
\r
1174 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1176 phNfc_sLowerIF_t *plower_if = &(psDnldContext->lower_interface);
\r
1178 if( (NULL != plower_if)
\r
1179 && (NULL != plower_if->send)
\r
1182 #ifndef DNLD_SUMMARY
\r
1183 DNLD_PRINT_BUFFER("Send Buffer",pdata,length);
\r
1185 status = plower_if->send((void *)plower_if->pcontext,
\r
1186 (void *)pHwRef, pdata, length);
\r
1188 #if defined(FW_DOWNLOAD_TIMER) && \
\r
1189 (FW_DOWNLOAD_TIMER == 2)
\r
1191 (NFCSTATUS_PENDING == status)
\r
1192 && ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
\r
1195 psDnldContext->dnld_timeout = NXP_DNLD_COMPLETE_TIMEOUT;
\r
1197 if ( psDnldContext->dnld_timeout
\r
1198 < DNLD_DEFAULT_RESPONSE_TIMEOUT)
\r
1200 psDnldContext->dnld_timeout
\r
1201 = DNLD_DEFAULT_RESPONSE_TIMEOUT;
\r
1203 /* Start the Download Timer */
\r
1204 phOsalNfc_Timer_Start( psDnldContext->timer_id,
\r
1205 psDnldContext->dnld_timeout,
\r
1206 (ppCallBck_t) phDnldNfc_Abort
\r
1207 #ifdef NFC_TIMER_CONTEXT
\r
1208 , (void *) psDnldContext
\r
1212 DNLD_DEBUG(" DNLD : Timer %X Started ", psDnldContext->timer_id);
\r
1213 DNLD_DEBUG(" \t\t With %U Timeout \n", psDnldContext->dnld_timeout);
\r
1216 #endif /* (NXP_NFC_DNLD_TIMER == 1) */
\r
1224 * \brief Receives the Download Mode Response from the corresponding peripheral device.
\r
1226 * This function receives the Download Command Response to the connected NFC
\r
1227 * Pheripheral device.
\r
1232 phDnldNfc_Receive(
\r
1239 phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext;
\r
1240 phNfc_sLowerIF_t *plower_if = NULL ;
\r
1241 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1243 if(NULL == psDnldContext )
\r
1245 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
\r
1249 plower_if = &(psDnldContext->lower_interface);
\r
1251 if( (NULL != plower_if)
\r
1252 && (NULL != plower_if->receive)
\r
1255 status = plower_if->receive((void *)plower_if->pcontext,
\r
1256 (void *)pHwRef, pdata, length);
\r
1266 phDnldNfc_sContext_t *psDnldContext,
\r
1268 section_info_t *p_sec_info
\r
1271 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1272 phDnldNfc_sData_t *p_dnld_data =
\r
1273 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
1274 phDnldNfc_sParam_t *p_data_param =
\r
1275 &p_dnld_data->param_info.data_param;
\r
1276 uint32_t read_addr = (p_sec_info->p_sec_hdr->section_address
\r
1277 + p_sec_info->section_offset);
\r
1278 static unsigned sec_type = 0;
\r
1280 uint16_t read_size = 0 ;
\r
1282 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
\r
1284 if( ( FALSE == p_sec_info->section_read )
\r
1285 && ((sec_type & DNLD_TRIM_MASK))
\r
1286 && (FALSE == p_sec_info->trim_write) )
\r
1288 read_size = (uint16_t) p_sec_info->p_sec_hdr->section_length;
\r
1289 DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size);
\r
1293 if (( FALSE == p_sec_info->section_read )
\r
1294 && ((sec_type & DNLD_VERIFY_MASK))
\r
1297 read_size = (uint16_t)(psDnldContext->prev_dnld_size );
\r
1298 DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size);
\r
1300 else if( ( TRUE == p_sec_info->section_read )
\r
1301 && ( TRUE == p_sec_info->section_write )
\r
1304 /*Already Read the Data Hence Ignore the Read */
\r
1305 DNLD_DEBUG(" FW_DNLD: Already Read, Read Ignored, read_size = %X \n", read_size);
\r
1309 /* Ignore the Read */
\r
1310 DNLD_DEBUG(" FW_DNLD: Section Read Status = %X \n", p_sec_info->section_read);
\r
1311 DNLD_DEBUG(" FW_DNLD: Section Write Status = %X \n", p_sec_info->section_write);
\r
1312 DNLD_DEBUG(" FW_DNLD: No Read Required, Read_size = %X \n", read_size);
\r
1316 if (read_size != 0)
\r
1319 read_size = (uint16_t)((PHDNLD_DATA_SIZE >= read_size)?
\r
1320 read_size: PHDNLD_DATA_SIZE);
\r
1322 p_dnld_data->frame_length[i] = (uint8_t)0;
\r
1323 /* Update the LSB of the Data and the Address Parameter*/
\r
1324 p_data_param->data_addr[i] = (uint8_t)((read_addr >>
\r
1325 (BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK);
\r
1326 p_data_param->data_len[i] = (uint8_t)((read_size >>
\r
1327 BYTE_SIZE) & BYTE_MASK);
\r
1330 p_dnld_data->frame_length[i] = (uint8_t)
\r
1331 ( PHDNLD_CMD_READ_LEN & BYTE_MASK);
\r
1332 /* Update the 2nd byte of the Data and the Address Parameter*/
\r
1333 p_data_param->data_addr[i] = (uint8_t)((read_addr >>
\r
1334 BYTE_SIZE) & BYTE_MASK);
\r
1335 p_data_param->data_len[i] = (uint8_t) (read_size & BYTE_MASK);
\r
1338 /* Update the 3rd byte of the the Address Parameter*/
\r
1339 p_data_param->data_addr[i] = (uint8_t)(read_addr & BYTE_MASK);
\r
1341 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1342 PHDNLD_CMD_READ, NULL , 0 );
\r
1344 if ( NFCSTATUS_PENDING == status )
\r
1346 p_sec_info->section_read = TRUE ;
\r
1347 psDnldContext->next_dnld_state = phDnld_Upgrade_State;
\r
1348 DNLD_DEBUG(" FW_DNLD: Memory Read at Address %X : ", read_addr);
\r
1349 DNLD_DEBUG(" of Size %X \n", read_size);
\r
1360 phDnldNfc_Process_Write(
\r
1361 phDnldNfc_sContext_t *psDnldContext,
\r
1363 section_info_t *p_sec_info,
\r
1364 uint32_t *p_sec_offset
\r
1367 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1368 phDnldNfc_sData_t *p_dnld_data =
\r
1369 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
1370 phDnldNfc_sParam_t *dnld_data =
\r
1371 &p_dnld_data->param_info.data_param;
\r
1372 uint8_t *p_sm_trim_data = (uint8_t *)psDnldContext->
\r
1373 dnld_resp.param_info.response_data;
\r
1374 uint32_t dnld_addr = 0;
\r
1375 #ifdef NXP_FW_SW_VMID_TRIM
\r
1376 uint32_t trim_addr = 0;
\r
1377 #endif /* #ifdef NXP_FW_SW_VMID_TRIM */
\r
1378 static unsigned sec_type = 0;
\r
1380 uint16_t dnld_size = 0;
\r
1381 int cmp_val = 0x00;
\r
1384 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
\r
1386 status = phDnldNfc_Read(psDnldContext, pHwRef, p_sec_info);
\r
1387 if( NFCSTATUS_PENDING != status )
\r
1389 if( (TRUE == p_sec_info->trim_write)
\r
1390 && (TRUE == p_sec_info->section_read)
\r
1391 && ((sec_type & DNLD_VERIFY_MASK))
\r
1394 if(NULL != psDnldContext->trim_store.buffer)
\r
1396 uint32_t trim_cmp_size = psDnldContext->prev_dnld_size;
\r
1398 if( p_sec_info->p_sec_hdr->section_address
\r
1399 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
\r
1401 trim_cmp_size = trim_cmp_size - 2;
\r
1404 /* Below Comparison fails due to the checksum */
\r
1405 cmp_val = phOsalNfc_MemCompare(
\r
1406 psDnldContext->trim_store.buffer,
\r
1407 &psDnldContext->dnld_resp.
\r
1408 param_info.response_data[0]
\r
1410 DNLD_DEBUG(" FW_DNLD: %X Bytes Trim Write Complete ",
\r
1411 psDnldContext->prev_dnld_size);
\r
1412 DNLD_DEBUG(" Comparison Status %X\n", cmp_val);
\r
1414 p_sec_info->trim_write = FALSE;
\r
1415 DNLD_DEBUG(" FW_DNLD: TRIMMED %X Bytes Write Complete\n", psDnldContext->prev_dnld_size);
\r
1419 if((NULL != psDnldContext->dnld_store.buffer)
\r
1420 && ((sec_type & DNLD_VERIFY_MASK))
\r
1421 && (TRUE == p_sec_info->section_write)
\r
1422 && (TRUE == p_sec_info->section_read)
\r
1425 cmp_val = phOsalNfc_MemCompare(
\r
1426 psDnldContext->dnld_store.buffer,
\r
1427 &psDnldContext->dnld_resp.
\r
1428 param_info.response_data[0]
\r
1429 ,psDnldContext->dnld_store.length);
\r
1430 p_sec_info->section_read = FALSE;
\r
1431 p_sec_info->section_write = FALSE;
\r
1432 DNLD_DEBUG(" FW_DNLD: %X Bytes Write Complete ",
\r
1433 psDnldContext->dnld_store.length);
\r
1434 DNLD_DEBUG(" Comparison Status %X\n", cmp_val);
\r
1438 if(( TRUE == p_sec_info->section_write)
\r
1439 && ( FALSE == p_sec_info->section_read)
\r
1442 p_sec_info->section_write = FALSE;
\r
1445 /* p_sec_info->section_read = FALSE; */
\r
1448 if (( 0 == psDnldContext->dnld_retry )
\r
1452 p_sec_info->sec_verify_retry = 0;
\r
1453 p_sec_info->section_offset = p_sec_info->section_offset +
\r
1454 psDnldContext->prev_dnld_size;
\r
1455 psDnldContext->prev_dnld_size = 0;
\r
1456 DNLD_DEBUG(" FW_DNLD: Memory Write Retry - %X \n",
\r
1457 psDnldContext->dnld_retry);
\r
1461 p_sec_info->sec_verify_retry++;
\r
1462 DNLD_DEBUG(" FW_DNLD: Memory Verification Failed, Retry = %X \n",
\r
1463 p_sec_info->sec_verify_retry);
\r
1466 if( p_sec_info->sec_verify_retry < NXP_MAX_SECTION_WRITE )
\r
1469 dnld_addr = (p_sec_info->p_sec_hdr->section_address + *p_sec_offset);
\r
1470 dnld_size = (uint16_t)(p_sec_info->p_sec_hdr->section_length
\r
1475 status = NFCSTATUS_FAILED;
\r
1476 DNLD_DEBUG(" FW_DNLD: Memory Verification - Maximum Limit, Retry = %X \n",
\r
1477 p_sec_info->sec_verify_retry);
\r
1482 if (dnld_size != 0)
\r
1485 dnld_size = (uint16_t)((PHDNLD_DATA_SIZE >= dnld_size)?
\r
1486 dnld_size: PHDNLD_DATA_SIZE);
\r
1488 /* Update the LSB of the Data and the Address Parameter*/
\r
1489 dnld_data->data_addr[i] = (uint8_t)((dnld_addr >>
\r
1490 (BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK);
\r
1491 dnld_data->data_len[i] = (uint8_t)((dnld_size >> BYTE_SIZE)
\r
1493 p_dnld_data->frame_length[i] = (uint8_t)
\r
1494 (((dnld_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE)
\r
1497 /* Update the 2nd byte of the Data and the Address Parameter*/
\r
1498 dnld_data->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE)
\r
1500 dnld_data->data_len[i] = (uint8_t) (dnld_size & BYTE_MASK);
\r
1501 p_dnld_data->frame_length[i] = (uint8_t) ((dnld_size +
\r
1502 PHDNLD_CMD_WRITE_MIN_LEN) & BYTE_MASK);
\r
1504 /* Update the 3rd byte of the the Address Parameter*/
\r
1505 dnld_data->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK);
\r
1507 (void)memcpy( dnld_data->data_packet,
\r
1508 (p_sec_info->p_sec_data + *p_sec_offset), dnld_size );
\r
1510 if( ((sec_type & DNLD_TRIM_MASK))
\r
1511 && (p_sec_info->sec_verify_retry != 0)
\r
1512 && (NULL != psDnldContext->trim_store.buffer)
\r
1515 (void)memcpy( dnld_data->data_packet,
\r
1516 psDnldContext->trim_store.buffer, dnld_size );
\r
1518 else if(((sec_type & DNLD_TRIM_MASK))
\r
1519 && ( TRUE == p_sec_info->section_read )
\r
1522 for(i = 0; i < *(p_sec_info->p_trim_data);i++)
\r
1525 #ifdef NXP_FW_SW_VMID_TRIM
\r
1528 if(bit 0 of 0x813D is equal to 1) then
\r
1530 Do not overwrite 0x9931 / 0x9981 during download
\r
1534 @0x9931 = 0x79 // card Mode
\r
1535 @0x9981 = 0x79 // Reader Mode
\r
1537 trim_addr = p_sec_info->p_sec_hdr->section_address
\r
1538 + p_sec_info->p_trim_data[i+1];
\r
1539 if (NXP_FW_VMID_TRIM_CHK_ADDR == trim_addr)
\r
1541 psDnldContext->vmid_trim_update =
\r
1542 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
\r
1545 if((NXP_FW_VMID_CARD_MODE_ADDR == trim_addr)
\r
1546 || (NXP_FW_VMID_RD_MODE_ADDR == trim_addr))
\r
1548 if (TRUE == psDnldContext->vmid_trim_update)
\r
1550 dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] =
\r
1551 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
\r
1558 dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] =
\r
1559 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ;
\r
1562 if(NULL != psDnldContext->trim_store.buffer)
\r
1564 phOsalNfc_FreeMemory(psDnldContext->trim_store.buffer);
\r
1565 psDnldContext->trim_store.buffer = NULL;
\r
1566 psDnldContext->trim_store.length = 0;
\r
1570 phDnldNfc_Allocate_Resource((void **)
\r
1571 &(psDnldContext->trim_store.buffer),dnld_size);
\r
1573 psDnldContext->trim_store.buffer =
\r
1574 (uint8_t *) phOsalNfc_GetMemory(dnld_size);
\r
1577 if(NULL != psDnldContext->trim_store.buffer)
\r
1579 (void )memset((void *)psDnldContext->trim_store.buffer,0,
\r
1581 (void)memcpy( psDnldContext->trim_store.buffer,
\r
1582 dnld_data->data_packet, dnld_size );
\r
1583 psDnldContext->trim_store.length = dnld_size;
\r
1584 DNLD_DEBUG(" FW_DNLD: Write with Trimming at Address %X ", dnld_addr );
\r
1585 DNLD_DEBUG(" of Size %X and ", dnld_size );
\r
1586 DNLD_DEBUG(" with %X Trimming Values \n", *(p_sec_info->p_trim_data) );
\r
1592 if(NULL != psDnldContext->dnld_store.buffer)
\r
1594 phOsalNfc_FreeMemory(psDnldContext->dnld_store.buffer);
\r
1595 psDnldContext->dnld_store.buffer = NULL;
\r
1596 psDnldContext->dnld_store.length = 0;
\r
1600 phDnldNfc_Allocate_Resource((void **)
\r
1601 &(psDnldContext->dnld_store.buffer),dnld_size);
\r
1603 psDnldContext->dnld_store.buffer =
\r
1604 (uint8_t *) phOsalNfc_GetMemory(dnld_size);
\r
1606 if(NULL != psDnldContext->dnld_store.buffer)
\r
1608 (void )memset((void *)psDnldContext->dnld_store.buffer,0,
\r
1610 (void)memcpy( psDnldContext->dnld_store.buffer,
\r
1611 dnld_data->data_packet, dnld_size );
\r
1612 psDnldContext->dnld_store.length = dnld_size;
\r
1613 DNLD_DEBUG(" FW_DNLD: Memory Write at Address %X ", dnld_addr );
\r
1614 DNLD_DEBUG(" of Size %X ", dnld_size );
\r
1618 if(PHDNLD_FW_PATCH_SEC != psDnldContext->p_fw_hdr->fw_patch)
\r
1620 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1621 PHDNLD_CMD_WRITE, NULL , 0 );
\r
1625 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1626 PHDNLD_CMD_SEC_WRITE, NULL , 0 );
\r
1629 DNLD_DEBUG(" FW_DNLD: Memory Write Status = %X \n", status);
\r
1630 if ( NFCSTATUS_PENDING == status )
\r
1632 psDnldContext->prev_dnld_size = dnld_size;
\r
1634 if((sec_type & DNLD_TRIM_MASK))
\r
1636 p_sec_info->trim_write = TRUE;
\r
1637 DNLD_DEBUG(" FW_DNLD: Bytes Downloaded (Trimming Values) = %X Bytes \n",
\r
1642 p_sec_info->section_write = TRUE;
\r
1643 DNLD_DEBUG(" FW_DNLD: Bytes Downloaded = %X : ",
\r
1644 (*p_sec_offset + dnld_size));
\r
1645 DNLD_DEBUG(" Bytes Remaining = %X \n",
\r
1646 (p_sec_info->p_sec_hdr->section_length -
\r
1647 (*p_sec_offset + dnld_size)));
\r
1650 p_sec_info->section_read = FALSE;
\r
1660 phDnldNfc_Resume_Write(
\r
1661 phDnldNfc_sContext_t *psDnldContext,
\r
1665 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1666 uint8_t sec_index = psDnldContext->section_index;
\r
1667 section_info_t *p_sec_info = (psDnldContext->p_fw_sec + sec_index);
\r
1669 while((sec_index < psDnldContext->p_fw_hdr->no_of_sections)
\r
1670 && (NFCSTATUS_SUCCESS == status )
\r
1674 status = phDnldNfc_Process_Write(psDnldContext, pHwRef,
\r
1675 p_sec_info, (uint32_t *)&(p_sec_info->section_offset));
\r
1676 if (NFCSTATUS_SUCCESS == status)
\r
1678 unsigned sec_type = 0;
\r
1679 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type;
\r
1681 p_sec_info->section_offset = 0;
\r
1682 p_sec_info->section_read = FALSE;
\r
1683 p_sec_info->section_write = FALSE;
\r
1684 p_sec_info->trim_write = FALSE;
\r
1686 DNLD_DEBUG(" FW_DNLD: Section %02X Download Complete\n", sec_index);
\r
1687 if((sec_type & DNLD_RESET_MASK))
\r
1689 DNLD_DEBUG(" FW_DNLD: Reset After Section %02X Download \n", sec_index);
\r
1690 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1691 PHDNLD_CMD_RESET , NULL, 0 );
\r
1693 DNLD_PRINT("*******************************************\n\n");
\r
1697 #ifdef NXP_FW_DNLD_CHECK_PHASE
\r
1698 if( p_sec_info->p_sec_hdr->section_address
\r
1699 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
\r
1701 gphDnldPhase = NXP_FW_DNLD_DATA_PHASE;
\r
1705 p_sec_info = (psDnldContext->p_fw_sec + sec_index);
\r
1707 if( (sec_index < psDnldContext->p_fw_hdr->no_of_sections)
\r
1708 && ( p_sec_info->p_sec_hdr->section_address
\r
1709 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) )
\r
1712 if( NXP_FW_DNLD_CFG_PHASE >= gphDnldPhase )
\r
1714 gphDnldPhase = NXP_FW_DNLD_CFG_PHASE;
\r
1719 p_sec_info = (psDnldContext->p_fw_sec + sec_index);
\r
1723 p_sec_info = (psDnldContext->p_fw_sec + sec_index);
\r
1724 #endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */
\r
1726 psDnldContext->section_index = sec_index;
\r
1727 /* psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State; */
\r
1730 if (NFCSTATUS_PENDING == status)
\r
1732 psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State;
\r
1734 else if (NFCSTATUS_SUCCESS == status)
\r
1736 /* Reset the PN544 Device */
\r
1737 psDnldContext->next_dnld_state = (uint8_t) phDnld_Complete_State;
\r
1747 #define NXP_DNLD_SM_UNLOCK_ADDR 0x008002U
\r
1749 #if !defined (ES_HW_VER)
\r
1750 #define ES_HW_VER 32
\r
1753 #if (ES_HW_VER <= 30)
\r
1754 #define NXP_DNLD_PATCH_ADDR 0x01AFFFU
\r
1756 #define NXP_DNLD_PATCH_ADDR 0x01A1E0U
\r
1759 #if (ES_HW_VER <= 30)
\r
1760 #define NXP_DNLD_PATCH_TABLE_ADDR 0x008107U
\r
1762 #define NXP_DNLD_PATCH_TABLE_ADDR 0x00825AU
\r
1768 phDnldNfc_Sequence(
\r
1769 phDnldNfc_sContext_t *psDnldContext,
\r
1775 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
1776 uint32_t dnld_addr = 0;
\r
1777 phDnldNfc_sData_t *p_dnld_data =
\r
1778 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
1779 phDnldNfc_sParam_t *p_data_param =
\r
1780 & p_dnld_data->param_info.data_param;
\r
1781 uint8_t *p_data = NULL;
\r
1782 static uint32_t patch_size = 0;
\r
1784 #if (ES_HW_VER == 32)
\r
1786 static uint8_t patch_table[] = {0xA0, 0xA1, 0xE0, 0x80, 0xA9, 0x6C };
\r
1787 static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5,
\r
1788 0xD0, 0xFC, 0xA5, 0x02, 0x80, 0xA9, 0x75};
\r
1790 #elif (ES_HW_VER == 31)
\r
1792 static uint8_t patch_table[] = {0xA0, 0xAF, 0xE0, 0x80, 0x78, 0x84 };
\r
1793 static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5,
\r
1794 0xD0, 0xFC, 0xD0, 0xE0, 0xA5, 0x02, 0x80, 0x78, 0x8D};
\r
1796 #elif (ES_HW_VER == 30)
\r
1798 static uint8_t patch_table[] = {0x80, 0x91, 0x51, 0xA0, 0xAF,
\r
1799 0xFF, 0x80, 0x91, 0x5A};
\r
1800 static uint8_t patch_data[] = {0x22};
\r
1804 static uint8_t unlock_data[] = {0x00, 0x00};
\r
1805 static uint8_t lock_data[] = {0x0C, 0x00};
\r
1809 PHNFC_UNUSED_VARIABLE(pdata);
\r
1810 PHNFC_UNUSED_VARIABLE(length);
\r
1811 switch(psDnldContext->cur_dnld_seq)
\r
1813 case phDnld_Reset_Seq:
\r
1815 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1816 PHDNLD_CMD_RESET , NULL , 0 );
\r
1817 /* status = (NFCSTATUS_PENDING == status)? NFCSTATUS_SUCCESS:
\r
1819 DNLD_DEBUG(" FW_DNLD: Reset Seq.. Status = %X \n", status);
\r
1823 case phDnld_Activate_Patch:
\r
1825 uint8_t patch_activate = 0x01;
\r
1826 psDnldContext->next_dnld_seq =
\r
1827 (uint8_t)phDnld_Update_Patch;
\r
1828 #ifdef NXP_FW_DNLD_CHECK_PHASE
\r
1829 gphDnldPhase = NXP_FW_DNLD_SYSTEM_PHASE;
\r
1830 #endif /* NXP_FW_DNLD_CHECK_PHASE */
\r
1832 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1833 PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) );
\r
1834 DNLD_PRINT(" FW_DNLD: Activate the Patch Update .... \n");
\r
1837 case phDnld_Deactivate_Patch:
\r
1839 uint8_t patch_activate = 0x00;
\r
1841 psDnldContext->next_dnld_state =
\r
1842 (uint8_t)phDnld_Reset_State;
\r
1844 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1845 PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) );
\r
1846 DNLD_PRINT(" FW_DNLD: Deactivate the Patch Update .... \n");
\r
1849 case phDnld_Update_Patch:
\r
1851 dnld_addr = NXP_DNLD_PATCH_ADDR;
\r
1852 patch_size = sizeof(patch_data) ;
\r
1853 p_data = patch_data;
\r
1854 psDnldContext->next_dnld_seq =
\r
1855 (uint8_t)phDnld_Update_Patchtable;
\r
1856 DNLD_PRINT(" FW_DNLD: Patch Update Seq.... \n");
\r
1859 case phDnld_Update_Patchtable:
\r
1861 dnld_addr = NXP_DNLD_PATCH_TABLE_ADDR;
\r
1862 patch_size = sizeof(patch_table) ;
\r
1863 p_data = patch_table;
\r
1865 psDnldContext->next_dnld_state =
\r
1866 (uint8_t)phDnld_Reset_State;
\r
1868 DNLD_PRINT(" FW_DNLD: Patch Table Update Seq.... \n");
\r
1871 case phDnld_Unlock_System:
\r
1873 dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR;
\r
1874 patch_size = sizeof(unlock_data) ;
\r
1875 p_data = unlock_data;
\r
1876 #define NXP_FW_PATCH_DISABLE
\r
1877 #ifdef NXP_FW_PATCH_DISABLE
\r
1878 psDnldContext->next_dnld_seq =
\r
1879 (uint8_t)phDnld_Deactivate_Patch;
\r
1881 psDnldContext->next_dnld_state =
\r
1882 (uint8_t)phDnld_Reset_State;
\r
1885 DNLD_PRINT(" FW_DNLD: System Memory Unlock Seq.... \n");
\r
1888 case phDnld_Lock_System:
\r
1890 dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR;
\r
1891 patch_size = sizeof(lock_data) ;
\r
1892 p_data = lock_data;
\r
1893 psDnldContext->next_dnld_state =
\r
1894 (uint8_t) phDnld_Reset_State;
\r
1896 DNLD_PRINT(" FW_DNLD: System Memory Lock Seq.... \n");
\r
1899 case phDnld_Upgrade_Section:
\r
1901 status = phDnldNfc_Resume_Write(
\r
1902 psDnldContext, pHwRef );
\r
1905 case phDnld_Verify_Integrity:
\r
1907 psDnldContext->next_dnld_state =
\r
1908 (uint8_t) phDnld_Reset_State;
\r
1910 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1911 PHDNLD_CMD_CHECK_INTEGRITY , NULL, 0 );
\r
1912 DNLD_PRINT(" FW_DNLD: System Memory Integrity Check Sequence.... \n");
\r
1915 case phDnld_Verify_Section:
\r
1925 if( NFCSTATUS_SUCCESS == status)
\r
1928 /* Update the LSB of the Data and the Address Parameter*/
\r
1929 p_data_param->data_addr[i] = (uint8_t)((dnld_addr >>
\r
1930 (BYTE_SIZE + BYTE_SIZE))
\r
1932 p_data_param->data_len[i] = (uint8_t)((patch_size >> BYTE_SIZE)
\r
1934 p_dnld_data->frame_length[i] = (uint8_t)
\r
1935 (((patch_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE)
\r
1938 /* Update the 2nd byte of the Data and the Address Parameter*/
\r
1939 p_data_param->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE)
\r
1941 p_data_param->data_len[i] = (uint8_t) (patch_size & BYTE_MASK);
\r
1942 p_dnld_data->frame_length[i] = (uint8_t)
\r
1943 ((patch_size + PHDNLD_CMD_WRITE_MIN_LEN)
\r
1946 /* Update the 3rd byte of the the Address Parameter*/
\r
1947 p_data_param->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK);
\r
1949 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
1950 PHDNLD_CMD_WRITE,(void *)p_data , (uint8_t)patch_size );
\r
1952 if (NFCSTATUS_PENDING != status)
\r
1954 status = phDnldNfc_Set_Seq(psDnldContext,
\r
1955 DNLD_SEQ_ROLLBACK);
\r
1961 #define FRAME_HEADER_LEN 0x03U
\r
1966 phDnldNfc_Tx_Reset(phDnldNfc_sContext_t *psDnldContext)
\r
1968 psDnldContext->tx_info.transmit_frame = NULL;
\r
1969 psDnldContext->tx_info.tx_total = 0x00;
\r
1970 psDnldContext->tx_info.tx_offset = 0x00;
\r
1971 psDnldContext->tx_info.tx_len = 0x00;
\r
1972 psDnldContext->tx_info.tx_chain = FALSE;
\r
1977 phDnldNfc_Extract_Chunks(
\r
1978 uint8_t *frame_data,
\r
1979 uint16_t frame_offset,
\r
1980 uint16_t frame_length,
\r
1981 uint16_t max_frame ,
\r
1982 uint16_t *chunk_length
\r
1988 phDnldNfc_Extract_Chunks(
\r
1989 uint8_t *frame_data,
\r
1990 uint16_t frame_offset,
\r
1991 uint16_t frame_length,
\r
1992 uint16_t max_frame ,
\r
1993 uint16_t *chunk_length
\r
1996 bool_t chunk_present = FALSE;
\r
1998 if( 0 == frame_offset)
\r
2000 if( max_frame >= (frame_length
\r
2003 *chunk_length = (frame_length - frame_offset);
\r
2007 *chunk_length = max_frame
\r
2008 - FRAME_HEADER_LEN;
\r
2009 chunk_present = TRUE;
\r
2014 if( max_frame >= (frame_length
\r
2017 *chunk_length = (frame_length - frame_offset);
\r
2021 *chunk_length = max_frame
\r
2022 - FRAME_HEADER_LEN;
\r
2023 chunk_present = TRUE;
\r
2027 return chunk_present;
\r
2033 phDnldNfc_Send_Raw(
\r
2034 phDnldNfc_sContext_t *psDnldContext,
\r
2036 uint8_t *raw_frame,
\r
2037 uint16_t frame_offset,
\r
2038 uint16_t frame_length
\r
2041 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2042 phDnldNfc_sRawHdr_t *raw_frame_hdr = ( phDnldNfc_sRawHdr_t * ) raw_frame;
\r
2044 switch(raw_frame_hdr->frame_type)
\r
2046 case PHDNLD_CMD_RESET:
\r
2050 case PHDNLD_CMD_READ:
\r
2052 /* TODO: To Update the length and the buffer to receive data */
\r
2055 case PHDNLD_CMD_WRITE:
\r
2057 phDnldNfc_sRawDataHdr_t *raw_data_hdr =
\r
2058 ( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN);
\r
2060 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
2064 case PHDNLD_CMD_SEC_WRITE:
\r
2066 uint16_t tx_length = 0x00;
\r
2067 uint16_t frame_offset =
\r
2068 psDnldContext->tx_info.tx_offset;
\r
2070 psDnldContext->tx_info.tx_chain;
\r
2073 phDnldNfc_Extract_Chunks(
\r
2077 PHDNLD_FW_TX_RX_LEN,
\r
2081 if( TRUE == chain )
\r
2083 status = phDnldNfc_Send_Command( psDnldContext,
\r
2084 pHwRef, PHDNLD_CMD_ENCAPSULATE,
\r
2085 (raw_frame + frame_offset),
\r
2087 if(NFCSTATUS_PENDING == status)
\r
2089 psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
\r
2090 /* TODO: Update for the Chaining */
\r
2091 psDnldContext->tx_info.tx_offset += tx_length;
\r
2092 psDnldContext->tx_info.tx_chain = chain;
\r
2095 else if (0 != frame_offset)
\r
2097 status = phDnldNfc_Send_Command( psDnldContext,
\r
2098 pHwRef, PHDNLD_CMD_ENCAPSULATE,
\r
2099 (raw_frame + frame_offset),
\r
2101 if(NFCSTATUS_PENDING == status)
\r
2103 psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
\r
2104 /* TODO: Update for the Chaining */
\r
2105 psDnldContext->prev_dnld_size = frame_length;
\r
2106 phDnldNfc_Tx_Reset(psDnldContext);
\r
2111 phDnldNfc_sRawDataHdr_t *raw_data_hdr =
\r
2112 ( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN);
\r
2113 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
2118 case PHDNLD_CMD_CHECK:
\r
2120 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
2123 case PHDNLD_CMD_SET_HIF:
\r
2125 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
2128 case PHDNLD_CMD_ACTIVATE_PATCH:
\r
2130 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
2133 case PHDNLD_CMD_CHECK_INTEGRITY:
\r
2135 uint8_t integrity_param =
\r
2136 *(raw_frame + FRAME_HEADER_LEN);
\r
2137 switch(integrity_param)
\r
2139 case CHK_INTEGRITY_CONFIG_PAGE_CRC:
\r
2140 case CHK_INTEGRITY_PATCH_TABLE_CRC:
\r
2142 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
2143 + CHECK_INTEGRITY_RESP_CRC16_LEN;
\r
2146 case CHK_INTEGRITY_FLASH_CODE_CRC:
\r
2147 case CHK_INTEGRITY_PATCH_CODE_CRC:
\r
2149 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
2150 + CHECK_INTEGRITY_RESP_CRC32_LEN;
\r
2153 case CHK_INTEGRITY_COMPLETE_CRC:
\r
2156 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
2157 + CHECK_INTEGRITY_RESP_COMP_LEN;
\r
2165 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED);
\r
2170 if (NFCSTATUS_SUCCESS == status)
\r
2172 status = phDnldNfc_Send( psDnldContext, pHwRef ,
\r
2173 raw_frame, frame_length);
\r
2175 if(NFCSTATUS_PENDING == status)
\r
2177 psDnldContext->prev_cmd = raw_frame_hdr->frame_type;
\r
2178 /* TODO: Update for the Chaining */
\r
2179 psDnldContext->prev_dnld_size = frame_length;
\r
2189 phDnldNfc_Frame_Complete(phDnldNfc_sContext_t *psDnldContext)
\r
2191 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2192 phDnldNfc_sData_Hdr_t *p_dnld_raw = NULL;
\r
2193 uint32_t dnld_index = psDnldContext->dnld_index;
\r
2194 uint8_t *p_raw_sec_hdr = NULL;
\r
2195 uint16_t tx_length = 0x00;
\r
2197 dnld_index = dnld_index + psDnldContext->prev_dnld_size;
\r
2198 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
\r
2199 dnld_index = dnld_index + *p_raw_sec_hdr;
\r
2201 p_dnld_raw = (phDnldNfc_sData_Hdr_t *) (psDnldContext->p_fw_raw +
\r
2202 psDnldContext->dnld_index);
\r
2204 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
\r
2205 p_dnld_raw->frame_length[1]);
\r
2207 tx_length = tx_length + PHDNLD_MIN_PACKET;
\r
2215 phDnldNfc_Raw_Write(
\r
2216 phDnldNfc_sContext_t *psDnldContext,
\r
2220 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2221 uint32_t dnld_index = psDnldContext->dnld_index;
\r
2222 uint32_t tx_length = 0;
\r
2223 uint8_t *p_raw_sec_hdr = NULL;
\r
2224 uint8_t dnld_flag = FALSE;
\r
2225 uint8_t skip_frame = FALSE;
\r
2227 if(NULL != psDnldContext->p_fw_raw)
\r
2230 if( (TRUE != psDnldContext->tx_info.tx_chain)
\r
2231 && (0x00 == psDnldContext->dnld_retry)
\r
2234 dnld_index = dnld_index + psDnldContext->prev_dnld_size;
\r
2235 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
\r
2236 dnld_index = dnld_index + *p_raw_sec_hdr;
\r
2240 phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *)
\r
2241 (psDnldContext->p_fw_raw +
\r
2242 psDnldContext->dnld_index);
\r
2244 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
\r
2245 p_dnld_raw->frame_length[1]);
\r
2247 tx_length = tx_length + PHDNLD_MIN_PACKET;
\r
2249 status = phDnldNfc_Send_Raw( psDnldContext, pHwRef,
\r
2250 (uint8_t *)(p_dnld_raw),
\r
2251 psDnldContext->tx_info.tx_offset,
\r
2252 (uint16_t)tx_length);
\r
2256 #define PHDNLD_MAJOR_OFFSET 0x04U
\r
2257 #define PHDNLD_MINOR_OFFSET 0x05U
\r
2258 #define PHDNLD_PHASE_OFFSET 0x06U
\r
2259 #define PHDNLD_FRAMETYPE_OFFSET 0x07U
\r
2261 #define PHDNLD_NO_OPERATION 0x00U
\r
2262 #define PHDNLD_NORMAL_OPERATION 0x10U
\r
2263 #define PHDNLD_ADVANCED_OPERATION 0x20U
\r
2264 #define PHDNLD_SETUP_OPERATION 0x40U
\r
2265 #define PHDNLD_RECOVER_OPERATION 0x80U
\r
2266 #define PHDNLD_COMPLETE_OPERATION 0xF0U
\r
2268 #define PHDNLD_TERMINATE_TYPE 0x0EU
\r
2270 #define PHDNLD_MARKER_MASK 0x0FU
\r
2272 while((NFCSTATUS_SUCCESS == status )
\r
2273 && (FALSE == dnld_flag)
\r
2276 phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *)
\r
2277 (psDnldContext->p_fw_raw + dnld_index);
\r
2278 uint8_t frame_type = *(p_raw_sec_hdr + PHDNLD_FRAMETYPE_OFFSET);
\r
2280 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) |
\r
2281 p_dnld_raw->frame_length[1]);
\r
2283 tx_length = tx_length + PHDNLD_MIN_PACKET;
\r
2285 skip_frame = FALSE;
\r
2287 if( (0x00 == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET))
\r
2288 || (0xFF == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET))
\r
2289 || !( psDnldContext->raw_mode_upgrade
\r
2290 & (frame_type & (~PHDNLD_MARKER_MASK)) )
\r
2293 dnld_index = dnld_index + tx_length;
\r
2294 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index;
\r
2295 dnld_index = dnld_index + *p_raw_sec_hdr;
\r
2296 skip_frame = TRUE;
\r
2298 if (PHDNLD_TERMINATE_TYPE ==
\r
2299 (frame_type & PHDNLD_MARKER_MASK))
\r
2301 if(TRUE != skip_frame)
\r
2303 psDnldContext->raw_mode_upgrade =
\r
2304 (psDnldContext->raw_mode_upgrade &
\r
2305 ~(frame_type & ~PHDNLD_MARKER_MASK));
\r
2308 if(PHDNLD_NO_OPERATION ==
\r
2309 psDnldContext->raw_mode_upgrade)
\r
2319 if((FALSE == skip_frame)
\r
2320 && (FALSE == dnld_flag)
\r
2323 status = phDnldNfc_Send_Raw( psDnldContext, pHwRef,
\r
2324 (uint8_t *)(p_dnld_raw),
\r
2325 psDnldContext->tx_info.tx_offset,
\r
2326 (uint16_t)tx_length);
\r
2329 if( NFCSTATUS_PENDING == status )
\r
2331 psDnldContext->dnld_index = dnld_index;
\r
2332 psDnldContext->cur_frame_info= frame_type;
\r
2342 phDnldNfc_Upgrade_Sequence(
\r
2343 phDnldNfc_sContext_t *psDnldContext,
\r
2349 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2351 PHNFC_UNUSED_VARIABLE(pdata);
\r
2352 PHNFC_UNUSED_VARIABLE(length);
\r
2354 if(phDnld_Raw_Upgrade == psDnldContext->cur_dnld_seq)
\r
2356 status = phDnldNfc_Raw_Write( psDnldContext, pHwRef );
\r
2360 status = phDnldNfc_Resume_Write( psDnldContext, pHwRef );
\r
2371 phDnldNfc_sContext_t *psDnldContext,
\r
2377 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2378 phDnldNfc_eState_t dnld_next_state = (phDnldNfc_eState_t)
\r
2379 psDnldContext->cur_dnld_state;
\r
2380 phNfc_sCompletionInfo_t comp_info = {0,0,0};
\r
2382 switch( dnld_next_state )
\r
2384 case phDnld_Reset_State:
\r
2386 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
2387 PHDNLD_CMD_RESET , NULL, 0 );
\r
2388 switch( psDnldContext->cur_dnld_seq )
\r
2390 case phDnld_Update_Patchtable:
\r
2392 psDnldContext->next_dnld_state =
\r
2393 (uint8_t)phDnld_Unlock_State;
\r
2394 psDnldContext->next_dnld_seq =
\r
2395 (uint8_t)phDnld_Unlock_System;
\r
2398 #ifdef NXP_FW_PATCH_DISABLE
\r
2399 case phDnld_Deactivate_Patch:
\r
2401 case phDnld_Unlock_System:
\r
2404 psDnldContext->next_dnld_state =
\r
2405 (uint8_t)phDnld_Upgrade_State;
\r
2406 psDnldContext->next_dnld_seq =
\r
2407 (uint8_t)phDnld_Upgrade_Section;
\r
2408 #ifdef NXP_FW_DNLD_CHECK_PHASE
\r
2409 gphDnldPhase = NXP_FW_DNLD_CFG_PHASE;
\r
2410 #endif /* NXP_FW_DNLD_CHECK_PHASE */
\r
2413 case phDnld_Lock_System:
\r
2415 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
2416 psDnldContext->next_dnld_state =
\r
2417 (uint8_t)phDnld_Verify_State;
\r
2418 psDnldContext->next_dnld_seq =
\r
2419 (uint8_t)phDnld_Verify_Integrity;
\r
2421 /* (void ) memset( (void *) &psDnldContext->chk_integrity_crc,
\r
2422 0, sizeof(psDnldContext->chk_integrity_crc)); */
\r
2423 psDnldContext->next_dnld_state =
\r
2424 (uint8_t) phDnld_Complete_State;
\r
2425 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
2428 case phDnld_Verify_Integrity:
\r
2430 psDnldContext->next_dnld_state =
\r
2431 (uint8_t) phDnld_Complete_State;
\r
2436 status = (NFCSTATUS_PENDING == status)?
\r
2437 NFCSTATUS_SUCCESS: status;
\r
2443 case phDnld_Unlock_State:
\r
2446 status = phDnldNfc_Sequence( psDnldContext, pHwRef,
\r
2450 case phDnld_Upgrade_State:
\r
2452 status = phDnldNfc_Upgrade_Sequence( psDnldContext, pHwRef,
\r
2454 if ((NFCSTATUS_SUCCESS == status )
\r
2455 && (phDnld_Complete_State == psDnldContext->next_dnld_state))
\r
2458 psDnldContext->cur_dnld_seq =
\r
2459 (uint8_t)phDnld_Lock_System;
\r
2460 psDnldContext->next_dnld_seq =
\r
2461 psDnldContext->cur_dnld_seq;
\r
2463 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
2464 psDnldContext->next_dnld_state =
\r
2465 (uint8_t)phDnld_Verify_State;
\r
2466 psDnldContext->next_dnld_seq =
\r
2467 (uint8_t)phDnld_Verify_Integrity;
\r
2468 psDnldContext->cur_dnld_seq =
\r
2469 psDnldContext->next_dnld_seq;
\r
2470 status = phDnldNfc_Sequence( psDnldContext,
\r
2471 pHwRef, pdata, length);
\r
2473 /* (void ) memset( (void *) &psDnldContext->chk_integrity_crc,
\r
2474 0, sizeof(psDnldContext->chk_integrity_crc)); */
\r
2475 psDnldContext->next_dnld_state =
\r
2476 (uint8_t) phDnld_Complete_State;
\r
2477 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
2481 case phDnld_Verify_State:
\r
2483 status = phDnldNfc_Sequence( psDnldContext,
\r
2484 pHwRef, pdata, length);
\r
2487 case phDnld_Complete_State:
\r
2489 uint8_t integrity_chk = 0xA5;
\r
2491 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
2492 uint8_t verify_crc = 0x96;
\r
2494 if ( (NULL != psDnldContext->p_flash_code_crc)
\r
2495 && (NULL != psDnldContext->p_patch_code_crc)
\r
2496 && (NULL != psDnldContext->p_patch_table_crc)
\r
2499 uint8_t crc_i = 0;
\r
2500 uint16_t patch_table_crc = 0;
\r
2501 uint32_t flash_code_crc = 0;
\r
2502 uint32_t patch_code_crc = 0;
\r
2504 for (crc_i = 0; crc_i < DNLD_CRC32_SIZE; crc_i++ )
\r
2506 if (crc_i < DNLD_CRC16_SIZE )
\r
2508 patch_table_crc = patch_table_crc
\r
2509 | psDnldContext->chk_integrity_crc.patch_table.Chk_Crc16[crc_i]
\r
2510 << (crc_i * BYTE_SIZE) ;
\r
2512 flash_code_crc = flash_code_crc
\r
2513 | psDnldContext->chk_integrity_crc.flash_code.Chk_Crc32[crc_i]
\r
2514 << (crc_i * BYTE_SIZE) ;
\r
2515 patch_code_crc = patch_code_crc
\r
2516 | psDnldContext->chk_integrity_crc.patch_code.Chk_Crc32[crc_i]
\r
2517 << (crc_i * BYTE_SIZE) ;
\r
2519 verify_crc =(uint8_t)( (*((uint32_t *) psDnldContext->p_flash_code_crc)) !=
\r
2521 verify_crc |=(uint8_t)( (*((uint32_t *) psDnldContext->p_patch_code_crc)) !=
\r
2523 verify_crc |=(uint8_t)( (*((uint16_t *) psDnldContext->p_patch_table_crc)) !=
\r
2524 patch_table_crc );
\r
2528 DNLD_PRINT(" FW_DNLD: Flash, Patch code and Patch Table CRC ");
\r
2529 DNLD_PRINT(" Not Available in the Firmware \n");
\r
2532 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
2534 integrity_chk = psDnldContext->chk_integrity_crc.config_page.Chk_status +
\r
2535 psDnldContext->chk_integrity_crc.patch_table.Chk_status +
\r
2536 psDnldContext->chk_integrity_crc.flash_code.Chk_status +
\r
2537 psDnldContext->chk_integrity_crc.patch_code.Chk_status;
\r
2539 if ( ( 0 != integrity_chk )
\r
2540 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
2541 || ( 0 != verify_crc )
\r
2542 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
2545 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED);
\r
2551 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED);
\r
2556 if (NFCSTATUS_PENDING == status)
\r
2558 /* Write/Receive is still pending */
\r
2562 pphNfcIF_Notification_CB_t p_upper_notify =
\r
2563 psDnldContext->p_upper_notify;
\r
2564 void *p_upper_context =
\r
2565 psDnldContext->p_upper_context;
\r
2567 DNLD_DEBUG(" FW_DNLD: Resume Termination Status = %X \n", status);
\r
2569 comp_info.status = status;
\r
2571 (void) phDal4Nfc_Unregister(
\r
2572 psDnldContext->lower_interface.pcontext, pHwRef);
\r
2573 phDnldNfc_Release_Lower(psDnldContext, pHwRef);
\r
2574 phDnldNfc_Release_Resources(&psDnldContext);
\r
2575 #ifndef NFC_TIMER_CONTEXT
\r
2576 gpphDnldContext = psDnldContext;
\r
2578 /* Notify the Error/Success Scenario to the upper layer */
\r
2579 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, (uint8_t)
\r
2580 ((NFCSTATUS_SUCCESS == comp_info.status )? NFC_IO_SUCCESS: NFC_IO_ERROR),
\r
2588 phDnldNfc_Process_Response(
\r
2589 phDnldNfc_sContext_t *psDnldContext,
\r
2595 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
2596 phDnldNfc_sData_Hdr_t *resp_data =
\r
2597 (phDnldNfc_sData_Hdr_t *) pdata;
\r
2599 PHNFC_UNUSED_VARIABLE(pHwRef);
\r
2600 DNLD_DEBUG(" FW_DNLD: Receive Length = %X \n", length );
\r
2601 if(( psDnldContext->rx_info.rx_total == 0 )
\r
2602 && (PHDNLD_MIN_PACKET <= length)
\r
2605 psDnldContext->rx_info.rx_total =
\r
2606 ((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)|
\r
2607 resp_data->frame_length[1];
\r
2608 if( psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET == length )
\r
2611 DNLD_DEBUG(" FW_DNLD: Success Memory Read = %X \n",
\r
2612 psDnldContext->rx_info.rx_total);
\r
2613 #ifndef DNLD_SUMMARY
\r
2614 /* DNLD_PRINT_BUFFER("Receive Buffer",pdata,length); */
\r
2620 /* status = phDnldNfc_Receive( psDnldContext, pHwRef,
\r
2621 psDnldContext->p_resp_buffer,
\r
2622 (uint8_t)((psDnldContext->rx_info.rx_total <= PHDNLD_MAX_PACKET)?
\r
2623 psDnldContext->rx_info.rx_total: PHDNLD_MAX_PACKET) ); */
\r
2624 DNLD_PRINT(" FW_DNLD: Invalid Receive length ");
\r
2625 DNLD_DEBUG(": Length Expected = %X \n",
\r
2626 (psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET));
\r
2627 status = PHNFCSTVAL( CID_NFC_DNLD,
\r
2628 NFCSTATUS_INVALID_RECEIVE_LENGTH );
\r
2634 psDnldContext->rx_info.rx_total = 0 ;
\r
2635 status = PHNFCSTVAL( CID_NFC_DNLD,
\r
2636 NFCSTATUS_INVALID_RECEIVE_LENGTH );
\r
2646 phDnldNfc_Receive_Complete (
\r
2649 phNfc_sTransactionInfo_t *pInfo
\r
2652 NFCSTATUS status = NFCSTATUS_SUCCESS ;
\r
2653 void *pdata = NULL ;
\r
2654 phDnldNfc_sData_Hdr_t *resp_data = NULL;
\r
2655 uint16_t length = 0 ;
\r
2656 phNfc_sCompletionInfo_t comp_info = {0,0,0};
\r
2658 DNLD_PRINT("\n FW_DNLD: Receive Response .... ");
\r
2659 if ( (NULL != psContext)
\r
2660 && (NULL != pInfo)
\r
2661 && (NULL != pHwRef)
\r
2664 phDnldNfc_sContext_t *psDnldContext =
\r
2665 (phDnldNfc_sContext_t *)psContext;
\r
2666 status = pInfo->status ;
\r
2667 length = pInfo->length ;
\r
2668 pdata = pInfo->buffer;
\r
2670 if(status != NFCSTATUS_SUCCESS)
\r
2672 DNLD_DEBUG(" Failed. Status = %02X\n",status);
\r
2673 /* Handle the Error Scenario */
\r
2675 else if (NULL == pdata)
\r
2677 DNLD_DEBUG(" Failed. No data received. pdata = %02X\n",pdata);
\r
2678 /* Handle the Error Scenario */
\r
2679 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_FAILED );
\r
2681 else if ((0 == length)
\r
2682 || (PHDNLD_MIN_PACKET > length ))
\r
2684 DNLD_DEBUG(" Receive Response Length = %u .... \n",length);
\r
2685 /* Handle the Error Scenario */
\r
2686 #ifndef HAL_SW_DNLD_RLEN
\r
2687 status = PHNFCSTVAL( CID_NFC_DNLD,
\r
2688 NFCSTATUS_INVALID_RECEIVE_LENGTH );
\r
2694 #if defined(FW_DOWNLOAD_TIMER) && \
\r
2695 (FW_DOWNLOAD_TIMER == 2)
\r
2696 if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
\r
2698 phOsalNfc_Timer_Stop( psDnldContext->timer_id );
\r
2703 #ifndef DNLD_SUMMARY
\r
2704 DNLD_PRINT_BUFFER("Receive Buffer",pdata,length);
\r
2706 DNLD_DEBUG(" Receive Response Length = %X. \n", length);
\r
2708 resp_data = (phDnldNfc_sData_Hdr_t *) pdata;
\r
2710 switch(resp_data->frame_type)
\r
2712 case PHDNLD_RESP_SUCCESS:
\r
2714 uint16_t resp_length =
\r
2715 ((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)|
\r
2716 resp_data->frame_length[1];
\r
2717 switch ( psDnldContext->prev_cmd )
\r
2719 case PHDNLD_CMD_READ :
\r
2721 if( PHDNLD_NO_OPERATION
\r
2722 == psDnldContext->raw_mode_upgrade)
\r
2724 status = phDnldNfc_Process_Response(
\r
2725 psDnldContext, pHwRef, pdata , length);
\r
2727 if (NFCSTATUS_SUCCESS != status)
\r
2729 /* psDnldContext->dnld_retry++; */
\r
2730 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2731 /* psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY */
\r
2740 case PHDNLD_CMD_CHECK_INTEGRITY :
\r
2742 if( PHDNLD_NO_OPERATION
\r
2743 == psDnldContext->raw_mode_upgrade)
\r
2745 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
2746 phDnldNfc_sChkCrcComplete_t *p_dnld_crc_all =
\r
2747 &psDnldContext->chk_integrity_crc;
\r
2748 switch(psDnldContext->chk_integrity_param)
\r
2750 case CHK_INTEGRITY_CONFIG_PAGE_CRC:
\r
2752 (void)memcpy(&p_dnld_crc_all->config_page,
\r
2753 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
\r
2756 case CHK_INTEGRITY_PATCH_TABLE_CRC:
\r
2758 (void)memcpy(&p_dnld_crc_all->patch_table,
\r
2759 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
\r
2762 case CHK_INTEGRITY_FLASH_CODE_CRC:
\r
2764 (void)memcpy(&p_dnld_crc_all->flash_code,
\r
2765 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
\r
2768 case CHK_INTEGRITY_PATCH_CODE_CRC:
\r
2770 (void)memcpy(&p_dnld_crc_all->patch_code,
\r
2771 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
\r
2774 case CHK_INTEGRITY_COMPLETE_CRC:
\r
2776 (void)memcpy(p_dnld_crc_all,
\r
2777 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length);
\r
2778 DNLD_DEBUG(" FW_DNLD: Check Integrity Complete Structure Size = %X \n",
\r
2779 sizeof(psDnldContext->chk_integrity_crc));
\r
2784 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2785 NFCSTATUS_FEATURE_NOT_SUPPORTED);
\r
2789 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
2793 psDnldContext->raw_mode_upgrade =
\r
2794 (PHDNLD_SETUP_OPERATION | PHDNLD_ADVANCED_OPERATION);
\r
2795 /* psDnldContext->raw_mode_upgrade =
\r
2796 (psDnldContext->raw_mode_upgrade &
\r
2797 ( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); */
\r
2801 case PHDNLD_CMD_WRITE:
\r
2803 psDnldContext->dnld_retry = 0;
\r
2806 case PHDNLD_CMD_SEC_WRITE:
\r
2808 psDnldContext->dnld_retry = 0;
\r
2811 case PHDNLD_CMD_ACTIVATE_PATCH:
\r
2812 case PHDNLD_CMD_CHECK:
\r
2815 if( PHDNLD_NO_OPERATION
\r
2816 == psDnldContext->raw_mode_upgrade)
\r
2818 if( ( (PHDNLD_MIN_PACKET > length)
\r
2819 || ( 0 != resp_length) )
\r
2822 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2823 status = PHNFCSTVAL( CID_NFC_DNLD,
\r
2824 NFCSTATUS_INVALID_RECEIVE_LENGTH );
\r
2828 psDnldContext->dnld_retry = 0;
\r
2833 psDnldContext->raw_mode_upgrade =
\r
2834 (psDnldContext->raw_mode_upgrade & ~PHDNLD_RECOVER_OPERATION);
\r
2838 } /* End of the Previous Command Switch Case */
\r
2840 }/* Case PHDNLD_RESP_SUCCESS*/
\r
2841 case PHDNLD_RESP_TIMEOUT:
\r
2842 case PHDNLD_RESP_CRC_ERROR:
\r
2843 case PHDNLD_RESP_WRITE_ERROR:
\r
2845 if(psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY )
\r
2847 psDnldContext->dnld_retry++;
\r
2849 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2850 resp_data->frame_type);
\r
2853 /* fall through */
\r
2854 case PHDNLD_RESP_ACCESS_DENIED:
\r
2855 case PHDNLD_RESP_INVALID_PARAMETER:
\r
2856 case PHDNLD_RESP_INVALID_LENGTH:
\r
2857 /* Initial Frame Checksum */
\r
2858 case PHDNLD_RESP_CHKSUM_ERROR:
\r
2859 case PHDNLD_RESP_MEMORY_UPDATE_ERROR:
\r
2861 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2862 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2863 resp_data->frame_type);
\r
2866 case PHDNLD_RESP_PROTOCOL_ERROR:
\r
2868 if(( PHDNLD_NO_OPERATION
\r
2869 == psDnldContext->raw_mode_upgrade)
\r
2870 || ( PHDNLD_ADVANCED_OPERATION
\r
2871 == psDnldContext->raw_mode_upgrade)
\r
2874 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2875 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2876 NFCSTATUS_INVALID_FORMAT);
\r
2878 else if( (PHDNLD_NORMAL_OPERATION
\r
2879 & psDnldContext->raw_mode_upgrade)
\r
2882 psDnldContext->raw_mode_upgrade =
\r
2883 (psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION);
\r
2885 else if ( PHDNLD_RECOVER_OPERATION
\r
2886 & psDnldContext->raw_mode_upgrade )
\r
2888 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2889 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2890 NFCSTATUS_INVALID_FORMAT);
\r
2894 psDnldContext->raw_mode_upgrade =
\r
2895 (psDnldContext->raw_mode_upgrade &
\r
2896 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
\r
2900 case PHDNLD_RESP_VERSION_UPTODATE:
\r
2902 /* TODO: to make sure that the Advance Frames are sent to get
\r
2903 * the updated status */
\r
2904 if ( PHDNLD_ADVANCED_OPERATION
\r
2905 == psDnldContext->raw_mode_upgrade)
\r
2907 status = ( CID_NFC_DNLD << BYTE_SIZE ) ;
\r
2909 else if ( PHDNLD_NO_OPERATION
\r
2910 != psDnldContext->raw_mode_upgrade)
\r
2913 psDnldContext->raw_mode_upgrade =
\r
2914 (psDnldContext->raw_mode_upgrade &
\r
2915 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
\r
2922 case PHDNLD_RESP_CMD_NOT_SUPPORTED:
\r
2925 if ( PHDNLD_NO_OPERATION
\r
2926 == psDnldContext->raw_mode_upgrade)
\r
2928 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2929 NFCSTATUS_FEATURE_NOT_SUPPORTED);
\r
2931 else if ( PHDNLD_ADVANCED_OPERATION
\r
2932 == psDnldContext->raw_mode_upgrade)
\r
2934 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2935 NFCSTATUS_FEATURE_NOT_SUPPORTED);
\r
2938 else if( (PHDNLD_NORMAL_OPERATION
\r
2939 & psDnldContext->raw_mode_upgrade)
\r
2942 psDnldContext->raw_mode_upgrade =
\r
2943 (psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION);
\r
2945 else if ( PHDNLD_SETUP_OPERATION
\r
2946 & psDnldContext->raw_mode_upgrade )
\r
2948 psDnldContext->raw_mode_upgrade =
\r
2949 (psDnldContext->raw_mode_upgrade & ~PHDNLD_SETUP_OPERATION);
\r
2954 psDnldContext->raw_mode_upgrade =
\r
2955 (psDnldContext->raw_mode_upgrade &
\r
2956 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK ));
\r
2960 /* The Chaining of the Command Frame
\r
2961 was Successful in the Download Mode */
\r
2962 case PHDNLD_RESP_CHAINING_SUCCESS:
\r
2964 /* TODO: Handle the Corner Case Scenarios
\r
2965 * the updated status */
\r
2966 psDnldContext->dnld_retry = 0x00;
\r
2969 /* The Error during the Chaining the Command Frame in the Download Mode */
\r
2970 case PHDNLD_RESP_CHAINING_ERROR:
\r
2972 /* TODO: Restart the Chunk in Corner Case
\r
2973 * the updated status */
\r
2974 psDnldContext->dnld_retry++;
\r
2975 phDnldNfc_Tx_Reset(psDnldContext);
\r
2978 /* The Command is not allowed anymore in the Download Mode */
\r
2979 case PHDNLD_RESP_CMD_NOT_ALLOWED:
\r
2982 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY;
\r
2983 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
2984 NFCSTATUS_NOT_ALLOWED);
\r
2988 } /* End of the Response Frame Type Switch */
\r
2990 if (NFCSTATUS_PENDING != status)
\r
2992 if ((NFCSTATUS_SUCCESS != status) &&
\r
2993 (psDnldContext->dnld_retry >= NXP_MAX_DNLD_RETRY))
\r
2995 pphNfcIF_Notification_CB_t p_upper_notify =
\r
2996 psDnldContext->p_upper_notify;
\r
2997 void *p_upper_context =
\r
2998 psDnldContext->p_upper_context;
\r
3000 comp_info.status = status;
\r
3001 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
\r
3002 status = phDal4Nfc_Unregister(
\r
3003 psDnldContext->lower_interface.pcontext, pHwRef);
\r
3004 phDnldNfc_Release_Lower(psDnldContext, pHwRef);
\r
3005 phDnldNfc_Release_Resources(&psDnldContext);
\r
3006 #ifndef NFC_TIMER_CONTEXT
\r
3007 gpphDnldContext = psDnldContext;
\r
3009 /* Notify the Error/Success Scenario to the upper layer */
\r
3010 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
\r
3011 (uint8_t) NFC_IO_ERROR, &comp_info );
\r
3013 else if ( (NFCSTATUS_SUCCESS != status) &&
\r
3014 (NFCSTATUS_SUCCESS == PHNFCSTATUS(status))
\r
3017 pphNfcIF_Notification_CB_t p_upper_notify =
\r
3018 psDnldContext->p_upper_notify;
\r
3019 void *p_upper_context =
\r
3020 psDnldContext->p_upper_context;
\r
3022 comp_info.status = NFCSTATUS_SUCCESS;
\r
3023 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
\r
3024 status = phDal4Nfc_Unregister(
\r
3025 psDnldContext->lower_interface.pcontext, pHwRef);
\r
3026 phDnldNfc_Release_Lower(psDnldContext, pHwRef);
\r
3027 phDnldNfc_Release_Resources(&psDnldContext);
\r
3028 #ifndef NFC_TIMER_CONTEXT
\r
3029 gpphDnldContext = psDnldContext;
\r
3031 /* Notify the Error/Success Scenario to the upper layer */
\r
3032 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
\r
3033 (uint8_t) NFC_IO_SUCCESS, &comp_info );
\r
3036 else if (NFCSTATUS_FEATURE_NOT_SUPPORTED == PHNFCSTATUS(status))
\r
3038 pphNfcIF_Notification_CB_t p_upper_notify =
\r
3039 psDnldContext->p_upper_notify;
\r
3040 void *p_upper_context =
\r
3041 psDnldContext->p_upper_context;
\r
3043 comp_info.status = status;
\r
3044 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status);
\r
3045 status = phDal4Nfc_Unregister(
\r
3046 psDnldContext->lower_interface.pcontext, pHwRef);
\r
3047 phDnldNfc_Release_Lower(psDnldContext, pHwRef);
\r
3048 phDnldNfc_Release_Resources(&psDnldContext);
\r
3049 #ifndef NFC_TIMER_CONTEXT
\r
3050 gpphDnldContext = psDnldContext;
\r
3052 /* Notify the Error/Success Scenario to the upper layer */
\r
3053 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef,
\r
3054 (uint8_t) NFC_IO_SUCCESS, &comp_info );
\r
3059 /* DNLD_PRINT(" FW_DNLD: Successful.\n"); */
\r
3060 psDnldContext->resp_length = /* PHDNLD_MIN_PACKET */ 0 ;
\r
3061 status = phDnldNfc_Set_Seq(psDnldContext,
\r
3063 status = phDnldNfc_Resume( psDnldContext,
\r
3064 pHwRef, pdata, length );
\r
3067 } /* End of status != Success */
\r
3074 phDnldNfc_Send_Complete (
\r
3077 phNfc_sTransactionInfo_t *pInfo
\r
3080 NFCSTATUS status = NFCSTATUS_SUCCESS ;
\r
3081 uint16_t length = 0;
\r
3083 DNLD_PRINT(" FW_DNLD: Send Data .... ");
\r
3084 if ( (NULL != psContext)
\r
3085 && (NULL != pInfo)
\r
3086 && (NULL != pHwRef)
\r
3089 phDnldNfc_sContext_t *psDnldContext =
\r
3090 (phDnldNfc_sContext_t *)psContext;
\r
3091 status = pInfo->status ;
\r
3092 length = pInfo->length ;
\r
3093 if(status != NFCSTATUS_SUCCESS)
\r
3095 DNLD_DEBUG(" Failed. Status = %02X\n",status);
\r
3096 /* Handle the Error Scenario */
\r
3100 DNLD_PRINT(" Successful.\n");
\r
3101 (void)memset((void *)&psDnldContext->dnld_data, 0,
\r
3102 sizeof(psDnldContext->dnld_data));
\r
3103 if ((PHDNLD_CMD_SET_HIF != psDnldContext->prev_cmd)
\r
3104 && (PHDNLD_CMD_RESET != psDnldContext->prev_cmd))
\r
3106 psDnldContext->rx_info.rx_total = 0;
\r
3107 status = phDnldNfc_Receive( psDnldContext, pHwRef,
\r
3108 (uint8_t *)(&psDnldContext->dnld_resp),
\r
3109 psDnldContext->resp_length);
\r
3113 psDnldContext->resp_length = 0;
\r
3114 psDnldContext->dnld_retry = 0;
\r
3115 /* clock unstable after SW reset command, especially on UART
\r
3116 * platform because of its sensitivity to clock. Experimentally
\r
3117 * we found clock unstable for 750us. Delay for 5ms to be sure.
\r
3119 if( PHDNLD_CMD_RESET == psDnldContext->prev_cmd )
\r
3121 DO_DELAY(PHDNLD_DNLD_DELAY);
\r
3123 #if defined(FW_DOWNLOAD_TIMER) && \
\r
3124 (FW_DOWNLOAD_TIMER == 2)
\r
3126 if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id )
\r
3128 phOsalNfc_Timer_Stop( psDnldContext->timer_id );
\r
3132 status = phDnldNfc_Set_Seq(psDnldContext,
\r
3136 if(NFCSTATUS_SUCCESS == status )
\r
3138 status = phDnldNfc_Resume( psDnldContext, pHwRef, NULL, length);
\r
3141 } /* End of status != Success */
\r
3143 } /* End of Context != NULL */
\r
3150 phDnldNfc_Send_Command(
\r
3151 phDnldNfc_sContext_t *psDnldContext,
\r
3155 uint16_t param_length
\r
3158 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
3159 uint16_t tx_length = 0;
\r
3160 uint16_t rx_length = 0;
\r
3161 uint8_t **pp_resp_data = &psDnldContext->p_resp_buffer;
\r
3162 phDnldNfc_sData_t *p_dnld_data =
\r
3163 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
3167 case PHDNLD_CMD_RESET:
\r
3169 (void)memset((void *)&psDnldContext->dnld_data, 0,
\r
3170 sizeof(psDnldContext->dnld_data));
\r
3173 case PHDNLD_CMD_READ:
\r
3175 phDnldNfc_sData_t *p_dnld_data =
\r
3176 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
3177 phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */
\r
3178 &p_dnld_data->param_info.data_param;
\r
3179 tx_length = PHDNLD_CMD_READ_LEN;
\r
3180 if (NULL != *pp_resp_data)
\r
3182 phOsalNfc_FreeMemory(*pp_resp_data);
\r
3183 *pp_resp_data = NULL;
\r
3185 rx_length = (uint16_t) (((uint16_t)param_info->data_len[0]
\r
3186 << BYTE_SIZE) + param_info->data_len[1]);
\r
3188 psDnldContext->resp_length =
\r
3189 (( rx_length + PHDNLD_MIN_PACKET ));
\r
3190 (void)phDnldNfc_Allocate_Resource( (void **) pp_resp_data,
\r
3194 case PHDNLD_CMD_WRITE:
\r
3195 case PHDNLD_CMD_SEC_WRITE:
\r
3197 phDnldNfc_sData_t *p_dnld_data =
\r
3198 (phDnldNfc_sData_t *)psDnldContext->dnld_data;
\r
3199 phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */
\r
3200 &p_dnld_data->param_info.data_param;
\r
3201 tx_length = (uint16_t) (((uint16_t)param_info->data_len[0]
\r
3202 << BYTE_SIZE) + param_info->data_len[1]
\r
3203 + PHDNLD_CMD_WRITE_MIN_LEN );
\r
3205 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
3206 if ((0 != param_length) && (NULL != params))
\r
3208 (void)memcpy(param_info->data_packet, params, param_length);
\r
3212 case PHDNLD_CMD_CHECK:
\r
3214 tx_length = PHDNLD_CMD_CHECK_LEN;
\r
3215 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
3218 case PHDNLD_CMD_ENCAPSULATE:
\r
3221 if ((0 != param_length) && (NULL != params))
\r
3223 p_dnld_data->frame_type =
\r
3224 PHDNLD_CMD_ENCAPSULATE;
\r
3225 (void)memcpy((void *)( ((uint8_t *)p_dnld_data)
\r
3226 + PHDNLD_FRAME_DATA_OFFSET)
\r
3227 , params, param_length);
\r
3228 tx_length = param_length;
\r
3230 p_dnld_data->frame_length[i++] =
\r
3231 (uint8_t)(tx_length >> BYTE_SIZE);
\r
3232 p_dnld_data->frame_length[i] =
\r
3233 (uint8_t)( tx_length & BYTE_MASK );
\r
3234 tx_length += PHDNLD_FRAME_DATA_OFFSET;
\r
3236 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
3238 status = phDnldNfc_Send( psDnldContext, pHwRef ,
\r
3239 (uint8_t *)p_dnld_data, tx_length);
\r
3243 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
3244 NFCSTATUS_NOT_ALLOWED);
\r
3248 case PHDNLD_CMD_SET_HIF:
\r
3251 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
3254 case PHDNLD_CMD_ACTIVATE_PATCH:
\r
3256 psDnldContext->resp_length = PHDNLD_MIN_PACKET;
\r
3257 if ((NULL != params) && ( param_length > 0 ))
\r
3259 p_dnld_data->param_info.cmd_param =
\r
3260 (*(uint8_t *)params);
\r
3261 tx_length = param_length;
\r
3265 p_dnld_data->param_info.cmd_param = FALSE;
\r
3270 case PHDNLD_CMD_CHECK_INTEGRITY:
\r
3272 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
3273 if ((NULL != params) && ( param_length > 0 ))
\r
3275 psDnldContext->chk_integrity_param =
\r
3276 (phDnldNfc_eChkCrc_t)(*(uint8_t *)params);
\r
3277 tx_length = param_length;
\r
3281 psDnldContext->chk_integrity_param = CHK_INTEGRITY_COMPLETE_CRC;
\r
3284 p_dnld_data->param_info.cmd_param =
\r
3285 (uint8_t) psDnldContext->chk_integrity_param;
\r
3286 switch(psDnldContext->chk_integrity_param)
\r
3288 case CHK_INTEGRITY_CONFIG_PAGE_CRC:
\r
3289 case CHK_INTEGRITY_PATCH_TABLE_CRC:
\r
3291 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
3292 + CHECK_INTEGRITY_RESP_CRC16_LEN;
\r
3295 case CHK_INTEGRITY_FLASH_CODE_CRC:
\r
3296 case CHK_INTEGRITY_PATCH_CODE_CRC:
\r
3298 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
3299 + CHECK_INTEGRITY_RESP_CRC32_LEN;
\r
3302 case CHK_INTEGRITY_COMPLETE_CRC:
\r
3305 psDnldContext->resp_length = PHDNLD_MIN_PACKET
\r
3306 + CHECK_INTEGRITY_RESP_COMP_LEN;
\r
3312 p_dnld_data->param_info.cmd_param =
\r
3313 (uint8_t) CHK_INTEGRITY_COMPLETE_CRC;
\r
3315 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
3320 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED);
\r
3324 if (NFCSTATUS_SUCCESS == status)
\r
3328 p_dnld_data->frame_type = cmd;
\r
3329 p_dnld_data->frame_length[i++] =
\r
3330 (uint8_t)(tx_length >> BYTE_SIZE);
\r
3331 p_dnld_data->frame_length[i] =
\r
3332 (uint8_t)( tx_length & BYTE_MASK );
\r
3333 tx_length = tx_length + PHDNLD_MIN_PACKET;
\r
3334 status = phDnldNfc_Send( psDnldContext, pHwRef ,
\r
3335 (uint8_t *)p_dnld_data, tx_length);
\r
3336 if(NFCSTATUS_PENDING == status)
\r
3338 psDnldContext->prev_cmd = cmd;
\r
3340 if( PHDNLD_CMD_RESET == cmd )
\r
3341 DO_DELAY(PHDNLD_DNLD_DELAY); //this seems like its on the wrong thread
\r
3350 phDnldNfc_Check_FW(
\r
3351 phHal_sHwReference_t *pHwRef,
\r
3352 fw_data_hdr_t *cur_fw_hdr
\r
3355 NFCSTATUS status = NFCSTATUS_FAILED;
\r
3357 if ( !pHwRef->device_info.fw_version )
\r
3359 /* Override the Firmware Version Check and upgrade*/;
\r
3360 DNLD_PRINT(" FW_DNLD_CHK: Forceful Upgrade of the Firmware .... Required \n");
\r
3361 status = NFCSTATUS_SUCCESS;
\r
3363 else if ( (pHwRef->device_info.fw_version >> (BYTE_SIZE * 2))
\r
3364 != ( cur_fw_hdr->fw_version >> (BYTE_SIZE * 2) ))
\r
3366 /* Check for the Compatible Romlib Version for the Hardware */
\r
3367 DNLD_PRINT(" FW_DNLD: IC Hardware Version Mismatch.. \n");
\r
3368 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED );
\r
3370 else if (( pHwRef->device_info.fw_version < cur_fw_hdr->fw_version )
\r
3373 /* TODO: Firmware Version Check and upgrade*/
\r
3374 DNLD_PRINT(" FW_DNLD: Older Firmware Upgrading to newerone.... \n");
\r
3375 status = NFCSTATUS_SUCCESS;
\r
3377 #ifdef NXP_FW_CHK_LATEST
\r
3378 else if (( pHwRef->device_info.fw_version > cur_fw_hdr->fw_version )
\r
3381 DNLD_PRINT(" FW_DNLD: Newer than the Stored One .... \n");
\r
3382 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED );
\r
3384 #endif /* NXP_FW_CHK_LATEST */
\r
3387 DNLD_PRINT(" FW_DNLD: Already Updated .... \n");
\r
3388 status = ( CID_NFC_DNLD << BYTE_SIZE ) ;
\r
3397 phDnldNfc_Process_FW(
\r
3398 phDnldNfc_sContext_t *psDnldContext,
\r
3399 phHal_sHwReference_t *pHwRef
\r
3400 #ifdef NXP_FW_PARAM
\r
3401 ,uint8_t *nxp_nfc_fw
\r
3402 ,uint32_t nxp_fw_len
\r
3406 NFCSTATUS status = NFCSTATUS_FAILED;
\r
3407 section_info_t *p_cur_sec = NULL;
\r
3408 static unsigned sec_type;
\r
3409 uint32_t fw_index = 0;
\r
3410 #ifdef NXP_NFC_MULTIPLE_FW
\r
3411 phDnldNfc_sFwImageInfo_t *p_cur_fw = NULL;
\r
3412 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */
\r
3413 fw_data_hdr_t *cur_fw_hdr = NULL;
\r
3414 uint8_t sec_index = 0;
\r
3417 psDnldContext->p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw;
\r
3419 #ifdef NXP_NFC_MULTIPLE_FW
\r
3421 /* TODO: Create a memory of pointers to store all the Firmwares */
\r
3422 if( (NXP_NFC_IMAG_FW_MAX > psDnldContext->p_img_hdr->no_of_fw_img)
\r
3423 && (0 != psDnldContext->p_img_hdr->no_of_fw_img)
\r
3426 ( void )phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_img_info,
\r
3427 (psDnldContext->p_img_hdr->no_of_fw_img * sizeof(phDnldNfc_sFwImageInfo_t)));
\r
3429 if(NULL != psDnldContext->p_img_info)
\r
3431 p_cur_fw = psDnldContext->p_img_info;
\r
3434 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */
\r
3436 fw_index = sizeof (img_data_hdr_t);
\r
3438 for ( i=0; i < psDnldContext->p_img_hdr->no_of_fw_img; i++ )
\r
3441 psDnldContext->p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index );
\r
3443 #ifdef NXP_NFC_MULTIPLE_FW
\r
3444 if(NULL != p_cur_fw)
\r
3446 ( p_cur_fw + i)->p_fw_hdr = psDnldContext->p_fw_hdr;
\r
3448 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */
\r
3449 cur_fw_hdr = psDnldContext->p_fw_hdr;
\r
3451 fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN);
\r
3453 status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr);
\r
3457 if ( ( NFCSTATUS_SUCCESS == status )
\r
3458 #if defined (NXP_FW_INTEGRITY_VERIFY)
\r
3459 || (NFCSTATUS_SUCCESS == PHNFCSTATUS(status) )
\r
3460 #endif /* !defined (NXP_FW_INTEGRITY_VERIFY) */
\r
3463 if( (BYTE_MASK > cur_fw_hdr->no_of_sections)
\r
3464 && (0 != cur_fw_hdr->no_of_sections)
\r
3467 (void) phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_fw_sec,
\r
3468 (cur_fw_hdr->no_of_sections * sizeof(section_info_t)));
\r
3470 if(NULL != psDnldContext->p_fw_sec)
\r
3472 DNLD_DEBUG(" FW_DNLD: FW Index : %x \n",
\r
3475 DNLD_DEBUG(" FW_DNLD: No of Sections : %x \n\n",
\r
3476 cur_fw_hdr->no_of_sections);
\r
3478 for(sec_index = 0; sec_index
\r
3479 < cur_fw_hdr->no_of_sections; sec_index++ )
\r
3481 p_cur_sec = ((section_info_t *)
\r
3482 (psDnldContext->p_fw_sec + sec_index ));
\r
3484 p_cur_sec->p_sec_hdr = (section_hdr_t *)
\r
3485 (nxp_nfc_fw + fw_index);
\r
3487 DNLD_DEBUG(" FW_DNLD: Section %x \n", sec_index);
\r
3488 DNLD_DEBUG(" FW_DNLD: Section Header Len : %x ",
\r
3489 p_cur_sec->p_sec_hdr->section_hdr_len);
\r
3490 DNLD_DEBUG(" Section Address : %x ",
\r
3491 p_cur_sec->p_sec_hdr->section_address);
\r
3492 DNLD_DEBUG(" Section Length : %x ",
\r
3493 p_cur_sec->p_sec_hdr->section_length);
\r
3494 DNLD_DEBUG(" Section Memory Type : %x \n",
\r
3495 p_cur_sec->p_sec_hdr->section_mem_type);
\r
3497 sec_type = (unsigned int)p_cur_sec->p_sec_hdr->section_mem_type;
\r
3499 if((sec_type & DNLD_TRIM_MASK))
\r
3501 p_cur_sec->p_trim_data = (uint8_t *)
\r
3502 (nxp_nfc_fw + fw_index + sizeof(section_hdr_t));
\r
3506 p_cur_sec->p_trim_data = NULL;
\r
3509 if (0 == sec_index)
\r
3511 if ((sec_type & DNLD_SM_UNLOCK_MASK))
\r
3513 (void)phDnldNfc_Set_Seq(psDnldContext,
\r
3518 (void)phDnldNfc_Set_Seq(psDnldContext,
\r
3522 p_cur_sec->section_read = FALSE;
\r
3524 p_cur_sec->section_offset = 0;
\r
3526 p_cur_sec->p_sec_data = ((uint8_t *) nxp_nfc_fw) + fw_index +
\r
3527 (p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN);
\r
3529 fw_index = fw_index +
\r
3530 (p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN)
\r
3531 + p_cur_sec->p_sec_hdr->section_length;
\r
3534 if( 0 != p_cur_sec->p_sec_hdr->section_checksum )
\r
3536 DNLD_DEBUG(" FW_DNLD: Section checksum : %x \n",
\r
3537 p_cur_sec->p_sec_hdr->section_checksum );
\r
3539 p_cur_sec->p_sec_chksum = ( uint8_t *)(nxp_nfc_fw + fw_index);
\r
3541 fw_index = fw_index +
\r
3542 p_cur_sec->p_sec_hdr->section_checksum;
\r
3545 DNLD_DEBUG(" FW_DNLD: FW Index : %x \n", fw_index );
\r
3547 #if (NXP_FW_INTEGRITY_CHK >= 0x01)
\r
3548 switch( p_cur_sec->p_sec_hdr->section_address )
\r
3550 case DNLD_FW_CODE_ADDR:
\r
3552 psDnldContext->p_flash_code_crc =
\r
3553 p_cur_sec->p_sec_data
\r
3554 + p_cur_sec->p_sec_hdr->section_length
\r
3555 - DNLD_CRC32_SIZE;
\r
3558 case DNLD_PATCH_CODE_ADDR:
\r
3560 psDnldContext->p_patch_code_crc =
\r
3561 p_cur_sec->p_sec_data
\r
3562 + p_cur_sec->p_sec_hdr->section_length
\r
3563 - DNLD_CRC32_SIZE;
\r
3566 case DNLD_PATCH_TABLE_ADDR:
\r
3568 psDnldContext->p_patch_table_crc =
\r
3569 p_cur_sec->p_sec_data
\r
3570 + p_cur_sec->p_sec_hdr->section_length
\r
3571 - DNLD_CRC16_SIZE;
\r
3579 } /* End of Address Switch */
\r
3580 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */
\r
3581 } /* End of For Loop */
\r
3582 } /* End of the Null Check */
\r
3585 status = PHNFCSTVAL(CID_NFC_DNLD,
\r
3586 NFCSTATUS_INSUFFICIENT_RESOURCES);
\r
3591 (0 == cur_fw_hdr->no_of_sections)
\r
3592 && (PHDNLD_FW_PATCH_SEC == cur_fw_hdr->fw_patch)
\r
3595 psDnldContext->p_fw_raw = (uint8_t *)(nxp_nfc_fw + fw_index);
\r
3597 psDnldContext->raw_mode_upgrade = PHDNLD_COMPLETE_OPERATION;
\r
3599 (void)phDnldNfc_Set_Seq(psDnldContext,
\r
3604 DNLD_PRINT("********* Empty Section and Firmware ******************\n\n");
\r
3607 DNLD_PRINT("*******************************************\n\n");
\r
3613 #if !defined (NXP_FW_INTEGRITY_VERIFY)
\r
3616 phDnldNfc_Run_Check(
\r
3617 phHal_sHwReference_t *pHwRef
\r
3618 #ifdef NXP_FW_PARAM
\r
3619 ,uint8_t *nxp_nfc_fw
\r
3620 uint32_t fw_length
\r
3624 NFCSTATUS status = NFCSTATUS_FAILED;
\r
3625 uint32_t fw_index = 0;
\r
3626 img_data_hdr_t *p_img_hdr = NULL;
\r
3627 fw_data_hdr_t *p_fw_hdr = NULL;
\r
3628 fw_data_hdr_t *cur_fw_hdr = NULL;
\r
3631 p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw;
\r
3633 fw_index = sizeof (img_data_hdr_t);
\r
3635 for ( i=0; i < p_img_hdr->no_of_fw_img; i++ )
\r
3637 p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index );
\r
3638 /* TODO: Create a memory of pointers to store all the Firmwares */
\r
3639 cur_fw_hdr = p_fw_hdr;
\r
3641 fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN);
\r
3643 status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr);
\r
3648 #endif /* #if !defined (NXP_FW_INTEGRITY_VERIFY) */
\r
3655 #ifdef NFC_TIMER_CONTEXT
\r
3656 , void *dnld_cntxt
\r
3661 phNfc_sCompletionInfo_t comp_info = {0,0,0};
\r
3663 phDnldNfc_sContext_t *p_dnld_context = NULL;
\r
3665 #ifdef NFC_TIMER_CONTEXT
\r
3666 p_dnld_context = (phDnldNfc_sContext_t *)dnld_cntxt;
\r
3668 p_dnld_context = gpphDnldContext;
\r
3671 if ( ( NULL != p_dnld_context)
\r
3672 && (abort_id == p_dnld_context->timer_id ))
\r
3674 pphNfcIF_Notification_CB_t p_upper_notify =
\r
3675 p_dnld_context->p_upper_notify;
\r
3676 void *p_upper_context =
\r
3677 p_dnld_context->p_upper_context;
\r
3678 phHal_sHwReference_t *pHwRef = p_dnld_context->p_hw_ref;
\r
3680 (void)phDal4Nfc_Unregister(
\r
3681 p_dnld_context->lower_interface.pcontext, pHwRef );
\r
3682 phDnldNfc_Release_Lower(p_dnld_context, pHwRef);
\r
3683 phDnldNfc_Release_Resources(&p_dnld_context);
\r
3684 #ifndef NFC_TIMER_CONTEXT
\r
3685 gpphDnldContext = p_dnld_context;
\r
3688 /* Notify the Error/Success Scenario to the upper layer */
\r
3689 DNLD_DEBUG(" FW_DNLD: FW_DNLD Aborted with %x Timer Timeout \n",
\r
3691 comp_info.status = NFCSTATUS_FAILED ;
\r
3692 phDnldNfc_Notify( p_upper_notify, p_upper_context,
\r
3693 pHwRef, (uint8_t) NFC_IO_ERROR, &comp_info );
\r
3702 phDnldNfc_Upgrade (
\r
3703 phHal_sHwReference_t *pHwRef,
\r
3704 #ifdef NXP_FW_PARAM
\r
3706 uint8_t *nxp_nfc_fw,
\r
3707 uint32_t fw_length,
\r
3709 pphNfcIF_Notification_CB_t upgrade_complete,
\r
3713 phDnldNfc_sContext_t *psDnldContext = NULL;
\r
3714 phNfcIF_sReference_t dnldReference = { NULL,0,0 };
\r
3715 phNfcIF_sCallBack_t if_callback = { NULL, NULL, NULL, NULL };
\r
3716 phNfc_sLowerIF_t *plower_if = NULL;
\r
3717 NFCSTATUS status = NFCSTATUS_SUCCESS;
\r
3718 section_info_t *p_cur_sec = NULL;
\r
3719 unsigned sec_type = 0;
\r
3721 if( (NULL == pHwRef)
\r
3724 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER);
\r
3728 DNLD_PRINT(" FW_DNLD: Starting the FW Upgrade Sequence .... \n");
\r
3731 phDnldNfc_Allocate_Resource((void **)
\r
3732 &psDnldContext,sizeof(phDnldNfc_sContext_t));
\r
3733 if(psDnldContext != NULL)
\r
3735 #ifndef NFC_TIMER_CONTEXT
\r
3736 gpphDnldContext = psDnldContext;
\r
3738 psDnldContext->p_hw_ref = pHwRef;
\r
3739 psDnldContext->timer_id = NXP_INVALID_TIMER_ID;
\r
3741 DNLD_PRINT(" FW_DNLD: Initialisation in Progress.... \n");
\r
3743 if_callback.pif_ctxt = psDnldContext ;
\r
3744 if_callback.send_complete = &phDnldNfc_Send_Complete;
\r
3745 if_callback.receive_complete= &phDnldNfc_Receive_Complete;
\r
3746 /* if_callback.notify = &phDnldNfc_Notify_Event; */
\r
3747 plower_if = dnldReference.plower_if = &(psDnldContext->lower_interface);
\r
3748 status = phDal4Nfc_Register(&dnldReference, if_callback,
\r
3750 DNLD_DEBUG(" FW_DNLD: Lower Layer Register, Status = %02X\n",status);
\r
3752 if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init))
\r
3754 /* psDnldContext->p_config_params = pHwConfig ; */
\r
3755 status = plower_if->init((void *)plower_if->pcontext,
\r
3757 DNLD_DEBUG(" FW_DNLD: Lower Layer Initialisation, Status = %02X\n",status);
\r
3761 /* TODO: Handle Initialisation in the Invalid State */
\r
3763 /* The Lower layer Initialisation successful */
\r
3764 if (NFCSTATUS_SUCCESS == status)
\r
3766 psDnldContext->p_upper_notify = upgrade_complete;
\r
3767 psDnldContext->p_upper_context = context;
\r
3769 status = phDnldNfc_Process_FW( psDnldContext, pHwRef
\r
3770 #ifdef NXP_FW_PARAM
\r
3771 ,*nxp_nfc_fw , fw_length
\r
3775 if (NFCSTATUS_SUCCESS == status)
\r
3777 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
3778 PHDNLD_CMD_RESET , NULL , 0 );
\r
3779 if (NFCSTATUS_PENDING == status)
\r
3781 DNLD_PRINT("\n FW_DNLD: Initial Reset .... \n");
\r
3783 #if defined(FW_DOWNLOAD_TIMER)
\r
3785 psDnldContext->timer_id = phOsalNfc_Timer_Create( );
\r
3787 #if (FW_DOWNLOAD_TIMER < 2)
\r
3788 phOsalNfc_Timer_Start( psDnldContext->timer_id,
\r
3789 NXP_DNLD_COMPLETE_TIMEOUT,
\r
3790 (ppCallBck_t) phDnldNfc_Abort
\r
3791 #ifdef NFC_TIMER_CONTEXT
\r
3792 , (void *) psDnldContext
\r
3796 #endif /* #if (FW_DOWNLOAD_TIMER < 2) */
\r
3798 #endif /* #if defined(FW_DOWNLOAD_TIMER) */
\r
3802 else if (NFCSTATUS_SUCCESS == PHNFCSTATUS(status))
\r
3804 #if defined (NXP_FW_INTEGRITY_VERIFY)
\r
3806 * To check for the integrity if the firmware is already
\r
3809 status = phDnldNfc_Send_Command( psDnldContext, pHwRef,
\r
3810 PHDNLD_CMD_RESET , NULL , 0 );
\r
3811 if (NFCSTATUS_PENDING == status)
\r
3813 DNLD_PRINT("\n FW_DNLD: Integrity Reset .... \n");
\r
3814 (void)phDnldNfc_Set_Seq(psDnldContext, DNLD_SEQ_COMPLETE);
\r
3815 status = PHNFCSTVAL( CID_NFC_DNLD,
\r
3816 NFCSTATUS_PENDING );
\r
3817 #if defined(FW_DOWNLOAD_TIMER)
\r
3818 psDnldContext->timer_id = phOsalNfc_Timer_Create( );
\r
3819 #if (FW_DOWNLOAD_TIMER < 2)
\r
3820 phOsalNfc_Timer_Start( psDnldContext->timer_id,
\r
3821 NXP_DNLD_COMPLETE_TIMEOUT,
\r
3822 (ppCallBck_t) phDnldNfc_Abort
\r
3823 #ifdef NFC_TIMER_CONTEXT
\r
3824 , (void *) psDnldContext
\r
3828 #endif /* #if (FW_DOWNLOAD_TIMER < 2) */
\r
3830 #endif /* #if defined(FW_DOWNLOAD_TIMER) */
\r
3834 status = NFCSTATUS_SUCCESS;
\r
3836 #endif /* #if defined (NXP_FW_INTEGRITY_VERIFY) */
\r
3841 DNLD_PRINT(" FW_DNLD Initialisation in Failed \n");
\r
3845 if (NFCSTATUS_PENDING != PHNFCSTATUS(status))
\r
3847 (void)phDal4Nfc_Unregister(
\r
3848 psDnldContext->lower_interface.pcontext, pHwRef);
\r
3849 phDnldNfc_Release_Lower(psDnldContext, pHwRef);
\r
3850 phDnldNfc_Release_Resources(&psDnldContext);
\r
3851 #ifndef NFC_TIMER_CONTEXT
\r
3852 gpphDnldContext = psDnldContext;
\r
3855 } /* End of Status Check for Memory */
\r
3858 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INSUFFICIENT_RESOURCES);
\r
3860 DNLD_PRINT(" FW_DNLD: Memory Allocation of Context Failed\n");
\r