1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2018 NXP 4 * 5 * Peng Fan <peng.fan@nxp.com> 6 */ 7 8 9 #include "imagetool.h" 10 #include <image.h> 11 #include "imximage.h" 12 #include "compiler.h" 13 14 static uint32_t ap_start_addr, sld_start_addr, sld_src_off; 15 static char *ap_img, *sld_img, *signed_hdmi; 16 static imx_header_v3_t imx_header[2]; /* At most there are 3 IVT headers */ 17 static uint32_t rom_image_offset; 18 static uint32_t sector_size = 0x200; 19 static uint32_t image_off; 20 static uint32_t sld_header_off; 21 static uint32_t ivt_offset; 22 static uint32_t using_fit; 23 24 #define CSF_SIZE 0x2000 25 #define HDMI_IVT_ID 0 26 #define IMAGE_IVT_ID 1 27 28 #define HDMI_FW_SIZE 0x17000 /* Use Last 0x1000 for IVT and CSF */ 29 #define ALIGN_SIZE 0x1000 30 #define ALIGN(x,a) __ALIGN_MASK((x), (__typeof__(x))(a) - 1, a) 31 #define __ALIGN_MASK(x,mask,mask2) (((x) + (mask)) / (mask2) * (mask2)) 32 33 static uint32_t get_cfg_value(char *token, char *name, int linenr) 34 { 35 char *endptr; 36 uint32_t value; 37 38 errno = 0; 39 value = strtoul(token, &endptr, 16); 40 if (errno || token == endptr) { 41 fprintf(stderr, "Error: %s[%d] - Invalid hex data(%s)\n", 42 name, linenr, token); 43 exit(EXIT_FAILURE); 44 } 45 return value; 46 } 47 48 int imx8mimage_check_params(struct image_tool_params *params) 49 { 50 return 0; 51 } 52 53 static void imx8mimage_set_header(void *ptr, struct stat *sbuf, int ifd, 54 struct image_tool_params *params) 55 { 56 } 57 58 static void imx8mimage_print_header(const void *ptr) 59 { 60 } 61 62 static int imx8mimage_check_image_types(uint8_t type) 63 { 64 return (type == IH_TYPE_IMX8MIMAGE) ? EXIT_SUCCESS : EXIT_FAILURE; 65 } 66 67 static table_entry_t imx8mimage_cmds[] = { 68 {CMD_BOOT_FROM, "BOOT_FROM", "boot command", }, 69 {CMD_FIT, "FIT", "fit image", }, 70 {CMD_SIGNED_HDMI, "SIGNED_HDMI", "signed hdmi image", }, 71 {CMD_LOADER, "LOADER", "loader image", }, 72 {CMD_SECOND_LOADER, "SECOND_LOADER", "2nd loader image", }, 73 {CMD_DDR_FW, "DDR_FW", "ddr firmware", }, 74 {-1, "", "", }, 75 }; 76 77 static table_entry_t imx8mimage_ivt_offset[] = { 78 {0x400, "sd", "sd/emmc",}, 79 {0x400, "emmc_fastboot", "emmc fastboot",}, 80 {0x1000, "fspi", "flexspi", }, 81 {-1, "", "Invalid", }, 82 }; 83 84 static void parse_cfg_cmd(int32_t cmd, char *token, char *name, int lineno) 85 { 86 switch (cmd) { 87 case CMD_BOOT_FROM: 88 ivt_offset = get_table_entry_id(imx8mimage_ivt_offset, 89 "imx8mimage ivt offset", 90 token); 91 if (!strncmp(token, "sd", 2)) 92 rom_image_offset = 0x8000; 93 break; 94 case CMD_LOADER: 95 ap_img = token; 96 break; 97 case CMD_SECOND_LOADER: 98 sld_img = token; 99 break; 100 case CMD_SIGNED_HDMI: 101 signed_hdmi = token; 102 case CMD_FIT: 103 using_fit = 1; 104 break; 105 case CMD_DDR_FW: 106 /* Do nothing */ 107 break; 108 } 109 } 110 111 static void parse_cfg_fld(int32_t *cmd, char *token, 112 char *name, int lineno, int fld) 113 { 114 switch (fld) { 115 case CFG_COMMAND: 116 *cmd = get_table_entry_id(imx8mimage_cmds, 117 "imx8mimage commands", token); 118 if (*cmd < 0) { 119 fprintf(stderr, "Error: %s[%d] - Invalid command" "(%s)\n", 120 name, lineno, token); 121 exit(EXIT_FAILURE); 122 } 123 break; 124 case CFG_REG_SIZE: 125 parse_cfg_cmd(*cmd, token, name, lineno); 126 break; 127 case CFG_REG_ADDRESS: 128 switch (*cmd) { 129 case CMD_LOADER: 130 ap_start_addr = get_cfg_value(token, name, lineno); 131 break; 132 case CMD_SECOND_LOADER: 133 sld_start_addr = get_cfg_value(token, name, lineno); 134 break; 135 } 136 break; 137 case CFG_REG_VALUE: 138 switch (*cmd) { 139 case CMD_SECOND_LOADER: 140 sld_src_off = get_cfg_value(token, name, lineno); 141 break; 142 } 143 default: 144 break; 145 } 146 } 147 148 static uint32_t parse_cfg_file(char *name) 149 { 150 FILE *fd = NULL; 151 char *line = NULL; 152 char *token, *saveptr1, *saveptr2; 153 int lineno = 0; 154 int fld; 155 size_t len; 156 int32_t cmd; 157 158 fd = fopen(name, "r"); 159 if (fd == 0) { 160 fprintf(stderr, "Error: %s - Can't open cfg file\n", name); 161 exit(EXIT_FAILURE); 162 } 163 164 /* 165 * Very simple parsing, line starting with # are comments 166 * and are dropped 167 */ 168 while ((getline(&line, &len, fd)) > 0) { 169 lineno++; 170 171 token = strtok_r(line, "\r\n", &saveptr1); 172 if (!token) 173 continue; 174 175 /* Check inside the single line */ 176 for (fld = CFG_COMMAND, cmd = CFG_INVALID, 177 line = token; ; line = NULL, fld++) { 178 token = strtok_r(line, " \t", &saveptr2); 179 if (!token) 180 break; 181 182 /* Drop all text starting with '#' as comments */ 183 if (token[0] == '#') 184 break; 185 186 parse_cfg_fld(&cmd, token, name, lineno, fld); 187 } 188 } 189 190 return 0; 191 } 192 193 static void fill_zero(int ifd, int size, int offset) 194 { 195 int fill_size; 196 uint8_t zeros[4096]; 197 int ret; 198 199 memset(zeros, 0, sizeof(zeros)); 200 201 ret = lseek(ifd, offset, SEEK_SET); 202 if (ret < 0) { 203 fprintf(stderr, "%s seek: %s\n", __func__, strerror(errno)); 204 exit(EXIT_FAILURE); 205 } 206 207 while (size) { 208 if (size > 4096) 209 fill_size = 4096; 210 else 211 fill_size = size; 212 213 if (write(ifd, (char *)&zeros, fill_size) != fill_size) { 214 fprintf(stderr, "Write error: %s\n", 215 strerror(errno)); 216 exit(EXIT_FAILURE); 217 } 218 219 size -= fill_size; 220 }; 221 } 222 223 static void copy_file(int ifd, const char *datafile, int pad, int offset, 224 int datafile_offset) 225 { 226 int dfd; 227 struct stat sbuf; 228 unsigned char *ptr; 229 int tail; 230 uint64_t zero = 0; 231 uint8_t zeros[4096]; 232 int size, ret; 233 234 memset(zeros, 0, sizeof(zeros)); 235 236 dfd = open(datafile, O_RDONLY | O_BINARY); 237 if (dfd < 0) { 238 fprintf(stderr, "Can't open %s: %s\n", 239 datafile, strerror(errno)); 240 exit(EXIT_FAILURE); 241 } 242 243 if (fstat(dfd, &sbuf) < 0) { 244 fprintf(stderr, "Can't stat %s: %s\n", 245 datafile, strerror(errno)); 246 exit(EXIT_FAILURE); 247 } 248 249 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 250 if (ptr == MAP_FAILED) { 251 fprintf(stderr, "Can't read %s: %s\n", 252 datafile, strerror(errno)); 253 exit(EXIT_FAILURE); 254 } 255 256 size = sbuf.st_size - datafile_offset; 257 ret = lseek(ifd, offset, SEEK_SET); 258 if (ret < 0) { 259 fprintf(stderr, "lseek ifd fail\n"); 260 exit(EXIT_FAILURE); 261 } 262 263 if (write(ifd, ptr + datafile_offset, size) != size) { 264 fprintf(stderr, "Write error %s\n", 265 strerror(errno)); 266 exit(EXIT_FAILURE); 267 } 268 269 tail = size % 4; 270 pad = pad - size; 271 if (pad == 1 && tail != 0) { 272 if (write(ifd, (char *)&zero, 4 - tail) != 4 - tail) { 273 fprintf(stderr, "Write error on %s\n", 274 strerror(errno)); 275 exit(EXIT_FAILURE); 276 } 277 } else if (pad > 1) { 278 while (pad > 0) { 279 int todo = sizeof(zeros); 280 281 if (todo > pad) 282 todo = pad; 283 if (write(ifd, (char *)&zeros, todo) != todo) { 284 fprintf(stderr, "Write error: %s\n", 285 strerror(errno)); 286 exit(EXIT_FAILURE); 287 } 288 pad -= todo; 289 } 290 } 291 292 munmap((void *)ptr, sbuf.st_size); 293 close(dfd); 294 } 295 296 /* Return this IVT offset in the final output file */ 297 static int generate_ivt_for_fit(int fd, int fit_offset, uint32_t ep, 298 uint32_t *fit_load_addr) 299 { 300 image_header_t image_header; 301 int ret; 302 303 uint32_t fit_size, load_addr; 304 int align_len = 64 - 1; /* 64 is cacheline size */ 305 306 ret = lseek(fd, fit_offset, SEEK_SET); 307 if (ret < 0) { 308 fprintf(stderr, "lseek fd fail for fit\n"); 309 exit(EXIT_FAILURE); 310 } 311 312 if (read(fd, (char *)&image_header, sizeof(image_header_t)) != 313 sizeof(image_header_t)) { 314 fprintf(stderr, "generate_ivt_for_fit read failed: %s\n", 315 strerror(errno)); 316 exit(EXIT_FAILURE); 317 } 318 319 if (be32_to_cpu(image_header.ih_magic) != FDT_MAGIC) { 320 fprintf(stderr, "%s error: not a FIT file\n", __func__); 321 exit(EXIT_FAILURE); 322 } 323 324 fit_size = fdt_totalsize(&image_header); 325 fit_size = (fit_size + 3) & ~3; 326 327 fit_size = ALIGN(fit_size, ALIGN_SIZE); 328 329 ret = lseek(fd, fit_offset + fit_size, SEEK_SET); 330 if (ret < 0) { 331 fprintf(stderr, "lseek fd fail for fit\n"); 332 exit(EXIT_FAILURE); 333 } 334 335 /* 336 * ep is the u-boot entry. SPL loads the FIT before the u-boot 337 * address. 0x2000 is for CSF_SIZE 338 */ 339 load_addr = (ep - (fit_size + CSF_SIZE) - 512 - align_len) & 340 ~align_len; 341 342 flash_header_v2_t ivt_header = { { 0xd1, 0x2000, 0x40 }, 343 load_addr, 0, 0, 0, 344 (load_addr + fit_size), 345 (load_addr + fit_size + 0x20), 346 0 }; 347 348 if (write(fd, &ivt_header, sizeof(flash_header_v2_t)) != 349 sizeof(flash_header_v2_t)) { 350 fprintf(stderr, "IVT writing error on fit image\n"); 351 exit(EXIT_FAILURE); 352 } 353 354 *fit_load_addr = load_addr; 355 356 return fit_offset + fit_size; 357 } 358 359 static void dump_header_v2(imx_header_v3_t *imx_header, int index) 360 { 361 const char *ivt_name[2] = {"HDMI FW", "LOADER IMAGE"}; 362 363 fprintf(stdout, "========= IVT HEADER [%s] =========\n", 364 ivt_name[index]); 365 fprintf(stdout, "header.tag: \t\t0x%x\n", 366 imx_header[index].fhdr.header.tag); 367 fprintf(stdout, "header.length: \t\t0x%x\n", 368 imx_header[index].fhdr.header.length); 369 fprintf(stdout, "header.version: \t0x%x\n", 370 imx_header[index].fhdr.header.version); 371 fprintf(stdout, "entry: \t\t\t0x%x\n", 372 imx_header[index].fhdr.entry); 373 fprintf(stdout, "reserved1: \t\t0x%x\n", 374 imx_header[index].fhdr.reserved1); 375 fprintf(stdout, "dcd_ptr: \t\t0x%x\n", 376 imx_header[index].fhdr.dcd_ptr); 377 fprintf(stdout, "boot_data_ptr: \t\t0x%x\n", 378 imx_header[index].fhdr.boot_data_ptr); 379 fprintf(stdout, "self: \t\t\t0x%x\n", 380 imx_header[index].fhdr.self); 381 fprintf(stdout, "csf: \t\t\t0x%x\n", 382 imx_header[index].fhdr.csf); 383 fprintf(stdout, "reserved2: \t\t0x%x\n", 384 imx_header[index].fhdr.reserved2); 385 386 fprintf(stdout, "boot_data.start: \t0x%x\n", 387 imx_header[index].boot_data.start); 388 fprintf(stdout, "boot_data.size: \t0x%x\n", 389 imx_header[index].boot_data.size); 390 fprintf(stdout, "boot_data.plugin: \t0x%x\n", 391 imx_header[index].boot_data.plugin); 392 } 393 394 void build_image(int ofd) 395 { 396 int file_off, header_hdmi_off = 0, header_image_off; 397 int hdmi_fd, ap_fd, sld_fd; 398 uint32_t sld_load_addr = 0; 399 uint32_t csf_off, sld_csf_off = 0; 400 int ret; 401 struct stat sbuf; 402 403 if (!ap_img) { 404 fprintf(stderr, "No LOADER image specificed\n"); 405 exit(EXIT_FAILURE); 406 } 407 408 file_off = 0; 409 410 if (signed_hdmi) { 411 header_hdmi_off = file_off + ivt_offset; 412 413 hdmi_fd = open(signed_hdmi, O_RDONLY | O_BINARY); 414 if (hdmi_fd < 0) { 415 fprintf(stderr, "%s: Can't open: %s\n", 416 signed_hdmi, strerror(errno)); 417 exit(EXIT_FAILURE); 418 } 419 420 if (fstat(hdmi_fd, &sbuf) < 0) { 421 fprintf(stderr, "%s: Can't stat: %s\n", 422 signed_hdmi, strerror(errno)); 423 exit(EXIT_FAILURE); 424 } 425 close(hdmi_fd); 426 427 /* 428 * Aligned to 104KB = 92KB FW image + 0x8000 429 * (IVT and alignment) + 0x4000 (second IVT + CSF) 430 */ 431 file_off += ALIGN(sbuf.st_size, 432 HDMI_FW_SIZE + 0x2000 + 0x1000); 433 } 434 435 header_image_off = file_off + ivt_offset; 436 437 ap_fd = open(ap_img, O_RDONLY | O_BINARY); 438 if (ap_fd < 0) { 439 fprintf(stderr, "%s: Can't open: %s\n", 440 ap_img, strerror(errno)); 441 exit(EXIT_FAILURE); 442 } 443 if (fstat(ap_fd, &sbuf) < 0) { 444 fprintf(stderr, "%s: Can't stat: %s\n", 445 ap_img, strerror(errno)); 446 exit(EXIT_FAILURE); 447 } 448 close(ap_fd); 449 450 imx_header[IMAGE_IVT_ID].fhdr.header.tag = IVT_HEADER_TAG; /* 0xD1 */ 451 imx_header[IMAGE_IVT_ID].fhdr.header.length = 452 cpu_to_be16(sizeof(flash_header_v2_t)); 453 imx_header[IMAGE_IVT_ID].fhdr.header.version = IVT_VERSION_V3; /* 0x41 */ 454 imx_header[IMAGE_IVT_ID].fhdr.entry = ap_start_addr; 455 imx_header[IMAGE_IVT_ID].fhdr.self = ap_start_addr - 456 sizeof(imx_header_v3_t); 457 imx_header[IMAGE_IVT_ID].fhdr.dcd_ptr = 0; 458 imx_header[IMAGE_IVT_ID].fhdr.boot_data_ptr = 459 imx_header[IMAGE_IVT_ID].fhdr.self + 460 offsetof(imx_header_v3_t, boot_data); 461 imx_header[IMAGE_IVT_ID].boot_data.start = 462 imx_header[IMAGE_IVT_ID].fhdr.self - ivt_offset; 463 imx_header[IMAGE_IVT_ID].boot_data.size = 464 ALIGN(sbuf.st_size + sizeof(imx_header_v3_t) + ivt_offset, 465 sector_size); 466 467 image_off = header_image_off + sizeof(imx_header_v3_t); 468 file_off += imx_header[IMAGE_IVT_ID].boot_data.size; 469 470 imx_header[IMAGE_IVT_ID].boot_data.plugin = 0; 471 imx_header[IMAGE_IVT_ID].fhdr.csf = 472 imx_header[IMAGE_IVT_ID].boot_data.start + 473 imx_header[IMAGE_IVT_ID].boot_data.size; 474 475 imx_header[IMAGE_IVT_ID].boot_data.size += CSF_SIZE; /* 8K region dummy CSF */ 476 477 csf_off = file_off; 478 file_off += CSF_SIZE; 479 480 /* Second boot loader image */ 481 if (sld_img) { 482 if (!using_fit) { 483 fprintf(stderr, "Not support no fit\n"); 484 exit(EXIT_FAILURE); 485 } else { 486 sld_header_off = sld_src_off - rom_image_offset; 487 /* 488 * Record the second bootloader relative offset in 489 * image's IVT reserved1 490 */ 491 imx_header[IMAGE_IVT_ID].fhdr.reserved1 = 492 sld_header_off - header_image_off; 493 sld_fd = open(sld_img, O_RDONLY | O_BINARY); 494 if (sld_fd < 0) { 495 fprintf(stderr, "%s: Can't open: %s\n", 496 sld_img, strerror(errno)); 497 exit(EXIT_FAILURE); 498 } 499 500 if (fstat(sld_fd, &sbuf) < 0) { 501 fprintf(stderr, "%s: Can't stat: %s\n", 502 sld_img, strerror(errno)); 503 exit(EXIT_FAILURE); 504 } 505 506 close(sld_fd); 507 508 file_off = sld_header_off; 509 file_off += sbuf.st_size + sizeof(image_header_t); 510 } 511 } 512 513 if (signed_hdmi) { 514 header_hdmi_off -= ivt_offset; 515 ret = lseek(ofd, header_hdmi_off, SEEK_SET); 516 if (ret < 0) { 517 fprintf(stderr, "lseek ofd fail for hdmi\n"); 518 exit(EXIT_FAILURE); 519 } 520 521 /* The signed HDMI FW has 0x400 IVT offset, need remove it */ 522 copy_file(ofd, signed_hdmi, 0, header_hdmi_off, 0x400); 523 } 524 525 /* Main Image */ 526 header_image_off -= ivt_offset; 527 image_off -= ivt_offset; 528 ret = lseek(ofd, header_image_off, SEEK_SET); 529 if (ret < 0) { 530 fprintf(stderr, "lseek ofd fail\n"); 531 exit(EXIT_FAILURE); 532 } 533 534 /* Write image header */ 535 if (write(ofd, &imx_header[IMAGE_IVT_ID], sizeof(imx_header_v3_t)) != 536 sizeof(imx_header_v3_t)) { 537 fprintf(stderr, "error writing image hdr\n"); 538 exit(1); 539 } 540 541 copy_file(ofd, ap_img, 0, image_off, 0); 542 543 csf_off -= ivt_offset; 544 fill_zero(ofd, CSF_SIZE, csf_off); 545 546 if (sld_img) { 547 sld_header_off -= ivt_offset; 548 ret = lseek(ofd, sld_header_off, SEEK_SET); 549 if (ret < 0) { 550 fprintf(stderr, "lseek ofd fail for sld_img\n"); 551 exit(EXIT_FAILURE); 552 } 553 554 /* Write image header */ 555 if (!using_fit) { 556 /* TODO */ 557 } else { 558 copy_file(ofd, sld_img, 0, sld_header_off, 0); 559 sld_csf_off = 560 generate_ivt_for_fit(ofd, sld_header_off, 561 sld_start_addr, 562 &sld_load_addr) + 0x20; 563 } 564 } 565 566 if (!signed_hdmi) 567 dump_header_v2(imx_header, 0); 568 dump_header_v2(imx_header, 1); 569 570 fprintf(stdout, "========= OFFSET dump ========="); 571 if (signed_hdmi) { 572 fprintf(stdout, "\nSIGNED HDMI FW:\n"); 573 fprintf(stdout, " header_hdmi_off \t0x%x\n", 574 header_hdmi_off); 575 } 576 577 fprintf(stdout, "\nLoader IMAGE:\n"); 578 fprintf(stdout, " header_image_off \t0x%x\n image_off \t\t0x%x\n csf_off \t\t0x%x\n", 579 header_image_off, image_off, csf_off); 580 fprintf(stdout, " spl hab block: \t0x%x 0x%x 0x%x\n", 581 imx_header[IMAGE_IVT_ID].fhdr.self, header_image_off, 582 csf_off - header_image_off); 583 584 fprintf(stdout, "\nSecond Loader IMAGE:\n"); 585 fprintf(stdout, " sld_header_off \t0x%x\n", 586 sld_header_off); 587 fprintf(stdout, " sld_csf_off \t\t0x%x\n", 588 sld_csf_off); 589 fprintf(stdout, " sld hab block: \t0x%x 0x%x 0x%x\n", 590 sld_load_addr, sld_header_off, sld_csf_off - sld_header_off); 591 } 592 593 int imx8mimage_copy_image(int outfd, struct image_tool_params *mparams) 594 { 595 /* 596 * SECO FW is a container image, this is to calculate the 597 * 2nd container offset. 598 */ 599 fprintf(stdout, "parsing %s\n", mparams->imagename); 600 parse_cfg_file(mparams->imagename); 601 602 build_image(outfd); 603 604 return 0; 605 } 606 607 /* 608 * imx8mimage parameters 609 */ 610 U_BOOT_IMAGE_TYPE( 611 imx8mimage, 612 "NXP i.MX8M Boot Image support", 613 0, 614 NULL, 615 imx8mimage_check_params, 616 NULL, 617 imx8mimage_print_header, 618 imx8mimage_set_header, 619 NULL, 620 imx8mimage_check_image_types, 621 NULL, 622 NULL 623 ); 624