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.hauer@xxxxxxxxxxxxxx> --- 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
