tools/imx8image.c

   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 );