1 // SPDX-License-Identifier: GPL-2.0+
3 * Image manipulator for Marvell SoCs
4 * supports Kirkwood, Dove, Armada 370, Armada XP, Armada 375, Armada 38x and
7 * (C) Copyright 2013 Thomas Petazzoni
8 * <thomas.petazzoni@free-electrons.com>
11 #define OPENSSL_API_COMPAT 0x10101000L
13 #include "imagetool.h"
20 #include <openssl/bn.h>
21 #include <openssl/rsa.h>
22 #include <openssl/pem.h>
23 #include <openssl/err.h>
24 #include <openssl/evp.h>
26 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
27 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
28 static void RSA_get0_key(const RSA *r,
29 const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
39 #elif !defined(LIBRESSL_VERSION_NUMBER)
40 void EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
42 EVP_MD_CTX_reset(ctx);
46 static struct image_cfg_element *image_cfg;
48 static int verbose_mode;
62 struct boot_mode boot_modes[] = {
63 { IBR_HDR_I2C_ID, "i2c" },
64 { IBR_HDR_SPI_ID, "spi" },
65 { IBR_HDR_NAND_ID, "nand" },
66 { IBR_HDR_SATA_ID, "sata" },
67 { IBR_HDR_PEX_ID, "pex" },
68 { IBR_HDR_UART_ID, "uart" },
69 { IBR_HDR_SDIO_ID, "sdio" },
73 struct nand_ecc_mode {
78 struct nand_ecc_mode nand_ecc_modes[] = {
79 { IBR_HDR_ECC_DEFAULT, "default" },
80 { IBR_HDR_ECC_FORCED_HAMMING, "hamming" },
81 { IBR_HDR_ECC_FORCED_RS, "rs" },
82 { IBR_HDR_ECC_DISABLED, "disabled" },
86 /* Used to identify an undefined execution or destination address */
87 #define ADDR_INVALID ((uint32_t)-1)
89 #define BINARY_MAX_ARGS 255
91 /* In-memory representation of a line of the configuration file */
94 IMAGE_CFG_VERSION = 0x1,
99 IMAGE_CFG_NAND_BADBLK_LOCATION,
100 IMAGE_CFG_NAND_ECC_MODE,
101 IMAGE_CFG_NAND_PAGESZ,
104 IMAGE_CFG_DATA_DELAY,
112 IMAGE_CFG_JTAG_DELAY,
115 IMAGE_CFG_SEC_COMMON_IMG,
116 IMAGE_CFG_SEC_SPECIALIZED_IMG,
117 IMAGE_CFG_SEC_BOOT_DEV,
118 IMAGE_CFG_SEC_FUSE_DUMP,
123 static const char * const id_strs[] = {
124 [IMAGE_CFG_VERSION] = "VERSION",
125 [IMAGE_CFG_BOOT_FROM] = "BOOT_FROM",
126 [IMAGE_CFG_DEST_ADDR] = "DEST_ADDR",
127 [IMAGE_CFG_EXEC_ADDR] = "EXEC_ADDR",
128 [IMAGE_CFG_NAND_BLKSZ] = "NAND_BLKSZ",
129 [IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
130 [IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
131 [IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
132 [IMAGE_CFG_BINARY] = "BINARY",
133 [IMAGE_CFG_DATA] = "DATA",
134 [IMAGE_CFG_DATA_DELAY] = "DATA_DELAY",
135 [IMAGE_CFG_BAUDRATE] = "BAUDRATE",
136 [IMAGE_CFG_UART_PORT] = "UART_PORT",
137 [IMAGE_CFG_UART_MPP] = "UART_MPP",
138 [IMAGE_CFG_DEBUG] = "DEBUG",
139 [IMAGE_CFG_KAK] = "KAK",
140 [IMAGE_CFG_CSK] = "CSK",
141 [IMAGE_CFG_CSK_INDEX] = "CSK_INDEX",
142 [IMAGE_CFG_JTAG_DELAY] = "JTAG_DELAY",
143 [IMAGE_CFG_BOX_ID] = "BOX_ID",
144 [IMAGE_CFG_FLASH_ID] = "FLASH_ID",
145 [IMAGE_CFG_SEC_COMMON_IMG] = "SEC_COMMON_IMG",
146 [IMAGE_CFG_SEC_SPECIALIZED_IMG] = "SEC_SPECIALIZED_IMG",
147 [IMAGE_CFG_SEC_BOOT_DEV] = "SEC_BOOT_DEV",
148 [IMAGE_CFG_SEC_FUSE_DUMP] = "SEC_FUSE_DUMP"
151 struct image_cfg_element {
152 enum image_cfg_type type;
154 unsigned int version;
155 unsigned int bootfrom;
158 unsigned int args[BINARY_MAX_ARGS];
161 unsigned int dstaddr;
162 unsigned int execaddr;
163 unsigned int nandblksz;
164 unsigned int nandbadblklocation;
165 unsigned int nandeccmode;
166 unsigned int nandpagesz;
167 struct ext_hdr_v0_reg regdata;
168 unsigned int regdata_delay;
169 unsigned int baudrate;
170 unsigned int uart_port;
171 unsigned int uart_mpp;
173 const char *key_name;
178 bool sec_specialized_img;
179 unsigned int sec_boot_dev;
184 #define IMAGE_CFG_ELEMENT_MAX 256
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)
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)
206 for (i = 0; boot_modes[i].name; i++)
207 if (!strcmp(boot_modes[i].name, boot_mode_name))
208 return boot_modes[i].id;
213 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
217 for (i = 0; nand_ecc_modes[i].name; i++)
218 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
219 return nand_ecc_modes[i].id;
223 static struct image_cfg_element *
224 image_find_option(unsigned int optiontype)
228 for (i = 0; i < cfgn; i++) {
229 if (image_cfg[i].type == optiontype)
230 return &image_cfg[i];
237 image_count_options(unsigned int optiontype)
240 unsigned int count = 0;
242 for (i = 0; i < cfgn; i++)
243 if (image_cfg[i].type == optiontype)
249 static int image_get_csk_index(void)
251 struct image_cfg_element *e;
253 e = image_find_option(IMAGE_CFG_CSK_INDEX);
260 static bool image_get_spezialized_img(void)
262 struct image_cfg_element *e;
264 e = image_find_option(IMAGE_CFG_SEC_SPECIALIZED_IMG);
268 return e->sec_specialized_img;
271 static int image_get_bootfrom(void)
273 struct image_cfg_element *e;
275 e = image_find_option(IMAGE_CFG_BOOT_FROM);
277 /* fallback to SPI if no BOOT_FROM is not provided */
278 return IBR_HDR_SPI_ID;
284 * Compute a 8-bit checksum of a memory area. This algorithm follows
285 * the requirements of the Marvell SoC BootROM specifications.
287 static uint8_t image_checksum8(void *start, uint32_t len)
292 /* check len and return zero checksum if invalid */
305 * Verify checksum over a complete header that includes the checksum field.
306 * Return 1 when OK, otherwise 0.
308 static int main_hdr_checksum_ok(void *hdr)
310 /* Offsets of checksum in v0 and v1 headers are the same */
311 struct main_hdr_v0 *main_hdr = (struct main_hdr_v0 *)hdr;
314 checksum = image_checksum8(hdr, kwbheader_size_for_csum(hdr));
315 /* Calculated checksum includes the header checksum field. Compensate
318 checksum -= main_hdr->checksum;
320 return checksum == main_hdr->checksum;
323 static uint32_t image_checksum32(void *start, uint32_t len)
328 /* check len and return zero checksum if invalid */
332 if (len % sizeof(uint32_t)) {
333 fprintf(stderr, "Length %d is not in multiple of %zu\n",
334 len, sizeof(uint32_t));
341 len -= sizeof(uint32_t);
347 static uint8_t baudrate_to_option(unsigned int baudrate)
351 return MAIN_HDR_V1_OPT_BAUD_2400;
353 return MAIN_HDR_V1_OPT_BAUD_4800;
355 return MAIN_HDR_V1_OPT_BAUD_9600;
357 return MAIN_HDR_V1_OPT_BAUD_19200;
359 return MAIN_HDR_V1_OPT_BAUD_38400;
361 return MAIN_HDR_V1_OPT_BAUD_57600;
363 return MAIN_HDR_V1_OPT_BAUD_115200;
365 return MAIN_HDR_V1_OPT_BAUD_DEFAULT;
369 static void kwb_msg(const char *fmt, ...)
375 vfprintf(stdout, fmt, ap);
380 static int openssl_err(const char *msg)
382 unsigned long ssl_err = ERR_get_error();
384 fprintf(stderr, "%s", msg);
385 fprintf(stderr, ": %s\n",
386 ERR_error_string(ssl_err, 0));
391 static int kwb_load_rsa_key(const char *keydir, const char *name, RSA **p_rsa)
400 snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
401 f = fopen(path, "r");
403 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
404 path, strerror(errno));
408 rsa = PEM_read_RSAPrivateKey(f, 0, NULL, "");
410 openssl_err("Failure reading private key");
420 static int kwb_load_cfg_key(struct image_tool_params *params,
421 unsigned int cfg_option, const char *key_name,
424 struct image_cfg_element *e_key;
430 e_key = image_find_option(cfg_option);
432 fprintf(stderr, "%s not configured\n", key_name);
436 res = kwb_load_rsa_key(params->keydir, e_key->key_name, &key);
438 fprintf(stderr, "Failed to load %s\n", key_name);
447 static int kwb_load_kak(struct image_tool_params *params, RSA **p_kak)
449 return kwb_load_cfg_key(params, IMAGE_CFG_KAK, "KAK", p_kak);
452 static int kwb_load_csk(struct image_tool_params *params, RSA **p_csk)
454 return kwb_load_cfg_key(params, IMAGE_CFG_CSK, "CSK", p_csk);
457 static int kwb_compute_pubkey_hash(struct pubkey_der_v1 *pk,
458 struct hash_v1 *hash)
461 unsigned int key_size;
462 unsigned int hash_size;
465 if (!pk || !hash || pk->key[0] != 0x30 || pk->key[1] != 0x82)
468 key_size = (pk->key[2] << 8) + pk->key[3] + 4;
470 ctx = EVP_MD_CTX_create();
472 return openssl_err("EVP context creation failed");
474 EVP_MD_CTX_init(ctx);
475 if (!EVP_DigestInit(ctx, EVP_sha256())) {
476 ret = openssl_err("Digest setup failed");
480 if (!EVP_DigestUpdate(ctx, pk->key, key_size)) {
481 ret = openssl_err("Hashing data failed");
485 if (!EVP_DigestFinal(ctx, hash->hash, &hash_size)) {
486 ret = openssl_err("Could not obtain hash");
490 EVP_MD_CTX_cleanup(ctx);
493 EVP_MD_CTX_destroy(ctx);
497 static int kwb_import_pubkey(RSA **key, struct pubkey_der_v1 *src, char *keyname)
500 const unsigned char *ptr;
506 rsa = d2i_RSAPublicKey(key, &ptr, sizeof(src->key));
508 openssl_err("error decoding public key");
514 fprintf(stderr, "Failed to decode %s pubkey\n", keyname);
518 static int kwb_export_pubkey(RSA *key, struct pubkey_der_v1 *dst, FILE *hashf,
521 int size_exp, size_mod, size_seq;
522 const BIGNUM *key_e, *key_n;
524 char *errmsg = "Failed to encode %s\n";
526 RSA_get0_key(key, NULL, &key_e, NULL);
527 RSA_get0_key(key, &key_n, NULL, NULL);
529 if (!key || !key_e || !key_n || !dst) {
530 fprintf(stderr, "export pk failed: (%p, %p, %p, %p)",
531 key, key_e, key_n, dst);
532 fprintf(stderr, errmsg, keyname);
537 * According to the specs, the key should be PKCS#1 DER encoded.
538 * But unfortunately the really required encoding seems to be different;
539 * it violates DER...! (But it still conformes to BER.)
540 * (Length always in long form w/ 2 byte length code; no leading zero
541 * when MSB of first byte is set...)
542 * So we cannot use the encoding func provided by OpenSSL and have to
543 * do the encoding manually.
546 size_exp = BN_num_bytes(key_e);
547 size_mod = BN_num_bytes(key_n);
548 size_seq = 4 + size_mod + 4 + size_exp;
550 if (size_mod > 256) {
551 fprintf(stderr, "export pk failed: wrong mod size: %d\n",
553 fprintf(stderr, errmsg, keyname);
557 if (4 + size_seq > sizeof(dst->key)) {
558 fprintf(stderr, "export pk failed: seq too large (%d, %zu)\n",
559 4 + size_seq, sizeof(dst->key));
560 fprintf(stderr, errmsg, keyname);
566 /* PKCS#1 (RFC3447) RSAPublicKey structure */
567 *cur++ = 0x30; /* SEQUENCE */
569 *cur++ = (size_seq >> 8) & 0xFF;
570 *cur++ = size_seq & 0xFF;
572 *cur++ = 0x02; /* INTEGER */
574 *cur++ = (size_mod >> 8) & 0xFF;
575 *cur++ = size_mod & 0xFF;
576 BN_bn2bin(key_n, cur);
579 *cur++ = 0x02; /* INTEGER */
581 *cur++ = (size_exp >> 8) & 0xFF;
582 *cur++ = size_exp & 0xFF;
583 BN_bn2bin(key_e, cur);
586 struct hash_v1 pk_hash;
590 ret = kwb_compute_pubkey_hash(dst, &pk_hash);
592 fprintf(stderr, errmsg, keyname);
596 fprintf(hashf, "SHA256 = ");
597 for (i = 0 ; i < sizeof(pk_hash.hash); ++i)
598 fprintf(hashf, "%02X", pk_hash.hash[i]);
599 fprintf(hashf, "\n");
605 int kwb_sign(RSA *key, void *data, int datasz, struct sig_v1 *sig, char *signame)
609 unsigned int sig_size;
613 evp_key = EVP_PKEY_new();
615 return openssl_err("EVP_PKEY object creation failed");
617 if (!EVP_PKEY_set1_RSA(evp_key, key)) {
618 ret = openssl_err("EVP key setup failed");
622 size = EVP_PKEY_size(evp_key);
623 if (size > sizeof(sig->sig)) {
624 fprintf(stderr, "Buffer to small for signature (%d bytes)\n",
630 ctx = EVP_MD_CTX_create();
632 ret = openssl_err("EVP context creation failed");
635 EVP_MD_CTX_init(ctx);
636 if (!EVP_SignInit(ctx, EVP_sha256())) {
637 ret = openssl_err("Signer setup failed");
641 if (!EVP_SignUpdate(ctx, data, datasz)) {
642 ret = openssl_err("Signing data failed");
646 if (!EVP_SignFinal(ctx, sig->sig, &sig_size, evp_key)) {
647 ret = openssl_err("Could not obtain signature");
651 EVP_MD_CTX_cleanup(ctx);
652 EVP_MD_CTX_destroy(ctx);
653 EVP_PKEY_free(evp_key);
658 EVP_MD_CTX_destroy(ctx);
660 EVP_PKEY_free(evp_key);
661 fprintf(stderr, "Failed to create %s signature\n", signame);
665 int kwb_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
673 evp_key = EVP_PKEY_new();
675 return openssl_err("EVP_PKEY object creation failed");
677 if (!EVP_PKEY_set1_RSA(evp_key, key)) {
678 ret = openssl_err("EVP key setup failed");
682 size = EVP_PKEY_size(evp_key);
683 if (size > sizeof(sig->sig)) {
684 fprintf(stderr, "Invalid signature size (%d bytes)\n",
690 ctx = EVP_MD_CTX_create();
692 ret = openssl_err("EVP context creation failed");
695 EVP_MD_CTX_init(ctx);
696 if (!EVP_VerifyInit(ctx, EVP_sha256())) {
697 ret = openssl_err("Verifier setup failed");
701 if (!EVP_VerifyUpdate(ctx, data, datasz)) {
702 ret = openssl_err("Hashing data failed");
706 if (EVP_VerifyFinal(ctx, sig->sig, sizeof(sig->sig), evp_key) != 1) {
707 ret = openssl_err("Could not verify signature");
711 EVP_MD_CTX_cleanup(ctx);
712 EVP_MD_CTX_destroy(ctx);
713 EVP_PKEY_free(evp_key);
718 EVP_MD_CTX_destroy(ctx);
720 EVP_PKEY_free(evp_key);
721 fprintf(stderr, "Failed to verify %s signature\n", signame);
725 int kwb_sign_and_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
728 if (kwb_sign(key, data, datasz, sig, signame) < 0)
731 if (kwb_verify(key, data, datasz, sig, signame) < 0)
738 int kwb_dump_fuse_cmds_38x(FILE *out, struct secure_hdr_v1 *sec_hdr)
740 struct hash_v1 kak_pub_hash;
741 struct image_cfg_element *e;
742 unsigned int fuse_line;
748 if (!out || !sec_hdr)
751 ret = kwb_compute_pubkey_hash(&sec_hdr->kak, &kak_pub_hash);
755 fprintf(out, "# burn KAK pub key hash\n");
756 ptr = kak_pub_hash.hash;
757 for (fuse_line = 26; fuse_line <= 30; ++fuse_line) {
758 fprintf(out, "fuse prog -y %u 0 ", fuse_line);
760 for (i = 4; i-- > 0;)
761 fprintf(out, "%02hx", (ushort)ptr[i]);
765 if (fuse_line < 30) {
766 for (i = 3; i-- > 0;)
767 fprintf(out, "%02hx", (ushort)ptr[i]);
770 fprintf(out, "000000");
773 fprintf(out, " 1\n");
776 fprintf(out, "# burn CSK selection\n");
778 idx = image_get_csk_index();
779 if (idx < 0 || idx > 15) {
784 for (fuse_line = 31; fuse_line < 31 + idx; ++fuse_line)
785 fprintf(out, "fuse prog -y %u 0 00000001 00000000 1\n",
788 fprintf(out, "# CSK index is 0; no mods needed\n");
791 e = image_find_option(IMAGE_CFG_BOX_ID);
793 fprintf(out, "# set box ID\n");
794 fprintf(out, "fuse prog -y 48 0 %08x 00000000 1\n", e->boxid);
797 e = image_find_option(IMAGE_CFG_FLASH_ID);
799 fprintf(out, "# set flash ID\n");
800 fprintf(out, "fuse prog -y 47 0 %08x 00000000 1\n", e->flashid);
803 fprintf(out, "# enable secure mode ");
804 fprintf(out, "(must be the last fuse line written)\n");
807 e = image_find_option(IMAGE_CFG_SEC_BOOT_DEV);
809 fprintf(stderr, "ERROR: secured mode boot device not given\n");
814 if (e->sec_boot_dev > 0xff) {
815 fprintf(stderr, "ERROR: secured mode boot device invalid\n");
820 val |= (e->sec_boot_dev << 8);
822 fprintf(out, "fuse prog -y 24 0 %08x 0103e0a9 1\n", val);
824 fprintf(out, "# lock (unused) fuse lines (0-23)s\n");
825 for (fuse_line = 0; fuse_line < 24; ++fuse_line)
826 fprintf(out, "fuse prog -y %u 2 1\n", fuse_line);
828 fprintf(out, "# OK, that's all :-)\n");
834 static int kwb_dump_fuse_cmds(struct secure_hdr_v1 *sec_hdr)
837 struct image_cfg_element *e;
839 e = image_find_option(IMAGE_CFG_SEC_FUSE_DUMP);
843 if (!strcmp(e->name, "a38x")) {
844 FILE *out = fopen("kwb_fuses_a38x.txt", "w+");
847 fprintf(stderr, "Couldn't open eFuse settings: '%s': %s\n",
848 "kwb_fuses_a38x.txt", strerror(errno));
852 kwb_dump_fuse_cmds_38x(out, sec_hdr);
863 static size_t image_headersz_align(size_t headersz, uint8_t blockid)
866 * Header needs to be 4-byte aligned, which is already ensured by code
867 * above. Moreover UART images must have header aligned to 128 bytes
868 * (xmodem block size), NAND images to 256 bytes (ECC calculation),
869 * and SATA and SDIO images to 512 bytes (storage block size).
870 * Note that SPI images do not have to have header size aligned
871 * to 256 bytes because it is possible to read from SPI storage from
872 * any offset (read offset does not have to be aligned to block size).
874 if (blockid == IBR_HDR_UART_ID)
875 return ALIGN(headersz, 128);
876 else if (blockid == IBR_HDR_NAND_ID)
877 return ALIGN(headersz, 256);
878 else if (blockid == IBR_HDR_SATA_ID || blockid == IBR_HDR_SDIO_ID)
879 return ALIGN(headersz, 512);
884 static size_t image_headersz_v0(int *hasext)
888 headersz = sizeof(struct main_hdr_v0);
889 if (image_count_options(IMAGE_CFG_DATA) > 0) {
890 headersz += sizeof(struct ext_hdr_v0);
895 return image_headersz_align(headersz, image_get_bootfrom());
898 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
901 struct image_cfg_element *e;
903 struct main_hdr_v0 *main_hdr;
908 * Calculate the size of the header and the size of the
911 headersz = image_headersz_v0(&has_ext);
913 image = malloc(headersz);
915 fprintf(stderr, "Cannot allocate memory for image\n");
919 memset(image, 0, headersz);
921 main_hdr = (struct main_hdr_v0 *)image;
923 /* Fill in the main header */
924 main_hdr->blocksize =
925 cpu_to_le32(payloadsz);
926 main_hdr->srcaddr = cpu_to_le32(headersz);
927 main_hdr->ext = has_ext;
928 main_hdr->version = 0;
929 main_hdr->destaddr = cpu_to_le32(params->addr);
930 main_hdr->execaddr = cpu_to_le32(params->ep);
931 main_hdr->blockid = image_get_bootfrom();
933 e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
935 main_hdr->nandeccmode = e->nandeccmode;
936 e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
938 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
939 main_hdr->checksum = image_checksum8(image,
940 sizeof(struct main_hdr_v0));
943 * For SATA srcaddr is specified in number of sectors starting from
944 * sector 0. The main header is stored at sector number 1.
945 * This expects the sector size to be 512 bytes.
946 * Header size is already aligned.
948 if (main_hdr->blockid == IBR_HDR_SATA_ID)
949 main_hdr->srcaddr = cpu_to_le32(headersz / 512 + 1);
952 * For SDIO srcaddr is specified in number of sectors starting from
953 * sector 0. The main header is stored at sector number 0.
954 * This expects sector size to be 512 bytes.
955 * Header size is already aligned.
957 if (main_hdr->blockid == IBR_HDR_SDIO_ID)
958 main_hdr->srcaddr = cpu_to_le32(headersz / 512);
960 /* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
961 if (main_hdr->blockid == IBR_HDR_PEX_ID)
962 main_hdr->srcaddr = cpu_to_le32(0xFFFFFFFF);
964 /* Generate the ext header */
966 struct ext_hdr_v0 *ext_hdr;
969 ext_hdr = (struct ext_hdr_v0 *)
970 (image + sizeof(struct main_hdr_v0));
971 ext_hdr->offset = cpu_to_le32(0x40);
973 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
974 e = &image_cfg[cfgi];
975 if (e->type != IMAGE_CFG_DATA)
978 ext_hdr->rcfg[datai].raddr =
979 cpu_to_le32(e->regdata.raddr);
980 ext_hdr->rcfg[datai].rdata =
981 cpu_to_le32(e->regdata.rdata);
985 ext_hdr->checksum = image_checksum8(ext_hdr,
986 sizeof(struct ext_hdr_v0));
993 static size_t image_headersz_v1(int *hasext)
995 struct image_cfg_element *binarye;
1001 * Calculate the size of the header and the size of the
1004 headersz = sizeof(struct main_hdr_v1);
1006 if (image_get_csk_index() >= 0) {
1007 headersz += sizeof(struct secure_hdr_v1);
1012 count = image_count_options(IMAGE_CFG_DATA);
1014 headersz += sizeof(struct register_set_hdr_v1) + 8 * count + 4;
1016 for (cfgi = 0; cfgi < cfgn; cfgi++) {
1020 binarye = &image_cfg[cfgi];
1021 if (binarye->type != IMAGE_CFG_BINARY)
1024 ret = stat(binarye->binary.file, &s);
1029 memset(cwd, 0, sizeof(cwd));
1030 if (!getcwd(cwd, sizeof(cwd))) {
1031 dir = "current working directory";
1032 perror("getcwd() failed");
1036 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
1037 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
1038 "image for your board. Use 'dumpimage -T kwbimage -p 0' to extract it from an existing image.\n",
1039 binarye->binary.file, dir);
1043 headersz += sizeof(struct opt_hdr_v1) + sizeof(uint32_t) +
1044 (binarye->binary.nargs) * sizeof(uint32_t);
1045 headersz = ALIGN(headersz, 16);
1046 headersz += ALIGN(s.st_size, 4) + sizeof(uint32_t);
1051 return image_headersz_align(headersz, image_get_bootfrom());
1054 int add_binary_header_v1(uint8_t **cur, uint8_t **next_ext,
1055 struct image_cfg_element *binarye,
1056 struct main_hdr_v1 *main_hdr)
1058 struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)*cur;
1068 hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
1070 bin = fopen(binarye->binary.file, "r");
1072 fprintf(stderr, "Cannot open binary file %s\n",
1073 binarye->binary.file);
1077 if (fstat(fileno(bin), &s)) {
1078 fprintf(stderr, "Cannot stat binary file %s\n",
1079 binarye->binary.file);
1083 *cur += sizeof(struct opt_hdr_v1);
1085 args = (uint32_t *)*cur;
1086 *args = cpu_to_le32(binarye->binary.nargs);
1088 for (argi = 0; argi < binarye->binary.nargs; argi++)
1089 args[argi] = cpu_to_le32(binarye->binary.args[argi]);
1091 *cur += (binarye->binary.nargs + 1) * sizeof(uint32_t);
1094 * ARM executable code inside the BIN header on some mvebu platforms
1095 * (e.g. A370, AXP) must always be aligned with the 128-bit boundary.
1096 * This requirement can be met by inserting dummy arguments into
1097 * BIN header, if needed.
1099 offset = *cur - (uint8_t *)main_hdr;
1100 add_args = ((16 - offset % 16) % 16) / sizeof(uint32_t);
1102 *(args - 1) = cpu_to_le32(binarye->binary.nargs + add_args);
1103 *cur += add_args * sizeof(uint32_t);
1106 ret = fread(*cur, s.st_size, 1, bin);
1109 "Could not read binary image %s\n",
1110 binarye->binary.file);
1116 *cur += ALIGN(s.st_size, 4);
1118 *((uint32_t *)*cur) = 0x00000000;
1122 *cur += sizeof(uint32_t);
1124 binhdrsz = sizeof(struct opt_hdr_v1) +
1125 (binarye->binary.nargs + add_args + 2) * sizeof(uint32_t) +
1126 ALIGN(s.st_size, 4);
1127 hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF);
1128 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
1138 int export_pub_kak_hash(RSA *kak, struct secure_hdr_v1 *secure_hdr)
1143 hashf = fopen("pub_kak_hash.txt", "w");
1145 fprintf(stderr, "Couldn't open hash file: '%s': %s\n",
1146 "pub_kak_hash.txt", strerror(errno));
1150 res = kwb_export_pubkey(kak, &secure_hdr->kak, hashf, "KAK");
1154 return res < 0 ? 1 : 0;
1157 int kwb_sign_csk_with_kak(struct image_tool_params *params,
1158 struct secure_hdr_v1 *secure_hdr, RSA *csk)
1161 RSA *kak_pub = NULL;
1162 int csk_idx = image_get_csk_index();
1163 struct sig_v1 tmp_sig;
1165 if (csk_idx < 0 || csk_idx > 15) {
1166 fprintf(stderr, "Invalid CSK index %d\n", csk_idx);
1170 if (kwb_load_kak(params, &kak) < 0)
1173 if (export_pub_kak_hash(kak, secure_hdr))
1176 if (kwb_import_pubkey(&kak_pub, &secure_hdr->kak, "KAK") < 0)
1179 if (kwb_export_pubkey(csk, &secure_hdr->csk[csk_idx], NULL, "CSK") < 0)
1182 if (kwb_sign_and_verify(kak, &secure_hdr->csk,
1183 sizeof(secure_hdr->csk) +
1184 sizeof(secure_hdr->csksig),
1185 &tmp_sig, "CSK") < 0)
1188 if (kwb_verify(kak_pub, &secure_hdr->csk,
1189 sizeof(secure_hdr->csk) +
1190 sizeof(secure_hdr->csksig),
1191 &tmp_sig, "CSK (2)") < 0)
1194 secure_hdr->csksig = tmp_sig;
1199 int add_secure_header_v1(struct image_tool_params *params, uint8_t *ptr,
1200 int payloadsz, size_t headersz, uint8_t *image,
1201 struct secure_hdr_v1 *secure_hdr)
1203 struct image_cfg_element *e_jtagdelay;
1204 struct image_cfg_element *e_boxid;
1205 struct image_cfg_element *e_flashid;
1207 unsigned char *image_ptr;
1209 struct sig_v1 tmp_sig;
1210 bool specialized_img = image_get_spezialized_img();
1212 kwb_msg("Create secure header content\n");
1214 e_jtagdelay = image_find_option(IMAGE_CFG_JTAG_DELAY);
1215 e_boxid = image_find_option(IMAGE_CFG_BOX_ID);
1216 e_flashid = image_find_option(IMAGE_CFG_FLASH_ID);
1218 if (kwb_load_csk(params, &csk) < 0)
1221 secure_hdr->headertype = OPT_HDR_V1_SECURE_TYPE;
1222 secure_hdr->headersz_msb = 0;
1223 secure_hdr->headersz_lsb = cpu_to_le16(sizeof(struct secure_hdr_v1));
1225 secure_hdr->jtag_delay = e_jtagdelay->jtag_delay;
1226 if (e_boxid && specialized_img)
1227 secure_hdr->boxid = cpu_to_le32(e_boxid->boxid);
1228 if (e_flashid && specialized_img)
1229 secure_hdr->flashid = cpu_to_le32(e_flashid->flashid);
1231 if (kwb_sign_csk_with_kak(params, secure_hdr, csk))
1234 image_ptr = ptr + headersz;
1235 image_size = payloadsz - headersz;
1237 if (kwb_sign_and_verify(csk, image_ptr, image_size,
1238 &secure_hdr->imgsig, "image") < 0)
1241 if (kwb_sign_and_verify(csk, image, headersz, &tmp_sig, "header") < 0)
1244 secure_hdr->hdrsig = tmp_sig;
1246 kwb_dump_fuse_cmds(secure_hdr);
1251 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
1252 uint8_t *ptr, int payloadsz)
1254 struct image_cfg_element *e;
1255 struct main_hdr_v1 *main_hdr;
1256 struct opt_hdr_v1 *ohdr;
1257 struct register_set_hdr_v1 *register_set_hdr;
1258 struct secure_hdr_v1 *secure_hdr = NULL;
1260 uint8_t *image, *cur;
1262 uint8_t *next_ext = NULL;
1263 int cfgi, datai, size;
1266 * Calculate the size of the header and the size of the
1269 headersz = image_headersz_v1(&hasext);
1273 image = malloc(headersz);
1275 fprintf(stderr, "Cannot allocate memory for image\n");
1279 memset(image, 0, headersz);
1281 main_hdr = (struct main_hdr_v1 *)image;
1283 cur += sizeof(struct main_hdr_v1);
1284 next_ext = &main_hdr->ext;
1286 /* Fill the main header */
1287 main_hdr->blocksize =
1288 cpu_to_le32(payloadsz);
1289 main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1290 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1291 main_hdr->destaddr = cpu_to_le32(params->addr);
1292 main_hdr->execaddr = cpu_to_le32(params->ep);
1293 main_hdr->srcaddr = cpu_to_le32(headersz);
1294 main_hdr->ext = hasext;
1295 main_hdr->version = 1;
1296 main_hdr->blockid = image_get_bootfrom();
1298 e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1300 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1301 e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
1303 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
1304 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1306 main_hdr->nandbadblklocation = e->nandbadblklocation;
1307 e = image_find_option(IMAGE_CFG_BAUDRATE);
1309 main_hdr->options |= baudrate_to_option(e->baudrate);
1310 e = image_find_option(IMAGE_CFG_UART_PORT);
1312 main_hdr->options |= (e->uart_port & 3) << 3;
1313 e = image_find_option(IMAGE_CFG_UART_MPP);
1315 main_hdr->options |= (e->uart_mpp & 7) << 5;
1316 e = image_find_option(IMAGE_CFG_DEBUG);
1318 main_hdr->flags = e->debug ? 0x1 : 0;
1321 * For SATA srcaddr is specified in number of sectors starting from
1322 * sector 0. The main header is stored at sector number 1.
1323 * This expects the sector size to be 512 bytes.
1324 * Header size is already aligned.
1326 if (main_hdr->blockid == IBR_HDR_SATA_ID)
1327 main_hdr->srcaddr = cpu_to_le32(headersz / 512 + 1);
1330 * For SDIO srcaddr is specified in number of sectors starting from
1331 * sector 0. The main header is stored at sector number 0.
1332 * This expects sector size to be 512 bytes.
1333 * Header size is already aligned.
1335 if (main_hdr->blockid == IBR_HDR_SDIO_ID)
1336 main_hdr->srcaddr = cpu_to_le32(headersz / 512);
1338 /* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
1339 if (main_hdr->blockid == IBR_HDR_PEX_ID)
1340 main_hdr->srcaddr = cpu_to_le32(0xFFFFFFFF);
1342 if (image_get_csk_index() >= 0) {
1344 * only reserve the space here; we fill the header later since
1345 * we need the header to be complete to compute the signatures
1347 secure_hdr = (struct secure_hdr_v1 *)cur;
1348 cur += sizeof(struct secure_hdr_v1);
1350 next_ext = &secure_hdr->next;
1354 register_set_hdr = (struct register_set_hdr_v1 *)cur;
1355 for (cfgi = 0; cfgi < cfgn; cfgi++) {
1356 e = &image_cfg[cfgi];
1357 if (e->type != IMAGE_CFG_DATA &&
1358 e->type != IMAGE_CFG_DATA_DELAY)
1360 if (e->type == IMAGE_CFG_DATA_DELAY) {
1361 size = sizeof(struct register_set_hdr_v1) + 8 * datai + 4;
1362 register_set_hdr->headertype = OPT_HDR_V1_REGISTER_TYPE;
1363 register_set_hdr->headersz_lsb = cpu_to_le16(size & 0xFFFF);
1364 register_set_hdr->headersz_msb = size >> 16;
1365 register_set_hdr->data[datai].last_entry.delay = e->regdata_delay;
1368 next_ext = ®ister_set_hdr->data[datai].last_entry.next;
1372 register_set_hdr->data[datai].entry.address =
1373 cpu_to_le32(e->regdata.raddr);
1374 register_set_hdr->data[datai].entry.value =
1375 cpu_to_le32(e->regdata.rdata);
1379 size = sizeof(struct register_set_hdr_v1) + 8 * datai + 4;
1380 register_set_hdr->headertype = OPT_HDR_V1_REGISTER_TYPE;
1381 register_set_hdr->headersz_lsb = cpu_to_le16(size & 0xFFFF);
1382 register_set_hdr->headersz_msb = size >> 16;
1383 /* Set delay to the smallest possible value 1ms. */
1384 register_set_hdr->data[datai].last_entry.delay = 1;
1387 next_ext = ®ister_set_hdr->data[datai].last_entry.next;
1390 for (cfgi = 0; cfgi < cfgn; cfgi++) {
1391 e = &image_cfg[cfgi];
1392 if (e->type != IMAGE_CFG_BINARY)
1395 if (add_binary_header_v1(&cur, &next_ext, e, main_hdr))
1399 if (secure_hdr && add_secure_header_v1(params, ptr, payloadsz + headersz,
1400 headersz, image, secure_hdr))
1403 *imagesz = headersz;
1405 /* Fill the real header size without padding into the main header */
1406 headersz = sizeof(*main_hdr);
1407 for_each_opt_hdr_v1 (ohdr, main_hdr)
1408 headersz += opt_hdr_v1_size(ohdr);
1409 main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1410 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1412 /* Calculate and set the header checksum */
1413 main_hdr->checksum = image_checksum8(main_hdr, headersz);
1418 int recognize_keyword(char *keyword)
1422 for (kw_id = 1; kw_id < IMAGE_CFG_COUNT; ++kw_id)
1423 if (!strcmp(keyword, id_strs[kw_id]))
1429 static int image_create_config_parse_oneline(char *line,
1430 struct image_cfg_element *el)
1432 char *keyword, *saveptr, *value1, *value2;
1433 char delimiters[] = " \t";
1434 int keyword_id, ret, argi;
1435 char *unknown_msg = "Ignoring unknown line '%s'\n";
1437 keyword = strtok_r(line, delimiters, &saveptr);
1438 keyword_id = recognize_keyword(keyword);
1441 fprintf(stderr, unknown_msg, line);
1445 el->type = keyword_id;
1447 value1 = strtok_r(NULL, delimiters, &saveptr);
1450 fprintf(stderr, "Parameter missing in line '%s'\n", line);
1454 switch (keyword_id) {
1455 case IMAGE_CFG_VERSION:
1456 el->version = atoi(value1);
1458 case IMAGE_CFG_BOOT_FROM:
1459 ret = image_boot_mode_id(value1);
1462 fprintf(stderr, "Invalid boot media '%s'\n", value1);
1467 case IMAGE_CFG_NAND_BLKSZ:
1468 el->nandblksz = strtoul(value1, NULL, 16);
1470 case IMAGE_CFG_NAND_BADBLK_LOCATION:
1471 el->nandbadblklocation = strtoul(value1, NULL, 16);
1473 case IMAGE_CFG_NAND_ECC_MODE:
1474 ret = image_nand_ecc_mode_id(value1);
1477 fprintf(stderr, "Invalid NAND ECC mode '%s'\n", value1);
1480 el->nandeccmode = ret;
1482 case IMAGE_CFG_NAND_PAGESZ:
1483 el->nandpagesz = strtoul(value1, NULL, 16);
1485 case IMAGE_CFG_BINARY:
1488 el->binary.file = strdup(value1);
1490 char *value = strtok_r(NULL, delimiters, &saveptr);
1494 el->binary.args[argi] = strtoul(value, NULL, 16);
1496 if (argi >= BINARY_MAX_ARGS) {
1498 "Too many arguments for BINARY\n");
1502 el->binary.nargs = argi;
1504 case IMAGE_CFG_DATA:
1505 value2 = strtok_r(NULL, delimiters, &saveptr);
1507 if (!value1 || !value2) {
1509 "Invalid number of arguments for DATA\n");
1513 el->regdata.raddr = strtoul(value1, NULL, 16);
1514 el->regdata.rdata = strtoul(value2, NULL, 16);
1516 case IMAGE_CFG_DATA_DELAY:
1517 if (!strcmp(value1, "SDRAM_SETUP"))
1518 el->regdata_delay = REGISTER_SET_HDR_OPT_DELAY_SDRAM_SETUP;
1520 el->regdata_delay = REGISTER_SET_HDR_OPT_DELAY_MS(strtoul(value1, NULL, 10));
1522 case IMAGE_CFG_BAUDRATE:
1523 el->baudrate = strtoul(value1, NULL, 10);
1525 case IMAGE_CFG_UART_PORT:
1526 el->uart_port = strtoul(value1, NULL, 16);
1528 case IMAGE_CFG_UART_MPP:
1529 el->uart_mpp = strtoul(value1, NULL, 16);
1531 case IMAGE_CFG_DEBUG:
1532 el->debug = strtoul(value1, NULL, 10);
1535 el->key_name = strdup(value1);
1538 el->key_name = strdup(value1);
1540 case IMAGE_CFG_CSK_INDEX:
1541 el->csk_idx = strtol(value1, NULL, 0);
1543 case IMAGE_CFG_JTAG_DELAY:
1544 el->jtag_delay = strtoul(value1, NULL, 0);
1546 case IMAGE_CFG_BOX_ID:
1547 el->boxid = strtoul(value1, NULL, 0);
1549 case IMAGE_CFG_FLASH_ID:
1550 el->flashid = strtoul(value1, NULL, 0);
1552 case IMAGE_CFG_SEC_SPECIALIZED_IMG:
1553 el->sec_specialized_img = true;
1555 case IMAGE_CFG_SEC_COMMON_IMG:
1556 el->sec_specialized_img = false;
1558 case IMAGE_CFG_SEC_BOOT_DEV:
1559 el->sec_boot_dev = strtoul(value1, NULL, 0);
1561 case IMAGE_CFG_SEC_FUSE_DUMP:
1562 el->name = strdup(value1);
1565 fprintf(stderr, unknown_msg, line);
1572 * Parse the configuration file 'fcfg' into the array of configuration
1573 * elements 'image_cfg', and return the number of configuration
1574 * elements in 'cfgn'.
1576 static int image_create_config_parse(FILE *fcfg)
1581 /* Parse the configuration file */
1582 while (!feof(fcfg)) {
1586 /* Read the current line */
1587 memset(buf, 0, sizeof(buf));
1588 line = fgets(buf, sizeof(buf), fcfg);
1592 /* Ignore useless lines */
1593 if (line[0] == '\n' || line[0] == '#')
1596 /* Strip final newline */
1597 if (line[strlen(line) - 1] == '\n')
1598 line[strlen(line) - 1] = 0;
1600 /* Parse the current line */
1601 ret = image_create_config_parse_oneline(line,
1608 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
1610 "Too many configuration elements in .cfg file\n");
1619 static int image_get_version(void)
1621 struct image_cfg_element *e;
1623 e = image_find_option(IMAGE_CFG_VERSION);
1630 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
1631 struct image_tool_params *params)
1636 size_t headersz = 0;
1643 * Do not use sbuf->st_size as it contains size with padding.
1644 * We need original image data size, so stat original file.
1646 if (stat(params->datafile, &s)) {
1647 fprintf(stderr, "Could not stat data file %s: %s\n",
1648 params->datafile, strerror(errno));
1651 datasz = ALIGN(s.st_size, 4);
1653 fcfg = fopen(params->imagename, "r");
1655 fprintf(stderr, "Could not open input file %s\n",
1660 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1661 sizeof(struct image_cfg_element));
1663 fprintf(stderr, "Cannot allocate memory\n");
1668 memset(image_cfg, 0,
1669 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1672 ret = image_create_config_parse(fcfg);
1679 version = image_get_version();
1682 * Fallback to version 0 if no version is provided in the
1687 image = image_create_v0(&headersz, params, datasz + 4);
1691 image = image_create_v1(&headersz, params, ptr, datasz + 4);
1695 fprintf(stderr, "Unsupported version %d\n", version);
1701 fprintf(stderr, "Could not create image\n");
1708 /* Build and add image data checksum */
1709 checksum = cpu_to_le32(image_checksum32((uint8_t *)ptr + headersz,
1711 memcpy((uint8_t *)ptr + headersz + datasz, &checksum, sizeof(uint32_t));
1713 /* Finally copy the header into the image area */
1714 memcpy(ptr, image, headersz);
1719 static void kwbimage_print_header(const void *ptr)
1721 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1722 struct opt_hdr_v1 *ohdr;
1724 printf("Image Type: MVEBU Boot from %s Image\n",
1725 image_boot_mode_name(mhdr->blockid));
1726 printf("Image version:%d\n", kwbimage_version(ptr));
1728 for_each_opt_hdr_v1 (ohdr, mhdr) {
1729 if (ohdr->headertype == OPT_HDR_V1_BINARY_TYPE) {
1730 printf("BIN Hdr Size: ");
1731 genimg_print_size(opt_hdr_v1_size(ohdr) - 12 -
1736 printf("Data Size: ");
1737 genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
1738 printf("Load Address: %08x\n", mhdr->destaddr);
1739 printf("Entry Point: %08x\n", mhdr->execaddr);
1742 static int kwbimage_check_image_types(uint8_t type)
1744 if (type == IH_TYPE_KWBIMAGE)
1745 return EXIT_SUCCESS;
1747 return EXIT_FAILURE;
1750 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
1751 struct image_tool_params *params)
1753 size_t header_size = kwbheader_size(ptr);
1759 if (header_size > image_size)
1760 return -FDT_ERR_BADSTRUCTURE;
1762 if (!main_hdr_checksum_ok(ptr))
1763 return -FDT_ERR_BADSTRUCTURE;
1765 /* Only version 0 extended header has checksum */
1766 if (kwbimage_version(ptr) == 0) {
1767 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1769 if (mhdr->ext & 0x1) {
1770 struct ext_hdr_v0 *ext_hdr = (void *)(mhdr + 1);
1772 csum = image_checksum8(ext_hdr, sizeof(*ext_hdr) - 1);
1773 if (csum != ext_hdr->checksum)
1774 return -FDT_ERR_BADSTRUCTURE;
1777 blockid = mhdr->blockid;
1778 offset = le32_to_cpu(mhdr->srcaddr);
1779 size = le32_to_cpu(mhdr->blocksize);
1780 } else if (kwbimage_version(ptr) == 1) {
1781 struct main_hdr_v1 *mhdr = (struct main_hdr_v1 *)ptr;
1782 const uint8_t *mhdr_end;
1783 struct opt_hdr_v1 *ohdr;
1785 mhdr_end = (uint8_t *)mhdr + header_size;
1786 for_each_opt_hdr_v1 (ohdr, ptr)
1787 if (!opt_hdr_v1_valid_size(ohdr, mhdr_end))
1788 return -FDT_ERR_BADSTRUCTURE;
1790 blockid = mhdr->blockid;
1791 offset = le32_to_cpu(mhdr->srcaddr);
1792 size = le32_to_cpu(mhdr->blocksize);
1794 return -FDT_ERR_BADSTRUCTURE;
1798 * For SATA srcaddr is specified in number of sectors.
1799 * The main header is must be stored at sector number 1.
1800 * This expects that sector size is 512 bytes and recalculates
1801 * data offset to bytes relative to the main header.
1803 if (blockid == IBR_HDR_SATA_ID) {
1805 return -FDT_ERR_BADSTRUCTURE;
1811 * For SDIO srcaddr is specified in number of sectors.
1812 * This expects that sector size is 512 bytes and recalculates
1813 * data offset to bytes.
1815 if (blockid == IBR_HDR_SDIO_ID)
1819 * For PCIe srcaddr is always set to 0xFFFFFFFF.
1820 * This expects that data starts after all headers.
1822 if (blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
1823 offset = header_size;
1825 if (offset > image_size || offset % 4 != 0)
1826 return -FDT_ERR_BADSTRUCTURE;
1828 if (size < 4 || offset + size > image_size || size % 4 != 0)
1829 return -FDT_ERR_BADSTRUCTURE;
1831 if (image_checksum32(ptr + offset, size - 4) !=
1832 *(uint32_t *)(ptr + offset + size - 4))
1833 return -FDT_ERR_BADSTRUCTURE;
1838 static int kwbimage_generate(struct image_tool_params *params,
1839 struct image_type_params *tparams)
1849 fcfg = fopen(params->imagename, "r");
1851 fprintf(stderr, "Could not open input file %s\n",
1856 if (stat(params->datafile, &s)) {
1857 fprintf(stderr, "Could not stat data file %s: %s\n",
1858 params->datafile, strerror(errno));
1862 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1863 sizeof(struct image_cfg_element));
1865 fprintf(stderr, "Cannot allocate memory\n");
1870 memset(image_cfg, 0,
1871 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1874 ret = image_create_config_parse(fcfg);
1881 bootfrom = image_get_bootfrom();
1882 version = image_get_version();
1885 * Fallback to version 0 if no version is provided in the
1890 alloc_len = image_headersz_v0(NULL);
1894 alloc_len = image_headersz_v1(NULL);
1898 fprintf(stderr, "Unsupported version %d\n", version);
1905 hdr = malloc(alloc_len);
1907 fprintf(stderr, "%s: malloc return failure: %s\n",
1908 params->cmdname, strerror(errno));
1912 memset(hdr, 0, alloc_len);
1913 tparams->header_size = alloc_len;
1917 * The resulting image needs to be 4-byte aligned. At least
1918 * the Marvell hdrparser tool complains if its unaligned.
1919 * After the image data is stored 4-byte checksum.
1920 * Final UART image must be aligned to 128 bytes.
1921 * Final SPI and NAND images must be aligned to 256 bytes.
1922 * Final SATA and SDIO images must be aligned to 512 bytes.
1924 if (bootfrom == IBR_HDR_SPI_ID || bootfrom == IBR_HDR_NAND_ID)
1925 return 4 + (256 - (alloc_len + s.st_size + 4) % 256) % 256;
1926 else if (bootfrom == IBR_HDR_SATA_ID || bootfrom == IBR_HDR_SDIO_ID)
1927 return 4 + (512 - (alloc_len + s.st_size + 4) % 512) % 512;
1928 else if (bootfrom == IBR_HDR_UART_ID)
1929 return 4 + (128 - (alloc_len + s.st_size + 4) % 128) % 128;
1931 return 4 + (4 - s.st_size % 4) % 4;
1934 static int kwbimage_extract_subimage(void *ptr, struct image_tool_params *params)
1936 struct main_hdr_v1 *mhdr = (struct main_hdr_v1 *)ptr;
1937 size_t header_size = kwbheader_size(ptr);
1938 struct opt_hdr_v1 *ohdr;
1939 int idx = params->pflag;
1945 for_each_opt_hdr_v1 (ohdr, ptr) {
1946 if (ohdr->headertype != OPT_HDR_V1_BINARY_TYPE)
1949 if (idx == cur_idx) {
1950 image = (ulong)&ohdr->data[4 + 4 * ohdr->data[0]];
1951 size = opt_hdr_v1_size(ohdr) - 12 - 4 * ohdr->data[0];
1958 if (idx != cur_idx) {
1959 printf("Image %d is not present\n", idx);
1963 offset = le32_to_cpu(mhdr->srcaddr);
1965 if (mhdr->blockid == IBR_HDR_SATA_ID) {
1970 if (mhdr->blockid == IBR_HDR_SDIO_ID)
1973 if (mhdr->blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
1974 offset = header_size;
1976 image = (ulong)((uint8_t *)ptr + offset);
1977 size = le32_to_cpu(mhdr->blocksize) - 4;
1980 return imagetool_save_subimage(params->outfile, image, size);
1984 * Report Error if xflag is set in addition to default
1986 static int kwbimage_check_params(struct image_tool_params *params)
1988 if (!params->iflag && (!params->imagename || !strlen(params->imagename))) {
1989 char *msg = "Configuration file for kwbimage creation omitted";
1991 fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg);
1995 return (params->dflag && (params->fflag || params->lflag)) ||
1996 (params->fflag && (params->dflag || params->lflag)) ||
1997 (params->lflag && (params->dflag || params->fflag)) ||
2002 * kwbimage type parameters definition
2006 "Marvell MVEBU Boot Image support",
2009 kwbimage_check_params,
2010 kwbimage_verify_header,
2011 kwbimage_print_header,
2012 kwbimage_set_header,
2013 kwbimage_extract_subimage,
2014 kwbimage_check_image_types,