1 /* 2 * Copyright (C) 2010 NXP Semiconductors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /*! 18 * =========================================================================== * 19 * * 20 * * 21 * \file phDnldNfc.c * 22 * \brief Download Mgmt Interface Source for the Firmware Download. * 23 * * 24 * * 25 * Project: NFC-FRI-1.1 * 26 * * 27 * $Date: Tue Jun 28 14:25:44 2011 $ * 28 * $Author: ing04880 $ * 29 * $Revision: 1.33 $ * 30 * $Aliases: $ 31 * * 32 * =========================================================================== * 33 */ 34 35 36 /* 37 ################################################################################ 38 ***************************** Header File Inclusion **************************** 39 ################################################################################ 40 */ 41 #include <stdlib.h> 42 #include <unistd.h> 43 #include <phNfcConfig.h> 44 #include <phNfcCompId.h> 45 #include <phNfcIoctlCode.h> 46 #include <phDnldNfc.h> 47 #include <phOsalNfc.h> 48 #include <phOsalNfc_Timer.h> 49 #include <phDal4Nfc.h> 50 #include <utils/Log.h> 51 /* 52 ################################################################################ 53 ****************************** Macro Definitions ******************************* 54 ################################################################################ 55 */ 56 57 #ifndef STATIC 58 #define STATIC static 59 #endif 60 61 #if defined (DNLD_SUMMARY) && !defined (DNLD_TRACE) 62 #define DNLD_TRACE 63 #endif 64 65 /* #if defined(PHDBG_INFO) && defined (PHDBG_CRITICAL_ERROR) */ 66 #if defined(DNLD_TRACE) 67 extern char phOsalNfc_DbgTraceBuffer[]; 68 69 #define MAX_TRACE_BUFFER 0x0410 70 #define Trace_buffer phOsalNfc_DbgTraceBuffer 71 /* #define DNLD_PRINT( str ) phOsalNfc_DbgTrace(str) */ 72 #define DNLD_PRINT( str ) phOsalNfc_DbgString(str) 73 #define DNLD_DEBUG(str, arg) \ 74 { \ 75 snprintf(Trace_buffer,MAX_TRACE_BUFFER,str,arg); \ 76 phOsalNfc_DbgString(Trace_buffer); \ 77 } 78 #define DNLD_PRINT_BUFFER(msg,buf,len) \ 79 { \ 80 snprintf(Trace_buffer,MAX_TRACE_BUFFER,"\n\t %s:",msg); \ 81 phOsalNfc_DbgString(Trace_buffer); \ 82 phOsalNfc_DbgTrace(buf,len); \ 83 phOsalNfc_DbgString("\r"); \ 84 } 85 #else 86 #define DNLD_PRINT( str ) 87 #define DNLD_DEBUG(str, arg) 88 #define DNLD_PRINT_BUFFER(msg,buf,len) 89 #endif 90 91 #define DO_DELAY(period) usleep(period) 92 93 /* delay after SW reset cmd in ms, required on uart for XTAL stability */ 94 #define PHDNLD_DNLD_DELAY 5000 95 //#define PHDNLD_MAX_PACKET 0x0200U /* Max Total Packet Size is 512 */ 96 #define PHDNLD_MAX_PACKET 32U /* Max Total Packet Size is 512 */ 97 #define PHDNLD_DATA_SIZE ((PHDNLD_MAX_PACKET)- 8U) /* 0x01F8U */ 98 /* Max Data Size is 504 */ 99 #define PHDNLD_MIN_PACKET 0x03U /* Minimum Packet Size is 3*/ 100 101 #define DNLD_DEFAULT_RESPONSE_TIMEOUT 0x4000U 102 103 #define NXP_FW_MIN_TX_RX_LEN 0x0AU 104 105 106 #if defined( NXP_FW_MAX_TX_RX_LEN ) && \ 107 ( NXP_FW_MAX_TX_RX_LEN > NXP_FW_MIN_TX_RX_LEN ) 108 109 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN 110 111 #elif !defined( NXP_FW_MAX_TX_RX_LEN ) 112 113 /* To specify the Maximum TX/RX Len */ 114 #define NXP_FW_MAX_TX_RX_LEN 0x200 115 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MAX_TX_RX_LEN 116 117 #else 118 119 #define PHDNLD_FW_TX_RX_LEN NXP_FW_MIN_TX_RX_LEN 120 121 #endif 122 123 #define PHDNLD_FRAME_LEN_SIZE 0x02U 124 #define PHDNLD_ADDR_SIZE 0x03U 125 #define PHDNLD_DATA_LEN_SIZE 0x02U 126 #define PHDNLD_FRAME_DATA_OFFSET 0x03U 127 128 #define DNLD_SM_UNLOCK_MASK 0x01U 129 #define DNLD_TRIM_MASK 0x02U 130 #define DNLD_RESET_MASK 0x04U 131 #define DNLD_VERIFY_MASK 0x08U 132 #define DNLD_CRITICAL_MASK 0x10U 133 134 135 #define NXP_NFC_IMAG_FW_MAX 0x05U 136 137 #define PHDNLD_FW_PATCH_SEC 0x5FU 138 139 #define PHDNLD_PAGE_SIZE 0x80U /* Page Size Configured for 64 Bytes */ 140 141 #define FW_MAX_SECTION 0x15U /* Max Number of Sections */ 142 143 #define DNLD_CRC16_SIZE 0x02U 144 145 #define DNLD_CRC32_SIZE 0x04U 146 147 #define DNLD_CFG_PG_ADDR 0x00008000U 148 #define DNLD_FW_CODE_ADDR 0x00800000U 149 #define DNLD_PATCH_CODE_ADDR 0x00018800U 150 #define DNLD_PATCH_TABLE_ADDR 0x00008200U 151 152 153 /* Raw Command to pass the Data in Download Mode */ 154 #define PHDNLD_CMD_RAW 0x00U 155 /* Command to Reset the Device in Download Mode */ 156 #define PHDNLD_CMD_RESET 0x01U 157 /* Command to Read from the Address specified in Download Mode */ 158 #define PHDNLD_CMD_READ 0x07U 159 #define PHDNLD_CMD_READ_LEN 0x0005U 160 /* Command to write to the Address specified in Download Mode */ 161 #define PHDNLD_CMD_WRITE 0x08U 162 #define PHDNLD_CMD_SEC_WRITE 0x0CU 163 #define PHDNLD_CMD_WRITE_MIN_LEN 0x0005U 164 #define PHDNLD_CMD_WRITE_MAX_LEN PHDNLD_DATA_SIZE 165 /* Command to verify the data written */ 166 #define PHDNLD_CMD_CHECK 0x06U 167 #define PHDNLD_CMD_CHECK_LEN 0x0007U 168 169 /* Command to Lock the */ 170 #define PHDNLD_CMD_LOCK 0x40U 171 #define PHDNLD_CMD_LOCK_LEN 0x0002U 172 173 174 /* Command to set the Host Interface properties */ 175 #define PHDNLD_CMD_SET_HIF 0x09U 176 177 /* Command to Activate the Patches Updated */ 178 #define PHDNLD_CMD_ACTIVATE_PATCH 0x0AU 179 180 /* Command to verify the Integrity of the data written */ 181 #define PHDNLD_CMD_CHECK_INTEGRITY 0x0BU 182 183 /* Command to verify the Integrity of the data written */ 184 #define PHDNLD_CMD_ENCAPSULATE 0x0DU 185 186 #define CHECK_INTEGRITY_RESP_CRC16_LEN 0x03U 187 #define CHECK_INTEGRITY_RESP_CRC32_LEN 0x05U 188 #define CHECK_INTEGRITY_RESP_COMP_LEN 0x10U 189 190 191 /* Success Response to a Command Sent in the Download Mode */ 192 #define PHDNLD_RESP_SUCCESS 0x00U 193 /* Timeout Response to a Command Sent in the Download Mode */ 194 #define PHDNLD_RESP_TIMEOUT 0x01U 195 /* CRC Error Response to a Command Sent in the Download Mode */ 196 #define PHDNLD_RESP_CRC_ERROR 0x02U 197 /* Access Denied Response to a Command Sent in the Download Mode */ 198 #define PHDNLD_RESP_ACCESS_DENIED 0x08U 199 /* PROTOCOL Error Response to a Command Sent in the Download Mode */ 200 #define PHDNLD_RESP_PROTOCOL_ERROR 0x0BU 201 /* Invalid parameter Response to a Command Sent in the Download Mode */ 202 #define PHDNLD_RESP_INVALID_PARAMETER 0x11U 203 /* Command Not Supported Response to a Command Sent in the Download Mode */ 204 #define PHDNLD_RESP_CMD_NOT_SUPPORTED 0x13U 205 /* Length parameter error Response to a Command Sent in the Download Mode */ 206 #define PHDNLD_RESP_INVALID_LENGTH 0x18U 207 /* Checksum Error Response to a Command Sent in the Download Mode */ 208 #define PHDNLD_RESP_CHKSUM_ERROR 0x19U 209 /* Version already uptodate Response to a Command Sent in the Download Mode */ 210 #define PHDNLD_RESP_VERSION_UPTODATE 0x1DU 211 /* Memory operation error during the processing of 212 the Command Frame in the Download Mode */ 213 #define PHDNLD_RESP_MEMORY_UPDATE_ERROR 0x20U 214 /* The Chaining of the Command Frame was Successful in the Download Mode */ 215 #define PHDNLD_RESP_CHAINING_SUCCESS 0x21U 216 /* The Command is not allowed anymore in the Download Mode */ 217 #define PHDNLD_RESP_CMD_NOT_ALLOWED 0xE0U 218 /* The Error during the Chaining the Command Frame in the Download Mode */ 219 #define PHDNLD_RESP_CHAINING_ERROR 0xE6U 220 /* Write Error Response to a Command Sent in the Download Mode */ 221 #define PHDNLD_RESP_WRITE_ERROR 0x74U 222 223 #define PNDNLD_WORD_LEN 0x04U 224 225 #define NXP_MAX_DNLD_RETRY 0x02U 226 227 #define NXP_MAX_SECTION_WRITE 0x05U 228 229 #define NXP_PATCH_VER_INDEX 0x05U 230 231 232 /* 233 ################################################################################ 234 ******************** Enumeration and Structure Definition ********************** 235 ################################################################################ 236 */ 237 238 typedef enum phDnldNfc_eSeqType{ 239 DNLD_SEQ_RESET = 0x00U, 240 DNLD_SEQ_INIT, 241 DNLD_SEQ_RAW, 242 DNLD_SEQ_LOCK, 243 DNLD_SEQ_UNLOCK, 244 DNLD_SEQ_UPDATE, 245 DNLD_SEQ_ROLLBACK, 246 DNLD_SEQ_COMPLETE 247 } phDnldNfc_eSeqType_t; 248 249 typedef enum phDnldNfc_eState 250 { 251 phDnld_Reset_State = 0x00, 252 phDnld_Unlock_State, 253 phDnld_Upgrade_State, 254 phDnld_Verify_State, 255 phDnld_Complete_State, 256 phDnld_Invalid_State 257 }phDnldNfc_eState_t; 258 259 260 typedef enum phDnldNfc_eSeq 261 { 262 phDnld_Reset_Seq = 0x00, 263 phDnld_Activate_Patch, 264 phDnld_Deactivate_Patch, 265 phDnld_Update_Patch, 266 phDnld_Update_Patchtable, 267 phDnld_Lock_System, 268 phDnld_Unlock_System, 269 phDnld_Upgrade_Section, 270 phDnld_Verify_Integrity, 271 phDnld_Verify_Section, 272 phDnld_Complete_Seq, 273 phDnld_Raw_Upgrade, 274 phDnld_Invalid_Seq 275 }phDnldNfc_eSeq_t; 276 277 typedef enum phDnldNfc_eChkCrc{ 278 CHK_INTEGRITY_CONFIG_PAGE_CRC = 0x00U, 279 CHK_INTEGRITY_PATCH_TABLE_CRC = 0x01U, 280 CHK_INTEGRITY_FLASH_CODE_CRC = 0x02U, 281 CHK_INTEGRITY_PATCH_CODE_CRC = 0x03U, 282 CHK_INTEGRITY_COMPLETE_CRC = 0xFFU 283 } phDnldNfc_eChkCrc_t; 284 285 286 287 typedef struct hw_comp_tbl 288 { 289 uint8_t hw_version[3]; 290 uint8_t compatibility; 291 }hw_comp_tbl_t; 292 293 294 typedef struct img_data_hdr 295 { 296 /* Image Identification */ 297 uint32_t img_id; 298 /* Offset of the Data from the header */ 299 uint8_t img_data_offset; 300 /* Number of fimware images available in the img_data */ 301 uint8_t no_of_fw_img; 302 /* Fimware image Padding in the img_data */ 303 uint8_t fw_img_pad[2]; 304 /* HW Compatiblity table for the set of the Hardwares */ 305 hw_comp_tbl_t comp_tbl; 306 /* This data consists of the firmware images required to download */ 307 }img_data_hdr_t; 308 309 310 typedef struct fw_data_hdr 311 { 312 /* The data offset from the firmware header. 313 * Just in case if in future we require to 314 * add some more information. 315 */ 316 uint8_t fw_hdr_len; 317 /* Total size of all the sections which needs to be updated */ 318 uint8_t no_of_sections; 319 uint8_t hw_comp_no; 320 uint8_t fw_patch; 321 uint32_t fw_version; 322 }fw_data_hdr_t; 323 324 325 326 /* This data consists all the sections that needs to be downloaded */ 327 typedef struct section_hdr 328 { 329 uint8_t section_hdr_len; 330 uint8_t section_mem_type; 331 uint8_t section_checksum; 332 uint8_t section_conf; 333 uint32_t section_address; 334 uint32_t section_length; 335 }section_hdr_t; 336 337 typedef struct section_info 338 { 339 section_hdr_t *p_sec_hdr; 340 uint8_t *p_trim_data; 341 /* The section data consist of the Firmware binary required 342 * to be loaded to the particular address. 343 */ 344 uint8_t *p_sec_data; 345 /* The Section checksum to verify the integrity of the section 346 * data. 347 */ 348 uint8_t *p_sec_chksum; 349 /** \internal Index used to refer and process the 350 * Firmware Section Data */ 351 volatile uint32_t section_offset; 352 353 /** \internal Section Read Sequence */ 354 volatile uint8_t section_read; 355 356 /** \internal Section Write Sequence */ 357 volatile uint8_t section_write; 358 359 /** \internal TRIM Write Sequence */ 360 volatile uint8_t trim_write; 361 362 volatile uint8_t sec_verify_retry; 363 364 }section_info_t; 365 366 367 typedef struct phDnldNfc_sParam 368 { 369 uint8_t data_addr[PHDNLD_ADDR_SIZE]; 370 uint8_t data_len[PHDNLD_DATA_LEN_SIZE]; 371 uint8_t data_packet[PHDNLD_DATA_SIZE]; 372 }phDnldNfc_sParam_t; 373 374 typedef struct phDnldNfc_sDataHdr 375 { 376 uint8_t frame_type; 377 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE]; 378 }phDnldNfc_sData_Hdr_t; 379 380 typedef struct phDnldNfc_sRawHdr 381 { 382 uint8_t frame_type; 383 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE]; 384 }phDnldNfc_sRawHdr_t; 385 386 typedef struct phDnldNfc_sRawDataHdr 387 { 388 uint8_t data_addr[PHDNLD_ADDR_SIZE]; 389 uint8_t data_len[PHDNLD_DATA_LEN_SIZE]; 390 }phDnldNfc_sRawDataHdr_t; 391 392 typedef struct phDnldNfc_sChkCrc16_Resp 393 { 394 uint8_t Chk_status; 395 uint8_t Chk_Crc16[2]; 396 397 }phDnldNfc_sChkCrc16_Resp_t; 398 399 typedef struct phDnldNfc_sChkCrc32_Resp 400 { 401 uint8_t Chk_status; 402 uint8_t Chk_Crc32[4]; 403 404 }phDnldNfc_sChkCrc32_Resp_t; 405 406 407 typedef struct phDnldNfc_sChkCrcComplete 408 { 409 phDnldNfc_sChkCrc16_Resp_t config_page; 410 phDnldNfc_sChkCrc16_Resp_t patch_table; 411 phDnldNfc_sChkCrc32_Resp_t flash_code; 412 phDnldNfc_sChkCrc32_Resp_t patch_code; 413 }phDnldNfc_sChkCrcComplete_t; 414 415 typedef struct phDnldNfc_sData 416 { 417 uint8_t frame_type; 418 uint8_t frame_length[PHDNLD_FRAME_LEN_SIZE]; 419 union param 420 { 421 phDnldNfc_sParam_t data_param; 422 uint8_t response_data[PHDNLD_MAX_PACKET]; 423 uint8_t cmd_param; 424 }param_info; 425 }phDnldNfc_sData_t; 426 427 #ifdef NXP_NFC_MULTIPLE_FW 428 429 typedef struct phDnldNfc_sFwImageInfo 430 { 431 /** \internal Data Pointer to the Firmware header section of the Firmware */ 432 fw_data_hdr_t *p_fw_hdr; 433 /** \internal Buffer pointer to store the Firmware Section Data */ 434 section_info_t *p_fw_sec; 435 /** \internal Buffer pointer to store the Firmware Raw Data */ 436 uint8_t *p_fw_raw; 437 }phDnldNfc_sFwImageInfo_t; 438 439 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */ 440 441 442 typedef struct phDnldNfc_TxInfo 443 { 444 uint8_t *transmit_frame; 445 446 uint16_t tx_offset; 447 448 /** \internal Remaining amount of data to be sent */ 449 uint16_t tx_len; 450 451 uint16_t tx_total; 452 453 /** \internal Chain information for the data to be sent */ 454 uint8_t tx_chain; 455 456 }phDnldNfc_TxInfo_t; 457 458 459 typedef struct phDnldNfc_RxInfo 460 { 461 /** \internal Total length of the received buffer */ 462 uint16_t rx_total; 463 /** \internal Chain information of the received buffer */ 464 uint16_t rx_chain; 465 /** \internal Remaining Data information to be read to complete the 466 * Data Information. 467 */ 468 uint16_t rx_remain; 469 470 /** \internal Buffer to Send the Raw Data Frame */ 471 uint8_t raw_buffer_data[PHDNLD_MAX_PACKET 472 + PHDNLD_PAGE_SIZE]; 473 }phDnldNfc_RxInfo_t; 474 475 476 typedef struct phDnldNfc_sContext 477 { 478 /** \internal Structure to store the lower interface operations */ 479 phNfc_sLowerIF_t lower_interface; 480 481 phNfc_sData_t *p_fw_version; 482 483 /** \internal Pointer to the Hardware Reference Sturcture */ 484 phHal_sHwReference_t *p_hw_ref; 485 486 /** \internal Pointer to the upper layer notification callback function */ 487 pphNfcIF_Notification_CB_t p_upper_notify; 488 /** \internal Pointer to the upper layer context */ 489 void *p_upper_context; 490 491 /** \internal Timer ID for the Download Abort */ 492 uint32_t timer_id; 493 /** \internal Internal Download for the Download Abort */ 494 uint32_t dnld_timeout; 495 /** \internal Data Pointer to the Image header section of the Firmware */ 496 img_data_hdr_t *p_img_hdr; 497 498 #ifdef NXP_NFC_MULTIPLE_FW 499 /** \internal Data Pointer to the Firmware Image Information */ 500 phDnldNfc_sFwImageInfo_t *p_img_info; 501 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */ 502 503 /** \internal Data Pointer to the Firmware header section of the Firmware */ 504 fw_data_hdr_t *p_fw_hdr; 505 /** \internal Buffer pointer to store the Firmware Data */ 506 section_info_t *p_fw_sec; 507 /** \internal Buffer pointer to store the Firmware Raw Data */ 508 uint8_t *p_fw_raw; 509 510 /** \internal Previous Download Size */ 511 uint32_t prev_dnld_size; 512 513 /** \internal Single Data Block to download the Firmware */ 514 uint8_t dnld_data[PHDNLD_MAX_PACKET 515 + PHDNLD_PAGE_SIZE]; 516 /** \internal Index used to refer and process the Download Data */ 517 volatile uint32_t dnld_index; 518 519 /** \internal Response Data to process the response */ 520 phDnldNfc_sData_t dnld_resp; 521 522 /** \internal Previously downloaded data stored 523 * to compare the written data */ 524 phNfc_sData_t dnld_store; 525 526 /** \internal Previously downloaded trimmed data stored 527 * to compare the written data */ 528 phNfc_sData_t trim_store; 529 530 uint8_t *p_resp_buffer; 531 532 phDnldNfc_sChkCrcComplete_t chk_integrity_crc; 533 534 phDnldNfc_eChkCrc_t chk_integrity_param; 535 536 #define NXP_FW_SW_VMID_TRIM 537 #ifdef NXP_FW_SW_VMID_TRIM 538 539 #define NXP_FW_VMID_TRIM_CHK_ADDR 0x0000813DU 540 #define NXP_FW_VMID_CARD_MODE_ADDR 0x00009931U 541 #define NXP_FW_VMID_RD_MODE_ADDR 0x00009981U 542 543 uint8_t vmid_trim_update; 544 #endif /* #ifdef NXP_FW_SW_VMID_TRIM */ 545 546 uint8_t cur_frame_info; 547 548 uint8_t raw_mode_upgrade; 549 550 uint8_t *p_patch_table_crc; 551 552 uint8_t *p_flash_code_crc; 553 554 uint8_t *p_patch_code_crc; 555 556 uint16_t resp_length; 557 558 /** \internal Current FW Section in Process */ 559 volatile uint8_t section_index; 560 561 /** \internal Previous Command sent */ 562 volatile uint8_t prev_cmd; 563 564 uint8_t dnld_retry; 565 566 /** \internal Current Download State */ 567 volatile uint8_t cur_dnld_state; 568 /** \internal Next Download State */ 569 volatile uint8_t next_dnld_state; 570 571 /** \internal Current step in Download Sequence */ 572 volatile uint8_t cur_dnld_seq; 573 /** \internal Next step in Download Sequence */ 574 volatile uint8_t next_dnld_seq; 575 576 /* \internal Data Transmit information */ 577 phDnldNfc_TxInfo_t tx_info; 578 579 /* \internal Data Receive information */ 580 phDnldNfc_RxInfo_t rx_info; 581 582 583 }phDnldNfc_sContext_t; 584 585 586 /* 587 ################################################################################ 588 ******************** Global and Static Variables Definition ******************** 589 ################################################################################ 590 */ 591 592 #ifndef NFC_TIMER_CONTEXT 593 static phDnldNfc_sContext_t *gpphDnldContext = NULL; 594 #endif 595 596 #ifdef NXP_FW_DNLD_CHECK_PHASE 597 598 #define NXP_FW_DNLD_COMPLETE_PHASE 0x00U 599 #define NXP_FW_DNLD_SYSTEM_PHASE 0x01U 600 #define NXP_FW_DNLD_CFG_PHASE 0x02U 601 #define NXP_FW_DNLD_DATA_PHASE 0x03U 602 #define NXP_FW_DNLD_RAW_PHASE 0x04U 603 #define NXP_FW_DNLD_INVALID_PHASE 0xFFU 604 605 static uint8_t gphDnldPhase = NXP_FW_DNLD_COMPLETE_PHASE; 606 607 #endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */ 608 609 /**/ 610 611 /* 612 *************************** Static Function Declaration ************************** 613 */ 614 615 STATIC 616 NFCSTATUS 617 phDnldNfc_Send_Command( 618 phDnldNfc_sContext_t *psDnldContext, 619 void *pHwRef, 620 uint8_t cmd, 621 void *params, 622 uint16_t param_length 623 ); 624 625 static 626 NFCSTATUS 627 phDnldNfc_Process_FW( 628 phDnldNfc_sContext_t *psDnldContext, 629 phHal_sHwReference_t *pHwRef 630 #ifdef NXP_FW_PARAM 631 , 632 uint8_t *nxp_nfc_fw, 633 uint32_t fw_length 634 #endif 635 ); 636 637 STATIC 638 void 639 phDnldNfc_Send_Complete ( 640 void *psContext, 641 void *pHwRef, 642 phNfc_sTransactionInfo_t *pInfo 643 ); 644 645 STATIC 646 void 647 phDnldNfc_Receive_Complete ( 648 void *psContext, 649 void *pHwRef, 650 phNfc_sTransactionInfo_t *pInfo 651 ); 652 653 STATIC 654 NFCSTATUS 655 phDnldNfc_Process_Response( 656 phDnldNfc_sContext_t *psDnldContext, 657 void *pHwRef, 658 void *pdata, 659 uint16_t length 660 ); 661 662 663 static 664 NFCSTATUS 665 phDnldNfc_Resume( 666 phDnldNfc_sContext_t *psDnldContext, 667 void *pHwRef, 668 void *pdata, 669 uint16_t length 670 ); 671 672 static 673 NFCSTATUS 674 phDnldNfc_Resume_Write( 675 phDnldNfc_sContext_t *psDnldContext, 676 void *pHwRef 677 ); 678 679 static 680 NFCSTATUS 681 phDnldNfc_Process_Write( 682 phDnldNfc_sContext_t *psDnldContext, 683 void *pHwRef, 684 section_info_t *p_sec_info, 685 uint32_t *p_sec_offset 686 ); 687 688 static 689 NFCSTATUS 690 phDnldNfc_Sequence( 691 phDnldNfc_sContext_t *psDnldContext, 692 void *pHwRef, 693 void *pdata, 694 uint16_t length 695 ); 696 697 static 698 NFCSTATUS 699 phDnldNfc_Upgrade_Sequence( 700 phDnldNfc_sContext_t *psDnldContext, 701 void *pHwRef, 702 void *pdata, 703 uint16_t length 704 ); 705 706 STATIC 707 NFCSTATUS 708 phDnldNfc_Receive( 709 void *psContext, 710 void *pHwRef, 711 uint8_t *pdata, 712 uint16_t length 713 ); 714 715 716 STATIC 717 NFCSTATUS 718 phDnldNfc_Send ( 719 void *psContext, 720 void *pHwRef, 721 uint8_t *pdata, 722 uint16_t length 723 ); 724 725 STATIC 726 NFCSTATUS 727 phDnldNfc_Set_Seq( 728 phDnldNfc_sContext_t *psDnldContext, 729 phDnldNfc_eSeqType_t seq_type 730 ); 731 732 static 733 void 734 phDnldNfc_Notify( 735 pphNfcIF_Notification_CB_t p_upper_notify, 736 void *p_upper_context, 737 void *pHwRef, 738 uint8_t type, 739 void *pInfo 740 ); 741 742 STATIC 743 NFCSTATUS 744 phDnldNfc_Allocate_Resource ( 745 void **ppBuffer, 746 uint16_t size 747 ); 748 749 STATIC 750 void 751 phDnldNfc_Release_Resources ( 752 phDnldNfc_sContext_t **ppsDnldContext 753 ); 754 755 STATIC 756 void 757 phDnldNfc_Release_Lower( 758 phDnldNfc_sContext_t *psDnldContext, 759 void *pHwRef 760 ); 761 762 763 static 764 NFCSTATUS 765 phDnldNfc_Read( 766 phDnldNfc_sContext_t *psDnldContext, 767 void *pHwRef, 768 section_info_t *p_sec_info 769 ); 770 771 STATIC 772 void 773 phDnldNfc_Abort ( 774 uint32_t abort_id 775 #ifdef NFC_TIMER_CONTEXT 776 , void *dnld_cntxt 777 #endif 778 ); 779 780 781 #ifdef DNLD_CRC_CALC 782 783 static 784 void 785 phDnldNfc_UpdateCrc16( 786 uint8_t crcByte, 787 uint16_t *pCrc 788 ); 789 790 STATIC 791 uint16_t 792 phDnldNfc_ComputeCrc16( 793 uint8_t *pData, 794 uint16_t length 795 ); 796 797 798 /* 799 *************************** Function Definitions ************************** 800 */ 801 #define CRC32_POLYNOMIAL 0xEDB88320L 802 803 static uint32_t CRC32Table[0x100]; 804 805 void BuildCRCTable() 806 { 807 unsigned long crc; 808 uint8_t i = 0, j = 0; 809 810 for ( i = 0; i <= 0xFF ; i++ ) 811 { 812 crc = i; 813 for ( j = 8 ; j> 0; j-- ) 814 { 815 if ( crc & 1 ) 816 { 817 crc = ( crc>> 1 ) ^ CRC32_POLYNOMIAL; 818 } 819 else 820 { 821 crc>>= 1; 822 } 823 } 824 CRC32Table[ i ] = crc; 825 } 826 } 827 828 /* 829 * This routine calculates the CRC for a block of data using the 830 * table lookup method. It accepts an original value for the crc, 831 * and returns the updated value. 832 */ 833 834 uint32_t CalculateCRC32( void *buffer , uint32_t count, uint32_t crc ) 835 { 836 uint8_t *p; 837 uint32_t temp1; 838 uint32_t temp2; 839 840 p = (uint8_t *) buffer; 841 while ( count-- != 0 ) { 842 temp1 = ( crc>> 8 ) & 0x00FFFFFFL; 843 temp2 = CRC32Table[ ( (int) crc ^ *p++ ) & 0xff ]; 844 crc = temp1 ^ temp2; 845 } 846 return( crc ); 847 } 848 849 850 static 851 void 852 phDnldNfc_UpdateCrc16( 853 uint8_t crcByte, 854 uint16_t *pCrc 855 ) 856 { 857 crcByte = (crcByte ^ (uint8_t)((*pCrc) & 0x00FF)); 858 crcByte = (crcByte ^ (uint8_t)(crcByte << 4)); 859 *pCrc = (*pCrc >> 8) ^ ((uint16_t)crcByte << 8) ^ 860 ((uint16_t)crcByte << 3) ^ 861 ((uint16_t)crcByte >> 4); 862 } 863 864 865 STATIC 866 uint16_t 867 phDnldNfc_ComputeCrc16( 868 uint8_t *pData, 869 uint16_t length 870 ) 871 { 872 uint8_t crc_byte = 0; 873 uint16_t index = 0; 874 uint16_t crc = 0; 875 876 #ifdef CRC_A 877 crc = 0x6363; /* ITU-V.41 */ 878 #else 879 crc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */ 880 #endif /* #ifdef CRC_A */ 881 882 do 883 { 884 crc_byte = pData[index]; 885 phDnldNfc_UpdateCrc16(crc_byte, &crc); 886 index++; 887 } while (index < length); 888 889 #ifndef INVERT_CRC 890 crc = ~crc; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */ 891 #endif /* #ifndef INVERT_CRC */ 892 893 /* *pCrc1 = (uint8_t) (crc & BYTE_MASK); 894 *pCrc2 = (uint8_t) ((crc >> 8) & BYTE_MASK); */ 895 return crc ; 896 } 897 898 #endif /* #ifdef DNLD_CRC_CALC */ 899 900 901 /*! 902 * \brief Allocation of the Download Interface resources. 903 * 904 * This function releases and frees all the resources used by Download Mode 905 * Feature. 906 */ 907 908 STATIC 909 NFCSTATUS 910 phDnldNfc_Allocate_Resource ( 911 void **ppBuffer, 912 uint16_t size 913 ) 914 { 915 NFCSTATUS status = NFCSTATUS_SUCCESS; 916 917 *ppBuffer = (void *) phOsalNfc_GetMemory(size); 918 if( *ppBuffer != NULL ) 919 { 920 (void )memset(((void *)*ppBuffer), 0, 921 size); 922 } 923 else 924 { 925 *ppBuffer = NULL; 926 status = PHNFCSTVAL(CID_NFC_DNLD, 927 NFCSTATUS_INSUFFICIENT_RESOURCES); 928 } 929 return status; 930 } 931 932 933 /*! 934 * \brief Release of the Download Interface resources. 935 * 936 * This function releases and frees all the resources used by Download layer. 937 */ 938 939 STATIC 940 void 941 phDnldNfc_Release_Resources ( 942 phDnldNfc_sContext_t **ppsDnldContext 943 ) 944 { 945 946 if(NULL != (*ppsDnldContext)->p_resp_buffer) 947 { 948 phOsalNfc_FreeMemory((*ppsDnldContext)->p_resp_buffer); 949 (*ppsDnldContext)->p_resp_buffer = NULL; 950 } 951 if(NULL != (*ppsDnldContext)->dnld_store.buffer) 952 { 953 phOsalNfc_FreeMemory((*ppsDnldContext)->dnld_store.buffer); 954 (*ppsDnldContext)->dnld_store.buffer = NULL; 955 (*ppsDnldContext)->dnld_store.length = 0; 956 } 957 if(NULL != (*ppsDnldContext)->trim_store.buffer) 958 { 959 phOsalNfc_FreeMemory((*ppsDnldContext)->trim_store.buffer); 960 (*ppsDnldContext)->trim_store.buffer = NULL; 961 (*ppsDnldContext)->trim_store.length = 0; 962 } 963 if(NULL != (*ppsDnldContext)->p_fw_sec) 964 { 965 phOsalNfc_FreeMemory((*ppsDnldContext)->p_fw_sec); 966 (*ppsDnldContext)->p_fw_sec = NULL; 967 } 968 if ( NXP_INVALID_TIMER_ID != (*ppsDnldContext)->timer_id ) 969 { 970 phOsalNfc_Timer_Stop((*ppsDnldContext)->timer_id ); 971 phOsalNfc_Timer_Delete((*ppsDnldContext)->timer_id ); 972 (*ppsDnldContext)->timer_id = NXP_INVALID_TIMER_ID; 973 } 974 975 phOsalNfc_FreeMemory((*ppsDnldContext)); 976 (*ppsDnldContext) = NULL; 977 978 return ; 979 } 980 981 982 STATIC 983 void 984 phDnldNfc_Release_Lower( 985 phDnldNfc_sContext_t *psDnldContext, 986 void *pHwRef 987 ) 988 { 989 phNfc_sLowerIF_t *plower_if = 990 &(psDnldContext->lower_interface); 991 NFCSTATUS status = NFCSTATUS_SUCCESS; 992 993 PHNFC_UNUSED_VARIABLE(status); 994 995 if(NULL != plower_if->release) 996 { 997 #ifdef DNLD_LOWER_RELEASE 998 status = plower_if->release((void *)plower_if->pcontext, 999 (void *)pHwRef); 1000 #else 1001 PHNFC_UNUSED_VARIABLE(pHwRef); 1002 1003 #endif 1004 (void)memset((void *)plower_if, 1005 0, sizeof(phNfc_sLowerIF_t)); 1006 DNLD_DEBUG(" FW_DNLD: Releasing the Lower Layer Resources: Status = %02X\n" 1007 ,status); 1008 } 1009 1010 return; 1011 } 1012 1013 1014 1015 static 1016 void 1017 phDnldNfc_Notify( 1018 pphNfcIF_Notification_CB_t p_upper_notify, 1019 void *p_upper_context, 1020 void *pHwRef, 1021 uint8_t type, 1022 void *pInfo 1023 ) 1024 { 1025 if( ( NULL != p_upper_notify) ) 1026 { 1027 /* Notify the to the Upper Layer */ 1028 (p_upper_notify)(p_upper_context, pHwRef, type, pInfo); 1029 } 1030 } 1031 1032 1033 STATIC 1034 NFCSTATUS 1035 phDnldNfc_Set_Seq( 1036 phDnldNfc_sContext_t *psDnldContext, 1037 phDnldNfc_eSeqType_t seq_type 1038 ) 1039 { 1040 NFCSTATUS status = NFCSTATUS_SUCCESS; 1041 static uint8_t prev_temp_state = 0; 1042 static uint8_t prev_temp_seq = 1043 (uint8_t) phDnld_Activate_Patch; 1044 1045 switch(seq_type) 1046 { 1047 case DNLD_SEQ_RESET: 1048 case DNLD_SEQ_INIT: 1049 { 1050 psDnldContext->cur_dnld_state = 1051 (uint8_t) phDnld_Reset_State; 1052 psDnldContext->next_dnld_state = 1053 (uint8_t)phDnld_Upgrade_State; 1054 psDnldContext->cur_dnld_seq = 1055 (uint8_t)phDnld_Upgrade_Section; 1056 psDnldContext->next_dnld_seq = 1057 psDnldContext->cur_dnld_seq; 1058 break; 1059 } 1060 case DNLD_SEQ_RAW: 1061 { 1062 psDnldContext->cur_dnld_state = 1063 (uint8_t) phDnld_Reset_State; 1064 psDnldContext->next_dnld_state = 1065 (uint8_t)phDnld_Upgrade_State; 1066 psDnldContext->cur_dnld_seq = 1067 (uint8_t)phDnld_Raw_Upgrade; 1068 psDnldContext->next_dnld_seq = 1069 psDnldContext->cur_dnld_seq; 1070 break; 1071 } 1072 case DNLD_SEQ_UNLOCK: 1073 { 1074 psDnldContext->cur_dnld_state = 1075 (uint8_t) phDnld_Reset_State; 1076 1077 #ifdef NXP_FW_DNLD_CHECK_PHASE 1078 if( NXP_FW_DNLD_SYSTEM_PHASE < gphDnldPhase ) 1079 { 1080 psDnldContext->next_dnld_state = 1081 (uint8_t)phDnld_Upgrade_State; 1082 psDnldContext->cur_dnld_seq = 1083 (uint8_t)phDnld_Upgrade_Section; 1084 } 1085 else 1086 #endif /* NXP_FW_DNLD_CHECK_PHASE */ 1087 { 1088 psDnldContext->next_dnld_state = 1089 (uint8_t) phDnld_Unlock_State; 1090 psDnldContext->cur_dnld_seq = 1091 (uint8_t) phDnld_Activate_Patch; 1092 } 1093 psDnldContext->next_dnld_seq = 1094 psDnldContext->cur_dnld_seq; 1095 break; 1096 } 1097 case DNLD_SEQ_LOCK: 1098 { 1099 psDnldContext->cur_dnld_state = 1100 (uint8_t) phDnld_Reset_State; 1101 psDnldContext->next_dnld_state = 1102 (uint8_t) phDnld_Reset_State; 1103 psDnldContext->cur_dnld_seq = 1104 (uint8_t) phDnld_Lock_System; 1105 psDnldContext->next_dnld_seq = 1106 psDnldContext->cur_dnld_seq; 1107 break; 1108 } 1109 case DNLD_SEQ_UPDATE: 1110 { 1111 prev_temp_state = (uint8_t) psDnldContext->cur_dnld_state; 1112 psDnldContext->cur_dnld_state = 1113 psDnldContext->next_dnld_state; 1114 /* psDnldContext->next_dnld_state = 1115 (uint8_t)phDnld_Invalid_State ; */ 1116 prev_temp_seq = (uint8_t) psDnldContext->cur_dnld_seq; 1117 psDnldContext->cur_dnld_seq = 1118 psDnldContext->next_dnld_seq; 1119 break; 1120 } 1121 case DNLD_SEQ_ROLLBACK: 1122 { 1123 psDnldContext->cur_dnld_seq = (uint8_t) prev_temp_seq; 1124 psDnldContext->next_dnld_seq = 1125 (uint8_t)phDnld_Invalid_Seq ; 1126 prev_temp_seq = 0; 1127 1128 psDnldContext->cur_dnld_state = (uint8_t) prev_temp_state; 1129 /* psDnldContext->next_dnld_state = 1130 (uint8_t)phDnld_Invalid_State ; */ 1131 prev_temp_state = 0; 1132 break; 1133 } 1134 case DNLD_SEQ_COMPLETE: 1135 { 1136 psDnldContext->cur_dnld_state = 1137 (uint8_t) phDnld_Reset_State; 1138 psDnldContext->next_dnld_state = 1139 (uint8_t) phDnld_Verify_State; 1140 psDnldContext->cur_dnld_seq = 1141 (uint8_t) phDnld_Verify_Integrity; 1142 psDnldContext->next_dnld_seq = 1143 psDnldContext->cur_dnld_seq ; 1144 break; 1145 } 1146 default: 1147 { 1148 break; 1149 } 1150 } 1151 1152 return status; 1153 } 1154 1155 1156 1157 /*! 1158 * \brief Sends the data the corresponding peripheral device. 1159 * 1160 * This function sends the Download data to the connected NFC Pheripheral device 1161 */ 1162 1163 1164 STATIC 1165 NFCSTATUS 1166 phDnldNfc_Send ( 1167 void *psContext, 1168 void *pHwRef, 1169 uint8_t *pdata, 1170 uint16_t length 1171 ) 1172 { 1173 phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext; 1174 NFCSTATUS status = NFCSTATUS_SUCCESS; 1175 1176 phNfc_sLowerIF_t *plower_if = &(psDnldContext->lower_interface); 1177 1178 if( (NULL != plower_if) 1179 && (NULL != plower_if->send) 1180 ) 1181 { 1182 #ifndef DNLD_SUMMARY 1183 DNLD_PRINT_BUFFER("Send Buffer",pdata,length); 1184 #endif 1185 status = plower_if->send((void *)plower_if->pcontext, 1186 (void *)pHwRef, pdata, length); 1187 1188 #if defined(FW_DOWNLOAD_TIMER) && \ 1189 (FW_DOWNLOAD_TIMER == 2) 1190 if ( 1191 (NFCSTATUS_PENDING == status) 1192 && ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id ) 1193 ) 1194 { 1195 psDnldContext->dnld_timeout = NXP_DNLD_COMPLETE_TIMEOUT; 1196 1197 if ( psDnldContext->dnld_timeout 1198 < DNLD_DEFAULT_RESPONSE_TIMEOUT) 1199 { 1200 psDnldContext->dnld_timeout 1201 = DNLD_DEFAULT_RESPONSE_TIMEOUT; 1202 } 1203 /* Start the Download Timer */ 1204 phOsalNfc_Timer_Start( psDnldContext->timer_id, 1205 psDnldContext->dnld_timeout, 1206 (ppCallBck_t) phDnldNfc_Abort 1207 #ifdef NFC_TIMER_CONTEXT 1208 , (void *) psDnldContext 1209 #endif 1210 ); 1211 1212 DNLD_DEBUG(" DNLD : Timer %X Started ", psDnldContext->timer_id); 1213 DNLD_DEBUG(" \t\t With %U Timeout \n", psDnldContext->dnld_timeout); 1214 } 1215 1216 #endif /* (NXP_NFC_DNLD_TIMER == 1) */ 1217 } 1218 1219 return status; 1220 } 1221 1222 1223 /*! 1224 * \brief Receives the Download Mode Response from the corresponding peripheral device. 1225 * 1226 * This function receives the Download Command Response to the connected NFC 1227 * Pheripheral device. 1228 */ 1229 1230 STATIC 1231 NFCSTATUS 1232 phDnldNfc_Receive( 1233 void *psContext, 1234 void *pHwRef, 1235 uint8_t *pdata, 1236 uint16_t length 1237 ) 1238 { 1239 phDnldNfc_sContext_t *psDnldContext= (phDnldNfc_sContext_t *)psContext; 1240 phNfc_sLowerIF_t *plower_if = NULL ; 1241 NFCSTATUS status = NFCSTATUS_SUCCESS; 1242 1243 if(NULL == psDnldContext ) 1244 { 1245 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER); 1246 } 1247 else 1248 { 1249 plower_if = &(psDnldContext->lower_interface); 1250 1251 if( (NULL != plower_if) 1252 && (NULL != plower_if->receive) 1253 ) 1254 { 1255 status = plower_if->receive((void *)plower_if->pcontext, 1256 (void *)pHwRef, pdata, length); 1257 } 1258 } 1259 return status; 1260 } 1261 1262 1263 static 1264 NFCSTATUS 1265 phDnldNfc_Read( 1266 phDnldNfc_sContext_t *psDnldContext, 1267 void *pHwRef, 1268 section_info_t *p_sec_info 1269 ) 1270 { 1271 NFCSTATUS status = NFCSTATUS_SUCCESS; 1272 phDnldNfc_sData_t *p_dnld_data = 1273 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 1274 phDnldNfc_sParam_t *p_data_param = 1275 &p_dnld_data->param_info.data_param; 1276 uint32_t read_addr = (p_sec_info->p_sec_hdr->section_address 1277 + p_sec_info->section_offset); 1278 static unsigned sec_type = 0; 1279 uint8_t i = 0; 1280 uint16_t read_size = 0 ; 1281 1282 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type; 1283 1284 if( ( FALSE == p_sec_info->section_read ) 1285 && ((sec_type & DNLD_TRIM_MASK)) 1286 && (FALSE == p_sec_info->trim_write) ) 1287 { 1288 read_size = (uint16_t) p_sec_info->p_sec_hdr->section_length; 1289 DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size); 1290 } 1291 else 1292 { 1293 if (( FALSE == p_sec_info->section_read ) 1294 && ((sec_type & DNLD_VERIFY_MASK)) 1295 ) 1296 { 1297 read_size = (uint16_t)(psDnldContext->prev_dnld_size ); 1298 DNLD_DEBUG(" FW_DNLD: Section Read = %X \n", read_size); 1299 } 1300 else if( ( TRUE == p_sec_info->section_read ) 1301 && ( TRUE == p_sec_info->section_write ) 1302 ) 1303 { 1304 /*Already Read the Data Hence Ignore the Read */ 1305 DNLD_DEBUG(" FW_DNLD: Already Read, Read Ignored, read_size = %X \n", read_size); 1306 } 1307 else 1308 { 1309 /* Ignore the Read */ 1310 DNLD_DEBUG(" FW_DNLD: Section Read Status = %X \n", p_sec_info->section_read); 1311 DNLD_DEBUG(" FW_DNLD: Section Write Status = %X \n", p_sec_info->section_write); 1312 DNLD_DEBUG(" FW_DNLD: No Read Required, Read_size = %X \n", read_size); 1313 } 1314 } 1315 1316 if (read_size != 0) 1317 { 1318 1319 read_size = (uint16_t)((PHDNLD_DATA_SIZE >= read_size)? 1320 read_size: PHDNLD_DATA_SIZE); 1321 1322 p_dnld_data->frame_length[i] = (uint8_t)0; 1323 /* Update the LSB of the Data and the Address Parameter*/ 1324 p_data_param->data_addr[i] = (uint8_t)((read_addr >> 1325 (BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK); 1326 p_data_param->data_len[i] = (uint8_t)((read_size >> 1327 BYTE_SIZE) & BYTE_MASK); 1328 i++; 1329 1330 p_dnld_data->frame_length[i] = (uint8_t) 1331 ( PHDNLD_CMD_READ_LEN & BYTE_MASK); 1332 /* Update the 2nd byte of the Data and the Address Parameter*/ 1333 p_data_param->data_addr[i] = (uint8_t)((read_addr >> 1334 BYTE_SIZE) & BYTE_MASK); 1335 p_data_param->data_len[i] = (uint8_t) (read_size & BYTE_MASK); 1336 i++; 1337 1338 /* Update the 3rd byte of the the Address Parameter*/ 1339 p_data_param->data_addr[i] = (uint8_t)(read_addr & BYTE_MASK); 1340 1341 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1342 PHDNLD_CMD_READ, NULL , 0 ); 1343 1344 if ( NFCSTATUS_PENDING == status ) 1345 { 1346 p_sec_info->section_read = TRUE ; 1347 psDnldContext->next_dnld_state = phDnld_Upgrade_State; 1348 DNLD_DEBUG(" FW_DNLD: Memory Read at Address %X : ", read_addr); 1349 DNLD_DEBUG(" of Size %X \n", read_size); 1350 } 1351 1352 } 1353 return status; 1354 } 1355 1356 1357 1358 static 1359 NFCSTATUS 1360 phDnldNfc_Process_Write( 1361 phDnldNfc_sContext_t *psDnldContext, 1362 void *pHwRef, 1363 section_info_t *p_sec_info, 1364 uint32_t *p_sec_offset 1365 ) 1366 { 1367 NFCSTATUS status = NFCSTATUS_SUCCESS; 1368 phDnldNfc_sData_t *p_dnld_data = 1369 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 1370 phDnldNfc_sParam_t *dnld_data = 1371 &p_dnld_data->param_info.data_param; 1372 uint8_t *p_sm_trim_data = (uint8_t *)psDnldContext-> 1373 dnld_resp.param_info.response_data; 1374 uint32_t dnld_addr = 0; 1375 #ifdef NXP_FW_SW_VMID_TRIM 1376 uint32_t trim_addr = 0; 1377 #endif /* #ifdef NXP_FW_SW_VMID_TRIM */ 1378 static unsigned sec_type = 0; 1379 uint8_t i = 0; 1380 uint16_t dnld_size = 0; 1381 int cmp_val = 0x00; 1382 1383 1384 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type; 1385 1386 status = phDnldNfc_Read(psDnldContext, pHwRef, p_sec_info); 1387 if( NFCSTATUS_PENDING != status ) 1388 { 1389 if( (TRUE == p_sec_info->trim_write) 1390 && (TRUE == p_sec_info->section_read) 1391 && ((sec_type & DNLD_VERIFY_MASK)) 1392 ) 1393 { 1394 if(NULL != psDnldContext->trim_store.buffer) 1395 { 1396 uint32_t trim_cmp_size = psDnldContext->prev_dnld_size; 1397 1398 if( p_sec_info->p_sec_hdr->section_address 1399 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) ) 1400 { 1401 trim_cmp_size = trim_cmp_size - 2; 1402 } 1403 1404 /* Below Comparison fails due to the checksum */ 1405 cmp_val = phOsalNfc_MemCompare( 1406 psDnldContext->trim_store.buffer, 1407 &psDnldContext->dnld_resp. 1408 param_info.response_data[0] 1409 ,trim_cmp_size); 1410 DNLD_DEBUG(" FW_DNLD: %X Bytes Trim Write Complete ", 1411 psDnldContext->prev_dnld_size); 1412 DNLD_DEBUG(" Comparison Status %X\n", cmp_val); 1413 } 1414 p_sec_info->trim_write = FALSE; 1415 DNLD_DEBUG(" FW_DNLD: TRIMMED %X Bytes Write Complete\n", psDnldContext->prev_dnld_size); 1416 } 1417 else 1418 { 1419 if((NULL != psDnldContext->dnld_store.buffer) 1420 && ((sec_type & DNLD_VERIFY_MASK)) 1421 && (TRUE == p_sec_info->section_write) 1422 && (TRUE == p_sec_info->section_read) 1423 ) 1424 { 1425 cmp_val = phOsalNfc_MemCompare( 1426 psDnldContext->dnld_store.buffer, 1427 &psDnldContext->dnld_resp. 1428 param_info.response_data[0] 1429 ,psDnldContext->dnld_store.length); 1430 p_sec_info->section_read = FALSE; 1431 p_sec_info->section_write = FALSE; 1432 DNLD_DEBUG(" FW_DNLD: %X Bytes Write Complete ", 1433 psDnldContext->dnld_store.length); 1434 DNLD_DEBUG(" Comparison Status %X\n", cmp_val); 1435 } 1436 else 1437 { 1438 if(( TRUE == p_sec_info->section_write) 1439 && ( FALSE == p_sec_info->section_read) 1440 ) 1441 { 1442 p_sec_info->section_write = FALSE; 1443 } 1444 } 1445 /* p_sec_info->section_read = FALSE; */ 1446 } 1447 1448 if (( 0 == psDnldContext->dnld_retry ) 1449 && (0 == cmp_val) 1450 ) 1451 { 1452 p_sec_info->sec_verify_retry = 0; 1453 p_sec_info->section_offset = p_sec_info->section_offset + 1454 psDnldContext->prev_dnld_size; 1455 psDnldContext->prev_dnld_size = 0; 1456 DNLD_DEBUG(" FW_DNLD: Memory Write Retry - %X \n", 1457 psDnldContext->dnld_retry); 1458 } 1459 else 1460 { 1461 p_sec_info->sec_verify_retry++; 1462 DNLD_DEBUG(" FW_DNLD: Memory Verification Failed, Retry = %X \n", 1463 p_sec_info->sec_verify_retry); 1464 } 1465 1466 if( p_sec_info->sec_verify_retry < NXP_MAX_SECTION_WRITE ) 1467 { 1468 1469 dnld_addr = (p_sec_info->p_sec_hdr->section_address + *p_sec_offset); 1470 dnld_size = (uint16_t)(p_sec_info->p_sec_hdr->section_length 1471 - *p_sec_offset); 1472 } 1473 else 1474 { 1475 status = NFCSTATUS_FAILED; 1476 DNLD_DEBUG(" FW_DNLD: Memory Verification - Maximum Limit, Retry = %X \n", 1477 p_sec_info->sec_verify_retry); 1478 } 1479 } 1480 1481 1482 if (dnld_size != 0) 1483 { 1484 1485 dnld_size = (uint16_t)((PHDNLD_DATA_SIZE >= dnld_size)? 1486 dnld_size: PHDNLD_DATA_SIZE); 1487 1488 /* Update the LSB of the Data and the Address Parameter*/ 1489 dnld_data->data_addr[i] = (uint8_t)((dnld_addr >> 1490 (BYTE_SIZE + BYTE_SIZE)) & BYTE_MASK); 1491 dnld_data->data_len[i] = (uint8_t)((dnld_size >> BYTE_SIZE) 1492 & BYTE_MASK); 1493 p_dnld_data->frame_length[i] = (uint8_t) 1494 (((dnld_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE) 1495 & BYTE_MASK); 1496 i++; 1497 /* Update the 2nd byte of the Data and the Address Parameter*/ 1498 dnld_data->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE) 1499 & BYTE_MASK); 1500 dnld_data->data_len[i] = (uint8_t) (dnld_size & BYTE_MASK); 1501 p_dnld_data->frame_length[i] = (uint8_t) ((dnld_size + 1502 PHDNLD_CMD_WRITE_MIN_LEN) & BYTE_MASK); 1503 i++; 1504 /* Update the 3rd byte of the the Address Parameter*/ 1505 dnld_data->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK); 1506 1507 (void)memcpy( dnld_data->data_packet, 1508 (p_sec_info->p_sec_data + *p_sec_offset), dnld_size ); 1509 1510 if( ((sec_type & DNLD_TRIM_MASK)) 1511 && (p_sec_info->sec_verify_retry != 0) 1512 && (NULL != psDnldContext->trim_store.buffer) 1513 ) 1514 { 1515 (void)memcpy( dnld_data->data_packet, 1516 psDnldContext->trim_store.buffer, dnld_size ); 1517 } 1518 else if(((sec_type & DNLD_TRIM_MASK)) 1519 && ( TRUE == p_sec_info->section_read ) 1520 ) 1521 { 1522 for(i = 0; i < *(p_sec_info->p_trim_data);i++) 1523 { 1524 1525 #ifdef NXP_FW_SW_VMID_TRIM 1526 1527 /* 1528 if(bit 0 of 0x813D is equal to 1) then 1529 1530 Do not overwrite 0x9931 / 0x9981 during download 1531 1532 else 1533 1534 @0x9931 = 0x79 // card Mode 1535 @0x9981 = 0x79 // Reader Mode 1536 */ 1537 trim_addr = p_sec_info->p_sec_hdr->section_address 1538 + p_sec_info->p_trim_data[i+1]; 1539 if (NXP_FW_VMID_TRIM_CHK_ADDR == trim_addr) 1540 { 1541 psDnldContext->vmid_trim_update = 1542 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ; 1543 } 1544 1545 if((NXP_FW_VMID_CARD_MODE_ADDR == trim_addr) 1546 || (NXP_FW_VMID_RD_MODE_ADDR == trim_addr)) 1547 { 1548 if (TRUE == psDnldContext->vmid_trim_update) 1549 { 1550 dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] = 1551 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ; 1552 } 1553 } 1554 else 1555 1556 #endif 1557 { 1558 dnld_data->data_packet[p_sec_info->p_trim_data[i+1]] = 1559 p_sm_trim_data[p_sec_info->p_trim_data[i+1]] ; 1560 } 1561 } 1562 if(NULL != psDnldContext->trim_store.buffer) 1563 { 1564 phOsalNfc_FreeMemory(psDnldContext->trim_store.buffer); 1565 psDnldContext->trim_store.buffer = NULL; 1566 psDnldContext->trim_store.length = 0; 1567 } 1568 #if 1 1569 (void) 1570 phDnldNfc_Allocate_Resource((void **) 1571 &(psDnldContext->trim_store.buffer),dnld_size); 1572 #else 1573 psDnldContext->trim_store.buffer = 1574 (uint8_t *) phOsalNfc_GetMemory(dnld_size); 1575 #endif 1576 1577 if(NULL != psDnldContext->trim_store.buffer) 1578 { 1579 (void )memset((void *)psDnldContext->trim_store.buffer,0, 1580 dnld_size); 1581 (void)memcpy( psDnldContext->trim_store.buffer, 1582 dnld_data->data_packet, dnld_size ); 1583 psDnldContext->trim_store.length = dnld_size; 1584 DNLD_DEBUG(" FW_DNLD: Write with Trimming at Address %X ", dnld_addr ); 1585 DNLD_DEBUG(" of Size %X and ", dnld_size ); 1586 DNLD_DEBUG(" with %X Trimming Values \n", *(p_sec_info->p_trim_data) ); 1587 1588 } 1589 } 1590 else 1591 { 1592 if(NULL != psDnldContext->dnld_store.buffer) 1593 { 1594 phOsalNfc_FreeMemory(psDnldContext->dnld_store.buffer); 1595 psDnldContext->dnld_store.buffer = NULL; 1596 psDnldContext->dnld_store.length = 0; 1597 } 1598 #if 1 1599 (void) 1600 phDnldNfc_Allocate_Resource((void **) 1601 &(psDnldContext->dnld_store.buffer),dnld_size); 1602 #else 1603 psDnldContext->dnld_store.buffer = 1604 (uint8_t *) phOsalNfc_GetMemory(dnld_size); 1605 #endif 1606 if(NULL != psDnldContext->dnld_store.buffer) 1607 { 1608 (void )memset((void *)psDnldContext->dnld_store.buffer,0, 1609 dnld_size); 1610 (void)memcpy( psDnldContext->dnld_store.buffer, 1611 dnld_data->data_packet, dnld_size ); 1612 psDnldContext->dnld_store.length = dnld_size; 1613 DNLD_DEBUG(" FW_DNLD: Memory Write at Address %X ", dnld_addr ); 1614 DNLD_DEBUG(" of Size %X ", dnld_size ); 1615 } 1616 } 1617 1618 if(PHDNLD_FW_PATCH_SEC != psDnldContext->p_fw_hdr->fw_patch) 1619 { 1620 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1621 PHDNLD_CMD_WRITE, NULL , 0 ); 1622 } 1623 else 1624 { 1625 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1626 PHDNLD_CMD_SEC_WRITE, NULL , 0 ); 1627 } 1628 1629 DNLD_DEBUG(" FW_DNLD: Memory Write Status = %X \n", status); 1630 if ( NFCSTATUS_PENDING == status ) 1631 { 1632 psDnldContext->prev_dnld_size = dnld_size; 1633 cmp_val = 0x00; 1634 if((sec_type & DNLD_TRIM_MASK)) 1635 { 1636 p_sec_info->trim_write = TRUE; 1637 DNLD_DEBUG(" FW_DNLD: Bytes Downloaded (Trimming Values) = %X Bytes \n", 1638 dnld_size); 1639 } 1640 else 1641 { 1642 p_sec_info->section_write = TRUE; 1643 DNLD_DEBUG(" FW_DNLD: Bytes Downloaded = %X : ", 1644 (*p_sec_offset + dnld_size)); 1645 DNLD_DEBUG(" Bytes Remaining = %X \n", 1646 (p_sec_info->p_sec_hdr->section_length - 1647 (*p_sec_offset + dnld_size))); 1648 } 1649 1650 p_sec_info->section_read = FALSE; 1651 } 1652 } 1653 return status; 1654 } 1655 1656 1657 1658 static 1659 NFCSTATUS 1660 phDnldNfc_Resume_Write( 1661 phDnldNfc_sContext_t *psDnldContext, 1662 void *pHwRef 1663 ) 1664 { 1665 NFCSTATUS status = NFCSTATUS_SUCCESS; 1666 uint8_t sec_index = psDnldContext->section_index; 1667 section_info_t *p_sec_info = (psDnldContext->p_fw_sec + sec_index); 1668 1669 while((sec_index < psDnldContext->p_fw_hdr->no_of_sections) 1670 && (NFCSTATUS_SUCCESS == status ) 1671 ) 1672 { 1673 1674 status = phDnldNfc_Process_Write(psDnldContext, pHwRef, 1675 p_sec_info, (uint32_t *)&(p_sec_info->section_offset)); 1676 if (NFCSTATUS_SUCCESS == status) 1677 { 1678 unsigned sec_type = 0; 1679 sec_type = (unsigned int)p_sec_info->p_sec_hdr->section_mem_type; 1680 1681 p_sec_info->section_offset = 0; 1682 p_sec_info->section_read = FALSE; 1683 p_sec_info->section_write = FALSE; 1684 p_sec_info->trim_write = FALSE; 1685 1686 DNLD_DEBUG(" FW_DNLD: Section %02X Download Complete\n", sec_index); 1687 if((sec_type & DNLD_RESET_MASK)) 1688 { 1689 DNLD_DEBUG(" FW_DNLD: Reset After Section %02X Download \n", sec_index); 1690 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1691 PHDNLD_CMD_RESET , NULL, 0 ); 1692 } 1693 DNLD_PRINT("*******************************************\n\n"); 1694 1695 sec_index++; 1696 1697 #ifdef NXP_FW_DNLD_CHECK_PHASE 1698 if( p_sec_info->p_sec_hdr->section_address 1699 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) ) 1700 { 1701 gphDnldPhase = NXP_FW_DNLD_DATA_PHASE; 1702 1703 } 1704 1705 p_sec_info = (psDnldContext->p_fw_sec + sec_index); 1706 1707 if( (sec_index < psDnldContext->p_fw_hdr->no_of_sections) 1708 && ( p_sec_info->p_sec_hdr->section_address 1709 < (DNLD_CFG_PG_ADDR + PHDNLD_PAGE_SIZE) ) 1710 ) 1711 { 1712 if( NXP_FW_DNLD_CFG_PHASE >= gphDnldPhase ) 1713 { 1714 gphDnldPhase = NXP_FW_DNLD_CFG_PHASE; 1715 } 1716 else 1717 { 1718 sec_index++; 1719 p_sec_info = (psDnldContext->p_fw_sec + sec_index); 1720 } 1721 } 1722 #else 1723 p_sec_info = (psDnldContext->p_fw_sec + sec_index); 1724 #endif /* #ifdef NXP_FW_DNLD_CHECK_PHASE */ 1725 1726 psDnldContext->section_index = sec_index; 1727 /* psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State; */ 1728 } 1729 } 1730 if (NFCSTATUS_PENDING == status) 1731 { 1732 psDnldContext->next_dnld_state = (uint8_t) phDnld_Upgrade_State; 1733 } 1734 else if (NFCSTATUS_SUCCESS == status) 1735 { 1736 /* Reset the PN544 Device */ 1737 psDnldContext->next_dnld_state = (uint8_t) phDnld_Complete_State; 1738 } 1739 else 1740 { 1741 1742 } 1743 return status; 1744 } 1745 1746 1747 #define NXP_DNLD_SM_UNLOCK_ADDR 0x008002U 1748 1749 #if !defined (ES_HW_VER) 1750 #define ES_HW_VER 32 1751 #endif 1752 1753 #if (ES_HW_VER <= 30) 1754 #define NXP_DNLD_PATCH_ADDR 0x01AFFFU 1755 #else 1756 #define NXP_DNLD_PATCH_ADDR 0x01A1E0U 1757 #endif 1758 1759 #if (ES_HW_VER <= 30) 1760 #define NXP_DNLD_PATCH_TABLE_ADDR 0x008107U 1761 #else 1762 #define NXP_DNLD_PATCH_TABLE_ADDR 0x00825AU 1763 #endif 1764 1765 1766 static 1767 NFCSTATUS 1768 phDnldNfc_Sequence( 1769 phDnldNfc_sContext_t *psDnldContext, 1770 void *pHwRef, 1771 void *pdata, 1772 uint16_t length 1773 ) 1774 { 1775 NFCSTATUS status = NFCSTATUS_SUCCESS; 1776 uint32_t dnld_addr = 0; 1777 phDnldNfc_sData_t *p_dnld_data = 1778 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 1779 phDnldNfc_sParam_t *p_data_param = 1780 & p_dnld_data->param_info.data_param; 1781 uint8_t *p_data = NULL; 1782 static uint32_t patch_size = 0; 1783 1784 #if (ES_HW_VER == 32) 1785 1786 static uint8_t patch_table[] = {0xA0, 0xA1, 0xE0, 0x80, 0xA9, 0x6C }; 1787 static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5, 1788 0xD0, 0xFC, 0xA5, 0x02, 0x80, 0xA9, 0x75}; 1789 1790 #elif (ES_HW_VER == 31) 1791 1792 static uint8_t patch_table[] = {0xA0, 0xAF, 0xE0, 0x80, 0x78, 0x84 }; 1793 static uint8_t patch_data[] = {0xA5, 0xD0, 0xFE, 0xA5, 0xD0, 0xFD, 0xA5, 1794 0xD0, 0xFC, 0xD0, 0xE0, 0xA5, 0x02, 0x80, 0x78, 0x8D}; 1795 1796 #elif (ES_HW_VER == 30) 1797 1798 static uint8_t patch_table[] = {0x80, 0x91, 0x51, 0xA0, 0xAF, 1799 0xFF, 0x80, 0x91, 0x5A}; 1800 static uint8_t patch_data[] = {0x22}; 1801 1802 #endif 1803 1804 static uint8_t unlock_data[] = {0x00, 0x00}; 1805 static uint8_t lock_data[] = {0x0C, 0x00}; 1806 1807 uint8_t i = 0; 1808 1809 PHNFC_UNUSED_VARIABLE(pdata); 1810 PHNFC_UNUSED_VARIABLE(length); 1811 switch(psDnldContext->cur_dnld_seq) 1812 { 1813 case phDnld_Reset_Seq: 1814 { 1815 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1816 PHDNLD_CMD_RESET , NULL , 0 ); 1817 /* status = (NFCSTATUS_PENDING == status)? NFCSTATUS_SUCCESS: 1818 status; */ 1819 DNLD_DEBUG(" FW_DNLD: Reset Seq.. Status = %X \n", status); 1820 1821 break; 1822 } 1823 case phDnld_Activate_Patch: 1824 { 1825 uint8_t patch_activate = 0x01; 1826 psDnldContext->next_dnld_seq = 1827 (uint8_t)phDnld_Update_Patch; 1828 #ifdef NXP_FW_DNLD_CHECK_PHASE 1829 gphDnldPhase = NXP_FW_DNLD_SYSTEM_PHASE; 1830 #endif /* NXP_FW_DNLD_CHECK_PHASE */ 1831 1832 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1833 PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) ); 1834 DNLD_PRINT(" FW_DNLD: Activate the Patch Update .... \n"); 1835 break; 1836 } 1837 case phDnld_Deactivate_Patch: 1838 { 1839 uint8_t patch_activate = 0x00; 1840 1841 psDnldContext->next_dnld_state = 1842 (uint8_t)phDnld_Reset_State; 1843 1844 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1845 PHDNLD_CMD_ACTIVATE_PATCH , &patch_activate, sizeof(patch_activate) ); 1846 DNLD_PRINT(" FW_DNLD: Deactivate the Patch Update .... \n"); 1847 break; 1848 } 1849 case phDnld_Update_Patch: 1850 { 1851 dnld_addr = NXP_DNLD_PATCH_ADDR; 1852 patch_size = sizeof(patch_data) ; 1853 p_data = patch_data; 1854 psDnldContext->next_dnld_seq = 1855 (uint8_t)phDnld_Update_Patchtable; 1856 DNLD_PRINT(" FW_DNLD: Patch Update Seq.... \n"); 1857 break; 1858 } 1859 case phDnld_Update_Patchtable: 1860 { 1861 dnld_addr = NXP_DNLD_PATCH_TABLE_ADDR; 1862 patch_size = sizeof(patch_table) ; 1863 p_data = patch_table; 1864 1865 psDnldContext->next_dnld_state = 1866 (uint8_t)phDnld_Reset_State; 1867 1868 DNLD_PRINT(" FW_DNLD: Patch Table Update Seq.... \n"); 1869 break; 1870 } 1871 case phDnld_Unlock_System: 1872 { 1873 dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR; 1874 patch_size = sizeof(unlock_data) ; 1875 p_data = unlock_data; 1876 #define NXP_FW_PATCH_DISABLE 1877 #ifdef NXP_FW_PATCH_DISABLE 1878 psDnldContext->next_dnld_seq = 1879 (uint8_t)phDnld_Deactivate_Patch; 1880 #else 1881 psDnldContext->next_dnld_state = 1882 (uint8_t)phDnld_Reset_State; 1883 #endif 1884 1885 DNLD_PRINT(" FW_DNLD: System Memory Unlock Seq.... \n"); 1886 break; 1887 } 1888 case phDnld_Lock_System: 1889 { 1890 dnld_addr = NXP_DNLD_SM_UNLOCK_ADDR; 1891 patch_size = sizeof(lock_data) ; 1892 p_data = lock_data; 1893 psDnldContext->next_dnld_state = 1894 (uint8_t) phDnld_Reset_State; 1895 1896 DNLD_PRINT(" FW_DNLD: System Memory Lock Seq.... \n"); 1897 break; 1898 } 1899 case phDnld_Upgrade_Section: 1900 { 1901 status = phDnldNfc_Resume_Write( 1902 psDnldContext, pHwRef ); 1903 break; 1904 } 1905 case phDnld_Verify_Integrity: 1906 { 1907 psDnldContext->next_dnld_state = 1908 (uint8_t) phDnld_Reset_State; 1909 1910 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1911 PHDNLD_CMD_CHECK_INTEGRITY , NULL, 0 ); 1912 DNLD_PRINT(" FW_DNLD: System Memory Integrity Check Sequence.... \n"); 1913 break; 1914 } 1915 case phDnld_Verify_Section: 1916 { 1917 break; 1918 } 1919 default: 1920 { 1921 break; 1922 } 1923 } 1924 1925 if( NFCSTATUS_SUCCESS == status) 1926 { 1927 1928 /* Update the LSB of the Data and the Address Parameter*/ 1929 p_data_param->data_addr[i] = (uint8_t)((dnld_addr >> 1930 (BYTE_SIZE + BYTE_SIZE)) 1931 & BYTE_MASK); 1932 p_data_param->data_len[i] = (uint8_t)((patch_size >> BYTE_SIZE) 1933 & BYTE_MASK); 1934 p_dnld_data->frame_length[i] = (uint8_t) 1935 (((patch_size + PHDNLD_CMD_WRITE_MIN_LEN) >> BYTE_SIZE) 1936 & BYTE_MASK); 1937 i++; 1938 /* Update the 2nd byte of the Data and the Address Parameter*/ 1939 p_data_param->data_addr[i] = (uint8_t)((dnld_addr >> BYTE_SIZE) 1940 & BYTE_MASK); 1941 p_data_param->data_len[i] = (uint8_t) (patch_size & BYTE_MASK); 1942 p_dnld_data->frame_length[i] = (uint8_t) 1943 ((patch_size + PHDNLD_CMD_WRITE_MIN_LEN) 1944 & BYTE_MASK); 1945 i++; 1946 /* Update the 3rd byte of the the Address Parameter*/ 1947 p_data_param->data_addr[i] = (uint8_t)(dnld_addr & BYTE_MASK); 1948 1949 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 1950 PHDNLD_CMD_WRITE,(void *)p_data , (uint8_t)patch_size ); 1951 1952 if (NFCSTATUS_PENDING != status) 1953 { 1954 status = phDnldNfc_Set_Seq(psDnldContext, 1955 DNLD_SEQ_ROLLBACK); 1956 } 1957 } 1958 return status; 1959 } 1960 1961 #define FRAME_HEADER_LEN 0x03U 1962 1963 1964 static 1965 void 1966 phDnldNfc_Tx_Reset(phDnldNfc_sContext_t *psDnldContext) 1967 { 1968 psDnldContext->tx_info.transmit_frame = NULL; 1969 psDnldContext->tx_info.tx_total = 0x00; 1970 psDnldContext->tx_info.tx_offset = 0x00; 1971 psDnldContext->tx_info.tx_len = 0x00; 1972 psDnldContext->tx_info.tx_chain = FALSE; 1973 } 1974 1975 STATIC 1976 bool_t 1977 phDnldNfc_Extract_Chunks( 1978 uint8_t *frame_data, 1979 uint16_t frame_offset, 1980 uint16_t frame_length, 1981 uint16_t max_frame , 1982 uint16_t *chunk_length 1983 ); 1984 1985 1986 STATIC 1987 bool_t 1988 phDnldNfc_Extract_Chunks( 1989 uint8_t *frame_data, 1990 uint16_t frame_offset, 1991 uint16_t frame_length, 1992 uint16_t max_frame , 1993 uint16_t *chunk_length 1994 ) 1995 { 1996 bool_t chunk_present = FALSE; 1997 1998 if( 0 == frame_offset) 1999 { 2000 if( max_frame >= (frame_length 2001 - frame_offset)) 2002 { 2003 *chunk_length = (frame_length - frame_offset); 2004 } 2005 else 2006 { 2007 *chunk_length = max_frame 2008 - FRAME_HEADER_LEN; 2009 chunk_present = TRUE; 2010 } 2011 } 2012 else 2013 { 2014 if( max_frame >= (frame_length 2015 - frame_offset)) 2016 { 2017 *chunk_length = (frame_length - frame_offset); 2018 } 2019 else 2020 { 2021 *chunk_length = max_frame 2022 - FRAME_HEADER_LEN; 2023 chunk_present = TRUE; 2024 } 2025 } 2026 2027 return chunk_present; 2028 } 2029 2030 2031 STATIC 2032 NFCSTATUS 2033 phDnldNfc_Send_Raw( 2034 phDnldNfc_sContext_t *psDnldContext, 2035 void *pHwRef, 2036 uint8_t *raw_frame, 2037 uint16_t frame_offset, 2038 uint16_t frame_length 2039 ) 2040 { 2041 NFCSTATUS status = NFCSTATUS_SUCCESS; 2042 phDnldNfc_sRawHdr_t *raw_frame_hdr = ( phDnldNfc_sRawHdr_t * ) raw_frame; 2043 2044 switch(raw_frame_hdr->frame_type) 2045 { 2046 case PHDNLD_CMD_RESET: 2047 { 2048 break; 2049 } 2050 case PHDNLD_CMD_READ: 2051 { 2052 /* TODO: To Update the length and the buffer to receive data */ 2053 break; 2054 } 2055 case PHDNLD_CMD_WRITE: 2056 { 2057 phDnldNfc_sRawDataHdr_t *raw_data_hdr = 2058 ( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN); 2059 2060 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 2061 2062 break; 2063 } 2064 case PHDNLD_CMD_SEC_WRITE: 2065 { 2066 uint16_t tx_length = 0x00; 2067 uint16_t frame_offset = 2068 psDnldContext->tx_info.tx_offset; 2069 uint16_t chain = 2070 psDnldContext->tx_info.tx_chain; 2071 2072 chain = 2073 phDnldNfc_Extract_Chunks( 2074 raw_frame, 2075 frame_offset, 2076 frame_length, 2077 PHDNLD_FW_TX_RX_LEN, 2078 &tx_length 2079 ); 2080 2081 if( TRUE == chain ) 2082 { 2083 status = phDnldNfc_Send_Command( psDnldContext, 2084 pHwRef, PHDNLD_CMD_ENCAPSULATE, 2085 (raw_frame + frame_offset), 2086 tx_length); 2087 if(NFCSTATUS_PENDING == status) 2088 { 2089 psDnldContext->prev_cmd = raw_frame_hdr->frame_type; 2090 /* TODO: Update for the Chaining */ 2091 psDnldContext->tx_info.tx_offset += tx_length; 2092 psDnldContext->tx_info.tx_chain = chain; 2093 } 2094 } 2095 else if (0 != frame_offset) 2096 { 2097 status = phDnldNfc_Send_Command( psDnldContext, 2098 pHwRef, PHDNLD_CMD_ENCAPSULATE, 2099 (raw_frame + frame_offset), 2100 tx_length); 2101 if(NFCSTATUS_PENDING == status) 2102 { 2103 psDnldContext->prev_cmd = raw_frame_hdr->frame_type; 2104 /* TODO: Update for the Chaining */ 2105 psDnldContext->prev_dnld_size = frame_length; 2106 phDnldNfc_Tx_Reset(psDnldContext); 2107 } 2108 } 2109 else 2110 { 2111 phDnldNfc_sRawDataHdr_t *raw_data_hdr = 2112 ( phDnldNfc_sRawDataHdr_t * ) (raw_frame + FRAME_HEADER_LEN); 2113 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 2114 } 2115 2116 break; 2117 } 2118 case PHDNLD_CMD_CHECK: 2119 { 2120 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 2121 break; 2122 } 2123 case PHDNLD_CMD_SET_HIF: 2124 { 2125 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 2126 break; 2127 } 2128 case PHDNLD_CMD_ACTIVATE_PATCH: 2129 { 2130 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 2131 break; 2132 } 2133 case PHDNLD_CMD_CHECK_INTEGRITY: 2134 { 2135 uint8_t integrity_param = 2136 *(raw_frame + FRAME_HEADER_LEN); 2137 switch(integrity_param) 2138 { 2139 case CHK_INTEGRITY_CONFIG_PAGE_CRC: 2140 case CHK_INTEGRITY_PATCH_TABLE_CRC: 2141 { 2142 psDnldContext->resp_length = PHDNLD_MIN_PACKET 2143 + CHECK_INTEGRITY_RESP_CRC16_LEN; 2144 break; 2145 } 2146 case CHK_INTEGRITY_FLASH_CODE_CRC: 2147 case CHK_INTEGRITY_PATCH_CODE_CRC: 2148 { 2149 psDnldContext->resp_length = PHDNLD_MIN_PACKET 2150 + CHECK_INTEGRITY_RESP_CRC32_LEN; 2151 break; 2152 } 2153 case CHK_INTEGRITY_COMPLETE_CRC: 2154 default: 2155 { 2156 psDnldContext->resp_length = PHDNLD_MIN_PACKET 2157 + CHECK_INTEGRITY_RESP_COMP_LEN; 2158 break; 2159 } 2160 } 2161 break; 2162 } 2163 default: 2164 { 2165 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED); 2166 break; 2167 } 2168 } 2169 2170 if (NFCSTATUS_SUCCESS == status) 2171 { 2172 status = phDnldNfc_Send( psDnldContext, pHwRef , 2173 raw_frame, frame_length); 2174 2175 if(NFCSTATUS_PENDING == status) 2176 { 2177 psDnldContext->prev_cmd = raw_frame_hdr->frame_type; 2178 /* TODO: Update for the Chaining */ 2179 psDnldContext->prev_dnld_size = frame_length; 2180 } 2181 } 2182 2183 return status; 2184 } 2185 2186 2187 static 2188 NFCSTATUS 2189 phDnldNfc_Frame_Complete(phDnldNfc_sContext_t *psDnldContext) 2190 { 2191 NFCSTATUS status = NFCSTATUS_SUCCESS; 2192 phDnldNfc_sData_Hdr_t *p_dnld_raw = NULL; 2193 uint32_t dnld_index = psDnldContext->dnld_index; 2194 uint8_t *p_raw_sec_hdr = NULL; 2195 uint16_t tx_length = 0x00; 2196 2197 dnld_index = dnld_index + psDnldContext->prev_dnld_size; 2198 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index; 2199 dnld_index = dnld_index + *p_raw_sec_hdr; 2200 2201 p_dnld_raw = (phDnldNfc_sData_Hdr_t *) (psDnldContext->p_fw_raw + 2202 psDnldContext->dnld_index); 2203 2204 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) | 2205 p_dnld_raw->frame_length[1]); 2206 2207 tx_length = tx_length + PHDNLD_MIN_PACKET; 2208 2209 return status; 2210 } 2211 2212 2213 static 2214 NFCSTATUS 2215 phDnldNfc_Raw_Write( 2216 phDnldNfc_sContext_t *psDnldContext, 2217 void *pHwRef 2218 ) 2219 { 2220 NFCSTATUS status = NFCSTATUS_SUCCESS; 2221 uint32_t dnld_index = psDnldContext->dnld_index; 2222 uint32_t tx_length = 0; 2223 uint8_t *p_raw_sec_hdr = NULL; 2224 uint8_t dnld_flag = FALSE; 2225 uint8_t skip_frame = FALSE; 2226 2227 if(NULL != psDnldContext->p_fw_raw) 2228 { 2229 2230 if( (TRUE != psDnldContext->tx_info.tx_chain) 2231 && (0x00 == psDnldContext->dnld_retry) 2232 ) 2233 { 2234 dnld_index = dnld_index + psDnldContext->prev_dnld_size; 2235 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index; 2236 dnld_index = dnld_index + *p_raw_sec_hdr; 2237 } 2238 else 2239 { 2240 phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *) 2241 (psDnldContext->p_fw_raw + 2242 psDnldContext->dnld_index); 2243 2244 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) | 2245 p_dnld_raw->frame_length[1]); 2246 2247 tx_length = tx_length + PHDNLD_MIN_PACKET; 2248 2249 status = phDnldNfc_Send_Raw( psDnldContext, pHwRef, 2250 (uint8_t *)(p_dnld_raw), 2251 psDnldContext->tx_info.tx_offset, 2252 (uint16_t)tx_length); 2253 } 2254 2255 2256 #define PHDNLD_MAJOR_OFFSET 0x04U 2257 #define PHDNLD_MINOR_OFFSET 0x05U 2258 #define PHDNLD_PHASE_OFFSET 0x06U 2259 #define PHDNLD_FRAMETYPE_OFFSET 0x07U 2260 2261 #define PHDNLD_NO_OPERATION 0x00U 2262 #define PHDNLD_NORMAL_OPERATION 0x10U 2263 #define PHDNLD_ADVANCED_OPERATION 0x20U 2264 #define PHDNLD_SETUP_OPERATION 0x40U 2265 #define PHDNLD_RECOVER_OPERATION 0x80U 2266 #define PHDNLD_COMPLETE_OPERATION 0xF0U 2267 2268 #define PHDNLD_TERMINATE_TYPE 0x0EU 2269 2270 #define PHDNLD_MARKER_MASK 0x0FU 2271 2272 while((NFCSTATUS_SUCCESS == status ) 2273 && (FALSE == dnld_flag) 2274 ) 2275 { 2276 phDnldNfc_sData_Hdr_t *p_dnld_raw = (phDnldNfc_sData_Hdr_t *) 2277 (psDnldContext->p_fw_raw + dnld_index); 2278 uint8_t frame_type = *(p_raw_sec_hdr + PHDNLD_FRAMETYPE_OFFSET); 2279 2280 tx_length = ((p_dnld_raw->frame_length[0] << BYTE_SIZE) | 2281 p_dnld_raw->frame_length[1]); 2282 2283 tx_length = tx_length + PHDNLD_MIN_PACKET; 2284 2285 skip_frame = FALSE; 2286 2287 if( (0x00 == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET)) 2288 || (0xFF == *(p_raw_sec_hdr + PHDNLD_PHASE_OFFSET)) 2289 || !( psDnldContext->raw_mode_upgrade 2290 & (frame_type & (~PHDNLD_MARKER_MASK)) ) 2291 ) 2292 { 2293 dnld_index = dnld_index + tx_length; 2294 p_raw_sec_hdr = psDnldContext->p_fw_raw + dnld_index; 2295 dnld_index = dnld_index + *p_raw_sec_hdr; 2296 skip_frame = TRUE; 2297 } 2298 if (PHDNLD_TERMINATE_TYPE == 2299 (frame_type & PHDNLD_MARKER_MASK)) 2300 { 2301 if(TRUE != skip_frame) 2302 { 2303 psDnldContext->raw_mode_upgrade = 2304 (psDnldContext->raw_mode_upgrade & 2305 ~(frame_type & ~PHDNLD_MARKER_MASK)); 2306 } 2307 2308 if(PHDNLD_NO_OPERATION == 2309 psDnldContext->raw_mode_upgrade) 2310 { 2311 dnld_flag = TRUE; 2312 } 2313 } 2314 else 2315 { 2316 2317 } 2318 2319 if((FALSE == skip_frame) 2320 && (FALSE == dnld_flag) 2321 ) 2322 { 2323 status = phDnldNfc_Send_Raw( psDnldContext, pHwRef, 2324 (uint8_t *)(p_dnld_raw), 2325 psDnldContext->tx_info.tx_offset, 2326 (uint16_t)tx_length); 2327 } 2328 2329 if( NFCSTATUS_PENDING == status ) 2330 { 2331 psDnldContext->dnld_index = dnld_index; 2332 psDnldContext->cur_frame_info= frame_type; 2333 } 2334 } 2335 } 2336 2337 return status; 2338 } 2339 2340 static 2341 NFCSTATUS 2342 phDnldNfc_Upgrade_Sequence( 2343 phDnldNfc_sContext_t *psDnldContext, 2344 void *pHwRef, 2345 void *pdata, 2346 uint16_t length 2347 ) 2348 { 2349 NFCSTATUS status = NFCSTATUS_SUCCESS; 2350 2351 PHNFC_UNUSED_VARIABLE(pdata); 2352 PHNFC_UNUSED_VARIABLE(length); 2353 2354 if(phDnld_Raw_Upgrade == psDnldContext->cur_dnld_seq) 2355 { 2356 status = phDnldNfc_Raw_Write( psDnldContext, pHwRef ); 2357 } 2358 else 2359 { 2360 status = phDnldNfc_Resume_Write( psDnldContext, pHwRef ); 2361 } 2362 2363 return status; 2364 } 2365 2366 2367 2368 static 2369 NFCSTATUS 2370 phDnldNfc_Resume( 2371 phDnldNfc_sContext_t *psDnldContext, 2372 void *pHwRef, 2373 void *pdata, 2374 uint16_t length 2375 ) 2376 { 2377 NFCSTATUS status = NFCSTATUS_SUCCESS; 2378 phDnldNfc_eState_t dnld_next_state = (phDnldNfc_eState_t) 2379 psDnldContext->cur_dnld_state; 2380 phNfc_sCompletionInfo_t comp_info = {0,0,0}; 2381 2382 switch( dnld_next_state ) 2383 { 2384 case phDnld_Reset_State: 2385 { 2386 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 2387 PHDNLD_CMD_RESET , NULL, 0 ); 2388 switch( psDnldContext->cur_dnld_seq ) 2389 { 2390 case phDnld_Update_Patchtable: 2391 { 2392 psDnldContext->next_dnld_state = 2393 (uint8_t)phDnld_Unlock_State; 2394 psDnldContext->next_dnld_seq = 2395 (uint8_t)phDnld_Unlock_System; 2396 break; 2397 } 2398 #ifdef NXP_FW_PATCH_DISABLE 2399 case phDnld_Deactivate_Patch: 2400 #else 2401 case phDnld_Unlock_System: 2402 #endif 2403 { 2404 psDnldContext->next_dnld_state = 2405 (uint8_t)phDnld_Upgrade_State; 2406 psDnldContext->next_dnld_seq = 2407 (uint8_t)phDnld_Upgrade_Section; 2408 #ifdef NXP_FW_DNLD_CHECK_PHASE 2409 gphDnldPhase = NXP_FW_DNLD_CFG_PHASE; 2410 #endif /* NXP_FW_DNLD_CHECK_PHASE */ 2411 break; 2412 } 2413 case phDnld_Lock_System: 2414 { 2415 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 2416 psDnldContext->next_dnld_state = 2417 (uint8_t)phDnld_Verify_State; 2418 psDnldContext->next_dnld_seq = 2419 (uint8_t)phDnld_Verify_Integrity; 2420 #else 2421 /* (void ) memset( (void *) &psDnldContext->chk_integrity_crc, 2422 0, sizeof(psDnldContext->chk_integrity_crc)); */ 2423 psDnldContext->next_dnld_state = 2424 (uint8_t) phDnld_Complete_State; 2425 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 2426 break; 2427 } 2428 case phDnld_Verify_Integrity: 2429 { 2430 psDnldContext->next_dnld_state = 2431 (uint8_t) phDnld_Complete_State; 2432 break; 2433 } 2434 default: 2435 { 2436 status = (NFCSTATUS_PENDING == status)? 2437 NFCSTATUS_SUCCESS: status; 2438 break; 2439 } 2440 } 2441 break; 2442 } 2443 case phDnld_Unlock_State: 2444 { 2445 2446 status = phDnldNfc_Sequence( psDnldContext, pHwRef, 2447 pdata, length); 2448 break; 2449 } 2450 case phDnld_Upgrade_State: 2451 { 2452 status = phDnldNfc_Upgrade_Sequence( psDnldContext, pHwRef, 2453 pdata, length); 2454 if ((NFCSTATUS_SUCCESS == status ) 2455 && (phDnld_Complete_State == psDnldContext->next_dnld_state)) 2456 { 2457 #if 0 2458 psDnldContext->cur_dnld_seq = 2459 (uint8_t)phDnld_Lock_System; 2460 psDnldContext->next_dnld_seq = 2461 psDnldContext->cur_dnld_seq; 2462 #endif 2463 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 2464 psDnldContext->next_dnld_state = 2465 (uint8_t)phDnld_Verify_State; 2466 psDnldContext->next_dnld_seq = 2467 (uint8_t)phDnld_Verify_Integrity; 2468 psDnldContext->cur_dnld_seq = 2469 psDnldContext->next_dnld_seq; 2470 status = phDnldNfc_Sequence( psDnldContext, 2471 pHwRef, pdata, length); 2472 #else 2473 /* (void ) memset( (void *) &psDnldContext->chk_integrity_crc, 2474 0, sizeof(psDnldContext->chk_integrity_crc)); */ 2475 psDnldContext->next_dnld_state = 2476 (uint8_t) phDnld_Complete_State; 2477 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 2478 } 2479 break; 2480 } 2481 case phDnld_Verify_State: 2482 { 2483 status = phDnldNfc_Sequence( psDnldContext, 2484 pHwRef, pdata, length); 2485 break; 2486 } 2487 case phDnld_Complete_State: 2488 { 2489 uint8_t integrity_chk = 0xA5; 2490 2491 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 2492 uint8_t verify_crc = 0x96; 2493 2494 if ( (NULL != psDnldContext->p_flash_code_crc) 2495 && (NULL != psDnldContext->p_patch_code_crc) 2496 && (NULL != psDnldContext->p_patch_table_crc) 2497 ) 2498 { 2499 uint8_t crc_i = 0; 2500 uint16_t patch_table_crc = 0; 2501 uint32_t flash_code_crc = 0; 2502 uint32_t patch_code_crc = 0; 2503 2504 for (crc_i = 0; crc_i < DNLD_CRC32_SIZE; crc_i++ ) 2505 { 2506 if (crc_i < DNLD_CRC16_SIZE ) 2507 { 2508 patch_table_crc = patch_table_crc 2509 | psDnldContext->chk_integrity_crc.patch_table.Chk_Crc16[crc_i] 2510 << (crc_i * BYTE_SIZE) ; 2511 } 2512 flash_code_crc = flash_code_crc 2513 | psDnldContext->chk_integrity_crc.flash_code.Chk_Crc32[crc_i] 2514 << (crc_i * BYTE_SIZE) ; 2515 patch_code_crc = patch_code_crc 2516 | psDnldContext->chk_integrity_crc.patch_code.Chk_Crc32[crc_i] 2517 << (crc_i * BYTE_SIZE) ; 2518 } 2519 verify_crc =(uint8_t)( (*((uint32_t *) psDnldContext->p_flash_code_crc)) != 2520 flash_code_crc ); 2521 verify_crc |=(uint8_t)( (*((uint32_t *) psDnldContext->p_patch_code_crc)) != 2522 patch_code_crc ); 2523 verify_crc |=(uint8_t)( (*((uint16_t *) psDnldContext->p_patch_table_crc)) != 2524 patch_table_crc ); 2525 } 2526 else 2527 { 2528 DNLD_PRINT(" FW_DNLD: Flash, Patch code and Patch Table CRC "); 2529 DNLD_PRINT(" Not Available in the Firmware \n"); 2530 } 2531 2532 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 2533 2534 integrity_chk = psDnldContext->chk_integrity_crc.config_page.Chk_status + 2535 psDnldContext->chk_integrity_crc.patch_table.Chk_status + 2536 psDnldContext->chk_integrity_crc.flash_code.Chk_status + 2537 psDnldContext->chk_integrity_crc.patch_code.Chk_status; 2538 2539 if ( ( 0 != integrity_chk ) 2540 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 2541 || ( 0 != verify_crc ) 2542 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 2543 ) 2544 { 2545 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED); 2546 } 2547 break; 2548 } 2549 default: 2550 { 2551 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FAILED); 2552 break; 2553 } 2554 } 2555 2556 if (NFCSTATUS_PENDING == status) 2557 { 2558 /* Write/Receive is still pending */ 2559 } 2560 else 2561 { 2562 pphNfcIF_Notification_CB_t p_upper_notify = 2563 psDnldContext->p_upper_notify; 2564 void *p_upper_context = 2565 psDnldContext->p_upper_context; 2566 2567 DNLD_DEBUG(" FW_DNLD: Resume Termination Status = %X \n", status); 2568 2569 comp_info.status = status; 2570 2571 (void) phDal4Nfc_Unregister( 2572 psDnldContext->lower_interface.pcontext, pHwRef); 2573 phDnldNfc_Release_Lower(psDnldContext, pHwRef); 2574 phDnldNfc_Release_Resources(&psDnldContext); 2575 #ifndef NFC_TIMER_CONTEXT 2576 gpphDnldContext = psDnldContext; 2577 #endif 2578 /* Notify the Error/Success Scenario to the upper layer */ 2579 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, (uint8_t) 2580 ((NFCSTATUS_SUCCESS == comp_info.status )? NFC_IO_SUCCESS: NFC_IO_ERROR), 2581 &comp_info ); 2582 } 2583 return status; 2584 } 2585 2586 STATIC 2587 NFCSTATUS 2588 phDnldNfc_Process_Response( 2589 phDnldNfc_sContext_t *psDnldContext, 2590 void *pHwRef, 2591 void *pdata, 2592 uint16_t length 2593 ) 2594 { 2595 NFCSTATUS status = NFCSTATUS_SUCCESS; 2596 phDnldNfc_sData_Hdr_t *resp_data = 2597 (phDnldNfc_sData_Hdr_t *) pdata; 2598 2599 PHNFC_UNUSED_VARIABLE(pHwRef); 2600 DNLD_DEBUG(" FW_DNLD: Receive Length = %X \n", length ); 2601 if(( psDnldContext->rx_info.rx_total == 0 ) 2602 && (PHDNLD_MIN_PACKET <= length) 2603 ) 2604 { 2605 psDnldContext->rx_info.rx_total = 2606 ((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)| 2607 resp_data->frame_length[1]; 2608 if( psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET == length ) 2609 { 2610 2611 DNLD_DEBUG(" FW_DNLD: Success Memory Read = %X \n", 2612 psDnldContext->rx_info.rx_total); 2613 #ifndef DNLD_SUMMARY 2614 /* DNLD_PRINT_BUFFER("Receive Buffer",pdata,length); */ 2615 #endif 2616 2617 } 2618 else 2619 { 2620 /* status = phDnldNfc_Receive( psDnldContext, pHwRef, 2621 psDnldContext->p_resp_buffer, 2622 (uint8_t)((psDnldContext->rx_info.rx_total <= PHDNLD_MAX_PACKET)? 2623 psDnldContext->rx_info.rx_total: PHDNLD_MAX_PACKET) ); */ 2624 DNLD_PRINT(" FW_DNLD: Invalid Receive length "); 2625 DNLD_DEBUG(": Length Expected = %X \n", 2626 (psDnldContext->rx_info.rx_total + PHDNLD_MIN_PACKET)); 2627 status = PHNFCSTVAL( CID_NFC_DNLD, 2628 NFCSTATUS_INVALID_RECEIVE_LENGTH ); 2629 } 2630 } 2631 else 2632 { 2633 /*TODO:*/ 2634 psDnldContext->rx_info.rx_total = 0 ; 2635 status = PHNFCSTVAL( CID_NFC_DNLD, 2636 NFCSTATUS_INVALID_RECEIVE_LENGTH ); 2637 } 2638 2639 return status; 2640 } 2641 2642 2643 2644 STATIC 2645 void 2646 phDnldNfc_Receive_Complete ( 2647 void *psContext, 2648 void *pHwRef, 2649 phNfc_sTransactionInfo_t *pInfo 2650 ) 2651 { 2652 NFCSTATUS status = NFCSTATUS_SUCCESS ; 2653 void *pdata = NULL ; 2654 phDnldNfc_sData_Hdr_t *resp_data = NULL; 2655 uint16_t length = 0 ; 2656 phNfc_sCompletionInfo_t comp_info = {0,0,0}; 2657 2658 DNLD_PRINT("\n FW_DNLD: Receive Response .... "); 2659 if ( (NULL != psContext) 2660 && (NULL != pInfo) 2661 && (NULL != pHwRef) 2662 ) 2663 { 2664 phDnldNfc_sContext_t *psDnldContext = 2665 (phDnldNfc_sContext_t *)psContext; 2666 status = pInfo->status ; 2667 length = pInfo->length ; 2668 pdata = pInfo->buffer; 2669 2670 if(status != NFCSTATUS_SUCCESS) 2671 { 2672 DNLD_DEBUG(" Failed. Status = %02X\n",status); 2673 /* Handle the Error Scenario */ 2674 } 2675 else if (NULL == pdata) 2676 { 2677 DNLD_DEBUG(" Failed. No data received. pdata = %02X\n",pdata); 2678 /* Handle the Error Scenario */ 2679 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_FAILED ); 2680 } 2681 else if ((0 == length) 2682 || (PHDNLD_MIN_PACKET > length )) 2683 { 2684 DNLD_DEBUG(" Receive Response Length = %u .... \n",length); 2685 /* Handle the Error Scenario */ 2686 #ifndef HAL_SW_DNLD_RLEN 2687 status = PHNFCSTVAL( CID_NFC_DNLD, 2688 NFCSTATUS_INVALID_RECEIVE_LENGTH ); 2689 #endif 2690 } 2691 else 2692 { 2693 2694 #if defined(FW_DOWNLOAD_TIMER) && \ 2695 (FW_DOWNLOAD_TIMER == 2) 2696 if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id ) 2697 { 2698 phOsalNfc_Timer_Stop( psDnldContext->timer_id ); 2699 } 2700 2701 #endif 2702 2703 #ifndef DNLD_SUMMARY 2704 DNLD_PRINT_BUFFER("Receive Buffer",pdata,length); 2705 #endif 2706 DNLD_DEBUG(" Receive Response Length = %X. \n", length); 2707 2708 resp_data = (phDnldNfc_sData_Hdr_t *) pdata; 2709 2710 switch(resp_data->frame_type) 2711 { 2712 case PHDNLD_RESP_SUCCESS: 2713 { 2714 uint16_t resp_length = 2715 ((uint16_t)resp_data->frame_length[0] << BYTE_SIZE)| 2716 resp_data->frame_length[1]; 2717 switch ( psDnldContext->prev_cmd ) 2718 { 2719 case PHDNLD_CMD_READ : 2720 { 2721 if( PHDNLD_NO_OPERATION 2722 == psDnldContext->raw_mode_upgrade) 2723 { 2724 status = phDnldNfc_Process_Response( 2725 psDnldContext, pHwRef, pdata , length); 2726 2727 if (NFCSTATUS_SUCCESS != status) 2728 { 2729 /* psDnldContext->dnld_retry++; */ 2730 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2731 /* psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY */ 2732 } 2733 } 2734 else 2735 { 2736 2737 } 2738 break; 2739 } 2740 case PHDNLD_CMD_CHECK_INTEGRITY : 2741 { 2742 if( PHDNLD_NO_OPERATION 2743 == psDnldContext->raw_mode_upgrade) 2744 { 2745 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 2746 phDnldNfc_sChkCrcComplete_t *p_dnld_crc_all = 2747 &psDnldContext->chk_integrity_crc; 2748 switch(psDnldContext->chk_integrity_param) 2749 { 2750 case CHK_INTEGRITY_CONFIG_PAGE_CRC: 2751 { 2752 (void)memcpy(&p_dnld_crc_all->config_page, 2753 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length); 2754 break; 2755 } 2756 case CHK_INTEGRITY_PATCH_TABLE_CRC: 2757 { 2758 (void)memcpy(&p_dnld_crc_all->patch_table, 2759 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length); 2760 break; 2761 } 2762 case CHK_INTEGRITY_FLASH_CODE_CRC: 2763 { 2764 (void)memcpy(&p_dnld_crc_all->flash_code, 2765 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length); 2766 break; 2767 } 2768 case CHK_INTEGRITY_PATCH_CODE_CRC: 2769 { 2770 (void)memcpy(&p_dnld_crc_all->patch_code, 2771 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length); 2772 break; 2773 } 2774 case CHK_INTEGRITY_COMPLETE_CRC: 2775 { 2776 (void)memcpy(p_dnld_crc_all, 2777 (((uint8_t *)pdata) + PHDNLD_MIN_PACKET), resp_length); 2778 DNLD_DEBUG(" FW_DNLD: Check Integrity Complete Structure Size = %X \n", 2779 sizeof(psDnldContext->chk_integrity_crc)); 2780 break; 2781 } 2782 default: 2783 { 2784 status = PHNFCSTVAL(CID_NFC_DNLD, 2785 NFCSTATUS_FEATURE_NOT_SUPPORTED); 2786 break; 2787 } 2788 } 2789 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 2790 } 2791 else 2792 { 2793 psDnldContext->raw_mode_upgrade = 2794 (PHDNLD_SETUP_OPERATION | PHDNLD_ADVANCED_OPERATION); 2795 /* psDnldContext->raw_mode_upgrade = 2796 (psDnldContext->raw_mode_upgrade & 2797 ( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); */ 2798 } 2799 break; 2800 } 2801 case PHDNLD_CMD_WRITE: 2802 { 2803 psDnldContext->dnld_retry = 0; 2804 break; 2805 } 2806 case PHDNLD_CMD_SEC_WRITE: 2807 { 2808 psDnldContext->dnld_retry = 0; 2809 break; 2810 } 2811 case PHDNLD_CMD_ACTIVATE_PATCH: 2812 case PHDNLD_CMD_CHECK: 2813 default: 2814 { 2815 if( PHDNLD_NO_OPERATION 2816 == psDnldContext->raw_mode_upgrade) 2817 { 2818 if( ( (PHDNLD_MIN_PACKET > length) 2819 || ( 0 != resp_length) ) 2820 ) 2821 { 2822 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2823 status = PHNFCSTVAL( CID_NFC_DNLD, 2824 NFCSTATUS_INVALID_RECEIVE_LENGTH ); 2825 } 2826 else 2827 { 2828 psDnldContext->dnld_retry = 0; 2829 } 2830 } 2831 else 2832 { 2833 psDnldContext->raw_mode_upgrade = 2834 (psDnldContext->raw_mode_upgrade & ~PHDNLD_RECOVER_OPERATION); 2835 } 2836 break; 2837 } 2838 } /* End of the Previous Command Switch Case */ 2839 break; 2840 }/* Case PHDNLD_RESP_SUCCESS*/ 2841 case PHDNLD_RESP_TIMEOUT: 2842 case PHDNLD_RESP_CRC_ERROR: 2843 case PHDNLD_RESP_WRITE_ERROR: 2844 { 2845 if(psDnldContext->dnld_retry < NXP_MAX_DNLD_RETRY ) 2846 { 2847 psDnldContext->dnld_retry++; 2848 } 2849 status = PHNFCSTVAL(CID_NFC_DNLD, 2850 resp_data->frame_type); 2851 break; 2852 } 2853 /* fall through */ 2854 case PHDNLD_RESP_ACCESS_DENIED: 2855 case PHDNLD_RESP_INVALID_PARAMETER: 2856 case PHDNLD_RESP_INVALID_LENGTH: 2857 /* Initial Frame Checksum */ 2858 case PHDNLD_RESP_CHKSUM_ERROR: 2859 case PHDNLD_RESP_MEMORY_UPDATE_ERROR: 2860 { 2861 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2862 status = PHNFCSTVAL(CID_NFC_DNLD, 2863 resp_data->frame_type); 2864 break; 2865 } 2866 case PHDNLD_RESP_PROTOCOL_ERROR: 2867 { 2868 if(( PHDNLD_NO_OPERATION 2869 == psDnldContext->raw_mode_upgrade) 2870 || ( PHDNLD_ADVANCED_OPERATION 2871 == psDnldContext->raw_mode_upgrade) 2872 ) 2873 { 2874 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2875 status = PHNFCSTVAL(CID_NFC_DNLD, 2876 NFCSTATUS_INVALID_FORMAT); 2877 } 2878 else if( (PHDNLD_NORMAL_OPERATION 2879 & psDnldContext->raw_mode_upgrade) 2880 ) 2881 { 2882 psDnldContext->raw_mode_upgrade = 2883 (psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION); 2884 } 2885 else if ( PHDNLD_RECOVER_OPERATION 2886 & psDnldContext->raw_mode_upgrade ) 2887 { 2888 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2889 status = PHNFCSTVAL(CID_NFC_DNLD, 2890 NFCSTATUS_INVALID_FORMAT); 2891 } 2892 else 2893 { 2894 psDnldContext->raw_mode_upgrade = 2895 (psDnldContext->raw_mode_upgrade & 2896 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); 2897 } 2898 break; 2899 } 2900 case PHDNLD_RESP_VERSION_UPTODATE: 2901 { 2902 /* TODO: to make sure that the Advance Frames are sent to get 2903 * the updated status */ 2904 if ( PHDNLD_ADVANCED_OPERATION 2905 == psDnldContext->raw_mode_upgrade) 2906 { 2907 status = ( CID_NFC_DNLD << BYTE_SIZE ) ; 2908 } 2909 else if ( PHDNLD_NO_OPERATION 2910 != psDnldContext->raw_mode_upgrade) 2911 { 2912 2913 psDnldContext->raw_mode_upgrade = 2914 (psDnldContext->raw_mode_upgrade & 2915 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); 2916 } 2917 else 2918 { 2919 } 2920 break; 2921 } 2922 case PHDNLD_RESP_CMD_NOT_SUPPORTED: 2923 { 2924 2925 if ( PHDNLD_NO_OPERATION 2926 == psDnldContext->raw_mode_upgrade) 2927 { 2928 status = PHNFCSTVAL(CID_NFC_DNLD, 2929 NFCSTATUS_FEATURE_NOT_SUPPORTED); 2930 } 2931 else if ( PHDNLD_ADVANCED_OPERATION 2932 == psDnldContext->raw_mode_upgrade) 2933 { 2934 status = PHNFCSTVAL(CID_NFC_DNLD, 2935 NFCSTATUS_FEATURE_NOT_SUPPORTED); 2936 } 2937 #if 0 2938 else if( (PHDNLD_NORMAL_OPERATION 2939 & psDnldContext->raw_mode_upgrade) 2940 ) 2941 { 2942 psDnldContext->raw_mode_upgrade = 2943 (psDnldContext->raw_mode_upgrade & ~PHDNLD_NORMAL_OPERATION); 2944 } 2945 else if ( PHDNLD_SETUP_OPERATION 2946 & psDnldContext->raw_mode_upgrade ) 2947 { 2948 psDnldContext->raw_mode_upgrade = 2949 (psDnldContext->raw_mode_upgrade & ~PHDNLD_SETUP_OPERATION); 2950 } 2951 #endif 2952 else 2953 { 2954 psDnldContext->raw_mode_upgrade = 2955 (psDnldContext->raw_mode_upgrade & 2956 ~( psDnldContext->cur_frame_info & ~PHDNLD_MARKER_MASK )); 2957 } 2958 break; 2959 } 2960 /* The Chaining of the Command Frame 2961 was Successful in the Download Mode */ 2962 case PHDNLD_RESP_CHAINING_SUCCESS: 2963 { 2964 /* TODO: Handle the Corner Case Scenarios 2965 * the updated status */ 2966 psDnldContext->dnld_retry = 0x00; 2967 break; 2968 } 2969 /* The Error during the Chaining the Command Frame in the Download Mode */ 2970 case PHDNLD_RESP_CHAINING_ERROR: 2971 { 2972 /* TODO: Restart the Chunk in Corner Case 2973 * the updated status */ 2974 psDnldContext->dnld_retry++; 2975 phDnldNfc_Tx_Reset(psDnldContext); 2976 break; 2977 } 2978 /* The Command is not allowed anymore in the Download Mode */ 2979 case PHDNLD_RESP_CMD_NOT_ALLOWED: 2980 default: 2981 { 2982 psDnldContext->dnld_retry = NXP_MAX_DNLD_RETRY; 2983 status = PHNFCSTVAL(CID_NFC_DNLD, 2984 NFCSTATUS_NOT_ALLOWED); 2985 break; 2986 } 2987 2988 } /* End of the Response Frame Type Switch */ 2989 2990 if (NFCSTATUS_PENDING != status) 2991 { 2992 if ((NFCSTATUS_SUCCESS != status) && 2993 (psDnldContext->dnld_retry >= NXP_MAX_DNLD_RETRY)) 2994 { 2995 pphNfcIF_Notification_CB_t p_upper_notify = 2996 psDnldContext->p_upper_notify; 2997 void *p_upper_context = 2998 psDnldContext->p_upper_context; 2999 3000 comp_info.status = status; 3001 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status); 3002 status = phDal4Nfc_Unregister( 3003 psDnldContext->lower_interface.pcontext, pHwRef); 3004 phDnldNfc_Release_Lower(psDnldContext, pHwRef); 3005 phDnldNfc_Release_Resources(&psDnldContext); 3006 #ifndef NFC_TIMER_CONTEXT 3007 gpphDnldContext = psDnldContext; 3008 #endif 3009 /* Notify the Error/Success Scenario to the upper layer */ 3010 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, 3011 (uint8_t) NFC_IO_ERROR, &comp_info ); 3012 } 3013 else if ( (NFCSTATUS_SUCCESS != status) && 3014 (NFCSTATUS_SUCCESS == PHNFCSTATUS(status)) 3015 ) 3016 { 3017 pphNfcIF_Notification_CB_t p_upper_notify = 3018 psDnldContext->p_upper_notify; 3019 void *p_upper_context = 3020 psDnldContext->p_upper_context; 3021 3022 comp_info.status = NFCSTATUS_SUCCESS; 3023 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status); 3024 status = phDal4Nfc_Unregister( 3025 psDnldContext->lower_interface.pcontext, pHwRef); 3026 phDnldNfc_Release_Lower(psDnldContext, pHwRef); 3027 phDnldNfc_Release_Resources(&psDnldContext); 3028 #ifndef NFC_TIMER_CONTEXT 3029 gpphDnldContext = psDnldContext; 3030 #endif 3031 /* Notify the Error/Success Scenario to the upper layer */ 3032 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, 3033 (uint8_t) NFC_IO_SUCCESS, &comp_info ); 3034 3035 } 3036 else if (NFCSTATUS_FEATURE_NOT_SUPPORTED == PHNFCSTATUS(status)) 3037 { 3038 pphNfcIF_Notification_CB_t p_upper_notify = 3039 psDnldContext->p_upper_notify; 3040 void *p_upper_context = 3041 psDnldContext->p_upper_context; 3042 3043 comp_info.status = status; 3044 DNLD_DEBUG(" FW_DNLD: Termination in Receive, Status = %X \n", status); 3045 status = phDal4Nfc_Unregister( 3046 psDnldContext->lower_interface.pcontext, pHwRef); 3047 phDnldNfc_Release_Lower(psDnldContext, pHwRef); 3048 phDnldNfc_Release_Resources(&psDnldContext); 3049 #ifndef NFC_TIMER_CONTEXT 3050 gpphDnldContext = psDnldContext; 3051 #endif 3052 /* Notify the Error/Success Scenario to the upper layer */ 3053 phDnldNfc_Notify( p_upper_notify, p_upper_context, pHwRef, 3054 (uint8_t) NFC_IO_SUCCESS, &comp_info ); 3055 3056 } 3057 else 3058 { 3059 /* DNLD_PRINT(" FW_DNLD: Successful.\n"); */ 3060 psDnldContext->resp_length = /* PHDNLD_MIN_PACKET */ 0 ; 3061 status = phDnldNfc_Set_Seq(psDnldContext, 3062 DNLD_SEQ_UPDATE); 3063 status = phDnldNfc_Resume( psDnldContext, 3064 pHwRef, pdata, length ); 3065 } 3066 } 3067 } /* End of status != Success */ 3068 } 3069 } 3070 3071 3072 STATIC 3073 void 3074 phDnldNfc_Send_Complete ( 3075 void *psContext, 3076 void *pHwRef, 3077 phNfc_sTransactionInfo_t *pInfo 3078 ) 3079 { 3080 NFCSTATUS status = NFCSTATUS_SUCCESS ; 3081 uint16_t length = 0; 3082 3083 DNLD_PRINT(" FW_DNLD: Send Data .... "); 3084 if ( (NULL != psContext) 3085 && (NULL != pInfo) 3086 && (NULL != pHwRef) 3087 ) 3088 { 3089 phDnldNfc_sContext_t *psDnldContext = 3090 (phDnldNfc_sContext_t *)psContext; 3091 status = pInfo->status ; 3092 length = pInfo->length ; 3093 if(status != NFCSTATUS_SUCCESS) 3094 { 3095 DNLD_DEBUG(" Failed. Status = %02X\n",status); 3096 /* Handle the Error Scenario */ 3097 } 3098 else 3099 { 3100 DNLD_PRINT(" Successful.\n"); 3101 (void)memset((void *)&psDnldContext->dnld_data, 0, 3102 sizeof(psDnldContext->dnld_data)); 3103 if ((PHDNLD_CMD_SET_HIF != psDnldContext->prev_cmd) 3104 && (PHDNLD_CMD_RESET != psDnldContext->prev_cmd)) 3105 { 3106 psDnldContext->rx_info.rx_total = 0; 3107 status = phDnldNfc_Receive( psDnldContext, pHwRef, 3108 (uint8_t *)(&psDnldContext->dnld_resp), 3109 psDnldContext->resp_length); 3110 } 3111 else 3112 { 3113 psDnldContext->resp_length = 0; 3114 psDnldContext->dnld_retry = 0; 3115 /* clock unstable after SW reset command, especially on UART 3116 * platform because of its sensitivity to clock. Experimentally 3117 * we found clock unstable for 750us. Delay for 5ms to be sure. 3118 */ 3119 if( PHDNLD_CMD_RESET == psDnldContext->prev_cmd ) 3120 { 3121 DO_DELAY(PHDNLD_DNLD_DELAY); 3122 } 3123 #if defined(FW_DOWNLOAD_TIMER) && \ 3124 (FW_DOWNLOAD_TIMER == 2) 3125 3126 if ( NXP_INVALID_TIMER_ID != psDnldContext->timer_id ) 3127 { 3128 phOsalNfc_Timer_Stop( psDnldContext->timer_id ); 3129 } 3130 #endif 3131 3132 status = phDnldNfc_Set_Seq(psDnldContext, 3133 DNLD_SEQ_UPDATE); 3134 } 3135 3136 if(NFCSTATUS_SUCCESS == status ) 3137 { 3138 status = phDnldNfc_Resume( psDnldContext, pHwRef, NULL, length); 3139 } 3140 3141 } /* End of status != Success */ 3142 3143 } /* End of Context != NULL */ 3144 } 3145 3146 3147 3148 STATIC 3149 NFCSTATUS 3150 phDnldNfc_Send_Command( 3151 phDnldNfc_sContext_t *psDnldContext, 3152 void *pHwRef, 3153 uint8_t cmd, 3154 void *params, 3155 uint16_t param_length 3156 ) 3157 { 3158 NFCSTATUS status = NFCSTATUS_SUCCESS; 3159 uint16_t tx_length = 0; 3160 uint16_t rx_length = 0; 3161 uint8_t **pp_resp_data = &psDnldContext->p_resp_buffer; 3162 phDnldNfc_sData_t *p_dnld_data = 3163 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 3164 3165 switch(cmd) 3166 { 3167 case PHDNLD_CMD_RESET: 3168 { 3169 (void)memset((void *)&psDnldContext->dnld_data, 0, 3170 sizeof(psDnldContext->dnld_data)); 3171 break; 3172 } 3173 case PHDNLD_CMD_READ: 3174 { 3175 phDnldNfc_sData_t *p_dnld_data = 3176 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 3177 phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */ 3178 &p_dnld_data->param_info.data_param; 3179 tx_length = PHDNLD_CMD_READ_LEN; 3180 if (NULL != *pp_resp_data) 3181 { 3182 phOsalNfc_FreeMemory(*pp_resp_data); 3183 *pp_resp_data = NULL; 3184 } 3185 rx_length = (uint16_t) (((uint16_t)param_info->data_len[0] 3186 << BYTE_SIZE) + param_info->data_len[1]); 3187 3188 psDnldContext->resp_length = 3189 (( rx_length + PHDNLD_MIN_PACKET )); 3190 (void)phDnldNfc_Allocate_Resource( (void **) pp_resp_data, 3191 rx_length); 3192 break; 3193 } 3194 case PHDNLD_CMD_WRITE: 3195 case PHDNLD_CMD_SEC_WRITE: 3196 { 3197 phDnldNfc_sData_t *p_dnld_data = 3198 (phDnldNfc_sData_t *)psDnldContext->dnld_data; 3199 phDnldNfc_sParam_t *param_info = /* (phDnldNfc_sParam_t *)params */ 3200 &p_dnld_data->param_info.data_param; 3201 tx_length = (uint16_t) (((uint16_t)param_info->data_len[0] 3202 << BYTE_SIZE) + param_info->data_len[1] 3203 + PHDNLD_CMD_WRITE_MIN_LEN ); 3204 3205 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 3206 if ((0 != param_length) && (NULL != params)) 3207 { 3208 (void)memcpy(param_info->data_packet, params, param_length); 3209 } 3210 break; 3211 } 3212 case PHDNLD_CMD_CHECK: 3213 { 3214 tx_length = PHDNLD_CMD_CHECK_LEN; 3215 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 3216 break; 3217 } 3218 case PHDNLD_CMD_ENCAPSULATE: 3219 { 3220 uint8_t i = 0x00; 3221 if ((0 != param_length) && (NULL != params)) 3222 { 3223 p_dnld_data->frame_type = 3224 PHDNLD_CMD_ENCAPSULATE; 3225 (void)memcpy((void *)( ((uint8_t *)p_dnld_data) 3226 + PHDNLD_FRAME_DATA_OFFSET) 3227 , params, param_length); 3228 tx_length = param_length; 3229 3230 p_dnld_data->frame_length[i++] = 3231 (uint8_t)(tx_length >> BYTE_SIZE); 3232 p_dnld_data->frame_length[i] = 3233 (uint8_t)( tx_length & BYTE_MASK ); 3234 tx_length += PHDNLD_FRAME_DATA_OFFSET; 3235 3236 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 3237 3238 status = phDnldNfc_Send( psDnldContext, pHwRef , 3239 (uint8_t *)p_dnld_data, tx_length); 3240 } 3241 else 3242 { 3243 status = PHNFCSTVAL(CID_NFC_DNLD, 3244 NFCSTATUS_NOT_ALLOWED); 3245 } 3246 break; 3247 } 3248 case PHDNLD_CMD_SET_HIF: 3249 { 3250 tx_length++; 3251 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 3252 break; 3253 } 3254 case PHDNLD_CMD_ACTIVATE_PATCH: 3255 { 3256 psDnldContext->resp_length = PHDNLD_MIN_PACKET; 3257 if ((NULL != params) && ( param_length > 0 )) 3258 { 3259 p_dnld_data->param_info.cmd_param = 3260 (*(uint8_t *)params); 3261 tx_length = param_length; 3262 } 3263 else 3264 { 3265 p_dnld_data->param_info.cmd_param = FALSE; 3266 tx_length++; 3267 } 3268 break; 3269 } 3270 case PHDNLD_CMD_CHECK_INTEGRITY: 3271 { 3272 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 3273 if ((NULL != params) && ( param_length > 0 )) 3274 { 3275 psDnldContext->chk_integrity_param = 3276 (phDnldNfc_eChkCrc_t)(*(uint8_t *)params); 3277 tx_length = param_length; 3278 } 3279 else 3280 { 3281 psDnldContext->chk_integrity_param = CHK_INTEGRITY_COMPLETE_CRC; 3282 tx_length++; 3283 } 3284 p_dnld_data->param_info.cmd_param = 3285 (uint8_t) psDnldContext->chk_integrity_param; 3286 switch(psDnldContext->chk_integrity_param) 3287 { 3288 case CHK_INTEGRITY_CONFIG_PAGE_CRC: 3289 case CHK_INTEGRITY_PATCH_TABLE_CRC: 3290 { 3291 psDnldContext->resp_length = PHDNLD_MIN_PACKET 3292 + CHECK_INTEGRITY_RESP_CRC16_LEN; 3293 break; 3294 } 3295 case CHK_INTEGRITY_FLASH_CODE_CRC: 3296 case CHK_INTEGRITY_PATCH_CODE_CRC: 3297 { 3298 psDnldContext->resp_length = PHDNLD_MIN_PACKET 3299 + CHECK_INTEGRITY_RESP_CRC32_LEN; 3300 break; 3301 } 3302 case CHK_INTEGRITY_COMPLETE_CRC: 3303 default: 3304 { 3305 psDnldContext->resp_length = PHDNLD_MIN_PACKET 3306 + CHECK_INTEGRITY_RESP_COMP_LEN; 3307 break; 3308 } 3309 } 3310 #else 3311 tx_length++; 3312 p_dnld_data->param_info.cmd_param = 3313 (uint8_t) CHK_INTEGRITY_COMPLETE_CRC; 3314 3315 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 3316 break; 3317 } 3318 default: 3319 { 3320 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_FEATURE_NOT_SUPPORTED); 3321 break; 3322 } 3323 } 3324 if (NFCSTATUS_SUCCESS == status) 3325 { 3326 uint8_t i = 0; 3327 3328 p_dnld_data->frame_type = cmd; 3329 p_dnld_data->frame_length[i++] = 3330 (uint8_t)(tx_length >> BYTE_SIZE); 3331 p_dnld_data->frame_length[i] = 3332 (uint8_t)( tx_length & BYTE_MASK ); 3333 tx_length = tx_length + PHDNLD_MIN_PACKET; 3334 status = phDnldNfc_Send( psDnldContext, pHwRef , 3335 (uint8_t *)p_dnld_data, tx_length); 3336 if(NFCSTATUS_PENDING == status) 3337 { 3338 psDnldContext->prev_cmd = cmd; 3339 3340 if( PHDNLD_CMD_RESET == cmd ) 3341 DO_DELAY(PHDNLD_DNLD_DELAY); //this seems like its on the wrong thread 3342 } 3343 } 3344 3345 return status; 3346 } 3347 3348 static 3349 NFCSTATUS 3350 phDnldNfc_Check_FW( 3351 phHal_sHwReference_t *pHwRef, 3352 fw_data_hdr_t *cur_fw_hdr 3353 ) 3354 { 3355 NFCSTATUS status = NFCSTATUS_FAILED; 3356 3357 if ( !pHwRef->device_info.fw_version ) 3358 { 3359 /* Override the Firmware Version Check and upgrade*/; 3360 DNLD_PRINT(" FW_DNLD_CHK: Forceful Upgrade of the Firmware .... Required \n"); 3361 status = NFCSTATUS_SUCCESS; 3362 } 3363 else if ( (pHwRef->device_info.fw_version >> (BYTE_SIZE * 2)) 3364 != ( cur_fw_hdr->fw_version >> (BYTE_SIZE * 2) )) 3365 { 3366 /* Check for the Compatible Romlib Version for the Hardware */ 3367 DNLD_PRINT(" FW_DNLD: IC Hardware Version Mismatch.. \n"); 3368 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED ); 3369 } 3370 else if (( pHwRef->device_info.fw_version < cur_fw_hdr->fw_version ) 3371 ) 3372 { 3373 /* TODO: Firmware Version Check and upgrade*/ 3374 DNLD_PRINT(" FW_DNLD: Older Firmware Upgrading to newerone.... \n"); 3375 status = NFCSTATUS_SUCCESS; 3376 } 3377 #ifdef NXP_FW_CHK_LATEST 3378 else if (( pHwRef->device_info.fw_version > cur_fw_hdr->fw_version ) 3379 ) 3380 { 3381 DNLD_PRINT(" FW_DNLD: Newer than the Stored One .... \n"); 3382 status = PHNFCSTVAL( CID_NFC_DNLD, NFCSTATUS_NOT_ALLOWED ); 3383 } 3384 #endif /* NXP_FW_CHK_LATEST */ 3385 else 3386 { 3387 DNLD_PRINT(" FW_DNLD: Already Updated .... \n"); 3388 status = ( CID_NFC_DNLD << BYTE_SIZE ) ; 3389 } 3390 3391 return status; 3392 } 3393 3394 3395 static 3396 NFCSTATUS 3397 phDnldNfc_Process_FW( 3398 phDnldNfc_sContext_t *psDnldContext, 3399 phHal_sHwReference_t *pHwRef 3400 #ifdef NXP_FW_PARAM 3401 ,uint8_t *nxp_nfc_fw 3402 ,uint32_t nxp_fw_len 3403 #endif 3404 ) 3405 { 3406 NFCSTATUS status = NFCSTATUS_FAILED; 3407 section_info_t *p_cur_sec = NULL; 3408 static unsigned sec_type; 3409 uint32_t fw_index = 0; 3410 #ifdef NXP_NFC_MULTIPLE_FW 3411 phDnldNfc_sFwImageInfo_t *p_cur_fw = NULL; 3412 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */ 3413 fw_data_hdr_t *cur_fw_hdr = NULL; 3414 uint8_t sec_index = 0; 3415 uint8_t i = 0; 3416 3417 psDnldContext->p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw; 3418 3419 #ifdef NXP_NFC_MULTIPLE_FW 3420 3421 /* TODO: Create a memory of pointers to store all the Firmwares */ 3422 if( (NXP_NFC_IMAG_FW_MAX > psDnldContext->p_img_hdr->no_of_fw_img) 3423 && (0 != psDnldContext->p_img_hdr->no_of_fw_img) 3424 ) 3425 { 3426 ( void )phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_img_info, 3427 (psDnldContext->p_img_hdr->no_of_fw_img * sizeof(phDnldNfc_sFwImageInfo_t))); 3428 3429 if(NULL != psDnldContext->p_img_info) 3430 { 3431 p_cur_fw = psDnldContext->p_img_info; 3432 } 3433 } 3434 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */ 3435 3436 fw_index = sizeof (img_data_hdr_t); 3437 3438 for ( i=0; i < psDnldContext->p_img_hdr->no_of_fw_img; i++ ) 3439 { 3440 3441 psDnldContext->p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index ); 3442 3443 #ifdef NXP_NFC_MULTIPLE_FW 3444 if(NULL != p_cur_fw) 3445 { 3446 ( p_cur_fw + i)->p_fw_hdr = psDnldContext->p_fw_hdr; 3447 } 3448 #endif /* #ifdef NXP_NFC_MULTIPLE_FW */ 3449 cur_fw_hdr = psDnldContext->p_fw_hdr; 3450 3451 fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN); 3452 3453 status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr); 3454 3455 } 3456 3457 if ( ( NFCSTATUS_SUCCESS == status ) 3458 #if defined (NXP_FW_INTEGRITY_VERIFY) 3459 || (NFCSTATUS_SUCCESS == PHNFCSTATUS(status) ) 3460 #endif /* !defined (NXP_FW_INTEGRITY_VERIFY) */ 3461 ) 3462 { 3463 if( (BYTE_MASK > cur_fw_hdr->no_of_sections) 3464 && (0 != cur_fw_hdr->no_of_sections) 3465 ) 3466 { 3467 (void) phDnldNfc_Allocate_Resource((void **)&psDnldContext->p_fw_sec, 3468 (cur_fw_hdr->no_of_sections * sizeof(section_info_t))); 3469 3470 if(NULL != psDnldContext->p_fw_sec) 3471 { 3472 DNLD_DEBUG(" FW_DNLD: FW Index : %x \n", 3473 fw_index ); 3474 3475 DNLD_DEBUG(" FW_DNLD: No of Sections : %x \n\n", 3476 cur_fw_hdr->no_of_sections); 3477 3478 for(sec_index = 0; sec_index 3479 < cur_fw_hdr->no_of_sections; sec_index++ ) 3480 { 3481 p_cur_sec = ((section_info_t *) 3482 (psDnldContext->p_fw_sec + sec_index )); 3483 3484 p_cur_sec->p_sec_hdr = (section_hdr_t *) 3485 (nxp_nfc_fw + fw_index); 3486 3487 DNLD_DEBUG(" FW_DNLD: Section %x \n", sec_index); 3488 DNLD_DEBUG(" FW_DNLD: Section Header Len : %x ", 3489 p_cur_sec->p_sec_hdr->section_hdr_len); 3490 DNLD_DEBUG(" Section Address : %x ", 3491 p_cur_sec->p_sec_hdr->section_address); 3492 DNLD_DEBUG(" Section Length : %x ", 3493 p_cur_sec->p_sec_hdr->section_length); 3494 DNLD_DEBUG(" Section Memory Type : %x \n", 3495 p_cur_sec->p_sec_hdr->section_mem_type); 3496 3497 sec_type = (unsigned int)p_cur_sec->p_sec_hdr->section_mem_type; 3498 3499 if((sec_type & DNLD_TRIM_MASK)) 3500 { 3501 p_cur_sec->p_trim_data = (uint8_t *) 3502 (nxp_nfc_fw + fw_index + sizeof(section_hdr_t)); 3503 } 3504 else 3505 { 3506 p_cur_sec->p_trim_data = NULL; 3507 } 3508 3509 if (0 == sec_index) 3510 { 3511 if ((sec_type & DNLD_SM_UNLOCK_MASK)) 3512 { 3513 (void)phDnldNfc_Set_Seq(psDnldContext, 3514 DNLD_SEQ_UNLOCK); 3515 } 3516 else 3517 { 3518 (void)phDnldNfc_Set_Seq(psDnldContext, 3519 DNLD_SEQ_INIT); 3520 } 3521 } 3522 p_cur_sec->section_read = FALSE; 3523 3524 p_cur_sec->section_offset = 0; 3525 3526 p_cur_sec->p_sec_data = ((uint8_t *) nxp_nfc_fw) + fw_index + 3527 (p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN); 3528 3529 fw_index = fw_index + 3530 (p_cur_sec->p_sec_hdr->section_hdr_len * PNDNLD_WORD_LEN) 3531 + p_cur_sec->p_sec_hdr->section_length; 3532 3533 3534 if( 0 != p_cur_sec->p_sec_hdr->section_checksum ) 3535 { 3536 DNLD_DEBUG(" FW_DNLD: Section checksum : %x \n", 3537 p_cur_sec->p_sec_hdr->section_checksum ); 3538 3539 p_cur_sec->p_sec_chksum = ( uint8_t *)(nxp_nfc_fw + fw_index); 3540 3541 fw_index = fw_index + 3542 p_cur_sec->p_sec_hdr->section_checksum; 3543 } 3544 3545 DNLD_DEBUG(" FW_DNLD: FW Index : %x \n", fw_index ); 3546 3547 #if (NXP_FW_INTEGRITY_CHK >= 0x01) 3548 switch( p_cur_sec->p_sec_hdr->section_address ) 3549 { 3550 case DNLD_FW_CODE_ADDR: 3551 { 3552 psDnldContext->p_flash_code_crc = 3553 p_cur_sec->p_sec_data 3554 + p_cur_sec->p_sec_hdr->section_length 3555 - DNLD_CRC32_SIZE; 3556 break; 3557 } 3558 case DNLD_PATCH_CODE_ADDR: 3559 { 3560 psDnldContext->p_patch_code_crc = 3561 p_cur_sec->p_sec_data 3562 + p_cur_sec->p_sec_hdr->section_length 3563 - DNLD_CRC32_SIZE; 3564 break; 3565 } 3566 case DNLD_PATCH_TABLE_ADDR: 3567 { 3568 psDnldContext->p_patch_table_crc = 3569 p_cur_sec->p_sec_data 3570 + p_cur_sec->p_sec_hdr->section_length 3571 - DNLD_CRC16_SIZE; 3572 break; 3573 } 3574 default: 3575 { 3576 break; 3577 } 3578 3579 } /* End of Address Switch */ 3580 #endif /* #if (NXP_FW_INTEGRITY_CHK >= 0x01) */ 3581 } /* End of For Loop */ 3582 } /* End of the Null Check */ 3583 else 3584 { 3585 status = PHNFCSTVAL(CID_NFC_DNLD, 3586 NFCSTATUS_INSUFFICIENT_RESOURCES); 3587 } 3588 3589 } 3590 else if ( 3591 (0 == cur_fw_hdr->no_of_sections) 3592 && (PHDNLD_FW_PATCH_SEC == cur_fw_hdr->fw_patch) 3593 ) 3594 { 3595 psDnldContext->p_fw_raw = (uint8_t *)(nxp_nfc_fw + fw_index); 3596 3597 psDnldContext->raw_mode_upgrade = PHDNLD_COMPLETE_OPERATION; 3598 3599 (void)phDnldNfc_Set_Seq(psDnldContext, 3600 DNLD_SEQ_RAW); 3601 } 3602 else 3603 { 3604 DNLD_PRINT("********* Empty Section and Firmware ******************\n\n"); 3605 } 3606 3607 DNLD_PRINT("*******************************************\n\n"); 3608 3609 } 3610 return status; 3611 } 3612 3613 #if !defined (NXP_FW_INTEGRITY_VERIFY) 3614 3615 NFCSTATUS 3616 phDnldNfc_Run_Check( 3617 phHal_sHwReference_t *pHwRef 3618 #ifdef NXP_FW_PARAM 3619 ,uint8_t *nxp_nfc_fw 3620 uint32_t fw_length 3621 #endif 3622 ) 3623 { 3624 NFCSTATUS status = NFCSTATUS_FAILED; 3625 uint32_t fw_index = 0; 3626 img_data_hdr_t *p_img_hdr = NULL; 3627 fw_data_hdr_t *p_fw_hdr = NULL; 3628 fw_data_hdr_t *cur_fw_hdr = NULL; 3629 uint8_t i = 0; 3630 3631 p_img_hdr = (img_data_hdr_t *) nxp_nfc_fw; 3632 3633 fw_index = sizeof (img_data_hdr_t); 3634 3635 for ( i=0; i < p_img_hdr->no_of_fw_img; i++ ) 3636 { 3637 p_fw_hdr = (fw_data_hdr_t *) ( nxp_nfc_fw + fw_index ); 3638 /* TODO: Create a memory of pointers to store all the Firmwares */ 3639 cur_fw_hdr = p_fw_hdr; 3640 3641 fw_index = fw_index + (cur_fw_hdr->fw_hdr_len * PNDNLD_WORD_LEN); 3642 3643 status = phDnldNfc_Check_FW( pHwRef, cur_fw_hdr); 3644 } 3645 return status; 3646 } 3647 3648 #endif /* #if !defined (NXP_FW_INTEGRITY_VERIFY) */ 3649 3650 3651 STATIC 3652 void 3653 phDnldNfc_Abort ( 3654 uint32_t abort_id 3655 #ifdef NFC_TIMER_CONTEXT 3656 , void *dnld_cntxt 3657 #endif 3658 ) 3659 { 3660 3661 phNfc_sCompletionInfo_t comp_info = {0,0,0}; 3662 3663 phDnldNfc_sContext_t *p_dnld_context = NULL; 3664 3665 #ifdef NFC_TIMER_CONTEXT 3666 p_dnld_context = (phDnldNfc_sContext_t *)dnld_cntxt; 3667 #else 3668 p_dnld_context = gpphDnldContext; 3669 #endif 3670 3671 if ( ( NULL != p_dnld_context) 3672 && (abort_id == p_dnld_context->timer_id )) 3673 { 3674 pphNfcIF_Notification_CB_t p_upper_notify = 3675 p_dnld_context->p_upper_notify; 3676 void *p_upper_context = 3677 p_dnld_context->p_upper_context; 3678 phHal_sHwReference_t *pHwRef = p_dnld_context->p_hw_ref; 3679 3680 (void)phDal4Nfc_Unregister( 3681 p_dnld_context->lower_interface.pcontext, pHwRef ); 3682 phDnldNfc_Release_Lower(p_dnld_context, pHwRef); 3683 phDnldNfc_Release_Resources(&p_dnld_context); 3684 #ifndef NFC_TIMER_CONTEXT 3685 gpphDnldContext = p_dnld_context; 3686 #endif 3687 3688 /* Notify the Error/Success Scenario to the upper layer */ 3689 DNLD_DEBUG(" FW_DNLD: FW_DNLD Aborted with %x Timer Timeout \n", 3690 abort_id); 3691 comp_info.status = NFCSTATUS_FAILED ; 3692 phDnldNfc_Notify( p_upper_notify, p_upper_context, 3693 pHwRef, (uint8_t) NFC_IO_ERROR, &comp_info ); 3694 } 3695 3696 return ; 3697 } 3698 3699 3700 3701 NFCSTATUS 3702 phDnldNfc_Upgrade ( 3703 phHal_sHwReference_t *pHwRef, 3704 #ifdef NXP_FW_PARAM 3705 uint8_t type, 3706 uint8_t *nxp_nfc_fw, 3707 uint32_t fw_length, 3708 #endif 3709 pphNfcIF_Notification_CB_t upgrade_complete, 3710 void *context 3711 ) 3712 { 3713 phDnldNfc_sContext_t *psDnldContext = NULL; 3714 phNfcIF_sReference_t dnldReference = { NULL,0,0 }; 3715 phNfcIF_sCallBack_t if_callback = { NULL, NULL, NULL, NULL }; 3716 phNfc_sLowerIF_t *plower_if = NULL; 3717 NFCSTATUS status = NFCSTATUS_SUCCESS; 3718 section_info_t *p_cur_sec = NULL; 3719 unsigned sec_type = 0; 3720 3721 if( (NULL == pHwRef) 3722 ) 3723 { 3724 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INVALID_PARAMETER); 3725 } 3726 else 3727 { 3728 DNLD_PRINT(" FW_DNLD: Starting the FW Upgrade Sequence .... \n"); 3729 3730 (void) 3731 phDnldNfc_Allocate_Resource((void **) 3732 &psDnldContext,sizeof(phDnldNfc_sContext_t)); 3733 if(psDnldContext != NULL) 3734 { 3735 #ifndef NFC_TIMER_CONTEXT 3736 gpphDnldContext = psDnldContext; 3737 #endif 3738 psDnldContext->p_hw_ref = pHwRef; 3739 psDnldContext->timer_id = NXP_INVALID_TIMER_ID; 3740 3741 DNLD_PRINT(" FW_DNLD: Initialisation in Progress.... \n"); 3742 3743 if_callback.pif_ctxt = psDnldContext ; 3744 if_callback.send_complete = &phDnldNfc_Send_Complete; 3745 if_callback.receive_complete= &phDnldNfc_Receive_Complete; 3746 /* if_callback.notify = &phDnldNfc_Notify_Event; */ 3747 plower_if = dnldReference.plower_if = &(psDnldContext->lower_interface); 3748 status = phDal4Nfc_Register(&dnldReference, if_callback, 3749 NULL); 3750 DNLD_DEBUG(" FW_DNLD: Lower Layer Register, Status = %02X\n",status); 3751 3752 if( (NFCSTATUS_SUCCESS == status) && (NULL != plower_if->init)) 3753 { 3754 /* psDnldContext->p_config_params = pHwConfig ; */ 3755 status = plower_if->init((void *)plower_if->pcontext, 3756 (void *)pHwRef); 3757 DNLD_DEBUG(" FW_DNLD: Lower Layer Initialisation, Status = %02X\n",status); 3758 } 3759 else 3760 { 3761 /* TODO: Handle Initialisation in the Invalid State */ 3762 } 3763 /* The Lower layer Initialisation successful */ 3764 if (NFCSTATUS_SUCCESS == status) 3765 { 3766 psDnldContext->p_upper_notify = upgrade_complete; 3767 psDnldContext->p_upper_context = context; 3768 3769 status = phDnldNfc_Process_FW( psDnldContext, pHwRef 3770 #ifdef NXP_FW_PARAM 3771 ,*nxp_nfc_fw , fw_length 3772 #endif 3773 ); 3774 3775 if (NFCSTATUS_SUCCESS == status) 3776 { 3777 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 3778 PHDNLD_CMD_RESET , NULL , 0 ); 3779 if (NFCSTATUS_PENDING == status) 3780 { 3781 DNLD_PRINT("\n FW_DNLD: Initial Reset .... \n"); 3782 3783 #if defined(FW_DOWNLOAD_TIMER) 3784 3785 psDnldContext->timer_id = phOsalNfc_Timer_Create( ); 3786 3787 #if (FW_DOWNLOAD_TIMER < 2) 3788 phOsalNfc_Timer_Start( psDnldContext->timer_id, 3789 NXP_DNLD_COMPLETE_TIMEOUT, 3790 (ppCallBck_t) phDnldNfc_Abort 3791 #ifdef NFC_TIMER_CONTEXT 3792 , (void *) psDnldContext 3793 #endif 3794 ); 3795 3796 #endif /* #if (FW_DOWNLOAD_TIMER < 2) */ 3797 3798 #endif /* #if defined(FW_DOWNLOAD_TIMER) */ 3799 3800 } 3801 } 3802 else if (NFCSTATUS_SUCCESS == PHNFCSTATUS(status)) 3803 { 3804 #if defined (NXP_FW_INTEGRITY_VERIFY) 3805 /* 3806 * To check for the integrity if the firmware is already 3807 * Upgraded. 3808 */ 3809 status = phDnldNfc_Send_Command( psDnldContext, pHwRef, 3810 PHDNLD_CMD_RESET , NULL , 0 ); 3811 if (NFCSTATUS_PENDING == status) 3812 { 3813 DNLD_PRINT("\n FW_DNLD: Integrity Reset .... \n"); 3814 (void)phDnldNfc_Set_Seq(psDnldContext, DNLD_SEQ_COMPLETE); 3815 status = PHNFCSTVAL( CID_NFC_DNLD, 3816 NFCSTATUS_PENDING ); 3817 #if defined(FW_DOWNLOAD_TIMER) 3818 psDnldContext->timer_id = phOsalNfc_Timer_Create( ); 3819 #if (FW_DOWNLOAD_TIMER < 2) 3820 phOsalNfc_Timer_Start( psDnldContext->timer_id, 3821 NXP_DNLD_COMPLETE_TIMEOUT, 3822 (ppCallBck_t) phDnldNfc_Abort 3823 #ifdef NFC_TIMER_CONTEXT 3824 , (void *) psDnldContext 3825 #endif 3826 ); 3827 3828 #endif /* #if (FW_DOWNLOAD_TIMER < 2) */ 3829 3830 #endif /* #if defined(FW_DOWNLOAD_TIMER) */ 3831 } 3832 3833 #else 3834 status = NFCSTATUS_SUCCESS; 3835 3836 #endif /* #if defined (NXP_FW_INTEGRITY_VERIFY) */ 3837 3838 } 3839 else 3840 { 3841 DNLD_PRINT(" FW_DNLD Initialisation in Failed \n"); 3842 } 3843 } 3844 3845 if (NFCSTATUS_PENDING != PHNFCSTATUS(status)) 3846 { 3847 (void)phDal4Nfc_Unregister( 3848 psDnldContext->lower_interface.pcontext, pHwRef); 3849 phDnldNfc_Release_Lower(psDnldContext, pHwRef); 3850 phDnldNfc_Release_Resources(&psDnldContext); 3851 #ifndef NFC_TIMER_CONTEXT 3852 gpphDnldContext = psDnldContext; 3853 #endif 3854 } 3855 } /* End of Status Check for Memory */ 3856 else 3857 { 3858 status = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_INSUFFICIENT_RESOURCES); 3859 3860 DNLD_PRINT(" FW_DNLD: Memory Allocation of Context Failed\n"); 3861 } 3862 } 3863 3864 return status; 3865 } 3866
