1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2018 NXP 4 * 5 * Peng Fan <peng.fan@nxp.com> 6 */ 7 8 #include "imx8image.h" 9 10 static int p_idx; 11 static int sector_size; 12 static soc_type_t soc; 13 static int container = -1; 14 static int32_t core_type = CFG_CORE_INVALID; 15 static bool emmc_fastboot; 16 static image_t param_stack[IMG_STACK_SIZE]; 17 static uint8_t fuse_version; 18 static uint16_t sw_version; 19 static uint32_t custom_partition; 20 static uint32_t scfw_flags; 21 22 int imx8image_check_params(struct image_tool_params *params) 23 { 24 return 0; 25 } 26 27 static void imx8image_set_header(void *ptr, struct stat *sbuf, int ifd, 28 struct image_tool_params *params) 29 { 30 } 31 32 static void imx8image_print_header(const void *ptr) 33 { 34 } 35 36 static int imx8image_check_image_types(uint8_t type) 37 { 38 return (type == IH_TYPE_IMX8IMAGE) ? EXIT_SUCCESS : EXIT_FAILURE; 39 } 40 41 static table_entry_t imx8image_cmds[] = { 42 {CMD_BOOT_FROM, "BOOT_FROM", "boot command", }, 43 {CMD_FUSE_VERSION, "FUSE_VERSION", "fuse version", }, 44 {CMD_SW_VERSION, "SW_VERSION", "sw version", }, 45 {CMD_MSG_BLOCK, "MSG_BLOCK", "msg block", }, 46 {CMD_FILEOFF, "FILEOFF", "fileoff", }, 47 {CMD_FLAG, "FLAG", "flag", }, 48 {CMD_APPEND, "APPEND", "append a container", }, 49 {CMD_PARTITION, "PARTITION", "new partition", }, 50 {CMD_SOC_TYPE, "SOC_TYPE", "soc type", }, 51 {CMD_CONTAINER, "CONTAINER", "new container", }, 52 {CMD_IMAGE, "IMAGE", "new image", }, 53 {CMD_DATA, "DATA", "new data", }, 54 {-1, "", "", }, 55 }; 56 57 static table_entry_t imx8image_core_entries[] = { 58 {CFG_SCU, "SCU", "scu core", }, 59 {CFG_M40, "M40", "M4 core 0", }, 60 {CFG_M41, "M41", "M4 core 1", }, 61 {CFG_A35, "A35", "A35 core", }, 62 {CFG_A53, "A53", "A53 core", }, 63 {CFG_A72, "A72", "A72 core", }, 64 {-1, "", "", }, 65 }; 66 67 static table_entry_t imx8image_sector_size[] = { 68 {0x400, "sd", "sd/emmc",}, 69 {0x400, "emmc_fastboot", "emmc fastboot",}, 70 {0x400, "fspi", "flexspi", }, 71 {0x1000, "nand_4k", "nand 4K", }, 72 {0x2000, "nand_8k", "nand 8K", }, 73 {0x4000, "nand_16k", "nand 16K", }, 74 {-1, "", "Invalid", }, 75 }; 76 77 static void parse_cfg_cmd(image_t *param_stack, int32_t cmd, char *token, 78 char *name, int lineno) 79 { 80 switch (cmd) { 81 case CMD_BOOT_FROM: 82 sector_size = get_table_entry_id(imx8image_sector_size, 83 "imximage boot option", 84 token); 85 if (!strncmp("emmc_fastboot", token, 13)) 86 emmc_fastboot = true; 87 break; 88 case CMD_FUSE_VERSION: 89 fuse_version = (uint8_t)(strtoll(token, NULL, 0) & 0xFF); 90 break; 91 case CMD_SW_VERSION: 92 sw_version = (uint8_t)(strtoll(token, NULL, 0) & 0xFFFF); 93 break; 94 case CMD_FILEOFF: 95 param_stack[p_idx].option = FILEOFF; 96 param_stack[p_idx++].dst = (uint32_t)strtoll(token, NULL, 0); 97 break; 98 case CMD_MSG_BLOCK: 99 param_stack[p_idx].option = MSG_BLOCK; 100 param_stack[p_idx].filename = token; 101 break; 102 case CMD_FLAG: 103 param_stack[p_idx].option = FLAG; 104 param_stack[p_idx++].entry = (uint32_t)strtoll(token, NULL, 0); 105 break; 106 case CMD_APPEND: 107 param_stack[p_idx].option = APPEND; 108 param_stack[p_idx++].filename = token; 109 break; 110 case CMD_PARTITION: 111 param_stack[p_idx].option = PARTITION; 112 param_stack[p_idx++].entry = (uint32_t)strtoll(token, NULL, 0); 113 break; 114 case CMD_SOC_TYPE: 115 if (!strncmp(token, "IMX8QX", 6)) { 116 soc = QX; 117 } else if (!strncmp(token, "IMX8QM", 6)) { 118 soc = QM; 119 } else { 120 fprintf(stderr, "Unknown CMD_SOC_TYPE"); 121 exit(EXIT_FAILURE); 122 } 123 break; 124 case CMD_IMAGE: 125 case CMD_DATA: 126 core_type = get_table_entry_id(imx8image_core_entries, 127 "imx8image core entries", 128 token); 129 if (core_type < 0) { 130 fprintf(stderr, "Wrong IMAGE core_type %s\n", token); 131 exit(EXIT_FAILURE); 132 } 133 break; 134 default: 135 break; 136 } 137 } 138 139 static void parse_cfg_fld(image_t *param_stack, int32_t *cmd, char *token, 140 char *name, int lineno, int fld) 141 { 142 switch (fld) { 143 case CFG_COMMAND: 144 *cmd = get_table_entry_id(imx8image_cmds, "imx8image cmds", 145 token); 146 if (*cmd < 0) { 147 fprintf(stderr, "Error: %s[%d] - Invalid command (%s)\n", name, lineno, token); 148 exit(EXIT_FAILURE); 149 } 150 151 if (*cmd == CMD_CONTAINER) { 152 fprintf(stdout, "New Container: \t%d\n", ++container); 153 param_stack[p_idx++].option = NEW_CONTAINER; 154 } 155 break; 156 case CFG_CORE_TYPE: 157 parse_cfg_cmd(param_stack, *cmd, token, name, lineno); 158 break; 159 case CFG_IMAGE_NAME: 160 if (*cmd == CMD_MSG_BLOCK) { 161 if (!strncmp(token, "fuse", 4)) { 162 param_stack[p_idx].ext = SC_R_OTP; 163 } else if (!strncmp(token, "debug", 5)) { 164 param_stack[p_idx].ext = SC_R_DEBUG; 165 } else if (!strncmp(token, "field", 5)) { 166 param_stack[p_idx].ext = SC_R_ROM_0; 167 } else { 168 fprintf(stderr, "MSG type not found %s\n", token); 169 exit(EXIT_FAILURE); 170 } 171 break; 172 } 173 switch (core_type) { 174 case CFG_SCU: 175 param_stack[p_idx].option = SCFW; 176 param_stack[p_idx++].filename = token; 177 break; 178 case CFG_M40: 179 param_stack[p_idx].option = M40; 180 param_stack[p_idx].ext = 0; 181 param_stack[p_idx].filename = token; 182 break; 183 case CFG_M41: 184 param_stack[p_idx].option = M41; 185 param_stack[p_idx].ext = 1; 186 param_stack[p_idx].filename = token; 187 break; 188 case CFG_A35: 189 param_stack[p_idx].ext = CORE_CA35; 190 param_stack[p_idx].option = 191 (*cmd == CMD_DATA) ? DATA : AP; 192 param_stack[p_idx].filename = token; 193 break; 194 case CFG_A53: 195 param_stack[p_idx].ext = CORE_CA53; 196 param_stack[p_idx].option = 197 (*cmd == CMD_DATA) ? DATA : AP; 198 param_stack[p_idx].filename = token; 199 break; 200 case CFG_A72: 201 param_stack[p_idx].ext = CORE_CA72; 202 param_stack[p_idx].option = 203 (*cmd == CMD_DATA) ? DATA : AP; 204 param_stack[p_idx].filename = token; 205 break; 206 } 207 break; 208 case CFG_LOAD_ADDR: 209 if (*cmd == CMD_MSG_BLOCK) { 210 param_stack[p_idx++].entry = 211 (uint32_t)strtoll(token, NULL, 0); 212 break; 213 } 214 switch (core_type) { 215 case CFG_SCU: 216 break; 217 case CFG_M40: 218 case CFG_M41: 219 case CFG_A35: 220 case CFG_A53: 221 case CFG_A72: 222 param_stack[p_idx++].entry = 223 (uint32_t)strtoll(token, NULL, 0); 224 break; 225 } 226 default: 227 break; 228 } 229 } 230 231 static uint32_t parse_cfg_file(image_t *param_stack, char *name) 232 { 233 FILE *fd = NULL; 234 char *line = NULL; 235 char *token, *saveptr1, *saveptr2; 236 int lineno = 0; 237 int fld; 238 size_t len; 239 int32_t cmd; 240 241 fd = fopen(name, "r"); 242 if (fd == 0) { 243 fprintf(stderr, "Error: %s - Can't open cfg file\n", name); 244 exit(EXIT_FAILURE); 245 } 246 247 /* 248 * Very simple parsing, line starting with # are comments 249 * and are dropped 250 */ 251 while ((getline(&line, &len, fd)) > 0) { 252 lineno++; 253 254 token = strtok_r(line, "\r\n", &saveptr1); 255 if (!token) 256 continue; 257 258 /* Check inside the single line */ 259 for (fld = CFG_COMMAND, cmd = CFG_INVALID, 260 line = token; ; line = NULL, fld++) { 261 token = strtok_r(line, " \t", &saveptr2); 262 if (!token) 263 break; 264 265 /* Drop all text starting with '#' as comments */ 266 if (token[0] == '#') 267 break; 268 269 parse_cfg_fld(param_stack, &cmd, token, name, lineno, 270 fld); 271 } 272 } 273 274 return 0; 275 } 276 277 static void check_file(struct stat *sbuf, char *filename) 278 { 279 int tmp_fd = open(filename, O_RDONLY | O_BINARY); 280 281 if (tmp_fd < 0) { 282 fprintf(stderr, "%s: Can't open: %s\n", 283 filename, strerror(errno)); 284 exit(EXIT_FAILURE); 285 } 286 287 if (fstat(tmp_fd, sbuf) < 0) { 288 fprintf(stderr, "%s: Can't stat: %s\n", 289 filename, strerror(errno)); 290 exit(EXIT_FAILURE); 291 } 292 293 close(tmp_fd); 294 } 295 296 static void copy_file_aligned(int ifd, const char *datafile, int offset, 297 int align) 298 { 299 int dfd; 300 struct stat sbuf; 301 unsigned char *ptr; 302 uint8_t zeros[0x4000]; 303 int size; 304 int ret; 305 306 if (align > 0x4000) { 307 fprintf(stderr, "Wrong alignment requested %d\n", align); 308 exit(EXIT_FAILURE); 309 } 310 311 memset(zeros, 0, sizeof(zeros)); 312 313 dfd = open(datafile, O_RDONLY | O_BINARY); 314 if (dfd < 0) { 315 fprintf(stderr, "Can't open %s: %s\n", 316 datafile, strerror(errno)); 317 exit(EXIT_FAILURE); 318 } 319 320 if (fstat(dfd, &sbuf) < 0) { 321 fprintf(stderr, "Can't stat %s: %s\n", 322 datafile, strerror(errno)); 323 exit(EXIT_FAILURE); 324 } 325 326 if (sbuf.st_size == 0) 327 goto close; 328 329 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 330 if (ptr == MAP_FAILED) { 331 fprintf(stderr, "Can't read %s: %s\n", 332 datafile, strerror(errno)); 333 exit(EXIT_FAILURE); 334 } 335 336 size = sbuf.st_size; 337 ret = lseek(ifd, offset, SEEK_SET); 338 if (ret < 0) { 339 fprintf(stderr, "%s: lseek error %s\n", 340 __func__, strerror(errno)); 341 exit(EXIT_FAILURE); 342 } 343 344 if (write(ifd, ptr, size) != size) { 345 fprintf(stderr, "Write error %s\n", strerror(errno)); 346 exit(EXIT_FAILURE); 347 } 348 349 align = ALIGN(size, align) - size; 350 351 if (write(ifd, (char *)&zeros, align) != align) { 352 fprintf(stderr, "Write error: %s\n", strerror(errno)); 353 exit(EXIT_FAILURE); 354 } 355 356 munmap((void *)ptr, sbuf.st_size); 357 close: 358 close(dfd); 359 } 360 361 static void copy_file (int ifd, const char *datafile, int pad, int offset) 362 { 363 int dfd; 364 struct stat sbuf; 365 unsigned char *ptr; 366 int tail; 367 int zero = 0; 368 uint8_t zeros[4096]; 369 int size, ret; 370 371 memset(zeros, 0, sizeof(zeros)); 372 373 dfd = open(datafile, O_RDONLY | O_BINARY); 374 if (dfd < 0) { 375 fprintf(stderr, "Can't open %s: %s\n", 376 datafile, strerror(errno)); 377 exit(EXIT_FAILURE); 378 } 379 380 if (fstat(dfd, &sbuf) < 0) { 381 fprintf(stderr, "Can't stat %s: %s\n", 382 datafile, strerror(errno)); 383 exit(EXIT_FAILURE); 384 } 385 386 if (sbuf.st_size == 0) 387 goto close; 388 389 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 390 if (ptr == MAP_FAILED) { 391 fprintf(stderr, "Can't read %s: %s\n", 392 datafile, strerror(errno)); 393 exit(EXIT_FAILURE); 394 } 395 396 size = sbuf.st_size; 397 ret = lseek(ifd, offset, SEEK_SET); 398 if (ret < 0) { 399 fprintf(stderr, "%s: lseek error %s\n", 400 __func__, strerror(errno)); 401 exit(EXIT_FAILURE); 402 } 403 404 if (write(ifd, ptr, size) != size) { 405 fprintf(stderr, "Write error %s\n", 406 strerror(errno)); 407 exit(EXIT_FAILURE); 408 } 409 410 tail = size % 4; 411 pad = pad - size; 412 if (pad == 1 && tail != 0) { 413 if (write(ifd, (char *)&zero, 4 - tail) != 4 - tail) { 414 fprintf(stderr, "Write error on %s\n", 415 strerror(errno)); 416 exit(EXIT_FAILURE); 417 } 418 } else if (pad > 1) { 419 while (pad > 0) { 420 int todo = sizeof(zeros); 421 422 if (todo > pad) 423 todo = pad; 424 if (write(ifd, (char *)&zeros, todo) != todo) { 425 fprintf(stderr, "Write error: %s\n", 426 strerror(errno)); 427 exit(EXIT_FAILURE); 428 } 429 pad -= todo; 430 } 431 } 432 433 munmap((void *)ptr, sbuf.st_size); 434 close: 435 close(dfd); 436 } 437 438 uint64_t read_dcd_offset(char *filename) 439 { 440 int dfd; 441 struct stat sbuf; 442 uint8_t *ptr; 443 uint64_t offset = 0; 444 445 dfd = open(filename, O_RDONLY | O_BINARY); 446 if (dfd < 0) { 447 fprintf(stderr, "Can't open %s: %s\n", filename, strerror(errno)); 448 exit(EXIT_FAILURE); 449 } 450 451 if (fstat(dfd, &sbuf) < 0) { 452 fprintf(stderr, "Can't stat %s: %s\n", filename, strerror(errno)); 453 exit(EXIT_FAILURE); 454 } 455 456 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 457 if (ptr == MAP_FAILED) { 458 fprintf(stderr, "Can't read %s: %s\n", filename, strerror(errno)); 459 exit(EXIT_FAILURE); 460 } 461 462 offset = *(uint32_t *)(ptr + DCD_ENTRY_ADDR_IN_SCFW); 463 464 munmap((void *)ptr, sbuf.st_size); 465 close(dfd); 466 467 return offset; 468 } 469 470 static void set_image_hash(boot_img_t *img, char *filename, uint32_t hash_type) 471 { 472 FILE *fp = NULL; 473 char sha_command[512]; 474 char hash[2 * HASH_MAX_LEN + 1]; 475 int i, ret; 476 477 if (img->size == 0) 478 sprintf(sha_command, "sha%dsum /dev/null", hash_type); 479 else 480 sprintf(sha_command, "dd if=/dev/zero of=tmp_pad bs=%d count=1;\ 481 dd if=\'%s\' of=tmp_pad conv=notrunc;\ 482 sha%dsum tmp_pad; rm -f tmp_pad", 483 img->size, filename, hash_type); 484 485 switch (hash_type) { 486 case HASH_TYPE_SHA_256: 487 img->hab_flags |= IMG_FLAG_HASH_SHA256; 488 break; 489 case HASH_TYPE_SHA_384: 490 img->hab_flags |= IMG_FLAG_HASH_SHA384; 491 break; 492 case HASH_TYPE_SHA_512: 493 img->hab_flags |= IMG_FLAG_HASH_SHA512; 494 break; 495 default: 496 fprintf(stderr, "Wrong hash type selected (%d) !!!\n\n", 497 hash_type); 498 exit(EXIT_FAILURE); 499 break; 500 } 501 memset(img->hash, 0, HASH_MAX_LEN); 502 503 fp = popen(sha_command, "r"); 504 if (!fp) { 505 fprintf(stderr, "Failed to run command hash\n"); 506 exit(EXIT_FAILURE); 507 } 508 509 if (!fgets(hash, hash_type / 4 + 1, fp)) { 510 fprintf(stderr, "Failed to hash file: %s\n", filename); 511 exit(EXIT_FAILURE); 512 } 513 514 for (i = 0; i < strlen(hash) / 2; i++) { 515 ret = sscanf(hash + 2 * i, "%02hhx", &img->hash[i]); 516 if (ret < 0) { 517 fprintf(stderr, "Failed sscanf hash: %d\n", ret); 518 exit(EXIT_FAILURE); 519 } 520 } 521 522 pclose(fp); 523 } 524 525 static void set_image_array_entry(flash_header_v3_t *container, 526 soc_type_t soc, const image_t *image_stack, 527 uint32_t offset, uint32_t size, 528 char *tmp_filename, bool dcd_skip) 529 { 530 uint64_t entry = image_stack->entry; 531 uint64_t core = image_stack->ext; 532 uint32_t meta; 533 char *tmp_name = ""; 534 option_type_t type = image_stack->option; 535 boot_img_t *img = &container->img[container->num_images]; 536 537 img->offset = offset; /* Is re-adjusted later */ 538 img->size = size; 539 540 set_image_hash(img, tmp_filename, IMAGE_HASH_ALGO_DEFAULT); 541 542 switch (type) { 543 case SECO: 544 img->hab_flags |= IMG_TYPE_SECO; 545 img->hab_flags |= CORE_SECO << BOOT_IMG_FLAGS_CORE_SHIFT; 546 tmp_name = "SECO"; 547 img->dst = 0x20C00000; 548 img->entry = 0x20000000; 549 break; 550 case AP: 551 if (soc == QX && core == CORE_CA35) { 552 meta = IMAGE_A35_DEFAULT_META(custom_partition); 553 } else if (soc == QM && core == CORE_CA53) { 554 meta = IMAGE_A53_DEFAULT_META(custom_partition); 555 } else if (soc == QM && core == CORE_CA72) { 556 meta = IMAGE_A72_DEFAULT_META(custom_partition); 557 } else { 558 fprintf(stderr, 559 "Error: invalid AP core id: %" PRIu64 "\n", 560 core); 561 exit(EXIT_FAILURE); 562 } 563 img->hab_flags |= IMG_TYPE_EXEC; 564 /* On B0, only core id = 4 is valid */ 565 img->hab_flags |= CORE_CA53 << BOOT_IMG_FLAGS_CORE_SHIFT; 566 tmp_name = "AP"; 567 img->dst = entry; 568 img->entry = entry; 569 img->meta = meta; 570 custom_partition = 0; 571 break; 572 case M40: 573 case M41: 574 if (core == 0) { 575 core = CORE_CM4_0; 576 meta = IMAGE_M4_0_DEFAULT_META(custom_partition); 577 } else if (core == 1) { 578 core = CORE_CM4_1; 579 meta = IMAGE_M4_1_DEFAULT_META(custom_partition); 580 } else { 581 fprintf(stderr, 582 "Error: invalid m4 core id: %" PRIu64 "\n", 583 core); 584 exit(EXIT_FAILURE); 585 } 586 img->hab_flags |= IMG_TYPE_EXEC; 587 img->hab_flags |= core << BOOT_IMG_FLAGS_CORE_SHIFT; 588 tmp_name = "M4"; 589 if ((entry & 0x7) != 0) { 590 fprintf(stderr, "\n\nWarning: M4 Destination address is not 8 byte aligned\n\n"); 591 exit(EXIT_FAILURE); 592 } 593 img->dst = entry; 594 img->entry = entry; 595 img->meta = meta; 596 custom_partition = 0; 597 break; 598 case DATA: 599 img->hab_flags |= IMG_TYPE_DATA; 600 img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT; 601 tmp_name = "DATA"; 602 img->dst = entry; 603 break; 604 case MSG_BLOCK: 605 img->hab_flags |= IMG_TYPE_DATA; 606 img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT; 607 img->meta = core << BOOT_IMG_META_MU_RID_SHIFT; 608 tmp_name = "MSG_BLOCK"; 609 img->dst = entry; 610 break; 611 case SCFW: 612 img->hab_flags |= scfw_flags & 0xFFFF0000; 613 img->hab_flags |= IMG_TYPE_EXEC; 614 img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT; 615 tmp_name = "SCFW"; 616 img->dst = 0x1FFE0000; 617 img->entry = 0x1FFE0000; 618 619 /* Lets add the DCD now */ 620 if (!dcd_skip) { 621 container->num_images++; 622 img = &container->img[container->num_images]; 623 img->hab_flags |= IMG_TYPE_DCD_DDR; 624 img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT; 625 set_image_hash(img, "/dev/null", 626 IMAGE_HASH_ALGO_DEFAULT); 627 img->offset = offset + img->size; 628 img->entry = read_dcd_offset(tmp_filename); 629 img->dst = img->entry - 1; 630 } 631 break; 632 default: 633 fprintf(stderr, "unrecognized image type (%d)\n", type); 634 exit(EXIT_FAILURE); 635 } 636 637 fprintf(stdout, "%s file_offset = 0x%x size = 0x%x\n", tmp_name, offset, size); 638 639 container->num_images++; 640 } 641 642 void set_container(flash_header_v3_t *container, uint16_t sw_version, 643 uint32_t alignment, uint32_t flags, uint16_t fuse_version) 644 { 645 container->sig_blk_hdr.tag = 0x90; 646 container->sig_blk_hdr.length = sizeof(sig_blk_hdr_t); 647 container->sw_version = sw_version; 648 container->padding = alignment; 649 container->fuse_version = fuse_version; 650 container->flags = flags; 651 fprintf(stdout, "container flags: 0x%x\n", container->flags); 652 } 653 654 static int get_container_image_start_pos(image_t *image_stack, uint32_t align) 655 { 656 image_t *img_sp = image_stack; 657 /*8K total container header*/ 658 int file_off = CONTAINER_IMAGE_ARRAY_START_OFFSET; 659 FILE *fd = NULL; 660 flash_header_v3_t header; 661 int ret; 662 663 while (img_sp->option != NO_IMG) { 664 if (img_sp->option == APPEND) { 665 fd = fopen(img_sp->filename, "r"); 666 if (!fd) { 667 fprintf(stderr, "Fail open first container file %s\n", img_sp->filename); 668 exit(EXIT_FAILURE); 669 } 670 671 ret = fread(&header, sizeof(header), 1, fd); 672 if (ret != 1) { 673 printf("Failure Read header %d\n", ret); 674 exit(EXIT_FAILURE); 675 } 676 677 fclose(fd); 678 679 if (header.tag != IVT_HEADER_TAG_B0) { 680 fprintf(stderr, "header tag mismatched \n"); 681 exit(EXIT_FAILURE); 682 } else { 683 file_off += 684 header.img[header.num_images - 1].size; 685 file_off = ALIGN(file_off, align); 686 } 687 } 688 689 img_sp++; 690 } 691 692 return file_off; 693 } 694 695 static void set_imx_hdr_v3(imx_header_v3_t *imxhdr, uint32_t cont_id) 696 { 697 flash_header_v3_t *fhdr_v3 = &imxhdr->fhdr[cont_id]; 698 699 /* Set magic number, Only >= B0 supported */ 700 fhdr_v3->tag = IVT_HEADER_TAG_B0; 701 fhdr_v3->version = IVT_VERSION_B0; 702 } 703 704 static uint8_t *flatten_container_header(imx_header_v3_t *imx_header, 705 uint8_t containers_count, 706 uint32_t *size_out, 707 uint32_t file_offset) 708 { 709 uint8_t *flat = NULL; 710 uint8_t *ptr = NULL; 711 uint16_t size = 0; 712 int i, j; 713 714 /* Compute size of all container headers */ 715 for (i = 0; i < containers_count; i++) { 716 flash_header_v3_t *container = &imx_header->fhdr[i]; 717 718 container->sig_blk_offset = HEADER_IMG_ARRAY_OFFSET + 719 container->num_images * IMG_ARRAY_ENTRY_SIZE; 720 721 container->length = HEADER_IMG_ARRAY_OFFSET + 722 (IMG_ARRAY_ENTRY_SIZE * container->num_images) + 723 sizeof(sig_blk_hdr_t); 724 725 /* Print info needed by CST to sign the container header */ 726 fprintf(stdout, "CST: CONTAINER %d offset: 0x%x\n", 727 i, file_offset + size); 728 fprintf(stdout, "CST: CONTAINER %d: Signature Block: offset is at 0x%x\n", i, 729 file_offset + size + container->length - 730 SIGNATURE_BLOCK_HEADER_LENGTH); 731 732 size += ALIGN(container->length, container->padding); 733 } 734 735 flat = calloc(size, sizeof(uint8_t)); 736 if (!flat) { 737 fprintf(stderr, "Failed to allocate memory (%d)\n", size); 738 exit(EXIT_FAILURE); 739 } 740 741 ptr = flat; 742 *size_out = size; 743 744 for (i = 0; i < containers_count; i++) { 745 flash_header_v3_t *container = &imx_header->fhdr[i]; 746 uint32_t container_start_offset = ptr - flat; 747 748 /* Append container header */ 749 append(ptr, container, HEADER_IMG_ARRAY_OFFSET); 750 751 /* Adjust images offset to start from container headers start */ 752 for (j = 0; j < container->num_images; j++) { 753 container->img[j].offset -= 754 container_start_offset + file_offset; 755 } 756 /* Append each image array entry */ 757 for (j = 0; j < container->num_images; j++) 758 append(ptr, &container->img[j], sizeof(boot_img_t)); 759 760 append(ptr, &container->sig_blk_hdr, sizeof(sig_blk_hdr_t)); 761 762 /* Padding for container (if necessary) */ 763 ptr += ALIGN(container->length, container->padding) - 764 container->length; 765 } 766 767 return flat; 768 } 769 770 static int build_container(soc_type_t soc, uint32_t sector_size, 771 bool emmc_fastboot, image_t *image_stack, 772 bool dcd_skip, uint8_t fuse_version, 773 uint16_t sw_version, int ofd) 774 { 775 static imx_header_v3_t imx_header; 776 image_t *img_sp = image_stack; 777 int file_off; 778 uint8_t *tmp; 779 struct stat sbuf; 780 char *tmp_filename = NULL; 781 uint32_t size = 0; 782 uint32_t file_padding = 0; 783 int ret; 784 785 int container = -1; 786 int cont_img_count = 0; /* indexes to arrange the container */ 787 788 memset((char *)&imx_header, 0, sizeof(imx_header_v3_t)); 789 790 if (!image_stack) { 791 fprintf(stderr, "Empty image stack "); 792 exit(EXIT_FAILURE); 793 } 794 795 if (soc == QX) 796 fprintf(stdout, "Platform:\ti.MX8QXP B0\n"); 797 else if (soc == QM) 798 fprintf(stdout, "Platform:\ti.MX8QM B0\n"); 799 800 set_imx_hdr_v3(&imx_header, 0); 801 set_imx_hdr_v3(&imx_header, 1); 802 803 file_off = get_container_image_start_pos(image_stack, sector_size); 804 fprintf(stdout, "container image offset (aligned):%x\n", file_off); 805 806 /* step through image stack and generate the header */ 807 img_sp = image_stack; 808 809 /* stop once we reach null terminator */ 810 while (img_sp->option != NO_IMG) { 811 switch (img_sp->option) { 812 case AP: 813 case M40: 814 case M41: 815 case SCFW: 816 case DATA: 817 case MSG_BLOCK: 818 if (container < 0) { 819 fprintf(stderr, "No container found\n"); 820 exit(EXIT_FAILURE); 821 } 822 check_file(&sbuf, img_sp->filename); 823 tmp_filename = img_sp->filename; 824 set_image_array_entry(&imx_header.fhdr[container], 825 soc, img_sp, file_off, 826 ALIGN(sbuf.st_size, sector_size), 827 tmp_filename, dcd_skip); 828 img_sp->src = file_off; 829 830 file_off += ALIGN(sbuf.st_size, sector_size); 831 cont_img_count++; 832 break; 833 834 case SECO: 835 if (container < 0) { 836 fprintf(stderr, "No container found\n"); 837 exit(EXIT_FAILURE); 838 } 839 check_file(&sbuf, img_sp->filename); 840 tmp_filename = img_sp->filename; 841 set_image_array_entry(&imx_header.fhdr[container], 842 soc, 843 img_sp, 844 file_off, 845 sbuf.st_size, 846 tmp_filename, dcd_skip); 847 img_sp->src = file_off; 848 849 file_off += sbuf.st_size; 850 cont_img_count++; 851 break; 852 853 case NEW_CONTAINER: 854 container++; 855 set_container(&imx_header.fhdr[container], sw_version, 856 CONTAINER_ALIGNMENT, 857 CONTAINER_FLAGS_DEFAULT, 858 fuse_version); 859 /* reset img count when moving to new container */ 860 cont_img_count = 0; 861 scfw_flags = 0; 862 break; 863 864 case APPEND: 865 /* 866 * nothing to do here, the container is appended 867 * in the output 868 */ 869 break; 870 case FLAG: 871 /* 872 * override the flags for scfw in current container 873 * mask off bottom 16 bits. 874 */ 875 scfw_flags = img_sp->entry & 0xFFFF0000; 876 break; 877 case FILEOFF: 878 if (file_off > img_sp->dst) { 879 fprintf(stderr, "FILEOFF address less than current file offset!!!\n"); 880 exit(EXIT_FAILURE); 881 } 882 if (img_sp->dst != ALIGN(img_sp->dst, sector_size)) { 883 fprintf(stderr, "FILEOFF address is not aligned to sector size!!!\n"); 884 exit(EXIT_FAILURE); 885 } 886 file_off = img_sp->dst; 887 break; 888 case PARTITION: 889 /* 890 * keep custom partition until next executable image 891 * use a global var for default behaviour 892 */ 893 custom_partition = img_sp->entry; 894 break; 895 default: 896 fprintf(stderr, "unrecognized option in input stack (%d)\n", img_sp->option); 897 exit(EXIT_FAILURE); 898 } 899 img_sp++; /* advance index */ 900 } 901 902 /* Append container (if specified) */ 903 img_sp = image_stack; 904 do { 905 if (img_sp->option == APPEND) { 906 copy_file(ofd, img_sp->filename, 0, 0); 907 file_padding += FIRST_CONTAINER_HEADER_LENGTH; 908 } 909 img_sp++; 910 } while (img_sp->option != NO_IMG); 911 912 /* Add padding or skip appended container */ 913 ret = lseek(ofd, file_padding, SEEK_SET); 914 if (ret < 0) { 915 fprintf(stderr, "%s: lseek error %s\n", 916 __func__, strerror(errno)); 917 exit(EXIT_FAILURE); 918 } 919 920 if (container >= 0) { 921 /* Note: Image offset are not contained in the image */ 922 tmp = flatten_container_header(&imx_header, container + 1, 923 &size, file_padding); 924 /* Write image header */ 925 if (write(ofd, tmp, size) != size) { 926 fprintf(stderr, "error writing image hdr\n"); 927 exit(EXIT_FAILURE); 928 } 929 930 /* Clean-up memory used by the headers */ 931 free(tmp); 932 } 933 934 /* 935 * step through the image stack again this time copying 936 * images to final bin, stop once we reach null terminator. 937 */ 938 img_sp = image_stack; 939 while (img_sp->option != NO_IMG) { 940 if (img_sp->option == M40 || img_sp->option == M41 || 941 img_sp->option == AP || img_sp->option == DATA || 942 img_sp->option == SCD || img_sp->option == SCFW || 943 img_sp->option == SECO || img_sp->option == MSG_BLOCK) { 944 copy_file_aligned(ofd, img_sp->filename, img_sp->src, 945 sector_size); 946 } 947 img_sp++; 948 } 949 950 return 0; 951 } 952 953 int imx8image_copy_image(int outfd, struct image_tool_params *mparams) 954 { 955 image_t *img_sp = param_stack; 956 957 /* 958 * SECO FW is a container image, this is to calculate the 959 * 2nd container offset. 960 */ 961 fprintf(stdout, "parsing %s\n", mparams->imagename); 962 parse_cfg_file(img_sp, mparams->imagename); 963 964 if (sector_size == 0) { 965 fprintf(stderr, "Wrong sector size\n"); 966 exit(EXIT_FAILURE); 967 } 968 969 fprintf(stdout, "CONTAINER Sector size:\t%08x\n", sector_size); 970 fprintf(stdout, "CONTAINER FUSE VERSION:\t0x%02x\n", fuse_version); 971 fprintf(stdout, "CONTAINER SW VERSION:\t0x%04x\n", sw_version); 972 973 build_container(soc, sector_size, emmc_fastboot, 974 img_sp, false, fuse_version, sw_version, outfd); 975 976 return 0; 977 } 978 979 /* 980 * imx8image parameters 981 */ 982 U_BOOT_IMAGE_TYPE( 983 imx8image, 984 "NXP i.MX8 Boot Image support", 985 0, 986 NULL, 987 imx8image_check_params, 988 NULL, 989 imx8image_print_header, 990 imx8image_set_header, 991 NULL, 992 imx8image_check_image_types, 993 NULL, 994 NULL 995 ); 996