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"
20 #define ALIGN_SUP(x, a) (((x) + (a - 1)) & ~(a - 1))
22 /* Structure of the main header, version 0 (Kirkwood, Dove) */
24 uint8_t blockid; /*0 */
25 uint8_t nandeccmode; /*1 */
26 uint16_t nandpagesize; /*2-3 */
27 uint32_t blocksize; /*4-7 */
28 uint32_t rsvd1; /*8-11 */
29 uint32_t srcaddr; /*12-15 */
30 uint32_t destaddr; /*16-19 */
31 uint32_t execaddr; /*20-23 */
32 uint8_t satapiomode; /*24 */
33 uint8_t rsvd3; /*25 */
34 uint16_t ddrinitdelay; /*26-27 */
35 uint16_t rsvd2; /*28-29 */
37 uint8_t checksum; /*31 */
40 struct ext_hdr_v0_reg {
45 #define EXT_HDR_V0_REG_COUNT ((0x1dc - 0x20) / sizeof(struct ext_hdr_v0_reg))
49 uint8_t reserved[0x20 - sizeof(uint32_t)];
50 struct ext_hdr_v0_reg rcfg[EXT_HDR_V0_REG_COUNT];
55 /* Structure of the main header, version 1 (Armada 370, Armada XP) */
57 uint8_t blockid; /* 0 */
58 uint8_t reserved1; /* 1 */
59 uint16_t reserved2; /* 2-3 */
60 uint32_t blocksize; /* 4-7 */
61 uint8_t version; /* 8 */
62 uint8_t headersz_msb; /* 9 */
63 uint16_t headersz_lsb; /* A-B */
64 uint32_t srcaddr; /* C-F */
65 uint32_t destaddr; /* 10-13 */
66 uint32_t execaddr; /* 14-17 */
67 uint8_t reserved3; /* 18 */
68 uint8_t nandblocksize; /* 19 */
69 uint8_t nandbadblklocation; /* 1A */
70 uint8_t reserved4; /* 1B */
71 uint16_t reserved5; /* 1C-1D */
73 uint8_t checksum; /* 1F */
77 * Header for the optional headers, version 1 (Armada 370, Armada XP)
82 uint16_t headersz_lsb;
87 * Various values for the opt_hdr_v1->headertype field, describing the
88 * different types of optional headers. The "secure" header contains
89 * informations related to secure boot (encryption keys, etc.). The
90 * "binary" header contains ARM binary code to be executed prior to
91 * executing the main payload (usually the bootloader). This is
92 * typically used to execute DDR3 training code. The "register" header
93 * allows to describe a set of (address, value) tuples that are
94 * generally used to configure the DRAM controller.
96 #define OPT_HDR_V1_SECURE_TYPE 0x1
97 #define OPT_HDR_V1_BINARY_TYPE 0x2
98 #define OPT_HDR_V1_REGISTER_TYPE 0x3
100 #define KWBHEADER_V1_SIZE(hdr) \
101 (((hdr)->headersz_msb << 16) | (hdr)->headersz_lsb)
103 static struct image_cfg_element *image_cfg;
111 struct boot_mode boot_modes[] = {
121 struct nand_ecc_mode {
126 struct nand_ecc_mode nand_ecc_modes[] = {
130 { 0x03, "disabled" },
134 /* Used to identify an undefined execution or destination address */
135 #define ADDR_INVALID ((uint32_t)-1)
137 #define BINARY_MAX_ARGS 8
139 /* In-memory representation of a line of the configuration file */
140 struct image_cfg_element {
142 IMAGE_CFG_VERSION = 0x1,
146 IMAGE_CFG_NAND_BLKSZ,
147 IMAGE_CFG_NAND_BADBLK_LOCATION,
148 IMAGE_CFG_NAND_ECC_MODE,
149 IMAGE_CFG_NAND_PAGESZ,
155 unsigned int version;
156 unsigned int bootfrom;
159 unsigned int args[BINARY_MAX_ARGS];
163 unsigned int dstaddr;
164 unsigned int execaddr;
165 unsigned int nandblksz;
166 unsigned int nandbadblklocation;
167 unsigned int nandeccmode;
168 unsigned int nandpagesz;
169 struct ext_hdr_v0_reg regdata;
173 #define IMAGE_CFG_ELEMENT_MAX 256
176 * Byte 8 of the image header contains the version number. In the v0
177 * header, byte 8 was reserved, and always set to 0. In the v1 header,
178 * byte 8 has been changed to a proper field, set to 1.
180 static unsigned int image_version(void *header)
182 unsigned char *ptr = header;
187 * Utility functions to manipulate boot mode and ecc modes (convert
188 * them back and forth between description strings and the
189 * corresponding numerical identifiers).
192 static const char *image_boot_mode_name(unsigned int id)
195 for (i = 0; boot_modes[i].name; i++)
196 if (boot_modes[i].id == id)
197 return boot_modes[i].name;
201 int image_boot_mode_id(const char *boot_mode_name)
204 for (i = 0; boot_modes[i].name; i++)
205 if (!strcmp(boot_modes[i].name, boot_mode_name))
206 return boot_modes[i].id;
211 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
214 for (i = 0; nand_ecc_modes[i].name; i++)
215 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
216 return nand_ecc_modes[i].id;
220 static struct image_cfg_element *
221 image_find_option(unsigned int optiontype)
225 for (i = 0; i < cfgn; i++) {
226 if (image_cfg[i].type == optiontype)
227 return &image_cfg[i];
234 image_count_options(unsigned int optiontype)
237 unsigned int count = 0;
239 for (i = 0; i < cfgn; i++)
240 if (image_cfg[i].type == optiontype)
247 * Compute a 8-bit checksum of a memory area. This algorithm follows
248 * the requirements of the Marvell SoC BootROM specifications.
250 static uint8_t image_checksum8(void *start, uint32_t len)
255 /* check len and return zero checksum if invalid */
267 static uint32_t image_checksum32(void *start, uint32_t len)
272 /* check len and return zero checksum if invalid */
276 if (len % sizeof(uint32_t)) {
277 fprintf(stderr, "Length %d is not in multiple of %zu\n",
278 len, sizeof(uint32_t));
285 len -= sizeof(uint32_t);
291 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
294 struct image_cfg_element *e;
296 struct main_hdr_v0 *main_hdr;
297 struct ext_hdr_v0 *ext_hdr;
302 * Calculate the size of the header and the size of the
305 headersz = sizeof(struct main_hdr_v0);
307 if (image_count_options(IMAGE_CFG_DATA) > 0) {
309 headersz += sizeof(struct ext_hdr_v0);
312 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
313 fprintf(stderr, "More than one payload, not possible\n");
317 image = malloc(headersz);
319 fprintf(stderr, "Cannot allocate memory for image\n");
323 memset(image, 0, headersz);
327 /* Fill in the main header */
328 main_hdr->blocksize = payloadsz + sizeof(uint32_t) - headersz;
329 main_hdr->srcaddr = headersz;
330 main_hdr->ext = has_ext;
331 main_hdr->destaddr = params->addr;
332 main_hdr->execaddr = params->ep;
334 e = image_find_option(IMAGE_CFG_BOOT_FROM);
336 main_hdr->blockid = e->bootfrom;
337 e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
339 main_hdr->nandeccmode = e->nandeccmode;
340 e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
342 main_hdr->nandpagesize = e->nandpagesz;
343 main_hdr->checksum = image_checksum8(image,
344 sizeof(struct main_hdr_v0));
346 /* Generate the ext header */
350 ext_hdr = image + sizeof(struct main_hdr_v0);
351 ext_hdr->offset = 0x40;
353 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
354 e = &image_cfg[cfgi];
355 if (e->type != IMAGE_CFG_DATA)
358 ext_hdr->rcfg[datai].raddr = e->regdata.raddr;
359 ext_hdr->rcfg[datai].rdata = e->regdata.rdata;
363 ext_hdr->checksum = image_checksum8(ext_hdr,
364 sizeof(struct ext_hdr_v0));
371 static size_t image_headersz_v1(struct image_tool_params *params,
374 struct image_cfg_element *binarye;
379 * Calculate the size of the header and the size of the
382 headersz = sizeof(struct main_hdr_v1);
384 if (image_count_options(IMAGE_CFG_BINARY) > 1) {
385 fprintf(stderr, "More than one binary blob, not supported\n");
389 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
390 fprintf(stderr, "More than one payload, not possible\n");
394 binarye = image_find_option(IMAGE_CFG_BINARY);
398 ret = stat(binarye->binary.file, &s);
403 memset(cwd, 0, sizeof(cwd));
404 if (!getcwd(cwd, sizeof(cwd))) {
405 dir = "current working directory";
406 perror("getcwd() failed");
410 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
411 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
412 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
413 binarye->binary.file, dir);
417 headersz += s.st_size +
418 binarye->binary.nargs * sizeof(unsigned int);
423 #if defined(CONFIG_SYS_SPI_U_BOOT_OFFS)
424 if (headersz > CONFIG_SYS_SPI_U_BOOT_OFFS) {
425 fprintf(stderr, "Error: Image header (incl. SPL image) too big!\n");
426 fprintf(stderr, "header=0x%x CONFIG_SYS_SPI_U_BOOT_OFFS=0x%x!\n",
427 (int)headersz, CONFIG_SYS_SPI_U_BOOT_OFFS);
428 fprintf(stderr, "Increase CONFIG_SYS_SPI_U_BOOT_OFFS!\n");
431 headersz = CONFIG_SYS_SPI_U_BOOT_OFFS;
436 * The payload should be aligned on some reasonable
439 return ALIGN_SUP(headersz, 4096);
442 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
445 struct image_cfg_element *e, *binarye;
446 struct main_hdr_v1 *main_hdr;
453 * Calculate the size of the header and the size of the
456 headersz = image_headersz_v1(params, &hasext);
460 image = malloc(headersz);
462 fprintf(stderr, "Cannot allocate memory for image\n");
466 memset(image, 0, headersz);
468 cur = main_hdr = image;
469 cur += sizeof(struct main_hdr_v1);
471 /* Fill the main header */
472 main_hdr->blocksize = payloadsz - headersz + sizeof(uint32_t);
473 main_hdr->headersz_lsb = headersz & 0xFFFF;
474 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
475 main_hdr->destaddr = params->addr;
476 main_hdr->execaddr = params->ep;
477 main_hdr->srcaddr = headersz;
478 main_hdr->ext = hasext;
479 main_hdr->version = 1;
480 e = image_find_option(IMAGE_CFG_BOOT_FROM);
482 main_hdr->blockid = e->bootfrom;
483 e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
485 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
486 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
488 main_hdr->nandbadblklocation = e->nandbadblklocation;
490 binarye = image_find_option(IMAGE_CFG_BINARY);
492 struct opt_hdr_v1 *hdr = cur;
499 hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
501 bin = fopen(binarye->binary.file, "r");
503 fprintf(stderr, "Cannot open binary file %s\n",
504 binarye->binary.file);
508 fstat(fileno(bin), &s);
510 binhdrsz = sizeof(struct opt_hdr_v1) +
511 (binarye->binary.nargs + 1) * sizeof(unsigned int) +
513 binhdrsz = ALIGN_SUP(binhdrsz, 32);
514 hdr->headersz_lsb = binhdrsz & 0xFFFF;
515 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
517 cur += sizeof(struct opt_hdr_v1);
520 *args = binarye->binary.nargs;
522 for (argi = 0; argi < binarye->binary.nargs; argi++)
523 args[argi] = binarye->binary.args[argi];
525 cur += (binarye->binary.nargs + 1) * sizeof(unsigned int);
527 ret = fread(cur, s.st_size, 1, bin);
530 "Could not read binary image %s\n",
531 binarye->binary.file);
540 * For now, we don't support more than one binary
541 * header, and no other header types are
542 * supported. So, the binary header is necessarily the
545 *((unsigned char *)cur) = 0;
547 cur += sizeof(uint32_t);
550 /* Calculate and set the header checksum */
551 main_hdr->checksum = image_checksum8(main_hdr, headersz);
557 static int image_create_config_parse_oneline(char *line,
558 struct image_cfg_element *el)
560 char *keyword, *saveptr;
561 char deliminiters[] = " \t";
563 keyword = strtok_r(line, deliminiters, &saveptr);
564 if (!strcmp(keyword, "VERSION")) {
565 char *value = strtok_r(NULL, deliminiters, &saveptr);
566 el->type = IMAGE_CFG_VERSION;
567 el->version = atoi(value);
568 } else if (!strcmp(keyword, "BOOT_FROM")) {
569 char *value = strtok_r(NULL, deliminiters, &saveptr);
570 int ret = image_boot_mode_id(value);
573 "Invalid boot media '%s'\n", value);
576 el->type = IMAGE_CFG_BOOT_FROM;
578 } else if (!strcmp(keyword, "NAND_BLKSZ")) {
579 char *value = strtok_r(NULL, deliminiters, &saveptr);
580 el->type = IMAGE_CFG_NAND_BLKSZ;
581 el->nandblksz = strtoul(value, NULL, 16);
582 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) {
583 char *value = strtok_r(NULL, deliminiters, &saveptr);
584 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION;
585 el->nandbadblklocation =
586 strtoul(value, NULL, 16);
587 } else if (!strcmp(keyword, "NAND_ECC_MODE")) {
588 char *value = strtok_r(NULL, deliminiters, &saveptr);
589 int ret = image_nand_ecc_mode_id(value);
592 "Invalid NAND ECC mode '%s'\n", value);
595 el->type = IMAGE_CFG_NAND_ECC_MODE;
596 el->nandeccmode = ret;
597 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) {
598 char *value = strtok_r(NULL, deliminiters, &saveptr);
599 el->type = IMAGE_CFG_NAND_PAGESZ;
600 el->nandpagesz = strtoul(value, NULL, 16);
601 } else if (!strcmp(keyword, "BINARY")) {
602 char *value = strtok_r(NULL, deliminiters, &saveptr);
605 el->type = IMAGE_CFG_BINARY;
606 el->binary.file = strdup(value);
608 value = strtok_r(NULL, deliminiters, &saveptr);
611 el->binary.args[argi] = strtoul(value, NULL, 16);
613 if (argi >= BINARY_MAX_ARGS) {
615 "Too many argument for binary\n");
619 el->binary.nargs = argi;
620 } else if (!strcmp(keyword, "DATA")) {
621 char *value1 = strtok_r(NULL, deliminiters, &saveptr);
622 char *value2 = strtok_r(NULL, deliminiters, &saveptr);
624 if (!value1 || !value2) {
626 "Invalid number of arguments for DATA\n");
630 el->type = IMAGE_CFG_DATA;
631 el->regdata.raddr = strtoul(value1, NULL, 16);
632 el->regdata.rdata = strtoul(value2, NULL, 16);
634 fprintf(stderr, "Ignoring unknown line '%s'\n", line);
641 * Parse the configuration file 'fcfg' into the array of configuration
642 * elements 'image_cfg', and return the number of configuration
643 * elements in 'cfgn'.
645 static int image_create_config_parse(FILE *fcfg)
650 /* Parse the configuration file */
651 while (!feof(fcfg)) {
655 /* Read the current line */
656 memset(buf, 0, sizeof(buf));
657 line = fgets(buf, sizeof(buf), fcfg);
661 /* Ignore useless lines */
662 if (line[0] == '\n' || line[0] == '#')
665 /* Strip final newline */
666 if (line[strlen(line) - 1] == '\n')
667 line[strlen(line) - 1] = 0;
669 /* Parse the current line */
670 ret = image_create_config_parse_oneline(line,
677 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
679 "Too many configuration elements in .cfg file\n");
688 static int image_get_version(void)
690 struct image_cfg_element *e;
692 e = image_find_option(IMAGE_CFG_VERSION);
699 static int image_version_file(const char *input)
705 fcfg = fopen(input, "r");
707 fprintf(stderr, "Could not open input file %s\n", input);
711 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
712 sizeof(struct image_cfg_element));
714 fprintf(stderr, "Cannot allocate memory\n");
720 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
723 ret = image_create_config_parse(fcfg);
730 version = image_get_version();
731 /* Fallback to version 0 is no version is provided in the cfg file */
740 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
741 struct image_tool_params *params)
751 fcfg = fopen(params->imagename, "r");
753 fprintf(stderr, "Could not open input file %s\n",
758 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
759 sizeof(struct image_cfg_element));
761 fprintf(stderr, "Cannot allocate memory\n");
767 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
770 ret = image_create_config_parse(fcfg);
777 version = image_get_version();
780 * Fallback to version 0 if no version is provided in the
785 image = image_create_v0(&headersz, params, sbuf->st_size);
789 image = image_create_v1(&headersz, params, sbuf->st_size);
793 fprintf(stderr, "Unsupported version %d\n", version);
799 fprintf(stderr, "Could not create image\n");
806 /* Build and add image checksum header */
807 checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size);
808 size = write(ifd, &checksum, sizeof(uint32_t));
809 if (size != sizeof(uint32_t)) {
810 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
811 params->cmdname, size, params->imagefile);
815 sbuf->st_size += sizeof(uint32_t);
817 /* Finally copy the header into the image area */
818 memcpy(ptr, image, headersz);
823 static void kwbimage_print_header(const void *ptr)
825 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
827 printf("Image Type: MVEBU Boot from %s Image\n",
828 image_boot_mode_name(mhdr->blockid));
829 printf("Image version:%d\n", image_version((void *)ptr));
830 printf("Data Size: ");
831 genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
832 printf("Load Address: %08x\n", mhdr->destaddr);
833 printf("Entry Point: %08x\n", mhdr->execaddr);
836 static int kwbimage_check_image_types(uint8_t type)
838 if (type == IH_TYPE_KWBIMAGE)
844 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
845 struct image_tool_params *params)
847 struct main_hdr_v0 *main_hdr;
848 struct ext_hdr_v0 *ext_hdr;
851 main_hdr = (void *)ptr;
852 checksum = image_checksum8(ptr,
853 sizeof(struct main_hdr_v0)
855 if (checksum != main_hdr->checksum)
856 return -FDT_ERR_BADSTRUCTURE;
858 /* Only version 0 extended header has checksum */
859 if (image_version((void *)ptr) == 0) {
860 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0);
861 checksum = image_checksum8(ext_hdr,
862 sizeof(struct ext_hdr_v0)
864 if (checksum != ext_hdr->checksum)
865 return -FDT_ERR_BADSTRUCTURE;
871 static int kwbimage_generate(struct image_tool_params *params,
872 struct image_type_params *tparams)
878 version = image_version_file(params->imagename);
880 alloc_len = sizeof(struct main_hdr_v0) +
881 sizeof(struct ext_hdr_v0);
883 alloc_len = image_headersz_v1(params, NULL);
886 hdr = malloc(alloc_len);
888 fprintf(stderr, "%s: malloc return failure: %s\n",
889 params->cmdname, strerror(errno));
893 memset(hdr, 0, alloc_len);
894 tparams->header_size = alloc_len;
901 * Report Error if xflag is set in addition to default
903 static int kwbimage_check_params(struct image_tool_params *params)
905 if (!strlen(params->imagename)) {
906 fprintf(stderr, "Error:%s - Configuration file not specified, "
907 "it is needed for kwbimage generation\n",
912 return (params->dflag && (params->fflag || params->lflag)) ||
913 (params->fflag && (params->dflag || params->lflag)) ||
914 (params->lflag && (params->dflag || params->fflag)) ||
915 (params->xflag) || !(strlen(params->imagename));
919 * kwbimage type parameters definition
923 "Marvell MVEBU Boot Image support",
926 kwbimage_check_params,
927 kwbimage_verify_header,
928 kwbimage_print_header,
931 kwbimage_check_image_types,