/*

* Copyright (C) 2016 Freescale Semiconductor, Inc.

*

* Copyright 2017 NXP

*

* SPDX-License-Identifier: GPL-2.0+

* derived from u-boot's mkimage utility

*

*/

#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, int size)

{

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 (!size || !filename)

sprintf(sha_command, "%s /dev/null", digest_type);

else

sprintf(sha_command, "cat \'%s\' /dev/zero | dd status=none bs=1 count=%d | %s",

filename, size, 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), size);

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

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

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 */

int isize;

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

isize = ALIGN(sbuf.st_size, sector_size);

if (pblsize && isize > ALIGN(pblsize, 1024))

isize = ALIGN(pblsize, 1024);

set_image_array_entry(&imx_header.fhdr[container],

soc,

img_sp,

file_off,

isize,

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;