This adds a tool for building images for the NXP i.MX9 SoC. The code
is based on:
https://github.com/nxp-imx/imx-mkimage/tree/5a0faefc223e51e088433663b6e7d6fbce89bf59
Signed-off-by: Sascha Hauer <s.ha...@pengutronix.de>
---
include/soc/imx9/flash_header.h | 88 ++
scripts/Kconfig | 7 +
scripts/Makefile | 1 +
scripts/imx9image.c | 2171 +++++++++++++++++++++++++++++++
4 files changed, 2267 insertions(+)
create mode 100644 include/soc/imx9/flash_header.h
create mode 100644 scripts/imx9image.c
diff --git a/include/soc/imx9/flash_header.h b/include/soc/imx9/flash_header.h
new file mode 100644
index 0000000000..51819929dd
--- /dev/null
+++ b/include/soc/imx9/flash_header.h
@@ -0,0 +1,88 @@
+#ifndef SOC_IMX_FLASH_HEADER_H
+#define SOC_IMX_FLASH_HEADER_H
+
+#define HASH_MAX_LEN 64
+#define IV_MAX_LEN 32
+#define MAX_NUM_IMGS 8
+#define MAX_NUM_OF_CONTAINER 3
+#define MAX_HW_CFG_SIZE_V2 359
+
+struct img_flags {
+ char type;
+ char core_id;
+ char hash_type;
+ bool encrypted;
+ uint16_t boot_flags;
+};
+
+struct sig_blk_hdr {
+ uint8_t version;
+ uint16_t length;
+ uint8_t tag;
+ uint16_t srk_table_offset;
+ uint16_t cert_offset;
+ uint16_t blob_offset;
+ uint16_t signature_offset;
+ uint32_t reserved;
+} __attribute__((packed));
+
+struct boot_img {
+ uint32_t offset;
+ uint32_t size;
+ uint64_t dst;
+ uint64_t entry;
+ uint32_t hab_flags;
+ uint32_t meta;
+ uint8_t hash[HASH_MAX_LEN];
+ uint8_t iv[IV_MAX_LEN];
+} __attribute__((packed));
+
+struct flash_header_v3 {
+ uint8_t version;
+ uint16_t length;
+ uint8_t tag;
+ uint32_t flags;
+ uint16_t sw_version;
+ uint8_t fuse_version;
+ uint8_t num_images;
+ uint16_t sig_blk_offset;
+ uint16_t reserved;
+ struct boot_img img[MAX_NUM_IMGS];
+ struct sig_blk_hdr sig_blk_hdr;
+ uint32_t sigblk_size;
+ uint32_t padding;
+} __attribute__((packed));
+
+struct ivt_header {
+ uint8_t tag;
+ uint16_t length;
+ uint8_t version;
+} __attribute__((packed));
+
+struct write_dcd_command {
+ uint8_t tag;
+ uint16_t length;
+ uint8_t param;
+} __attribute__((packed));
+
+struct dcd_addr_data {
+ uint32_t addr;
+ uint32_t value;
+};
+
+struct dcd_v2_cmd {
+ struct write_dcd_command write_dcd_command; /*4*/
+ struct dcd_addr_data addr_data[MAX_HW_CFG_SIZE_V2]; /*2872*/
+} __attribute__((packed));
+
+struct dcd_v2 {
+ struct ivt_header header; /*4*/
+ struct dcd_v2_cmd dcd_cmd; /*2876*/
+} __attribute__((packed)) ; /*2880*/
+
+struct imx_header_v3 {
+ struct flash_header_v3 fhdr[MAX_NUM_OF_CONTAINER];
+ struct dcd_v2 dcd_table;
+} __attribute__((packed));
+
+#endif /* SOC_IMX_FLASH_HEADER_H */
diff --git a/scripts/Kconfig b/scripts/Kconfig
index 9be04fa7c8..4b675671ee 100644
--- a/scripts/Kconfig
+++ b/scripts/Kconfig
@@ -28,6 +28,13 @@ config ZYNQ_MKIMAGE
help
This enables building the image creation tool for Zynq
+config IMX9_IMAGE
+ bool "imx9image"
+ depends on ARCH_IMX93 || COMPILE_HOST_TOOLS
+ default y if ARCH_IMX93
+ help
+ This enables building the image tool for NXP i.MX9 SoCs
+
config MXS_HOSTTOOLS
bool "MXS host tools" if COMPILE_HOST_TOOLS
depends on ARCH_MXS || COMPILE_HOST_TOOLS
diff --git a/scripts/Makefile b/scripts/Makefile
index 42ac4e548b..cb1d916439 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -25,6 +25,7 @@ hostprogs-always-$(CONFIG_SOCFPGA_MKIMAGE) +=
socfpga_mkimage
hostprogs-always-$(CONFIG_MXS_HOSTTOOLS) += mxsimage mxsboot
hostprogs-always-$(CONFIG_LAYERSCAPE_PBLIMAGE) += pblimage
hostprogs-always-$(CONFIG_STM32_IMAGE) += stm32image
+hostprogs-always-$(CONFIG_IMX9_IMAGE) += imx9image
hostprogs-always-$(CONFIG_RISCV) += prelink-riscv
hostprogs-always-$(CONFIG_RK_IMAGE) += rkimage
HOSTCFLAGS_rkimage.o = `$(PKG_CONFIG) --cflags openssl`
diff --git a/scripts/imx9image.c b/scripts/imx9image.c
new file mode 100644
index 0000000000..a991ba5f35
--- /dev/null
+++ b/scripts/imx9image.c
@@ -0,0 +1,2171 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ * derived from u-boot's mkimage utility
+ *
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <sys/stat.h>
+#include <getopt.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include <linux/kernel.h>
+
+#include "../include/soc/imx9/flash_header.h"
+#include "compiler.h"
+
+typedef enum option_type {
+ NO_IMG = 0,
+ DCD,
+ SCFW,
+ SECO,
+ M4,
+ AP,
+ OUTPUT,
+ SCD,
+ CSF,
+ FLAG,
+ DEVICE,
+ NEW_CONTAINER,
+ APPEND,
+ DATA,
+ PARTITION,
+ FILEOFF,
+ MSG_BLOCK,
+ DUMMY_V2X,
+ SENTINEL,
+ UPOWER,
+ FCB
+} option_type_t;
+
+typedef struct {
+ option_type_t option;
+ char* filename;
+ uint64_t src;
+ uint64_t dst;
+ uint64_t entry;/* image entry address or general purpose num */
+ uint64_t ext;
+ uint64_t mu;
+ uint64_t part;
+} image_t;
+
+typedef enum REVISION_TYPE {
+ NO_REV = 0,
+ A0,
+ B0
+} rev_type_t;
+
+typedef enum SOC_TYPE {
+ NONE = 0,
+ QX,
+ QM,
+ DXL,
+ ULP,
+ IMX9,
+} soc_type_t;
+
+#define CORE_SC 0x1
+#define CORE_CM4_0 0x2
+#define CORE_CM4_1 0x3
+#define CORE_CA53 0x4
+#define CORE_CA35 0x4
+#define CORE_CA72 0x5
+#define CORE_SECO 0x6
+#define CORE_V2X_P 0x9
+#define CORE_V2X_S 0xA
+
+#define CORE_ULP_CM33 0x1
+#define CORE_ULP_CA35 0x2
+#define CORE_ULP_UPOWER 0x4
+#define CORE_ULP_SENTINEL 0x6
+
+#define SC_R_OTP 357U
+#define SC_R_DEBUG 354U
+#define SC_R_ROM_0 236U
+#define SC_R_PWM_0 191U
+#define SC_R_SNVS 356U
+#define SC_R_DC_0 32U
+
+#define IMG_TYPE_CSF 0x01 /* CSF image type */
+#define IMG_TYPE_SCD 0x02 /* SCD image type */
+#define IMG_TYPE_EXEC 0x03 /* Executable image type */
+#define IMG_TYPE_DATA 0x04 /* Data image type */
+#define IMG_TYPE_DCD_DDR 0x05 /* DCD/DDR image type */
+#define IMG_TYPE_SECO 0x06 /* SECO image type */
+#define IMG_TYPE_SENTINEL 0x06 /* SENTINEL image type */
+#define IMG_TYPE_PROV 0x07 /* Provisioning image type */
+#define IMG_TYPE_DEK 0x08 /* DEK validation type */
+#define IMG_TYPE_FCB_CHK 0x08 /* The FCB copy image */
+#define IMG_TYPE_PRIM_V2X 0x0B /* Primary V2X FW image */
+#define IMG_TYPE_SEC_V2X 0x0C /* Secondary V2X FW image*/
+#define IMG_TYPE_V2X_ROM 0x0D /* V2X ROM Patch image */
+#define IMG_TYPE_V2X_DUMMY 0x0E /* V2X Dummy image */
+
+#define IMG_TYPE_SHIFT 0
+#define IMG_TYPE_MASK 0x1f
+#define IMG_TYPE(x) (((x) & IMG_TYPE_MASK) >> IMG_TYPE_SHIFT)
+
+#define BOOT_IMG_FLAGS_CORE_MASK 0xF
+#define BOOT_IMG_FLAGS_CORE_SHIFT 0x04
+#define BOOT_IMG_FLAGS_CPU_RID_MASK 0x3FF0
+#define BOOT_IMG_FLAGS_CPU_RID_SHIFT 4
+#define BOOT_IMG_FLAGS_MU_RID_MASK 0xFFC000
+#define BOOT_IMG_FLAGS_MU_RID_SHIFT 14
+#define BOOT_IMG_FLAGS_PARTITION_ID_MASK 0x1F000000
+#define BOOT_IMG_FLAGS_PARTITION_ID_SHIFT 24
+
+#define SC_R_A35_0 508
+#define SC_R_A53_0 1
+#define SC_R_A72_0 6
+#define SC_R_MU_0A 213
+#define SC_R_MU_3A 216
+#define SC_R_M4_0_PID0 278
+#define SC_R_M4_0_MU_1A 297
+#define SC_R_M4_1_PID0 298
+#define SC_R_M4_1_MU_1A 317
+#define PARTITION_ID_M4 0
+#define PARTITION_ID_AP 1
+#define PARTITION_ID_AP2 3
+
+/* Command tags and parameters */
+#define HAB_DATA_WIDTH_BYTE 1 /* 8-bit value */
+#define HAB_DATA_WIDTH_HALF 2 /* 16-bit value */
+#define HAB_DATA_WIDTH_WORD 4 /* 32-bit value */
+#define HAB_CMD_WRT_DAT_MSK 1 /* mask/value flag */
+#define HAB_CMD_WRT_DAT_SET 2 /* set/clear flag */
+#define HAB_CMD_CHK_DAT_SET 2 /* set/clear flag */
+#define HAB_CMD_CHK_DAT_ANY 4 /* any/all flag */
+#define HAB_CMD_WRT_DAT_FLAGS_WIDTH 5 /* flags field width */
+#define HAB_CMD_WRT_DAT_FLAGS_SHIFT 3 /* flags field offset */
+#define HAB_CMD_WRT_DAT_BYTES_WIDTH 3 /* bytes field width */
+#define HAB_CMD_WRT_DAT_BYTES_SHIFT 0 /* bytes field offset */
+
+#define IVT_VER 0x01
+#define IVT_VERSION 0x43
+#define DCD_HEADER_TAG 0xD2
+#define DCD_VERSION 0x43
+#define DCD_WRITE_DATA_COMMAND_TAG 0xCC
+#define DCD_WRITE_DATA_PARAM (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT) /* 0x4 */
+#define DCD_WRITE_CLR_BIT_PARAM ((HAB_CMD_WRT_DAT_MSK <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT)) /* 0xC */
+#define DCD_WRITE_SET_BIT_PARAM ((HAB_CMD_WRT_DAT_MSK <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_CMD_WRT_DAT_SET <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT)) /* 0x1C */
+#define DCD_CHECK_DATA_COMMAND_TAG 0xCF
+#define DCD_CHECK_BITS_CLR_PARAM (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT) /* 0x04 */
+#define DCD_CHECK_BITS_SET_PARAM ((HAB_CMD_CHK_DAT_SET <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT)) /* 0x14 */
+#define DCD_CHECK_ANY_BIT_CLR_PARAM ((HAB_CMD_CHK_DAT_ANY <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT)) /* 0x24 */
+#define DCD_CHECK_ANY_BIT_SET_PARAM ((HAB_CMD_CHK_DAT_ANY <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_CMD_CHK_DAT_SET <<
HAB_CMD_WRT_DAT_FLAGS_SHIFT) | (HAB_DATA_WIDTH_WORD <<
HAB_CMD_WRT_DAT_BYTES_SHIFT)) /* 0x34 */
+
+#define IVT_OFFSET_NAND (0x400)
+#define IVT_OFFSET_I2C (0x400)
+#define IVT_OFFSET_FLEXSPI (0x1000)
+#define IVT_OFFSET_SD (0x400)
+#define IVT_OFFSET_SATA (0x400)
+#define IVT_OFFSET_EMMC (0x400)
+
+#define CSF_DATA_SIZE (0x4000)
+#define INITIAL_LOAD_ADDR_SCU_ROM 0x2000e000
+#define INITIAL_LOAD_ADDR_AP_ROM 0x00110000
+#define INITIAL_LOAD_ADDR_FLEXSPI 0x08000000
+#define IMG_AUTO_ALIGN 0x10
+
+#define UNDEFINED 0xFFFFFFFF
+
+#define OCRAM_START 0x00100000
+#define OCRAM_END 0x00400000
+
+#define MAX_NUM_SRK_RECORDS 4
+
+#define IVT_HEADER_TAG_B0 0x87
+#define IVT_VERSION_B0 0x00
+
+#define IMG_FLAG_HASH_SHA256 0x000
+#define IMG_FLAG_HASH_SHA384 0x100
+#define IMG_FLAG_HASH_SHA512 0x200
+#define IMG_FLAG_HASH_SM3 0x300
+
+#define IMG_FLAG_ENCRYPTED_MASK 0x400
+#define IMG_FLAG_ENCRYPTED_SHIFT 0x0A
+
+#define IMG_FLAG_BOOTFLAGS_MASK 0xFFFF0000
+#define IMG_FLAG_BOOTFLAGS_SHIFT 0x10
+
+#define IMG_ARRAY_ENTRY_SIZE 128
+#define HEADER_IMG_ARRAY_OFFSET 0x10
+
+#define HASH_STR_SHA_256 "sha256"
+#define HASH_STR_SHA_384 "sha384"
+#define HASH_STR_SHA_512 "sha512"
+#define HASH_STR_SM3 "sm3"
+
+#define HASH_TYPE_SHA_256 256
+#define HASH_TYPE_SHA_384 384
+#define HASH_TYPE_SHA_512 512
+#define HASH_TYPE_SM3 003
+
+#define IMAGE_HASH_ALGO_DEFAULT HASH_TYPE_SHA_384
+#define IMAGE_HASH_ALGO_DEFAULT_NAME HASH_STR_SHA_384
+#define IMAGE_PADDING_DEFAULT 0x1000
+
+#define DCD_ENTRY_ADDR_IN_SCFW 0x240
+
+#define CONTAINER_ALIGNMENT 0x400
+#define CONTAINER_FLAGS_DEFAULT 0x10
+#define CONTAINER_FUSE_DEFAULT 0x0
+
+#define SIGNATURE_BLOCK_HEADER_LENGTH 0x10
+
+#define BOOT_IMG_META_MU_RID_SHIFT 10
+#define BOOT_IMG_META_PART_ID_SHIFT 20
+
+#define IMAGE_TYPE_MASK 0xF
+
+#define CORE_ID_SHIFT 0x4
+#define CORE_ID_MASK 0xF
+
+#define HASH_TYPE_SHIFT 0x8
+#define HASH_TYPE_MASK 0x7
+
+#define IMAGE_ENCRYPTED_SHIFT 0x11
+#define IMAGE_ENCRYPTED_MASK 0x1
+
+#define IMAGE_A35_DEFAULT_META(PART, SC_R_MU)
\
+ (((PART == 0 ) ? PARTITION_ID_AP : PART) << BOOT_IMG_META_PART_ID_SHIFT
| \
+ SC_R_MU << BOOT_IMG_META_MU_RID_SHIFT | SC_R_A35_0)
+
+#define IMAGE_A53_DEFAULT_META(PART, SC_R_MU)
\
+ (((PART == 0 ) ? PARTITION_ID_AP : PART) << BOOT_IMG_META_PART_ID_SHIFT
| \
+ SC_R_MU << BOOT_IMG_META_MU_RID_SHIFT |
\
+ SC_R_A53_0)
+
+#define IMAGE_A72_DEFAULT_META(PART, SC_R_MU)
\
+ (((PART == 0 ) ? PARTITION_ID_AP2 : PART) <<
BOOT_IMG_META_PART_ID_SHIFT | \
+ SC_R_MU << BOOT_IMG_META_MU_RID_SHIFT | SC_R_A72_0)
+
+#define IMAGE_M4_0_DEFAULT_META(PART)
\
+ (((PART == 0) ? PARTITION_ID_M4 : PART) << BOOT_IMG_META_PART_ID_SHIFT
| \
+ SC_R_M4_0_MU_1A << BOOT_IMG_META_MU_RID_SHIFT | SC_R_M4_0_PID0)
+
+#define IMAGE_M4_1_DEFAULT_META(PART)
\
+ (((PART == 0) ? PARTITION_ID_M4 : PART) << BOOT_IMG_META_PART_ID_SHIFT
| \
+ SC_R_M4_1_MU_1A << BOOT_IMG_META_MU_RID_SHIFT | SC_R_M4_1_PID0)
+
+#define CONTAINER_IMAGE_ARRAY_START_OFFSET 0x2000
+
+uint32_t scfw_flags = 0;
+
+static uint32_t custom_partition = 0;
+
+static void copy_file_aligned(int ifd, const char *datafile, int offset, int
align)
+{
+ int dfd;
+ struct stat sbuf;
+ unsigned char *ptr;
+ uint8_t zeros[0x4000];
+ int size;
+ int ret;
+
+ if (align > 0x4000) {
+ fprintf (stderr, "Wrong alignment requested %d\n",
+ align);
+ exit (EXIT_FAILURE);
+ }
+
+ memset(zeros, 0, sizeof(zeros));
+
+ if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
+ fprintf (stderr, "Can't open %s: %s\n",
+ datafile, strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ if (fstat(dfd, &sbuf) < 0) {
+ fprintf (stderr, "Can't stat %s: %s\n",
+ datafile, strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ if (sbuf.st_size == 0)
+ goto close;
+
+ ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
+ if (ptr == MAP_FAILED) {
+ fprintf (stderr, "Can't read %s: %s\n",
+ datafile, strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ size = sbuf.st_size;
+ ret = lseek(ifd, offset, SEEK_SET);
+ if (ret < 0) {
+ fprintf(stderr, "%s: lseek error %s\n",
+ __func__, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ if (write(ifd, ptr, size) != size) {
+ fprintf (stderr, "Write error %s\n",
+ strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ align = ALIGN(size, align) - size;
+
+ if (write(ifd, (char *)&zeros, align) != align) {
+ fprintf(stderr, "Write error: %s\n",
+ strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ (void) munmap((void *)ptr, sbuf.st_size);
+close:
+ (void) close (dfd);
+
+}
+
+static void set_imx_hdr_v3(struct imx_header_v3 *imxhdr, uint32_t dcd_len,
+ uint32_t flash_offset, uint32_t hdr_base, uint32_t cont_id)
+{
+ struct flash_header_v3 *fhdr_v3 = &imxhdr->fhdr[cont_id];
+
+ /* Set magic number */
+ fhdr_v3->tag = IVT_HEADER_TAG_B0;
+ fhdr_v3->version = IVT_VERSION_B0;
+}
+
+static void set_image_hash(struct boot_img *img, char *filename, uint32_t
hash_type)
+{
+ FILE *fp = NULL;
+ char sha_command[512];
+ char digest_type[10];
+ char hash[2 * HASH_MAX_LEN + 1];
+ int digest_length = 0;
+ int i;
+
+ switch (hash_type) {
+ case HASH_TYPE_SHA_256:
+ img->hab_flags |= IMG_FLAG_HASH_SHA256;
+ strcpy(digest_type, "sha256sum" );
+ digest_length = 64;
+ break;
+ case HASH_TYPE_SHA_384:
+ img->hab_flags |= IMG_FLAG_HASH_SHA384;
+ strcpy(digest_type, "sha384sum" );
+ digest_length = 96;
+ break;
+ case HASH_TYPE_SHA_512:
+ img->hab_flags |= IMG_FLAG_HASH_SHA512;
+ strcpy(digest_type, "sha512sum" );
+ digest_length = 128;
+ break;
+ case HASH_TYPE_SM3:
+ img->hab_flags |= IMG_FLAG_HASH_SM3;
+ strcpy(digest_type, "sm3sum" );
+ digest_length = 64;
+ break;
+ default:
+ fprintf(stderr, "Wrong hash type selected (%d) !!!\n\n",
+ hash_type);
+ exit(EXIT_FAILURE);
+ break;
+ }
+
+ if (img->size == 0 || !filename)
+ sprintf(sha_command, "%s /dev/null", digest_type);
+ else
+ sprintf(sha_command, "dd status=none if=/dev/zero of=tmp_pad
bs=%d count=1;\
+ dd status=none if=\'%s\' of=tmp_pad
conv=notrunc;\
+ %s tmp_pad; rm -f tmp_pad",
+ img->size, filename, digest_type);
+
+ memset(img->hash, 0, HASH_MAX_LEN);
+
+ fp = popen(sha_command, "r");
+ if (fp == NULL) {
+ fprintf(stderr, "Failed to run command hash\n" );
+ exit(EXIT_FAILURE);
+ }
+
+ if (fgets(hash, digest_length + 1, fp) == NULL) {
+ fprintf(stderr, "Failed to hash file: %s\n", filename ?
filename : "<none>");
+ exit(EXIT_FAILURE);
+ }
+
+ for (i = 0; i < strlen(hash)/2; i++)
+ sscanf(hash + 2*i, "%02hhx", &img->hash[i]);
+
+ pclose(fp);
+}
+
+#define append(p, s, l) do {memcpy(p, (uint8_t *)s, l); p += l; } while (0)
+
+static uint8_t *flatten_container_header(struct imx_header_v3 *imx_header,
+ uint8_t containers_count,
+ uint32_t *size_out, uint32_t
file_offset)
+{
+ uint8_t *flat = NULL;
+ uint8_t *ptr = NULL;
+ uint16_t size = 0;
+ int i;
+
+ /* Compute size of all container headers */
+ for (i = 0; i < containers_count; i++) {
+
+ struct flash_header_v3 *container = &imx_header->fhdr[i];
+
+ container->sig_blk_offset = HEADER_IMG_ARRAY_OFFSET +
+ container->num_images * IMG_ARRAY_ENTRY_SIZE;
+
+ container->length = HEADER_IMG_ARRAY_OFFSET +
+ (IMG_ARRAY_ENTRY_SIZE * container->num_images) +
sizeof(struct sig_blk_hdr);
+
+ /* Print info needed by CST to sign the container header */
+ printf("CST: CONTAINER %d offset: 0x%x\n", i, file_offset +
size);
+ printf("CST: CONTAINER %d: Signature Block: offset is at
0x%x\n", i,
+ file_offset + size +
container->length - SIGNATURE_BLOCK_HEADER_LENGTH);
+
+ printf("\tOffsets = \t0x%x \t0x%x\n", file_offset + size,
+ file_offset + size +
container->length - SIGNATURE_BLOCK_HEADER_LENGTH);
+
+ size += ALIGN(container->length, container->padding);
+ }
+
+ flat = calloc(size, sizeof(uint8_t));
+ if (!flat) {
+ fprintf(stderr, "Failed to allocate memory (%d)\n", size);
+ exit(EXIT_FAILURE);
+ }
+
+ ptr = flat;
+ *size_out = size;
+
+ for (i = 0; i < containers_count; i++) {
+ struct flash_header_v3 *container = &imx_header->fhdr[i];
+ uint32_t container_start_offset = ptr - flat;
+ int j;
+
+ /* Append container header */
+ append(ptr, container, HEADER_IMG_ARRAY_OFFSET);
+
+ /* Adjust images offset to start from container headers start */
+ for (j = 0; j < container->num_images; j++)
+ container->img[j].offset -= container_start_offset +
file_offset;
+
+ /* Append each image array entry */
+ for (j = 0; j < container->num_images; j++)
+ append(ptr, &container->img[j], sizeof(struct
boot_img));
+
+ append(ptr, &container->sig_blk_hdr, sizeof(struct
sig_blk_hdr));
+
+ /* Padding for container (if necessary) */
+ ptr += ALIGN(container->length, container->padding) -
container->length;
+ }
+
+ return flat;
+}
+
+static uint64_t read_dcd_offset(char *filename)
+{
+ int dfd;
+ struct stat sbuf;
+ uint8_t *ptr;
+ uint64_t offset = 0;
+
+ dfd = open(filename, O_RDONLY|O_BINARY);
+ if (dfd < 0) {
+ fprintf(stderr, "Can't open %s: %s\n", filename,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ if (fstat(dfd, &sbuf) < 0) {
+ fprintf(stderr, "Can't stat %s: %s\n", filename,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
+ if (ptr == MAP_FAILED) {
+ fprintf(stderr, "Can't read %s: %s\n", filename,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ offset = *(uint32_t *)(ptr + DCD_ENTRY_ADDR_IN_SCFW);
+
+ (void) munmap((void *)ptr, sbuf.st_size);
+ (void) close(dfd);
+
+ return offset;
+}
+
+static uint32_t get_hash_algo(char *images_hash)
+{
+ uint32_t hash_algo;
+ const char *hash_name;
+
+ if (!images_hash) {
+ hash_algo = IMAGE_HASH_ALGO_DEFAULT;
+ hash_name = IMAGE_HASH_ALGO_DEFAULT_NAME;
+ } else if (!strcmp(images_hash, HASH_STR_SHA_256)) {
+ hash_algo = HASH_TYPE_SHA_256;
+ hash_name = HASH_STR_SHA_256;
+ } else if (!strcmp(images_hash, HASH_STR_SHA_384)) {
+ hash_algo = HASH_TYPE_SHA_384;
+ hash_name = HASH_STR_SHA_384;
+ } else if (!strcmp(images_hash, HASH_STR_SHA_512)) {
+ hash_algo = HASH_TYPE_SHA_512;
+ hash_name = HASH_STR_SHA_512;
+ } else if (!strcmp(images_hash, HASH_STR_SM3)) {
+ hash_algo = HASH_TYPE_SM3;
+ hash_name = HASH_STR_SM3;
+ } else {
+ fprintf(stderr,
+ "\nERROR: %s is an invalid hash argument\n"
+ " Expected values: %s, %s, %s, %s\n\n",
+ images_hash, HASH_STR_SHA_256, HASH_STR_SHA_384,
+ HASH_STR_SHA_512, HASH_STR_SM3);
+ exit(EXIT_FAILURE);
+ }
+
+ printf("image hash type:\t%s\n", hash_name);
+ return hash_algo;
+}
+
+static void set_image_array_entry(struct flash_header_v3 *container,
soc_type_t soc,
+ const image_t *image_stack, uint32_t offset,
+ uint32_t size, char *tmp_filename, bool dcd_skip, char
*images_hash)
+{
+ uint64_t entry = image_stack->entry;
+ uint64_t dst = image_stack->dst;
+ uint64_t core = image_stack->ext;
+ uint32_t meta;
+ char *tmp_name = "";
+ option_type_t type = image_stack->option;
+ struct boot_img *img = &container->img[container->num_images];
+
+ if (container->num_images >= MAX_NUM_IMGS) {
+ fprintf(stderr, "Error: Container allows 8 images at most\n");
+ exit(EXIT_FAILURE);
+ }
+
+ img->offset = offset; /* Is re-adjusted later */
+ img->size = size;
+
+ set_image_hash(img, tmp_filename, get_hash_algo(images_hash));
+
+ switch (type) {
+ case SECO:
+ if (container->num_images > 0) {
+ fprintf(stderr, "Error: SECO container only allows 1
image\n");
+ exit(EXIT_FAILURE);
+ }
+
+ img->hab_flags |= IMG_TYPE_SECO;
+ img->hab_flags |= CORE_SECO << BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "SECO";
+ img->dst = 0x20C00000;
+ img->entry = 0x20000000;
+
+ break;
+ case SENTINEL:
+ if (container->num_images > 0) {
+ fprintf(stderr, "Error: SENTINEL container only allows
1 image\n");
+ exit(EXIT_FAILURE);
+ }
+
+ img->hab_flags |= IMG_TYPE_SENTINEL;
+ img->hab_flags |= CORE_ULP_SENTINEL <<
BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "SENTINEL";
+ img->dst = 0XE7FE8000; /* S400 IRAM base */
+ img->entry = 0XE7FE8000;
+
+ break;
+ case AP:
+ if ((soc == QX || soc == DXL) && core == CORE_CA35)
+ meta = IMAGE_A35_DEFAULT_META(image_stack->part,
image_stack->mu);
+ else if (soc == QM && core == CORE_CA53)
+ meta = IMAGE_A53_DEFAULT_META(image_stack->part,
image_stack->mu);
+ else if (soc == QM && core == CORE_CA72)
+ meta = IMAGE_A72_DEFAULT_META(image_stack->part,
image_stack->mu);
+ else if (((soc == ULP) || (soc == IMX9)) && core == CORE_CA35)
+ meta = 0;
+ else {
+ fprintf(stderr, "Error: invalid AP core id: %" PRIi64
"\n", core);
+ exit(EXIT_FAILURE);
+ }
+ img->hab_flags |= IMG_TYPE_EXEC;
+ if ((soc == ULP) || (soc == IMX9))
+ img->hab_flags |= CORE_ULP_CA35 <<
BOOT_IMG_FLAGS_CORE_SHIFT;
+ else
+ img->hab_flags |= CORE_CA53 <<
BOOT_IMG_FLAGS_CORE_SHIFT; /* On B0, only core id = 4 is valid */
+ tmp_name = "AP";
+ img->dst = entry;
+ img->entry = entry;
+ img->meta = meta;
+ custom_partition = 0;
+ break;
+ case M4:
+ if ((soc == ULP) || (soc == IMX9)) {
+ core = CORE_ULP_CM33;
+ meta = 0;
+ } else if (core == 0) {
+ core = CORE_CM4_0;
+ meta = IMAGE_M4_0_DEFAULT_META(custom_partition);
+ } else if (core == 1) {
+ core = CORE_CM4_1;
+ meta = IMAGE_M4_1_DEFAULT_META(custom_partition);
+ } else {
+ fprintf(stderr, "Error: invalid m4 core id: %" PRIi64
"\n", core);
+ exit(EXIT_FAILURE);
+ }
+
+ img->hab_flags |= IMG_TYPE_EXEC;
+ img->hab_flags |= core << BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "M4";
+ if ((entry & 0x7) != 0)
+ fprintf(stderr, "\n\nWarning: M4 Destination address is
not 8 byte aligned\n\n");
+
+ if (dst)
+ img->dst = dst;
+ else
+ img->dst = entry;
+
+ img->entry = entry;
+ img->meta = meta;
+ custom_partition = 0;
+ break;
+ case DATA:
+ img->hab_flags |= IMG_TYPE_DATA;
+ if ((soc == ULP) || (soc == IMX9))
+ if (core == CORE_CM4_0)
+ img->hab_flags |= CORE_ULP_CM33 <<
BOOT_IMG_FLAGS_CORE_SHIFT;
+ else
+ img->hab_flags |= CORE_ULP_CA35 <<
BOOT_IMG_FLAGS_CORE_SHIFT;
+ else
+ img->hab_flags |= core << BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "DATA";
+ img->dst = entry;
+ break;
+ case MSG_BLOCK:
+ img->hab_flags |= IMG_TYPE_DATA;
+ img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT;
+ img->meta = core << BOOT_IMG_META_MU_RID_SHIFT;
+ tmp_name = "MSG_BLOCK";
+ img->dst = entry;
+ break;
+ case SCFW:
+ img->hab_flags |= scfw_flags & 0xFFFF0000;
+ img->hab_flags |= IMG_TYPE_EXEC;
+ img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "SCFW";
+ img->dst = 0x1FFE0000;
+ img->entry = 0x1FFE0000;
+
+ /* Lets add the DCD now */
+ if (!dcd_skip) {
+ container->num_images++;
+ img = &container->img[container->num_images];
+ img->hab_flags |= IMG_TYPE_DCD_DDR;
+ img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
+ set_image_hash(img, "/dev/null",
IMAGE_HASH_ALGO_DEFAULT);
+ img->offset = offset + img->size;
+ img->entry = read_dcd_offset(tmp_filename);
+ img->dst = img->entry - 1;
+ }
+ break;
+ case UPOWER:
+ if (soc == ULP) {
+ img->hab_flags |= IMG_TYPE_EXEC;
+ img->hab_flags |= CORE_ULP_UPOWER <<
BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "UPOWER";
+ img->dst = 0x28300200; /* UPOWER code RAM */
+ img->entry = 0x28300200;
+ }
+ break;
+ case DUMMY_V2X:
+ img->hab_flags |= IMG_TYPE_V2X_DUMMY;
+ img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
+ tmp_name = "V2X Dummy";
+ img->dst = entry;
+ img->entry = entry;
+ img->size = 0; /* dummy image has no size */
+ break;
+ case FCB:
+ img->hab_flags |= IMG_TYPE_FCB_CHK;
+ img->dst = entry;
+ tmp_name = "FCB";
+ break;
+ default:
+ fprintf(stderr, "unrecognized image type (%d)\n", type);
+ exit(EXIT_FAILURE);
+ }
+
+ printf("%s file_offset = 0x%x size = 0x%x\n", tmp_name, offset, size);
+
+ container->num_images++;
+}
+
+static void set_container(struct flash_header_v3 *container, uint16_t
sw_version,
+ uint32_t alignment, uint32_t flags, uint16_t
fuse_version)
+{
+ container->sig_blk_hdr.tag = 0x90;
+ container->sig_blk_hdr.length = sizeof(struct sig_blk_hdr);
+ container->sw_version = sw_version;
+ container->padding = alignment;
+ container->fuse_version = fuse_version;
+ container->flags = flags;
+ printf("flags:\t\t\t0x%x\n", container->flags);
+}
+
+static int get_container_image_start_pos(image_t *image_stack, uint32_t align,
soc_type_t soc,
+ uint32_t *scu_cont_hdr_off)
+{
+ image_t *img_sp = image_stack;
+ /* 8K total container header */
+ int file_off = CONTAINER_IMAGE_ARRAY_START_OFFSET, ofd = -1;
+ struct flash_header_v3 header;
+
+ while (img_sp->option != NO_IMG) {
+ if (img_sp->option != APPEND) {
+ img_sp++;
+ continue;
+ }
+
+ ofd = open(img_sp->filename, O_RDONLY);
+ if (ofd < 0) {
+ printf("Failure open first container file %s\n",
img_sp->filename);
+ break;
+ }
+
+ if (soc == DXL) {
+ /* Skip SECO container, jump to V2X container */
+ if (lseek(ofd, CONTAINER_ALIGNMENT, SEEK_SET) < 0) {
+ printf("Failure Skip SECO header \n");
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ if (read(ofd, &header, sizeof(header)) != sizeof(header)) {
+ printf("Failure Read header \n");
+ exit(EXIT_FAILURE);
+ }
+
+ close(ofd);
+
+ if (header.tag != IVT_HEADER_TAG_B0) {
+ printf("header tag mismatch %x\n", header.tag);
+ } else if (header.num_images == 0) {
+ printf("image num is 0 \n");
+ } else {
+ file_off = header.img[header.num_images - 1].offset +
header.img[header.num_images - 1].size;
+ if (soc == DXL) {
+ file_off += CONTAINER_ALIGNMENT;
+ *scu_cont_hdr_off = CONTAINER_ALIGNMENT +
ALIGN(header.length, CONTAINER_ALIGNMENT);
+ } else {
+ *scu_cont_hdr_off = ALIGN(header.length,
CONTAINER_ALIGNMENT);
+ }
+ file_off = ALIGN(file_off, align);
+ }
+
+ img_sp++;
+ }
+
+ return file_off;
+}
+
+static void check_file(struct stat *sbuf, char *filename)
+{
+ int tmp_fd = open(filename, O_RDONLY | O_BINARY);
+
+ if (tmp_fd < 0) {
+ fprintf(stderr, "%s: Can't open: %s\n", filename,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ if (fstat(tmp_fd, sbuf) < 0) {
+ fprintf(stderr, "%s: Can't stat: %s\n", filename,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ close(tmp_fd);
+}
+
+static void copy_file(int ifd, const char *datafile, int pad, int offset)
+{
+ int dfd;
+ struct stat sbuf;
+ unsigned char *ptr;
+ int tail;
+ uint8_t zeros[4096];
+ int size, ret;
+
+ memset(zeros, 0, sizeof(zeros));
+
+ if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) {
+ fprintf(stderr, "Can't open %s: %s\n", datafile,
strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ if (fstat(dfd, &sbuf) < 0) {
+ fprintf(stderr, "Can't stat %s: %s\n", datafile,
strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ if (sbuf.st_size == 0)
+ goto close;
+
+ ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
+ if (ptr == MAP_FAILED) {
+ fprintf(stderr, "Can't read %s: %s\n", datafile,
strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ size = sbuf.st_size;
+ ret = lseek(ifd, offset, SEEK_SET);
+ if (ret < 0) {
+ fprintf(stderr, "%s: lseek error %s\n", __func__,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ if (write(ifd, ptr, size) != size) {
+ fprintf(stderr, "Write error %s\n", strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+
+ tail = size % 4;
+ pad = pad - size;
+ if ((pad == 1) && (tail != 0)) {
+
+ if (write(ifd, zeros, 4 - tail) != 4 - tail) {
+ fprintf(stderr, "Write error on %s\n", strerror(errno));
+ exit (EXIT_FAILURE);
+ }
+ } else if (pad > 1) {
+ while (pad > 0) {
+ int todo = sizeof(zeros);
+
+ if (todo > pad)
+ todo = pad;
+ if (write(ifd, (char *)&zeros, todo) != todo) {
+ fprintf(stderr, "Write error: %s\n",
+ strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ pad -= todo;
+ }
+ }
+
+ (void) munmap((void *)ptr, sbuf.st_size);
+close:
+ (void) close (dfd);
+}
+
+static int build_container_qx_qm_b0(soc_type_t soc, uint32_t sector_size,
uint32_t ivt_offset,
+ char *out_file, bool emmc_fastboot, image_t
*image_stack,
+ bool dcd_skip, uint8_t fuse_version,
uint16_t sw_version,
+ char *images_hash)
+{
+ int file_off, ofd = -1;
+ unsigned int dcd_len = 0;
+ struct imx_header_v3 imx_header = {};
+ image_t *img_sp = image_stack;
+ struct stat sbuf;
+ uint32_t size = 0;
+ uint32_t file_padding = 0;
+ int ret;
+ const char *platform;
+
+ int container = -1;
+ int cont_img_count = 0; /* indexes to arrange the container */
+
+ if (image_stack == NULL) {
+ fprintf(stderr, "Empty image stack ");
+ exit(EXIT_FAILURE);
+ }
+
+ switch (soc) {
+ case QX: platform = "i.MX8QXP B0"; break;
+ case QM: platform = "i.MX8QM B0"; break;
+ case DXL: platform = "i.MX8DXL A0"; break;
+ case ULP: platform = "i.MX8ULP A0"; break;
+ case IMX9: platform = "i.MX9"; break;
+ default:
+ exit(EXIT_FAILURE);
+ }
+
+ printf("Platform:\t\t%s\n", platform);
+
+ set_imx_hdr_v3(&imx_header, dcd_len, ivt_offset,
INITIAL_LOAD_ADDR_SCU_ROM, 0);
+ set_imx_hdr_v3(&imx_header, 0, ivt_offset, INITIAL_LOAD_ADDR_AP_ROM, 1);
+
+ printf("ivt_offset:\t\t0x%x\n", ivt_offset);
+
+ file_off = get_container_image_start_pos(image_stack, sector_size, soc,
&file_padding);
+ printf("container image offset (aligned): 0x%x\n", file_off);
+
+ printf("csf_off:\t\t0x%x\n", ivt_offset + file_off);
+
+ /* step through image stack and generate the header */
+ img_sp = image_stack;
+
+ while (img_sp->option != NO_IMG) { /* stop once we reach null
terminator */
+ switch (img_sp->option) {
+ case FCB:
+ case AP:
+ case M4:
+ case SCFW:
+ case DATA:
+ case UPOWER:
+ case MSG_BLOCK:
+ case SENTINEL:
+ if (container < 0) {
+ fprintf(stderr, "No container found\n");
+ exit(EXIT_FAILURE);
+ }
+ check_file(&sbuf, img_sp->filename);
+ set_image_array_entry(&imx_header.fhdr[container],
+ soc,
+ img_sp,
+ file_off,
+ ALIGN(sbuf.st_size,
sector_size),
+ img_sp->filename,
+ dcd_skip,
+ images_hash);
+ img_sp->src = file_off;
+
+ file_off += ALIGN(sbuf.st_size, sector_size);
+ cont_img_count++;
+ break;
+
+ case DUMMY_V2X:
+ if (container < 0) {
+ fprintf(stderr, "No container found\n");
+ exit(EXIT_FAILURE);
+ }
+ set_image_array_entry(&imx_header.fhdr[container],
+ soc,
+ img_sp,
+ file_off,
+ 0,
+ NULL,
+ dcd_skip,
+ images_hash);
+ img_sp->src = file_off;
+
+ cont_img_count++;
+ break;
+
+ case SECO:
+ if (container < 0) {
+ fprintf(stderr, "No container found\n");
+ exit(EXIT_FAILURE);
+ }
+ check_file(&sbuf, img_sp->filename);
+ set_image_array_entry(&imx_header.fhdr[container],
+ soc,
+ img_sp,
+ file_off,
+ sbuf.st_size,
+ img_sp->filename,
+ dcd_skip,
+ "sha384");
+ img_sp->src = file_off;
+
+ file_off += sbuf.st_size;
+ cont_img_count++;
+ break;
+
+ case NEW_CONTAINER:
+ container++;
+ set_container(&imx_header.fhdr[container], sw_version,
+ CONTAINER_ALIGNMENT,
+ CONTAINER_FLAGS_DEFAULT,
+ fuse_version);
+ cont_img_count = 0; /* reset img count when moving to
new container */
+ scfw_flags = 0;
+ break;
+
+ case APPEND:
+ /* nothing to do here, the container is appended in the
output */
+ break;
+ case FLAG:
+ /* override the flags for scfw in current container */
+ scfw_flags = img_sp->entry & 0xFFFF0000;/* mask off
bottom 16 bits */
+ break;
+ case FILEOFF:
+ if (file_off > img_sp->dst) {
+ fprintf(stderr, "FILEOFF address less than
current file offset!!!\n");
+ exit(EXIT_FAILURE);
+ }
+ if (img_sp->dst != ALIGN(img_sp->dst, sector_size)) {
+ fprintf(stderr, "FILEOFF address is not aligned
to sector size!!!\n");
+ exit(EXIT_FAILURE);
+ }
+ file_off = img_sp->dst;
+ break;
+ case PARTITION: /* keep custom partition until next executable
image */
+ custom_partition = img_sp->entry; /* use a global var
for default behaviour */
+ break;
+ default:
+ fprintf(stderr, "unrecognized option in input stack
(%d)\n", img_sp->option);
+ exit(EXIT_FAILURE);
+ }
+ img_sp++;/* advance index */
+ }
+
+ /* Open output file */
+ ofd = open(out_file, O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666);
+ if (ofd < 0) {
+ fprintf(stderr, "%s: Can't open: %s\n",
+ out_file, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ /* Append container (if specified) */
+ img_sp = image_stack;
+ while (img_sp->option != NO_IMG) {
+ if (img_sp->option == APPEND)
+ copy_file(ofd, img_sp->filename, 0, 0);
+
+ img_sp++;
+ }
+
+ /* Add padding or skip appended container */
+ ret = lseek(ofd, file_padding, SEEK_SET);
+ if (ret < 0) {
+ fprintf(stderr, "%s: lseek error %s\n", __func__,
strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ /* Note: Image offset are not contained in the image */
+ uint8_t *tmp = flatten_container_header(&imx_header, container + 1,
&size, file_padding);
+ /* Write image header */
+ if (write(ofd, tmp, size) != size) {
+ fprintf(stderr, "error writing image hdr\n");
+ exit(1);
+ }
+
+ /* Clean-up memory used by the headers */
+ free(tmp);
+
+ if (emmc_fastboot)
+ ivt_offset = 0; /*set ivt offset to 0 if emmc */
+
+ /* step through the image stack again this time copying images to final
bin */
+ img_sp = image_stack;
+ while (img_sp->option != NO_IMG) { /* stop once we reach null
terminator */
+ if (img_sp->option == M4 ||
+ img_sp->option == AP ||
+ img_sp->option == DATA ||
+ img_sp->option == SCD ||
+ img_sp->option == SCFW ||
+ img_sp->option == SECO ||
+ img_sp->option == MSG_BLOCK ||
+ img_sp->option == UPOWER ||
+ img_sp->option == SENTINEL ||
+ img_sp->option == FCB) {
+ copy_file_aligned(ofd, img_sp->filename, img_sp->src,
sector_size);
+ }
+ img_sp++;
+ }
+
+ /* Close output file */
+ close(ofd);
+ return 0;
+}
+
+static struct img_flags parse_image_flags(uint32_t flags, char *flag_list,
soc_type_t soc)
+{
+ struct img_flags img_flags;
+
+ strcpy(flag_list, "(");
+
+ /* first extract the image type */
+ strcat(flag_list, "IMG TYPE: ");
+ img_flags.type = flags & IMAGE_TYPE_MASK;
+
+ switch (img_flags.type) {
+
+ case 0x3:
+ strcat(flag_list, "Executable");
+ break;
+ case 0x4:
+ strcat(flag_list, "Data");
+ break;
+ case 0x5:
+ strcat(flag_list, "DDR Init");
+ break;
+ case 0x6:
+ if ((soc == ULP) || (soc == IMX9))
+ strcat(flag_list, "SENTINEL");
+ else
+ strcat(flag_list, "SECO");
+ break;
+ case 0x7:
+ strcat(flag_list, "Provisioning");
+ break;
+ case 0x8:
+ if (soc == IMX9)
+ strcat(flag_list, "FCB Check");
+ else
+ strcat(flag_list, "DEK validation");
+ break;
+ case 0xB:
+ strcat(flag_list, "Primary V2X FW image");
+ break;
+ case 0xC:
+ strcat(flag_list, "Secondary V2X FW image");
+ break;
+ case 0xD:
+ strcat(flag_list, "V2X ROM Patch image");
+ break;
+ case 0xE:
+ strcat(flag_list, "V2X Dummy image");
+ break;
+ default:
+ strcat(flag_list, "Invalid img type");
+ break;
+ }
+ strcat(flag_list, " | ");
+
+ /* next get the core id */
+ strcat(flag_list, "CORE ID: ");
+ img_flags.core_id = (flags >> CORE_ID_SHIFT) & CORE_ID_MASK;
+
+ if ((soc == ULP) || (soc == IMX9)) {
+ switch (img_flags.core_id) {
+ case CORE_ULP_CM33:
+ strcat(flag_list, "CORE_CM33");
+ break;
+ case CORE_ULP_SENTINEL:
+ strcat(flag_list, "CORE_SENTINEL");
+ break;
+ case CORE_ULP_UPOWER:
+ strcat(flag_list, "CORE_UPOWER");
+ break;
+ case CORE_ULP_CA35:
+ if (soc == IMX9)
+ strcat(flag_list, "CORE_CA55");
+ else
+ strcat(flag_list, "CORE_CA35");
+ break;
+ default:
+ strcat(flag_list, "Invalid core id");
+ break;
+ }
+ } else {
+ switch (img_flags.core_id) {
+ case CORE_SC:
+ strcat(flag_list, "CORE_SC");
+ break;
+ case CORE_CM4_0:
+ strcat(flag_list, "CORE_CM4_0");
+ break;
+ case CORE_CM4_1:
+ strcat(flag_list, "CORE_CM4_1");
+ break;
+ case CORE_CA53:
+ strcat(flag_list, "CORE_CA53");
+ break;
+ case CORE_CA72:
+ strcat(flag_list, "CORE_CA72");
+ break;
+ case CORE_SECO:
+ strcat(flag_list, "CORE_SECO");
+ break;
+ case CORE_V2X_P:
+ strcat(flag_list, "CORE_V2X_P");
+ break;
+ case CORE_V2X_S:
+ strcat(flag_list, "CORE_V2X_S");
+ break;
+ default:
+ strcat(flag_list, "Invalid core id");
+ break;
+ }
+ }
+ strcat(flag_list, " | ");
+
+ /* next get the hash type */
+ strcat(flag_list, "HASH TYPE: ");
+ img_flags.hash_type = (flags >> HASH_TYPE_SHIFT) & HASH_TYPE_MASK;
+
+ switch (img_flags.hash_type) {
+ case 0x0:
+ strcat(flag_list, "SHA256");
+ break;
+ case 0x1:
+ strcat(flag_list, "SHA384");
+ break;
+ case 0x2:
+ strcat(flag_list, "SHA512");
+ break;
+ case 0x3:
+ strcat(flag_list, "SM3");
+ break;
+ default:
+ break;
+ }
+ strcat(flag_list, " | ");
+
+ /* lastly, read the encrypted bit */
+ strcat(flag_list, "ENCRYPTED: ");
+ img_flags.encrypted = (flags >> IMAGE_ENCRYPTED_SHIFT) &
IMAGE_ENCRYPTED_MASK;
+
+ if (img_flags.encrypted)
+ strcat(flag_list, "YES");
+ else
+ strcat(flag_list, "NO");
+
+ /* terminate flag string */
+ strcat(flag_list, ")");
+
+ return img_flags;
+}
+
+static void print_image_array_fields(struct flash_header_v3 *container_hdrs,
soc_type_t soc, bool app_cntr)
+{
+ struct boot_img img; /* image array entry */
+ struct img_flags img_flags; /* image hab flags */
+ int hash_length = 0;
+ char img_name[32]; /* scfw, bootloader, etc. */
+ char hash_name[8]; /* sha256, sha384, or sha512 */
+ char flag_string[128]; /* text representation of image hab flags */
+ int i;
+
+ for (i = 0; i < container_hdrs->num_images; i++) {
+ /* get the next image array entry */
+ img = container_hdrs->img[i];
+
+ /* get the image flags */
+ img_flags = parse_image_flags(img.hab_flags, flag_string, soc);
+
+ /* determine the type of image */
+ switch (img_flags.type) {
+ case 0x3:
+ if ((soc == ULP) || (soc == IMX9)) {
+ if (img_flags.core_id == CORE_ULP_UPOWER)
+ strcpy(img_name, "uPower FW");
+ else if ((img_flags.core_id == CORE_ULP_CA35))
+ if (app_cntr)
+ strcpy(img_name, "A core
Image");
+ else
+ strcpy(img_name, "Bootloader");
+ else if ((img_flags.core_id == CORE_ULP_CM33))
+ strcpy(img_name, "M33");
+
+ } else {
+ if (img_flags.core_id == CORE_SC)
+ strcpy(img_name, "SCFW");
+ else if ((img_flags.core_id == CORE_CA53) ||
(img_flags.core_id == CORE_CA72))
+ if (app_cntr)
+ strcpy(img_name, "A core
Image");
+ else
+ strcpy(img_name, "Bootloader");
+ else if (img_flags.core_id == CORE_CM4_0)
+ strcpy(img_name, "M4_0");
+ else if (img_flags.core_id == CORE_CM4_1)
+ strcpy(img_name, "M4_1");
+ }
+ break;
+ case 0x4:
+ strcpy(img_name, "Data");
+ break;
+ case 0x5:
+ strcpy(img_name, "DDR Init");
+ break;
+ case 0x6:
+ if ((soc == ULP) || (soc == IMX9))
+ strcpy(img_name, "SENTINEL FW");
+ else
+ strcpy(img_name, "SECO FW");
+ break;
+ case 0x7:
+ strcpy(img_name, "Provisioning");
+ break;
+ case 0x8:
+ if (soc == IMX9)
+ strcpy(img_name, "FCB Check");
+ else
+ strcpy(img_name, "DEK Validation");
+ break;
+ case 0xB:
+ strcpy(img_name, "Primary V2X FW image");
+ break;
+ case 0xC:
+ strcpy(img_name, "Secondary V2X FW image");
+ break;
+ case 0xD:
+ strcpy(img_name, "V2X ROM Patch image");
+ break;
+ case 0xE:
+ strcpy(img_name, "V2X Dummy image");
+ break;
+ default:
+ strcpy(img_name, "Unknown image");
+ break;
+ }
+
+ /* get the image hash type */
+ switch (img_flags.hash_type) {
+ case 0x0:
+ hash_length = 256 / 8;
+ strcpy(hash_name, "SHA256");
+ break;
+ case 0x1:
+ hash_length = 384 / 8;
+ strcpy(hash_name, "SHA384");
+ break;
+ case 0x2:
+ hash_length = 512 / 8;
+ strcpy(hash_name, "SHA512");
+ break;
+ case 0x3:
+ hash_length = 256 / 8;
+ strcpy(hash_name, "SM3");
+ break;
+ default:
+ strcpy(hash_name, "Unknown");
+ break;
+ }
+
+ /* print the image array fields */
+ printf("%sIMAGE %d (%s)%s\n", "\x1B[33m", i+1, img_name,
"\x1B[37m");
+ printf("Offset: %#X\n", img.offset);
+ printf("Size: %#X (%d)\n", img.size, img.size);
+ printf("Load Addr: %#lX\n", img.dst);
+ printf("Entry Addr: %#lX\n", img.entry);
+ printf("Flags: %#X %s\n", img.hab_flags, flag_string);
+
+ /* only print metadata and hash if the image isn't DDR init */
+ if (img_flags.type != 0x5) {
+ int j;
+
+ printf("Metadata: %#X\n", img.meta);
+
+ /* print the image hash */
+ printf("Hash: ");
+ for (j = 0; j < hash_length; j++)
+ printf("%02x", img.hash[j]);
+
+ printf(" (%s)\n", hash_name);
+
+ }
+ printf("\n");
+ }
+}
+
+static void print_container_hdr_fields(struct flash_header_v3 *container_hdrs,
int num_cntrs,
+ soc_type_t soc, bool app_cntr)
+{
+ int i;
+
+ for (i = 0; i < num_cntrs; i++) {
+ printf("\n");
+ printf("*********************************\n");
+ printf("* *\n");
+ if (app_cntr)
+ printf("* APP CONTAINER %-2d *\n", i + 1);
+ else
+ printf("* ROM CONTAINER %-2d *\n", i + 1);
+ printf("* *\n");
+ printf("*********************************\n\n");
+ printf("%16s", "Length: ");
+ printf("%#X (%d)\n", container_hdrs->length,
container_hdrs->length);
+ printf("%16s", "Tag: ");
+ printf("%#X\n", container_hdrs->tag);
+ printf("%16s", "Version: ");
+ printf("%#X\n", container_hdrs->version);
+ printf("%16s", "Flags: ");
+ printf("%#X\n", container_hdrs->flags);
+ printf("%16s", "Num images: ");
+ printf("%d\n", container_hdrs->num_images);
+ printf("%16s", "Fuse version: ");
+ printf("%#X\n", container_hdrs->fuse_version);
+ printf("%16s", "SW version: ");
+ printf("%#X\n", container_hdrs->sw_version);
+ printf("%16s", "Sig blk offset: ");
+ printf("%#X\n\n", container_hdrs->sig_blk_offset);
+
+ print_image_array_fields(container_hdrs, soc, app_cntr);
+
+ container_hdrs++;
+ }
+}
+
+static int get_container_size(struct flash_header_v3 *phdr)
+{
+ uint8_t i = 0;
+ uint32_t max_offset = 0, img_end;
+
+ max_offset = phdr->length;
+
+ for (i = 0; i < phdr->num_images; i++) {
+ img_end = phdr->img[i].offset + phdr->img[i].size;
+ if (img_end > max_offset)
+ max_offset = img_end;
+ }
+
+ if (phdr->sig_blk_offset != 0) {
+ uint16_t len = phdr->sig_blk_hdr.length;
+
+ if (phdr->sig_blk_offset + len > max_offset)
+ max_offset = phdr->sig_blk_offset + len;
+ }
+
+ return max_offset;
+}
+
+static int search_app_container(struct flash_header_v3 *container_hdrs, int
num_cntrs, int ifd,
+ struct flash_header_v3 *app_container_hdr)
+{
+ int off[MAX_NUM_OF_CONTAINER];
+ int end = 0, last = 0;
+ int img_array_entries = 0;
+ ssize_t rd_err;
+ off_t err;
+ int i;
+
+ off[0] = 0;
+
+ for (i = 0; i < num_cntrs; i++) {
+ end = get_container_size(&container_hdrs[i]);
+ if (end + off[i] > last)
+ last = end + off[i];
+
+ if ((i + 1) < num_cntrs)
+ off[i + 1] = off[i] + ALIGN(container_hdrs[i].length,
CONTAINER_ALIGNMENT);
+ }
+
+ /* Check app container tag at each 1KB beginning until 16KB */
+ last = ALIGN(last, 0x400);
+ for (i = 0; i < 16; i++) {
+ last = last + (i * 0x400);
+ err = lseek(ifd, last, SEEK_SET);
+ if (err < 0)
+ break;
+
+ rd_err = read(ifd, (void *)app_container_hdr, 16);
+ if (rd_err < 0) {
+ fprintf(stderr, "Error reading from input binary\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* check that the current container has a valid tag */
+ if (app_container_hdr->tag != IVT_HEADER_TAG_B0)
+ continue;
+
+ if (app_container_hdr->num_images > MAX_NUM_IMGS) {
+ fprintf(stderr, "This container includes %d images,
beyond max 8 images\n",
+ app_container_hdr->num_images);
+ exit(EXIT_FAILURE);
+ }
+
+ /* compute the size of the image array */
+ img_array_entries = app_container_hdr->num_images *
sizeof(struct boot_img);
+
+ /* read in the full image array */
+ rd_err = read(ifd, (void *)&app_container_hdr->img,
img_array_entries);
+ if (rd_err < 0) {
+ fprintf(stderr, "Error reading from input binary\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* read in signature block header */
+ if (app_container_hdr->sig_blk_offset != 0) {
+ lseek(ifd, last + app_container_hdr->sig_blk_offset,
SEEK_SET);
+ rd_err = read(ifd, (void
*)&app_container_hdr->sig_blk_hdr, sizeof(struct sig_blk_hdr));
+ if (rd_err == -1) {
+ fprintf(stderr, "Error reading from input
binary\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ return last;
+ }
+
+ return 0;
+}
+
+static int extract_container_images(struct flash_header_v3 *container_hdr,
char *ifname, int num_cntrs,
+ int ifd, soc_type_t soc, int app_cntr_off)
+{
+ uint32_t img_offset = 0; /* image offset from container header */
+ uint32_t img_size = 0; /* image size */
+ uint32_t file_off = 0; /* current offset within container binary */
+ const uint32_t pad = 0;
+ int ofd = 0;
+ int ret = 0;
+ uint32_t seco_off = 0;
+ char dd_cmd[512]; /* dd cmd to extract each image from container binary
*/
+ struct stat buf;
+ FILE *f_ptr = NULL; /* file pointer to the dd process */
+ char *mem_ptr; /* pointer to input container in memory */
+ int i, j;
+
+ printf("Extracting container images...\n");
+
+ /* create output directory if it does not exist */
+ if (stat("extracted_imgs", &buf) == -1)
+ mkdir("extracted_imgs", S_IRWXU|S_IRWXG|S_IRWXO);
+
+ /* open container binary and map to memory */
+ fstat(ifd, &buf);
+ mem_ptr = mmap(NULL, buf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
+
+ for (i = 0; i < num_cntrs; i++) {
+ for (j = 0; j < container_hdr->num_images; j++) {
+
+ /* first get the image offset and size from the
container header */
+ img_offset = container_hdr->img[j].offset;
+ img_size = container_hdr->img[j].size;
+
+ if (!img_size) {
+ /* check for images with zero size (DDR Init) */
+ continue;
+ } else if (app_cntr_off > 0) {
+ sprintf(dd_cmd, "dd status=none if=%s
of=extracted_imgs/app_container%d_img%d.bin ibs=1 skip=%d count=%d
conv=notrunc",
+ ifname, i+1, j+1,
app_cntr_off+img_offset, img_size);
+ printf("APP Container %d Image %d ->
extracted_imgs/app_container%d_img%d.bin\n", i+1, j+1, i+1, j+1);
+
+ } else if ((i == 0) && (soc != DXL)) { /* first
container is always SECO FW */
+ int k;
+
+ /* open output file */
+ ofd = open("extracted_imgs/ahab-container.img",
O_CREAT|O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO);
+
+ /* first copy container header to output image
*/
+ ret = write(ofd, (void *)mem_ptr, 1024);
+ if (ret < 0)
+ fprintf(stderr, "Error writing to
output file\n");
+
+
+ /* next, pad the output with zeros until the
start of the image */
+ for (k = 0; k <
(img_offset-CONTAINER_ALIGNMENT)/4; k++)
+ ret = write(ofd, (void *)&pad, 4);
+
+ /* now write the fw image to the output file */
+ ret = write(ofd, (void *)(mem_ptr+img_offset),
img_size);
+ if (ret < 0)
+ fprintf(stderr, "Error writing to
output file\n");
+
+ /* close output file and unmap input file */
+ close(ofd);
+
+ printf("Container %d Image %d ->
extracted_imgs/ahab-container.img\n", i+1, j+1);
+
+ } else if ((i < 2 ) && (soc == DXL)) { /* Second
Container is Always V2X for DXL */
+ if (i == 0) {
+ /* open output file */
+ ofd =
open("extracted_imgs/ahab-container.img", O_CREAT|O_WRONLY,
S_IRWXU|S_IRWXG|S_IRWXO);
+
+ /* first copy container header to
output image */
+ ret = write(ofd, (void *)mem_ptr,
0x400);
+ if (ret < 0)
+ fprintf(stderr, "Error writing
to output file1\n");
+
+ /* For DXL go to next container to copy
header */
+ seco_off = img_offset;
+ continue;
+ } else if (i == 1 && j == 0) {
+ int k;
+
+ /* copy v2x container header and seco
fw */
+ ret = write(ofd,(void *) mem_ptr +
file_off, container_hdr->length);
+ if (ret < 0)
+ fprintf(stderr, "Error writing
to output file2\n");
+
+
+ /* next, pad the output with zeros
until the start of SECO image */
+ for (k = 0; k < (seco_off - (file_off +
container_hdr->length)) / 4; k++)
+ ret = write(ofd, (void *)&pad,
4);
+
+ /* now write the SECO fw image to the
output file */
+ ret = write(ofd, (void
*)(mem_ptr+seco_off), file_off + img_offset - seco_off);
+ if (ret < 0)
+ fprintf(stderr, "Error writing
to output file3: %x\n",ret);
+ }
+
+ /* now write the next image to the output file
*/
+ ret = write(ofd, (void *)(mem_ptr + file_off +
img_offset), img_size);
+ if (ret < 0)
+ fprintf(stderr, "Error writing to
output file4: %x\n",ret);
+
+ /* Iterate through V2X container for other
images */
+ if (j < (container_hdr->num_images - 1))
+ continue;
+
+ /* close output file and unmap input file */
+ close(ofd);
+
+
+ printf("Container %d Image %d ->
extracted_imgs/v2x-container.img\n", i+1, j+1);
+
+ } else {
+ sprintf(dd_cmd, "dd status=none if=%s
of=extracted_imgs/container%d_img%d.bin ibs=1 skip=%d count=%d conv=notrunc",
+ ifname, i+1, j+1,
file_off+img_offset, img_size);
+ printf("Container %d Image %d ->
extracted_imgs/container%d_img%d.bin\n", i+1, j+1, i+1, j+1);
+ }
+
+ /* run dd command to extract current image from
container */
+ fprintf(stderr, "FOOO: %s\n", dd_cmd);
+ f_ptr = popen(dd_cmd, "r");
+ if (f_ptr == NULL) {
+ fprintf(stderr, "Failed to extract image\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* close the pipe */
+ pclose(f_ptr);
+ }
+
+ file_off += ALIGN(container_hdr->length, CONTAINER_ALIGNMENT);
+ container_hdr++;
+ }
+
+ munmap((void *)mem_ptr, buf.st_size);
+ printf("Done\n\n");
+ return 0;
+}
+
+static int parse_container_hdrs_qx_qm_b0(char *ifname, bool extract,
soc_type_t soc, off_t file_off)
+{
+ int ifd; /* container file descriptor */
+ int max_containers = (soc == DXL) ? 3 : 2;
+ int cntr_num = 0; /* number of containers in binary */
+ int img_array_entries = 0; /* number of images in container */
+ ssize_t rd_err;
+ struct flash_header_v3 container_headers[MAX_NUM_OF_CONTAINER];
+ struct flash_header_v3 app_container_header;
+ int app_cntr_off;
+
+ /* initialize region of memory where flash header will be stored */
+ memset((void *)container_headers, 0, sizeof(container_headers));
+
+ /* open container binary */
+ ifd = open(ifname, O_RDONLY|O_BINARY);
+
+ if (file_off) /* inital offset within container binary */
+ lseek(ifd, file_off, SEEK_SET);
+
+ while (cntr_num < max_containers) {
+
+ /* read in next container header up to the image array */
+ rd_err = read(ifd, (void *)&container_headers[cntr_num], 16);
+ if (rd_err == -1) {
+ fprintf(stderr, "Error reading from input binary\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* check that the current container has a valid tag */
+ if (container_headers[cntr_num].tag != IVT_HEADER_TAG_B0)
+ break;
+
+ if (container_headers[cntr_num].num_images > MAX_NUM_IMGS) {
+ fprintf(stderr, "This container includes %d images,
beyond max 8 images\n",
+ container_headers[cntr_num].num_images);
+ exit(EXIT_FAILURE);
+ }
+
+ /* compute the size of the image array */
+ img_array_entries = container_headers[cntr_num].num_images *
sizeof(struct boot_img);
+
+ /* read in the full image array */
+ rd_err = read(ifd, (void *)&container_headers[cntr_num].img,
img_array_entries);
+ if (rd_err == -1) {
+ fprintf(stderr, "Error reading from input binary\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (container_headers[cntr_num].sig_blk_offset != 0) {
+ /* read in signature block header */
+ lseek(ifd, file_off +
container_headers[cntr_num].sig_blk_offset, SEEK_SET);
+ rd_err = read(ifd, (void
*)&container_headers[cntr_num].sig_blk_hdr, sizeof(struct sig_blk_hdr));
+ if (rd_err == -1) {
+ fprintf(stderr, "Error reading from input
binary\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ /* seek to next container in binary */
+ file_off += ALIGN(container_headers[cntr_num].length,
CONTAINER_ALIGNMENT);
+ lseek(ifd, file_off, SEEK_SET);
+
+ /* increment current container count */
+ cntr_num++;
+ }
+
+
+ print_container_hdr_fields(container_headers, cntr_num, soc, false);
+
+ if (extract)
+ extract_container_images(container_headers, ifname, cntr_num,
ifd, soc, 0);
+
+ app_cntr_off = search_app_container(container_headers, cntr_num, ifd,
&app_container_header);
+
+ if (app_cntr_off > 0) {
+ print_container_hdr_fields(&app_container_header, 1, soc, true);
+ if (extract)
+ extract_container_images(&app_container_header, ifname,
1, ifd, soc, app_cntr_off);
+ }
+
+ close(ifd);
+
+ return 0;
+
+}
+
+#define IMG_STACK_SIZE 32 /* max of 32 images for commandline
images */
+
+/*
+ * Read commandline parameters and construct the header in order
+ *
+ * This will then construct the image according to the header and
+ *
+ * parameters passed in
+ *
+ */
+int main(int argc, char **argv)
+{
+ int c;
+ char *ofname = NULL;
+ char *ifname = NULL;
+ bool output = false;
+ bool dcd_skip = false;
+ bool emmc_fastboot = false;
+ bool extract = false;
+ bool parse = false;
+
+ int container = -1;
+ image_t param_stack[IMG_STACK_SIZE];/* stack of input images */
+ int p_idx = 0;/* param index counter */
+ off_t file_off = 0;
+
+ uint32_t ivt_offset = IVT_OFFSET_SD;
+ uint32_t sector_size = 0x400; /* default sector size */
+ soc_type_t soc = NONE; /* Initially No SOC defined */
+
+ uint8_t fuse_version = 0;
+ uint16_t sw_version = 0;
+ char *images_hash = NULL;
+
+ static struct option long_options[] = {
+ {"scfw", required_argument, NULL, 'f'},
+ {"seco", required_argument, NULL, 'O'},
+ {"m4", required_argument, NULL, 'm'},
+ {"ap", required_argument, NULL, 'a'},
+ {"dcd", required_argument, NULL, 'd'},
+ {"out", required_argument, NULL, 'o'},
+ {"flags", required_argument, NULL, 'l'},
+ {"scd", required_argument, NULL, 'x'},
+ {"csf", required_argument, NULL, 'z'},
+ {"dev", required_argument, NULL, 'e'},
+ {"soc", required_argument, NULL, 's'},
+ {"dummy",required_argument, NULL, 'y'},
+ {"container", no_argument, NULL, 'c'},
+ {"partition", required_argument, NULL, 'p'},
+ {"append", no_argument, NULL, 'A'},
+ {"data", required_argument, NULL, 'D'},
+ {"fileoff", required_argument, NULL, 'P'},
+ {"msg_blk", required_argument, NULL, 'M'},
+ {"fuse_version", required_argument, NULL, 'u'},
+ {"sw_version", required_argument, NULL, 'v'},
+ {"images_hash", required_argument, NULL, 'h'},
+ {"extract", required_argument, NULL, 'X'},
+ {"parse", required_argument, NULL, 'R'},
+ {"sentinel", required_argument, NULL, 'i'},
+ {"upower", required_argument, NULL, 'w'},
+ {"fcb", required_argument, NULL, 'b'},
+ {"padding", required_argument, NULL, 'G'},
+ {NULL, 0, NULL, 0}
+ };
+
+ /* scan in parameters in order */
+ while (1) {
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+
+ c = getopt_long_only (argc, argv,
":f:m:a:d:o:l:x:z:e:p:cu:v:h:i:w:",
+ long_options, &option_index);
+
+ /* Detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 0:
+ fprintf(stderr, "option %s",
long_options[option_index].name);
+ if (optarg)
+ fprintf(stderr, " with arg %s", optarg);
+ fprintf(stderr, "\n");
+ break;
+ case 'A':
+ param_stack[p_idx].option = APPEND;
+ param_stack[p_idx++].filename = argv[optind++];
+ break;
+ case 'p':
+ printf("PARTITION:\t%s\n", optarg);
+ param_stack[p_idx].option = PARTITION;
+ param_stack[p_idx++].entry = (uint32_t) strtoll(optarg,
NULL, 0);
+ break;
+ case 's':
+ if (!strncmp(optarg, "QX", 2)) {
+ soc = QX;
+ } else if (!strncmp(optarg, "QM", 2)) {
+ soc = QM;
+ } else if (!strncmp(optarg, "DXL", 3)) {
+ soc = DXL;
+ } else if (!strncmp(optarg, "ULP", 3)) {
+ soc = ULP;
+ } else if (!strncmp(optarg, "IMX9", 4)) {
+ soc = IMX9;
+ } else {
+ printf("unrecognized SOC: %s \n",optarg);
+ exit(EXIT_FAILURE);
+ }
+ printf("SOC: %s \n",optarg);
+ break;
+ case 'b':
+ printf("FCB:\t%s\n", optarg);
+ param_stack[p_idx].option = FCB;
+ param_stack[p_idx].filename = optarg;
+ if (optind < argc && *argv[optind] != '-') {
+ param_stack[p_idx].entry = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+ p_idx++;
+ } else {
+ fprintf(stderr, "\n-fcb option require Two
arguments: filename, load address in hex\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'i':
+ printf("SENTINEL:\t%s\n", optarg);
+ param_stack[p_idx].option = SENTINEL;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'w':
+ printf("UPOWER:\t%s\n", optarg);
+ param_stack[p_idx].option = UPOWER;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'f':
+ printf("SCFW:\t%s\n", optarg);
+ param_stack[p_idx].option = SCFW;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'O':
+ printf("SECO:\t%s\n", optarg);
+ param_stack[p_idx].option = SECO;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'd':
+ printf("DCD:\t%s\n", optarg);
+ if (soc == DXL) {
+ if (!strncmp(optarg, "skip", 4)) {
+ dcd_skip = true;
+ } else {
+ fprintf(stderr, "\n-dcd option requires
argument skip\n\n");
+ exit(EXIT_FAILURE);
+ }
+ } else if ((soc == ULP) || (soc == IMX9)) {
+ fprintf(stderr, "\n-dcd option is not used on
ULP and IMX9\n\n");
+ exit(EXIT_FAILURE);
+ } else {
+ param_stack[p_idx].option = DCD;
+ param_stack[p_idx].filename = optarg;
+ p_idx++;
+ }
+ break;
+ case 'D':
+ if ((soc == DXL) || (soc == ULP) || (soc == IMX9)) {
+ printf("Data:\t%s", optarg);
+ param_stack[p_idx].option = DATA;
+ param_stack[p_idx].filename = optarg;
+ if ((optind < argc && *argv[optind] != '-') &&
+ (optind+1 < argc && *argv[optind+1] != '-'
)) {
+ if (!strncmp(argv[optind], "a53", 3))
+ param_stack[p_idx].ext =
CORE_CA53;
+ else if (!strncmp(argv[optind], "a55",
3))
+ param_stack[p_idx].ext =
CORE_CA35; /* fake id for a55 */
+ else if (!strncmp(argv[optind], "a35",
3))
+ param_stack[p_idx].ext =
CORE_CA35;
+ else if (!strncmp(argv[optind], "a72",
3))
+ param_stack[p_idx].ext =
CORE_CA72;
+ else if (!strncmp(argv[optind], "m4_1",
4))
+ param_stack[p_idx].ext =
CORE_CM4_1;
+ else if (!strncmp(argv[optind], "m4",
2))
+ param_stack[p_idx].ext =
CORE_CM4_0;
+ else {
+ fprintf(stderr, "ERROR:
incorrect core ID for --data option: %s\n", argv[optind]);
+ exit(EXIT_FAILURE);
+ }
+ printf("\tcore: %s\n", argv[optind++]);
+ param_stack[p_idx].entry = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+ } else {
+ fprintf(stderr, "\n-data option require
THREE arguments: filename, core: a55/a35/a53/a72/m4_0/m4_1, load address in
hex\n\n");
+ exit(EXIT_FAILURE);
+ }
+ p_idx++;
+ } else {
+ fprintf(stderr, "\n-data option is only used
with -rev B0, or DXL or ULP or IMX9 soc.\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'm':
+ printf("CM4:\t%s", optarg);
+ param_stack[p_idx].option = M4;
+ param_stack[p_idx].filename = optarg;
+ if ((optind < argc && *argv[optind] != '-') &&
+ (optind + 1 < argc &&*argv[optind+1] != '-' )) {
+ param_stack[p_idx].ext = strtol(argv[optind++],
NULL, 0);
+ param_stack[p_idx].entry = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+ param_stack[p_idx].dst = 0;
+ printf("\tcore: %" PRIi64,
param_stack[p_idx].ext);
+ printf(" entry addr: 0x%08" PRIx64 ,
param_stack[p_idx].entry);
+ if (optind < argc && *argv[optind] != '-') {
+ param_stack[p_idx].dst = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+ printf(" load addr: 0x%08" PRIx64 ,
param_stack[p_idx].dst);
+ }
+ printf("\n");
+ p_idx++;
+ } else {
+ fprintf(stderr, "\n-m4 option require FOUR
arguments: filename, core: 0/1, entry address in hex, load address in
hex(optional)\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'a':
+ printf("AP:\t%s", optarg);
+ param_stack[p_idx].option = AP;
+ param_stack[p_idx].filename = optarg;
+ if ((optind < argc && *argv[optind] != '-') &&
+ (optind + 1 < argc &&*argv[optind+1] != '-' )) {
+ if (!strncmp(argv[optind], "a53", 3))
+ param_stack[p_idx].ext = CORE_CA53;
+ else if (!strncmp(argv[optind], "a55", 3))
+ param_stack[p_idx].ext = CORE_CA35; /*
fake id for a55 */
+ else if (!strncmp(argv[optind], "a35", 3))
+ param_stack[p_idx].ext = CORE_CA35;
+ else if (!strncmp(argv[optind], "a72", 3))
+ param_stack[p_idx].ext = CORE_CA72;
+ else {
+ fprintf(stderr, "ERROR: AP Core not
found %s\n", argv[optind+2]);
+ exit(EXIT_FAILURE);
+ }
+ printf("\tcore: %s", argv[optind++]);
+
+ param_stack[p_idx].entry = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+ param_stack[p_idx].mu = SC_R_MU_0A;
+ param_stack[p_idx].part = 1;
+
+ if (optind < argc && *argv[optind] != '-') {
+ if (!strncmp(argv[optind], "mu0", 3))
+ param_stack[p_idx].mu =
SC_R_MU_0A;
+ else if (!strncmp(argv[optind], "mu3",
3))
+ param_stack[p_idx].mu =
SC_R_MU_3A;
+ else {
+ fprintf(stderr, "ERROR: MU
number %s not found\n", argv[optind]);
+ exit(EXIT_FAILURE);
+ }
+ printf("\tMU: %s ", argv[optind++]);
+ }
+ if (optind < argc && *argv[optind] != '-') {
+ if (!strncmp(argv[optind], "pt", 2) &&
+ (argv[optind][2] > '0') &&
+ (argv[optind][2] != '2') &&
+ (argv[optind][2] <= '9')) {
+ char str[2];
+ str[0] = argv[optind][2];
+ str[1] = '\0';
+ param_stack[p_idx].part =
strtoll(str, NULL, 0);
+ } else {
+ fprintf(stderr, "ERROR:
partition number %s not found\n", argv[optind]);
+ exit(EXIT_FAILURE);
+ }
+ printf("\tPartition: %s ",
argv[optind++]);
+ }
+ printf(" addr: 0x%08" PRIx64 "\n",
param_stack[p_idx++].entry);
+ } else {
+ fprintf(stderr, "\n-ap option require THREE
arguments: filename, a35/a53/a72, start address in hex\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'l':
+ printf("FLAG:\t%s\n", optarg);
+ param_stack[p_idx].option = FLAG;
+ param_stack[p_idx++].entry = (uint32_t) strtoll(optarg,
NULL, 0);
+ break;
+ case 'o':
+ printf("Output:\t%s\n", optarg);
+ ofname = optarg;
+ output = true;
+ break;
+ case 'x':
+ printf("SCD:\t%s\n", optarg);
+ param_stack[p_idx].option = SCD;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'z':
+ printf("CSF:\t%s\n", optarg);
+ param_stack[p_idx].option = CSF;
+ param_stack[p_idx++].filename = optarg;
+ break;
+ case 'e':
+ printf("BOOT DEVICE:\t%s\n", optarg);
+ if (!strcmp(optarg, "flexspi")) {
+ ivt_offset = IVT_OFFSET_FLEXSPI;
+ } else if (!strcmp(optarg, "sd")) {
+ ivt_offset = IVT_OFFSET_SD;
+ } else if (!strcmp(optarg, "nand")) {
+ sector_size = 0x8000;/* sector size for NAND */
+ if ((soc == DXL) || (soc == IMX9)) {
+ if (optind < argc && *argv[optind] !=
'-') {
+ if (!strcmp(argv[optind],
"4K")) {
+ sector_size = 0x1000;
+ } else if
(!strcmp(argv[optind], "8K")) {
+ sector_size = 0x2000;
+ } else if
(!strcmp(argv[optind], "16K")) {
+ sector_size = 0x4000;
+ } else
+ printf("\nwrong nand
page size:\r\n 4K\r\n8K\r\n16K\n\n");
+ } else {
+ printf("\n-dev nand requires
the page size:\r\n 4K\r\n8K\r\n16K\n\n");
+ }
+ }
+ } else if (!strcmp(optarg, "emmc_fast")) {
+ ivt_offset = IVT_OFFSET_EMMC;
+ emmc_fastboot = true;/* emmc boot */
+ } else {
+ printf("\n-dev option, Valid boot devices
are:\r\n sd\r\nflexspi\r\nnand\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'c':
+ printf("New Container: \t%d\n",++container);
+ param_stack[p_idx++].option = NEW_CONTAINER;
+ break;
+ case ':':
+ fprintf(stderr, "option %c missing arguments\n",
optopt);
+ exit(EXIT_FAILURE);
+ break;
+ case 'P':
+ printf("FILEOFF:\t%s\n", optarg);
+ param_stack[p_idx].option = FILEOFF;
+ param_stack[p_idx++].dst = (uint64_t) strtoll(optarg,
NULL, 0);
+ break;
+ case 'M':
+ printf("MSG BLOCK:\t%s", optarg);
+ param_stack[p_idx].option = MSG_BLOCK;
+ param_stack[p_idx].filename = optarg;
+ if ((optind < argc && *argv[optind] != '-') &&
+ (optind+1 < argc &&*argv[optind + 1] != '-' )) {
+ if (!strncmp(argv[optind], "fuse", 4))
+ param_stack[p_idx].ext = SC_R_OTP;
+ else if (!strncmp(argv[optind], "debug", 5))
+ param_stack[p_idx].ext = SC_R_DEBUG;
+ else if (!strncmp(argv[optind], "field", 5))
+ param_stack[p_idx].ext = SC_R_ROM_0;
+ else if (!strncmp(argv[optind], "zero", 4))
+ param_stack[p_idx].ext = SC_R_PWM_0;
+ else if (!strncmp(argv[optind], "patch", 5))
+ param_stack[p_idx].ext = SC_R_SNVS;
+ else if (!strncmp(argv[optind], "degrade", 7))
+ param_stack[p_idx].ext = SC_R_DC_0;
+ else {
+ fprintf(stderr, "ERROR: MSG type not
found %s\n", argv[optind+2]);
+ exit(EXIT_FAILURE);
+ }
+ printf("\ttype: %s", argv[optind++]);
+
+ param_stack[p_idx].entry = (uint32_t)
strtoll(argv[optind++], NULL, 0);
+
+ printf(" addr: 0x%08" PRIx64 "\n",
param_stack[p_idx++].entry);
+ } else {
+ fprintf(stderr, "\nmsg block option require
THREE arguments: filename, debug/fuse/field/patch, start address in hex\n\n");
+ exit(EXIT_FAILURE);
+ }
+ break;
+ case 'u':
+ fuse_version = (uint8_t) (strtoll(optarg, NULL, 0) &
0xFF);
+ break;
+ case 'v':
+ sw_version = (uint16_t) (strtoll(optarg, NULL, 0) &
0xFFFF);
+ break;
+ case 'h':
+ images_hash = optarg;
+ break;
+ case 'X':
+ printf("Input container binary to be deconstructed:
%s\n", optarg);
+ ifname = optarg;
+ extract = true;
+ break;
+ case 'R':
+ printf("Input container binary to be parsed: %s\n",
optarg);
+ ifname = optarg;
+ parse = true;
+ break;
+ case 'y':
+ printf("Dummy V2X image at:\t%s\n", optarg);
+ param_stack[p_idx].option = DUMMY_V2X;
+ param_stack[p_idx++].entry = (uint64_t) strtoll(optarg,
NULL, 0);
+ break;
+ case 'G':
+ printf("Padding length:\t%s bytes\n", optarg);
+ file_off = atoi(optarg);
+ break;
+ case '?':
+ default:
+ /* invalid option */
+ fprintf(stderr, "option '%c' is invalid: ignored\n",
+ optopt);
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ if (!parse) {
+ printf("CONTAINER FUSE VERSION:\t0x%02x\n", fuse_version);
+ printf("CONTAINER SW VERSION:\t0x%04x\n", sw_version);
+ }
+
+ param_stack[p_idx].option = NO_IMG; /* null terminate the img stack */
+
+ if (soc == NONE) {
+ fprintf(stderr, " No SOC defined");
+ exit(EXIT_FAILURE);
+ }
+
+ if (parse || extract) {
+ parse_container_hdrs_qx_qm_b0(ifname, extract, soc, file_off);
+ return 0;
+ }
+
+ if (container < 0) {
+ /* check to make sure there is at least 1 container defined */
+ fprintf(stderr, " No Container defined");
+ exit(EXIT_FAILURE);
+ }
+
+ if (!output) {
+ fprintf(stderr, "mandatory args scfw and output file name
missing! abort\n");
+ exit(EXIT_FAILURE);
+ }
+
+ build_container_qx_qm_b0(soc, sector_size, ivt_offset, ofname,
emmc_fastboot,
+ (image_t *) param_stack, dcd_skip,
fuse_version,
+ sw_version, images_hash);
+
+ printf("DONE.\n");
+ printf("Note: Please copy image to offset: IVT_OFFSET +
IMAGE_OFFSET\n");
+
+ return 0;
+}
+
--
2.39.2
