tools/imx8mimage.c

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