2 * Image manipulator for Marvell SoCs
3 * supports Kirkwood, Dove, Armada 370, and Armada XP
5 * (C) Copyright 2013 Thomas Petazzoni
6 * <thomas.petazzoni@free-electrons.com>
8 * SPDX-License-Identifier: GPL-2.0+
10 * Not implemented: support for the register headers and secure
11 * headers in v1 images
14 #include "imagetool.h"
21 #define ALIGN_SUP(x, a) (((x) + (a - 1)) & ~(a - 1))
23 /* Structure of the main header, version 0 (Kirkwood, Dove) */
25 uint8_t blockid; /*0 */
26 uint8_t nandeccmode; /*1 */
27 uint16_t nandpagesize; /*2-3 */
28 uint32_t blocksize; /*4-7 */
29 uint32_t rsvd1; /*8-11 */
30 uint32_t srcaddr; /*12-15 */
31 uint32_t destaddr; /*16-19 */
32 uint32_t execaddr; /*20-23 */
33 uint8_t satapiomode; /*24 */
34 uint8_t rsvd3; /*25 */
35 uint16_t ddrinitdelay; /*26-27 */
36 uint16_t rsvd2; /*28-29 */
38 uint8_t checksum; /*31 */
41 struct ext_hdr_v0_reg {
46 #define EXT_HDR_V0_REG_COUNT ((0x1dc - 0x20) / sizeof(struct ext_hdr_v0_reg))
50 uint8_t reserved[0x20 - sizeof(uint32_t)];
51 struct ext_hdr_v0_reg rcfg[EXT_HDR_V0_REG_COUNT];
56 /* Structure of the main header, version 1 (Armada 370, Armada XP) */
58 uint8_t blockid; /* 0 */
59 uint8_t reserved1; /* 1 */
60 uint16_t reserved2; /* 2-3 */
61 uint32_t blocksize; /* 4-7 */
62 uint8_t version; /* 8 */
63 uint8_t headersz_msb; /* 9 */
64 uint16_t headersz_lsb; /* A-B */
65 uint32_t srcaddr; /* C-F */
66 uint32_t destaddr; /* 10-13 */
67 uint32_t execaddr; /* 14-17 */
68 uint8_t reserved3; /* 18 */
69 uint8_t nandblocksize; /* 19 */
70 uint8_t nandbadblklocation; /* 1A */
71 uint8_t reserved4; /* 1B */
72 uint16_t reserved5; /* 1C-1D */
74 uint8_t checksum; /* 1F */
78 * Header for the optional headers, version 1 (Armada 370, Armada XP)
83 uint16_t headersz_lsb;
88 * Various values for the opt_hdr_v1->headertype field, describing the
89 * different types of optional headers. The "secure" header contains
90 * informations related to secure boot (encryption keys, etc.). The
91 * "binary" header contains ARM binary code to be executed prior to
92 * executing the main payload (usually the bootloader). This is
93 * typically used to execute DDR3 training code. The "register" header
94 * allows to describe a set of (address, value) tuples that are
95 * generally used to configure the DRAM controller.
97 #define OPT_HDR_V1_SECURE_TYPE 0x1
98 #define OPT_HDR_V1_BINARY_TYPE 0x2
99 #define OPT_HDR_V1_REGISTER_TYPE 0x3
101 #define KWBHEADER_V1_SIZE(hdr) \
102 (((hdr)->headersz_msb << 16) | (hdr)->headersz_lsb)
104 static struct image_cfg_element *image_cfg;
112 struct boot_mode boot_modes[] = {
122 struct nand_ecc_mode {
127 struct nand_ecc_mode nand_ecc_modes[] = {
131 { 0x03, "disabled" },
135 /* Used to identify an undefined execution or destination address */
136 #define ADDR_INVALID ((uint32_t)-1)
138 #define BINARY_MAX_ARGS 8
140 /* In-memory representation of a line of the configuration file */
141 struct image_cfg_element {
143 IMAGE_CFG_VERSION = 0x1,
147 IMAGE_CFG_NAND_BLKSZ,
148 IMAGE_CFG_NAND_BADBLK_LOCATION,
149 IMAGE_CFG_NAND_ECC_MODE,
150 IMAGE_CFG_NAND_PAGESZ,
156 unsigned int version;
157 unsigned int bootfrom;
160 unsigned int args[BINARY_MAX_ARGS];
164 unsigned int dstaddr;
165 unsigned int execaddr;
166 unsigned int nandblksz;
167 unsigned int nandbadblklocation;
168 unsigned int nandeccmode;
169 unsigned int nandpagesz;
170 struct ext_hdr_v0_reg regdata;
174 #define IMAGE_CFG_ELEMENT_MAX 256
177 * Byte 8 of the image header contains the version number. In the v0
178 * header, byte 8 was reserved, and always set to 0. In the v1 header,
179 * byte 8 has been changed to a proper field, set to 1.
181 static unsigned int image_version(void *header)
183 unsigned char *ptr = header;
188 * Utility functions to manipulate boot mode and ecc modes (convert
189 * them back and forth between description strings and the
190 * corresponding numerical identifiers).
193 static const char *image_boot_mode_name(unsigned int id)
196 for (i = 0; boot_modes[i].name; i++)
197 if (boot_modes[i].id == id)
198 return boot_modes[i].name;
202 int image_boot_mode_id(const char *boot_mode_name)
205 for (i = 0; boot_modes[i].name; i++)
206 if (!strcmp(boot_modes[i].name, boot_mode_name))
207 return boot_modes[i].id;
212 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
215 for (i = 0; nand_ecc_modes[i].name; i++)
216 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
217 return nand_ecc_modes[i].id;
221 static struct image_cfg_element *
222 image_find_option(unsigned int optiontype)
226 for (i = 0; i < cfgn; i++) {
227 if (image_cfg[i].type == optiontype)
228 return &image_cfg[i];
235 image_count_options(unsigned int optiontype)
238 unsigned int count = 0;
240 for (i = 0; i < cfgn; i++)
241 if (image_cfg[i].type == optiontype)
248 * Compute a 8-bit checksum of a memory area. This algorithm follows
249 * the requirements of the Marvell SoC BootROM specifications.
251 static uint8_t image_checksum8(void *start, uint32_t len)
256 /* check len and return zero checksum if invalid */
268 static uint32_t image_checksum32(void *start, uint32_t len)
273 /* check len and return zero checksum if invalid */
277 if (len % sizeof(uint32_t)) {
278 fprintf(stderr, "Length %d is not in multiple of %zu\n",
279 len, sizeof(uint32_t));
286 len -= sizeof(uint32_t);
292 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
295 struct image_cfg_element *e;
297 struct main_hdr_v0 *main_hdr;
298 struct ext_hdr_v0 *ext_hdr;
303 * Calculate the size of the header and the size of the
306 headersz = sizeof(struct main_hdr_v0);
308 if (image_count_options(IMAGE_CFG_DATA) > 0) {
310 headersz += sizeof(struct ext_hdr_v0);
313 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
314 fprintf(stderr, "More than one payload, not possible\n");
318 image = malloc(headersz);
320 fprintf(stderr, "Cannot allocate memory for image\n");
324 memset(image, 0, headersz);
328 /* Fill in the main header */
329 main_hdr->blocksize = payloadsz + sizeof(uint32_t) - headersz;
330 main_hdr->srcaddr = headersz;
331 main_hdr->ext = has_ext;
332 main_hdr->destaddr = params->addr;
333 main_hdr->execaddr = params->ep;
335 e = image_find_option(IMAGE_CFG_BOOT_FROM);
337 main_hdr->blockid = e->bootfrom;
338 e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
340 main_hdr->nandeccmode = e->nandeccmode;
341 e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
343 main_hdr->nandpagesize = e->nandpagesz;
344 main_hdr->checksum = image_checksum8(image,
345 sizeof(struct main_hdr_v0));
347 /* Generate the ext header */
351 ext_hdr = image + sizeof(struct main_hdr_v0);
352 ext_hdr->offset = 0x40;
354 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
355 e = &image_cfg[cfgi];
356 if (e->type != IMAGE_CFG_DATA)
359 ext_hdr->rcfg[datai].raddr = e->regdata.raddr;
360 ext_hdr->rcfg[datai].rdata = e->regdata.rdata;
364 ext_hdr->checksum = image_checksum8(ext_hdr,
365 sizeof(struct ext_hdr_v0));
372 static size_t image_headersz_v1(struct image_tool_params *params,
375 struct image_cfg_element *binarye;
380 * Calculate the size of the header and the size of the
383 headersz = sizeof(struct main_hdr_v1);
385 if (image_count_options(IMAGE_CFG_BINARY) > 1) {
386 fprintf(stderr, "More than one binary blob, not supported\n");
390 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
391 fprintf(stderr, "More than one payload, not possible\n");
395 binarye = image_find_option(IMAGE_CFG_BINARY);
399 ret = stat(binarye->binary.file, &s);
404 memset(cwd, 0, sizeof(cwd));
405 if (!getcwd(cwd, sizeof(cwd))) {
406 dir = "current working directory";
407 perror("getcwd() failed");
411 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
412 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
413 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
414 binarye->binary.file, dir);
418 headersz += s.st_size +
419 binarye->binary.nargs * sizeof(unsigned int);
425 * The payload should be aligned on some reasonable
428 return ALIGN_SUP(headersz, 4096);
431 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
434 struct image_cfg_element *e, *binarye;
435 struct main_hdr_v1 *main_hdr;
442 * Calculate the size of the header and the size of the
445 headersz = image_headersz_v1(params, &hasext);
449 image = malloc(headersz);
451 fprintf(stderr, "Cannot allocate memory for image\n");
455 memset(image, 0, headersz);
457 cur = main_hdr = image;
458 cur += sizeof(struct main_hdr_v1);
460 /* Fill the main header */
461 main_hdr->blocksize = payloadsz - headersz + sizeof(uint32_t);
462 main_hdr->headersz_lsb = headersz & 0xFFFF;
463 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
464 main_hdr->destaddr = params->addr;
465 main_hdr->execaddr = params->ep;
466 main_hdr->srcaddr = headersz;
467 main_hdr->ext = hasext;
468 main_hdr->version = 1;
469 e = image_find_option(IMAGE_CFG_BOOT_FROM);
471 main_hdr->blockid = e->bootfrom;
472 e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
474 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
475 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
477 main_hdr->nandbadblklocation = e->nandbadblklocation;
479 binarye = image_find_option(IMAGE_CFG_BINARY);
481 struct opt_hdr_v1 *hdr = cur;
488 hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
490 bin = fopen(binarye->binary.file, "r");
492 fprintf(stderr, "Cannot open binary file %s\n",
493 binarye->binary.file);
497 fstat(fileno(bin), &s);
499 binhdrsz = sizeof(struct opt_hdr_v1) +
500 (binarye->binary.nargs + 1) * sizeof(unsigned int) +
502 hdr->headersz_lsb = binhdrsz & 0xFFFF;
503 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
505 cur += sizeof(struct opt_hdr_v1);
508 *args = binarye->binary.nargs;
510 for (argi = 0; argi < binarye->binary.nargs; argi++)
511 args[argi] = binarye->binary.args[argi];
513 cur += (binarye->binary.nargs + 1) * sizeof(unsigned int);
515 ret = fread(cur, s.st_size, 1, bin);
518 "Could not read binary image %s\n",
519 binarye->binary.file);
528 * For now, we don't support more than one binary
529 * header, and no other header types are
530 * supported. So, the binary header is necessarily the
533 *((unsigned char *)cur) = 0;
535 cur += sizeof(uint32_t);
538 /* Calculate and set the header checksum */
539 main_hdr->checksum = image_checksum8(main_hdr, headersz);
545 static int image_create_config_parse_oneline(char *line,
546 struct image_cfg_element *el)
548 char *keyword, *saveptr;
549 char deliminiters[] = " \t";
551 keyword = strtok_r(line, deliminiters, &saveptr);
552 if (!strcmp(keyword, "VERSION")) {
553 char *value = strtok_r(NULL, deliminiters, &saveptr);
554 el->type = IMAGE_CFG_VERSION;
555 el->version = atoi(value);
556 } else if (!strcmp(keyword, "BOOT_FROM")) {
557 char *value = strtok_r(NULL, deliminiters, &saveptr);
558 int ret = image_boot_mode_id(value);
561 "Invalid boot media '%s'\n", value);
564 el->type = IMAGE_CFG_BOOT_FROM;
566 } else if (!strcmp(keyword, "NAND_BLKSZ")) {
567 char *value = strtok_r(NULL, deliminiters, &saveptr);
568 el->type = IMAGE_CFG_NAND_BLKSZ;
569 el->nandblksz = strtoul(value, NULL, 16);
570 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) {
571 char *value = strtok_r(NULL, deliminiters, &saveptr);
572 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION;
573 el->nandbadblklocation =
574 strtoul(value, NULL, 16);
575 } else if (!strcmp(keyword, "NAND_ECC_MODE")) {
576 char *value = strtok_r(NULL, deliminiters, &saveptr);
577 int ret = image_nand_ecc_mode_id(value);
580 "Invalid NAND ECC mode '%s'\n", value);
583 el->type = IMAGE_CFG_NAND_ECC_MODE;
584 el->nandeccmode = ret;
585 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) {
586 char *value = strtok_r(NULL, deliminiters, &saveptr);
587 el->type = IMAGE_CFG_NAND_PAGESZ;
588 el->nandpagesz = strtoul(value, NULL, 16);
589 } else if (!strcmp(keyword, "BINARY")) {
590 char *value = strtok_r(NULL, deliminiters, &saveptr);
593 el->type = IMAGE_CFG_BINARY;
594 el->binary.file = strdup(value);
596 value = strtok_r(NULL, deliminiters, &saveptr);
599 el->binary.args[argi] = strtoul(value, NULL, 16);
601 if (argi >= BINARY_MAX_ARGS) {
603 "Too many argument for binary\n");
607 el->binary.nargs = argi;
608 } else if (!strcmp(keyword, "DATA")) {
609 char *value1 = strtok_r(NULL, deliminiters, &saveptr);
610 char *value2 = strtok_r(NULL, deliminiters, &saveptr);
612 if (!value1 || !value2) {
614 "Invalid number of arguments for DATA\n");
618 el->type = IMAGE_CFG_DATA;
619 el->regdata.raddr = strtoul(value1, NULL, 16);
620 el->regdata.rdata = strtoul(value2, NULL, 16);
622 fprintf(stderr, "Ignoring unknown line '%s'\n", line);
629 * Parse the configuration file 'fcfg' into the array of configuration
630 * elements 'image_cfg', and return the number of configuration
631 * elements in 'cfgn'.
633 static int image_create_config_parse(FILE *fcfg)
638 /* Parse the configuration file */
639 while (!feof(fcfg)) {
643 /* Read the current line */
644 memset(buf, 0, sizeof(buf));
645 line = fgets(buf, sizeof(buf), fcfg);
649 /* Ignore useless lines */
650 if (line[0] == '\n' || line[0] == '#')
653 /* Strip final newline */
654 if (line[strlen(line) - 1] == '\n')
655 line[strlen(line) - 1] = 0;
657 /* Parse the current line */
658 ret = image_create_config_parse_oneline(line,
665 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
667 "Too many configuration elements in .cfg file\n");
676 static int image_get_version(void)
678 struct image_cfg_element *e;
680 e = image_find_option(IMAGE_CFG_VERSION);
687 static int image_version_file(const char *input)
693 fcfg = fopen(input, "r");
695 fprintf(stderr, "Could not open input file %s\n", input);
699 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
700 sizeof(struct image_cfg_element));
702 fprintf(stderr, "Cannot allocate memory\n");
708 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
711 ret = image_create_config_parse(fcfg);
718 version = image_get_version();
719 /* Fallback to version 0 is no version is provided in the cfg file */
728 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
729 struct image_tool_params *params)
739 fcfg = fopen(params->imagename, "r");
741 fprintf(stderr, "Could not open input file %s\n",
746 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
747 sizeof(struct image_cfg_element));
749 fprintf(stderr, "Cannot allocate memory\n");
755 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
758 ret = image_create_config_parse(fcfg);
765 version = image_get_version();
768 * Fallback to version 0 if no version is provided in the
773 image = image_create_v0(&headersz, params, sbuf->st_size);
777 image = image_create_v1(&headersz, params, sbuf->st_size);
781 fprintf(stderr, "Unsupported version %d\n", version);
787 fprintf(stderr, "Could not create image\n");
794 /* Build and add image checksum header */
795 checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size);
796 size = write(ifd, &checksum, sizeof(uint32_t));
797 if (size != sizeof(uint32_t)) {
798 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
799 params->cmdname, size, params->imagefile);
803 sbuf->st_size += sizeof(uint32_t);
805 /* Finally copy the header into the image area */
806 memcpy(ptr, image, headersz);
811 static void kwbimage_print_header(const void *ptr)
813 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
815 printf("Image Type: MVEBU Boot from %s Image\n",
816 image_boot_mode_name(mhdr->blockid));
817 printf("Image version:%d\n", image_version((void *)ptr));
818 printf("Data Size: ");
819 genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
820 printf("Load Address: %08x\n", mhdr->destaddr);
821 printf("Entry Point: %08x\n", mhdr->execaddr);
824 static int kwbimage_check_image_types(uint8_t type)
826 if (type == IH_TYPE_KWBIMAGE)
832 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
833 struct image_tool_params *params)
835 struct main_hdr_v0 *main_hdr;
836 struct ext_hdr_v0 *ext_hdr;
839 main_hdr = (void *)ptr;
840 checksum = image_checksum8(ptr,
841 sizeof(struct main_hdr_v0)
843 if (checksum != main_hdr->checksum)
844 return -FDT_ERR_BADSTRUCTURE;
846 /* Only version 0 extended header has checksum */
847 if (image_version((void *)ptr) == 0) {
848 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0);
849 checksum = image_checksum8(ext_hdr,
850 sizeof(struct ext_hdr_v0)
852 if (checksum != ext_hdr->checksum)
853 return -FDT_ERR_BADSTRUCTURE;
859 static int kwbimage_generate(struct image_tool_params *params,
860 struct image_type_params *tparams)
866 version = image_version_file(params->imagename);
868 alloc_len = sizeof(struct main_hdr_v0) +
869 sizeof(struct ext_hdr_v0);
871 alloc_len = image_headersz_v1(params, NULL);
872 #if defined(CONFIG_SYS_SPI_U_BOOT_OFFS)
873 if (alloc_len > CONFIG_SYS_SPI_U_BOOT_OFFS) {
874 fprintf(stderr, "Error: Image header (incl. SPL image) too big!\n");
875 fprintf(stderr, "header=0x%x CONFIG_SYS_SPI_U_BOOT_OFFS=0x%x!\n",
876 alloc_len, CONFIG_SYS_SPI_U_BOOT_OFFS);
877 fprintf(stderr, "Increase CONFIG_SYS_SPI_U_BOOT_OFFS!\n");
879 alloc_len = CONFIG_SYS_SPI_U_BOOT_OFFS;
884 hdr = malloc(alloc_len);
886 fprintf(stderr, "%s: malloc return failure: %s\n",
887 params->cmdname, strerror(errno));
891 memset(hdr, 0, alloc_len);
892 tparams->header_size = alloc_len;
899 * Report Error if xflag is set in addition to default
901 static int kwbimage_check_params(struct image_tool_params *params)
903 if (!strlen(params->imagename)) {
904 fprintf(stderr, "Error:%s - Configuration file not specified, "
905 "it is needed for kwbimage generation\n",
910 return (params->dflag && (params->fflag || params->lflag)) ||
911 (params->fflag && (params->dflag || params->lflag)) ||
912 (params->lflag && (params->dflag || params->fflag)) ||
913 (params->xflag) || !(strlen(params->imagename));
917 * kwbimage type parameters definition
921 "Marvell MVEBU Boot Image support",
924 kwbimage_check_params,
925 kwbimage_verify_header,
926 kwbimage_print_header,
929 kwbimage_check_image_types,