xref: /openbmc/u-boot/tools/kwbimage.c (revision 4aac44be)
1 /*
2  * Image manipulator for Marvell SoCs
3  *  supports Kirkwood, Dove, Armada 370, Armada XP, and Armada 38x
4  *
5  * (C) Copyright 2013 Thomas Petazzoni
6  * <thomas.petazzoni@free-electrons.com>
7  *
8  * SPDX-License-Identifier:	GPL-2.0+
9  *
10  * Not implemented: support for the register headers in v1 images
11  */
12 
13 #include "imagetool.h"
14 #include <limits.h>
15 #include <image.h>
16 #include <stdarg.h>
17 #include <stdint.h>
18 #include "kwbimage.h"
19 
20 #ifdef CONFIG_KWB_SECURE
21 #include <openssl/rsa.h>
22 #include <openssl/pem.h>
23 #include <openssl/err.h>
24 #include <openssl/evp.h>
25 #endif
26 
27 static struct image_cfg_element *image_cfg;
28 static int cfgn;
29 #ifdef CONFIG_KWB_SECURE
30 static int verbose_mode;
31 #endif
32 
33 struct boot_mode {
34 	unsigned int id;
35 	const char *name;
36 };
37 
38 /*
39  * SHA2-256 hash
40  */
41 struct hash_v1 {
42 	uint8_t hash[32];
43 };
44 
45 struct boot_mode boot_modes[] = {
46 	{ 0x4D, "i2c"  },
47 	{ 0x5A, "spi"  },
48 	{ 0x8B, "nand" },
49 	{ 0x78, "sata" },
50 	{ 0x9C, "pex"  },
51 	{ 0x69, "uart" },
52 	{ 0xAE, "sdio" },
53 	{},
54 };
55 
56 struct nand_ecc_mode {
57 	unsigned int id;
58 	const char *name;
59 };
60 
61 struct nand_ecc_mode nand_ecc_modes[] = {
62 	{ 0x00, "default" },
63 	{ 0x01, "hamming" },
64 	{ 0x02, "rs" },
65 	{ 0x03, "disabled" },
66 	{},
67 };
68 
69 /* Used to identify an undefined execution or destination address */
70 #define ADDR_INVALID ((uint32_t)-1)
71 
72 #define BINARY_MAX_ARGS 8
73 
74 /* In-memory representation of a line of the configuration file */
75 
76 enum image_cfg_type {
77 	IMAGE_CFG_VERSION = 0x1,
78 	IMAGE_CFG_BOOT_FROM,
79 	IMAGE_CFG_DEST_ADDR,
80 	IMAGE_CFG_EXEC_ADDR,
81 	IMAGE_CFG_NAND_BLKSZ,
82 	IMAGE_CFG_NAND_BADBLK_LOCATION,
83 	IMAGE_CFG_NAND_ECC_MODE,
84 	IMAGE_CFG_NAND_PAGESZ,
85 	IMAGE_CFG_BINARY,
86 	IMAGE_CFG_PAYLOAD,
87 	IMAGE_CFG_DATA,
88 	IMAGE_CFG_BAUDRATE,
89 	IMAGE_CFG_DEBUG,
90 	IMAGE_CFG_KAK,
91 	IMAGE_CFG_CSK,
92 	IMAGE_CFG_CSK_INDEX,
93 	IMAGE_CFG_JTAG_DELAY,
94 	IMAGE_CFG_BOX_ID,
95 	IMAGE_CFG_FLASH_ID,
96 	IMAGE_CFG_SEC_COMMON_IMG,
97 	IMAGE_CFG_SEC_SPECIALIZED_IMG,
98 	IMAGE_CFG_SEC_BOOT_DEV,
99 	IMAGE_CFG_SEC_FUSE_DUMP,
100 
101 	IMAGE_CFG_COUNT
102 } type;
103 
104 static const char * const id_strs[] = {
105 	[IMAGE_CFG_VERSION] = "VERSION",
106 	[IMAGE_CFG_BOOT_FROM] = "BOOT_FROM",
107 	[IMAGE_CFG_DEST_ADDR] = "DEST_ADDR",
108 	[IMAGE_CFG_EXEC_ADDR] = "EXEC_ADDR",
109 	[IMAGE_CFG_NAND_BLKSZ] = "NAND_BLKSZ",
110 	[IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
111 	[IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
112 	[IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
113 	[IMAGE_CFG_BINARY] = "BINARY",
114 	[IMAGE_CFG_PAYLOAD] = "PAYLOAD",
115 	[IMAGE_CFG_DATA] = "DATA",
116 	[IMAGE_CFG_BAUDRATE] = "BAUDRATE",
117 	[IMAGE_CFG_DEBUG] = "DEBUG",
118 	[IMAGE_CFG_KAK] = "KAK",
119 	[IMAGE_CFG_CSK] = "CSK",
120 	[IMAGE_CFG_CSK_INDEX] = "CSK_INDEX",
121 	[IMAGE_CFG_JTAG_DELAY] = "JTAG_DELAY",
122 	[IMAGE_CFG_BOX_ID] = "BOX_ID",
123 	[IMAGE_CFG_FLASH_ID] = "FLASH_ID",
124 	[IMAGE_CFG_SEC_COMMON_IMG] = "SEC_COMMON_IMG",
125 	[IMAGE_CFG_SEC_SPECIALIZED_IMG] = "SEC_SPECIALIZED_IMG",
126 	[IMAGE_CFG_SEC_BOOT_DEV] = "SEC_BOOT_DEV",
127 	[IMAGE_CFG_SEC_FUSE_DUMP] = "SEC_FUSE_DUMP"
128 };
129 
130 struct image_cfg_element {
131 	enum image_cfg_type type;
132 	union {
133 		unsigned int version;
134 		unsigned int bootfrom;
135 		struct {
136 			const char *file;
137 			unsigned int args[BINARY_MAX_ARGS];
138 			unsigned int nargs;
139 		} binary;
140 		const char *payload;
141 		unsigned int dstaddr;
142 		unsigned int execaddr;
143 		unsigned int nandblksz;
144 		unsigned int nandbadblklocation;
145 		unsigned int nandeccmode;
146 		unsigned int nandpagesz;
147 		struct ext_hdr_v0_reg regdata;
148 		unsigned int baudrate;
149 		unsigned int debug;
150 		const char *key_name;
151 		int csk_idx;
152 		uint8_t jtag_delay;
153 		uint32_t boxid;
154 		uint32_t flashid;
155 		bool sec_specialized_img;
156 		unsigned int sec_boot_dev;
157 		const char *name;
158 	};
159 };
160 
161 #define IMAGE_CFG_ELEMENT_MAX 256
162 
163 /*
164  * Utility functions to manipulate boot mode and ecc modes (convert
165  * them back and forth between description strings and the
166  * corresponding numerical identifiers).
167  */
168 
169 static const char *image_boot_mode_name(unsigned int id)
170 {
171 	int i;
172 
173 	for (i = 0; boot_modes[i].name; i++)
174 		if (boot_modes[i].id == id)
175 			return boot_modes[i].name;
176 	return NULL;
177 }
178 
179 int image_boot_mode_id(const char *boot_mode_name)
180 {
181 	int i;
182 
183 	for (i = 0; boot_modes[i].name; i++)
184 		if (!strcmp(boot_modes[i].name, boot_mode_name))
185 			return boot_modes[i].id;
186 
187 	return -1;
188 }
189 
190 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
191 {
192 	int i;
193 
194 	for (i = 0; nand_ecc_modes[i].name; i++)
195 		if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
196 			return nand_ecc_modes[i].id;
197 	return -1;
198 }
199 
200 static struct image_cfg_element *
201 image_find_option(unsigned int optiontype)
202 {
203 	int i;
204 
205 	for (i = 0; i < cfgn; i++) {
206 		if (image_cfg[i].type == optiontype)
207 			return &image_cfg[i];
208 	}
209 
210 	return NULL;
211 }
212 
213 static unsigned int
214 image_count_options(unsigned int optiontype)
215 {
216 	int i;
217 	unsigned int count = 0;
218 
219 	for (i = 0; i < cfgn; i++)
220 		if (image_cfg[i].type == optiontype)
221 			count++;
222 
223 	return count;
224 }
225 
226 #if defined(CONFIG_KWB_SECURE)
227 
228 static int image_get_csk_index(void)
229 {
230 	struct image_cfg_element *e;
231 
232 	e = image_find_option(IMAGE_CFG_CSK_INDEX);
233 	if (!e)
234 		return -1;
235 
236 	return e->csk_idx;
237 }
238 
239 static bool image_get_spezialized_img(void)
240 {
241 	struct image_cfg_element *e;
242 
243 	e = image_find_option(IMAGE_CFG_SEC_SPECIALIZED_IMG);
244 	if (!e)
245 		return false;
246 
247 	return e->sec_specialized_img;
248 }
249 
250 #endif
251 
252 /*
253  * Compute a 8-bit checksum of a memory area. This algorithm follows
254  * the requirements of the Marvell SoC BootROM specifications.
255  */
256 static uint8_t image_checksum8(void *start, uint32_t len)
257 {
258 	uint8_t csum = 0;
259 	uint8_t *p = start;
260 
261 	/* check len and return zero checksum if invalid */
262 	if (!len)
263 		return 0;
264 
265 	do {
266 		csum += *p;
267 		p++;
268 	} while (--len);
269 
270 	return csum;
271 }
272 
273 static uint32_t image_checksum32(void *start, uint32_t len)
274 {
275 	uint32_t csum = 0;
276 	uint32_t *p = start;
277 
278 	/* check len and return zero checksum if invalid */
279 	if (!len)
280 		return 0;
281 
282 	if (len % sizeof(uint32_t)) {
283 		fprintf(stderr, "Length %d is not in multiple of %zu\n",
284 			len, sizeof(uint32_t));
285 		return 0;
286 	}
287 
288 	do {
289 		csum += *p;
290 		p++;
291 		len -= sizeof(uint32_t);
292 	} while (len > 0);
293 
294 	return csum;
295 }
296 
297 static uint8_t baudrate_to_option(unsigned int baudrate)
298 {
299 	switch (baudrate) {
300 	case 2400:
301 		return MAIN_HDR_V1_OPT_BAUD_2400;
302 	case 4800:
303 		return MAIN_HDR_V1_OPT_BAUD_4800;
304 	case 9600:
305 		return MAIN_HDR_V1_OPT_BAUD_9600;
306 	case 19200:
307 		return MAIN_HDR_V1_OPT_BAUD_19200;
308 	case 38400:
309 		return MAIN_HDR_V1_OPT_BAUD_38400;
310 	case 57600:
311 		return MAIN_HDR_V1_OPT_BAUD_57600;
312 	case 115200:
313 		return MAIN_HDR_V1_OPT_BAUD_115200;
314 	default:
315 		return MAIN_HDR_V1_OPT_BAUD_DEFAULT;
316 	}
317 }
318 
319 #if defined(CONFIG_KWB_SECURE)
320 static void kwb_msg(const char *fmt, ...)
321 {
322 	if (verbose_mode) {
323 		va_list ap;
324 
325 		va_start(ap, fmt);
326 		vfprintf(stdout, fmt, ap);
327 		va_end(ap);
328 	}
329 }
330 
331 static int openssl_err(const char *msg)
332 {
333 	unsigned long ssl_err = ERR_get_error();
334 
335 	fprintf(stderr, "%s", msg);
336 	fprintf(stderr, ": %s\n",
337 		ERR_error_string(ssl_err, 0));
338 
339 	return -1;
340 }
341 
342 static int kwb_load_rsa_key(const char *keydir, const char *name, RSA **p_rsa)
343 {
344 	char path[PATH_MAX];
345 	RSA *rsa;
346 	FILE *f;
347 
348 	if (!keydir)
349 		keydir = ".";
350 
351 	snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
352 	f = fopen(path, "r");
353 	if (!f) {
354 		fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
355 			path, strerror(errno));
356 		return -ENOENT;
357 	}
358 
359 	rsa = PEM_read_RSAPrivateKey(f, 0, NULL, "");
360 	if (!rsa) {
361 		openssl_err("Failure reading private key");
362 		fclose(f);
363 		return -EPROTO;
364 	}
365 	fclose(f);
366 	*p_rsa = rsa;
367 
368 	return 0;
369 }
370 
371 static int kwb_load_cfg_key(struct image_tool_params *params,
372 			    unsigned int cfg_option, const char *key_name,
373 			    RSA **p_key)
374 {
375 	struct image_cfg_element *e_key;
376 	RSA *key;
377 	int res;
378 
379 	*p_key = NULL;
380 
381 	e_key = image_find_option(cfg_option);
382 	if (!e_key) {
383 		fprintf(stderr, "%s not configured\n", key_name);
384 		return -ENOENT;
385 	}
386 
387 	res = kwb_load_rsa_key(params->keydir, e_key->key_name, &key);
388 	if (res < 0) {
389 		fprintf(stderr, "Failed to load %s\n", key_name);
390 		return -ENOENT;
391 	}
392 
393 	*p_key = key;
394 
395 	return 0;
396 }
397 
398 static int kwb_load_kak(struct image_tool_params *params, RSA **p_kak)
399 {
400 	return kwb_load_cfg_key(params, IMAGE_CFG_KAK, "KAK", p_kak);
401 }
402 
403 static int kwb_load_csk(struct image_tool_params *params, RSA **p_csk)
404 {
405 	return kwb_load_cfg_key(params, IMAGE_CFG_CSK, "CSK", p_csk);
406 }
407 
408 static int kwb_compute_pubkey_hash(struct pubkey_der_v1 *pk,
409 				   struct hash_v1 *hash)
410 {
411 	EVP_MD_CTX *ctx;
412 	unsigned int key_size;
413 	unsigned int hash_size;
414 	int ret = 0;
415 
416 	if (!pk || !hash || pk->key[0] != 0x30 || pk->key[1] != 0x82)
417 		return -EINVAL;
418 
419 	key_size = (pk->key[2] << 8) + pk->key[3] + 4;
420 
421 	ctx = EVP_MD_CTX_create();
422 	if (!ctx)
423 		return openssl_err("EVP context creation failed");
424 
425 	EVP_MD_CTX_init(ctx);
426 	if (!EVP_DigestInit(ctx, EVP_sha256())) {
427 		ret = openssl_err("Digest setup failed");
428 		goto hash_err_ctx;
429 	}
430 
431 	if (!EVP_DigestUpdate(ctx, pk->key, key_size)) {
432 		ret = openssl_err("Hashing data failed");
433 		goto hash_err_ctx;
434 	}
435 
436 	if (!EVP_DigestFinal(ctx, hash->hash, &hash_size)) {
437 		ret = openssl_err("Could not obtain hash");
438 		goto hash_err_ctx;
439 	}
440 
441 	EVP_MD_CTX_cleanup(ctx);
442 
443 hash_err_ctx:
444 	EVP_MD_CTX_destroy(ctx);
445 	return ret;
446 }
447 
448 static int kwb_import_pubkey(RSA **key, struct pubkey_der_v1 *src, char *keyname)
449 {
450 	RSA *rsa;
451 	const unsigned char *ptr;
452 
453 	if (!key || !src)
454 		goto fail;
455 
456 	ptr = src->key;
457 	rsa = d2i_RSAPublicKey(key, &ptr, sizeof(src->key));
458 	if (!rsa) {
459 		openssl_err("error decoding public key");
460 		goto fail;
461 	}
462 
463 	return 0;
464 fail:
465 	fprintf(stderr, "Failed to decode %s pubkey\n", keyname);
466 	return -EINVAL;
467 }
468 
469 static int kwb_export_pubkey(RSA *key, struct pubkey_der_v1 *dst, FILE *hashf,
470 			     char *keyname)
471 {
472 	int size_exp, size_mod, size_seq;
473 	uint8_t *cur;
474 	char *errmsg = "Failed to encode %s\n";
475 
476 	if (!key || !key->e || !key->n || !dst) {
477 		fprintf(stderr, "export pk failed: (%p, %p, %p, %p)",
478 			key, key->e, key->n, dst);
479 		fprintf(stderr, errmsg, keyname);
480 		return -EINVAL;
481 	}
482 
483 	/*
484 	 * According to the specs, the key should be PKCS#1 DER encoded.
485 	 * But unfortunately the really required encoding seems to be different;
486 	 * it violates DER...! (But it still conformes to BER.)
487 	 * (Length always in long form w/ 2 byte length code; no leading zero
488 	 * when MSB of first byte is set...)
489 	 * So we cannot use the encoding func provided by OpenSSL and have to
490 	 * do the encoding manually.
491 	 */
492 
493 	size_exp = BN_num_bytes(key->e);
494 	size_mod = BN_num_bytes(key->n);
495 	size_seq = 4 + size_mod + 4 + size_exp;
496 
497 	if (size_mod > 256) {
498 		fprintf(stderr, "export pk failed: wrong mod size: %d\n",
499 			size_mod);
500 		fprintf(stderr, errmsg, keyname);
501 		return -EINVAL;
502 	}
503 
504 	if (4 + size_seq > sizeof(dst->key)) {
505 		fprintf(stderr, "export pk failed: seq too large (%d, %lu)\n",
506 			4 + size_seq, sizeof(dst->key));
507 		fprintf(stderr, errmsg, keyname);
508 		return -ENOBUFS;
509 	}
510 
511 	cur = dst->key;
512 
513 	/* PKCS#1 (RFC3447) RSAPublicKey structure */
514 	*cur++ = 0x30;		/* SEQUENCE */
515 	*cur++ = 0x82;
516 	*cur++ = (size_seq >> 8) & 0xFF;
517 	*cur++ = size_seq & 0xFF;
518 	/* Modulus */
519 	*cur++ = 0x02;		/* INTEGER */
520 	*cur++ = 0x82;
521 	*cur++ = (size_mod >> 8) & 0xFF;
522 	*cur++ = size_mod & 0xFF;
523 	BN_bn2bin(key->n, cur);
524 	cur += size_mod;
525 	/* Exponent */
526 	*cur++ = 0x02;		/* INTEGER */
527 	*cur++ = 0x82;
528 	*cur++ = (size_exp >> 8) & 0xFF;
529 	*cur++ = size_exp & 0xFF;
530 	BN_bn2bin(key->e, cur);
531 
532 	if (hashf) {
533 		struct hash_v1 pk_hash;
534 		int i;
535 		int ret = 0;
536 
537 		ret = kwb_compute_pubkey_hash(dst, &pk_hash);
538 		if (ret < 0) {
539 			fprintf(stderr, errmsg, keyname);
540 			return ret;
541 		}
542 
543 		fprintf(hashf, "SHA256 = ");
544 		for (i = 0 ; i < sizeof(pk_hash.hash); ++i)
545 			fprintf(hashf, "%02X", pk_hash.hash[i]);
546 		fprintf(hashf, "\n");
547 	}
548 
549 	return 0;
550 }
551 
552 int kwb_sign(RSA *key, void *data, int datasz, struct sig_v1 *sig, char *signame)
553 {
554 	EVP_PKEY *evp_key;
555 	EVP_MD_CTX *ctx;
556 	unsigned int sig_size;
557 	int size;
558 	int ret = 0;
559 
560 	evp_key = EVP_PKEY_new();
561 	if (!evp_key)
562 		return openssl_err("EVP_PKEY object creation failed");
563 
564 	if (!EVP_PKEY_set1_RSA(evp_key, key)) {
565 		ret = openssl_err("EVP key setup failed");
566 		goto err_key;
567 	}
568 
569 	size = EVP_PKEY_size(evp_key);
570 	if (size > sizeof(sig->sig)) {
571 		fprintf(stderr, "Buffer to small for signature (%d bytes)\n",
572 			size);
573 		ret = -ENOBUFS;
574 		goto err_key;
575 	}
576 
577 	ctx = EVP_MD_CTX_create();
578 	if (!ctx) {
579 		ret = openssl_err("EVP context creation failed");
580 		goto err_key;
581 	}
582 	EVP_MD_CTX_init(ctx);
583 	if (!EVP_SignInit(ctx, EVP_sha256())) {
584 		ret = openssl_err("Signer setup failed");
585 		goto err_ctx;
586 	}
587 
588 	if (!EVP_SignUpdate(ctx, data, datasz)) {
589 		ret = openssl_err("Signing data failed");
590 		goto err_ctx;
591 	}
592 
593 	if (!EVP_SignFinal(ctx, sig->sig, &sig_size, evp_key)) {
594 		ret = openssl_err("Could not obtain signature");
595 		goto err_ctx;
596 	}
597 
598 	EVP_MD_CTX_cleanup(ctx);
599 	EVP_MD_CTX_destroy(ctx);
600 	EVP_PKEY_free(evp_key);
601 
602 	return 0;
603 
604 err_ctx:
605 	EVP_MD_CTX_destroy(ctx);
606 err_key:
607 	EVP_PKEY_free(evp_key);
608 	fprintf(stderr, "Failed to create %s signature\n", signame);
609 	return ret;
610 }
611 
612 int kwb_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
613 	       char *signame)
614 {
615 	EVP_PKEY *evp_key;
616 	EVP_MD_CTX *ctx;
617 	int size;
618 	int ret = 0;
619 
620 	evp_key = EVP_PKEY_new();
621 	if (!evp_key)
622 		return openssl_err("EVP_PKEY object creation failed");
623 
624 	if (!EVP_PKEY_set1_RSA(evp_key, key)) {
625 		ret = openssl_err("EVP key setup failed");
626 		goto err_key;
627 	}
628 
629 	size = EVP_PKEY_size(evp_key);
630 	if (size > sizeof(sig->sig)) {
631 		fprintf(stderr, "Invalid signature size (%d bytes)\n",
632 			size);
633 		ret = -EINVAL;
634 		goto err_key;
635 	}
636 
637 	ctx = EVP_MD_CTX_create();
638 	if (!ctx) {
639 		ret = openssl_err("EVP context creation failed");
640 		goto err_key;
641 	}
642 	EVP_MD_CTX_init(ctx);
643 	if (!EVP_VerifyInit(ctx, EVP_sha256())) {
644 		ret = openssl_err("Verifier setup failed");
645 		goto err_ctx;
646 	}
647 
648 	if (!EVP_VerifyUpdate(ctx, data, datasz)) {
649 		ret = openssl_err("Hashing data failed");
650 		goto err_ctx;
651 	}
652 
653 	if (!EVP_VerifyFinal(ctx, sig->sig, sizeof(sig->sig), evp_key)) {
654 		ret = openssl_err("Could not verify signature");
655 		goto err_ctx;
656 	}
657 
658 	EVP_MD_CTX_cleanup(ctx);
659 	EVP_MD_CTX_destroy(ctx);
660 	EVP_PKEY_free(evp_key);
661 
662 	return 0;
663 
664 err_ctx:
665 	EVP_MD_CTX_destroy(ctx);
666 err_key:
667 	EVP_PKEY_free(evp_key);
668 	fprintf(stderr, "Failed to verify %s signature\n", signame);
669 	return ret;
670 }
671 
672 int kwb_sign_and_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
673 			char *signame)
674 {
675 	if (kwb_sign(key, data, datasz, sig, signame) < 0)
676 		return -1;
677 
678 	if (kwb_verify(key, data, datasz, sig, signame) < 0)
679 		return -1;
680 
681 	return 0;
682 }
683 
684 
685 int kwb_dump_fuse_cmds_38x(FILE *out, struct secure_hdr_v1 *sec_hdr)
686 {
687 	struct hash_v1 kak_pub_hash;
688 	struct image_cfg_element *e;
689 	unsigned int fuse_line;
690 	int i, idx;
691 	uint8_t *ptr;
692 	uint32_t val;
693 	int ret = 0;
694 
695 	if (!out || !sec_hdr)
696 		return -EINVAL;
697 
698 	ret = kwb_compute_pubkey_hash(&sec_hdr->kak, &kak_pub_hash);
699 	if (ret < 0)
700 		goto done;
701 
702 	fprintf(out, "# burn KAK pub key hash\n");
703 	ptr = kak_pub_hash.hash;
704 	for (fuse_line = 26; fuse_line <= 30; ++fuse_line) {
705 		fprintf(out, "fuse prog -y %u 0 ", fuse_line);
706 
707 		for (i = 4; i-- > 0;)
708 			fprintf(out, "%02hx", (ushort)ptr[i]);
709 		ptr += 4;
710 		fprintf(out, " 00");
711 
712 		if (fuse_line < 30) {
713 			for (i = 3; i-- > 0;)
714 				fprintf(out, "%02hx", (ushort)ptr[i]);
715 			ptr += 3;
716 		} else {
717 			fprintf(out, "000000");
718 		}
719 
720 		fprintf(out, " 1\n");
721 	}
722 
723 	fprintf(out, "# burn CSK selection\n");
724 
725 	idx = image_get_csk_index();
726 	if (idx < 0 || idx > 15) {
727 		ret = -EINVAL;
728 		goto done;
729 	}
730 	if (idx > 0) {
731 		for (fuse_line = 31; fuse_line < 31 + idx; ++fuse_line)
732 			fprintf(out, "fuse prog -y %u 0 00000001 00000000 1\n",
733 				fuse_line);
734 	} else {
735 		fprintf(out, "# CSK index is 0; no mods needed\n");
736 	}
737 
738 	e = image_find_option(IMAGE_CFG_BOX_ID);
739 	if (e) {
740 		fprintf(out, "# set box ID\n");
741 		fprintf(out, "fuse prog -y 48 0 %08x 00000000 1\n", e->boxid);
742 	}
743 
744 	e = image_find_option(IMAGE_CFG_FLASH_ID);
745 	if (e) {
746 		fprintf(out, "# set flash ID\n");
747 		fprintf(out, "fuse prog -y 47 0 %08x 00000000 1\n", e->flashid);
748 	}
749 
750 	fprintf(out, "# enable secure mode ");
751 	fprintf(out, "(must be the last fuse line written)\n");
752 
753 	val = 1;
754 	e = image_find_option(IMAGE_CFG_SEC_BOOT_DEV);
755 	if (!e) {
756 		fprintf(stderr, "ERROR: secured mode boot device not given\n");
757 		ret = -EINVAL;
758 		goto done;
759 	}
760 
761 	if (e->sec_boot_dev > 0xff) {
762 		fprintf(stderr, "ERROR: secured mode boot device invalid\n");
763 		ret = -EINVAL;
764 		goto done;
765 	}
766 
767 	val |= (e->sec_boot_dev << 8);
768 
769 	fprintf(out, "fuse prog -y 24 0 %08x 0103e0a9 1\n", val);
770 
771 	fprintf(out, "# lock (unused) fuse lines (0-23)s\n");
772 	for (fuse_line = 0; fuse_line < 24; ++fuse_line)
773 		fprintf(out, "fuse prog -y %u 2 1\n", fuse_line);
774 
775 	fprintf(out, "# OK, that's all :-)\n");
776 
777 done:
778 	return ret;
779 }
780 
781 static int kwb_dump_fuse_cmds(struct secure_hdr_v1 *sec_hdr)
782 {
783 	int ret = 0;
784 	struct image_cfg_element *e;
785 
786 	e = image_find_option(IMAGE_CFG_SEC_FUSE_DUMP);
787 	if (!e)
788 		return 0;
789 
790 	if (!strcmp(e->name, "a38x")) {
791 		FILE *out = fopen("kwb_fuses_a38x.txt", "w+");
792 
793 		kwb_dump_fuse_cmds_38x(out, sec_hdr);
794 		fclose(out);
795 		goto done;
796 	}
797 
798 	ret = -ENOSYS;
799 
800 done:
801 	return ret;
802 }
803 
804 #endif
805 
806 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
807 			     int payloadsz)
808 {
809 	struct image_cfg_element *e;
810 	size_t headersz;
811 	struct main_hdr_v0 *main_hdr;
812 	uint8_t *image;
813 	int has_ext = 0;
814 
815 	/*
816 	 * Calculate the size of the header and the size of the
817 	 * payload
818 	 */
819 	headersz  = sizeof(struct main_hdr_v0);
820 
821 	if (image_count_options(IMAGE_CFG_DATA) > 0) {
822 		has_ext = 1;
823 		headersz += sizeof(struct ext_hdr_v0);
824 	}
825 
826 	if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
827 		fprintf(stderr, "More than one payload, not possible\n");
828 		return NULL;
829 	}
830 
831 	image = malloc(headersz);
832 	if (!image) {
833 		fprintf(stderr, "Cannot allocate memory for image\n");
834 		return NULL;
835 	}
836 
837 	memset(image, 0, headersz);
838 
839 	main_hdr = (struct main_hdr_v0 *)image;
840 
841 	/* Fill in the main header */
842 	main_hdr->blocksize =
843 		cpu_to_le32(payloadsz + sizeof(uint32_t) - headersz);
844 	main_hdr->srcaddr   = cpu_to_le32(headersz);
845 	main_hdr->ext       = has_ext;
846 	main_hdr->destaddr  = cpu_to_le32(params->addr);
847 	main_hdr->execaddr  = cpu_to_le32(params->ep);
848 
849 	e = image_find_option(IMAGE_CFG_BOOT_FROM);
850 	if (e)
851 		main_hdr->blockid = e->bootfrom;
852 	e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
853 	if (e)
854 		main_hdr->nandeccmode = e->nandeccmode;
855 	e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
856 	if (e)
857 		main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
858 	main_hdr->checksum = image_checksum8(image,
859 					     sizeof(struct main_hdr_v0));
860 
861 	/* Generate the ext header */
862 	if (has_ext) {
863 		struct ext_hdr_v0 *ext_hdr;
864 		int cfgi, datai;
865 
866 		ext_hdr = (struct ext_hdr_v0 *)
867 				(image + sizeof(struct main_hdr_v0));
868 		ext_hdr->offset = cpu_to_le32(0x40);
869 
870 		for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
871 			e = &image_cfg[cfgi];
872 			if (e->type != IMAGE_CFG_DATA)
873 				continue;
874 
875 			ext_hdr->rcfg[datai].raddr =
876 				cpu_to_le32(e->regdata.raddr);
877 			ext_hdr->rcfg[datai].rdata =
878 				cpu_to_le32(e->regdata.rdata);
879 			datai++;
880 		}
881 
882 		ext_hdr->checksum = image_checksum8(ext_hdr,
883 						    sizeof(struct ext_hdr_v0));
884 	}
885 
886 	*imagesz = headersz;
887 	return image;
888 }
889 
890 static size_t image_headersz_v1(int *hasext)
891 {
892 	struct image_cfg_element *binarye;
893 	size_t headersz;
894 
895 	/*
896 	 * Calculate the size of the header and the size of the
897 	 * payload
898 	 */
899 	headersz = sizeof(struct main_hdr_v1);
900 
901 	if (image_count_options(IMAGE_CFG_BINARY) > 1) {
902 		fprintf(stderr, "More than one binary blob, not supported\n");
903 		return 0;
904 	}
905 
906 	if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
907 		fprintf(stderr, "More than one payload, not possible\n");
908 		return 0;
909 	}
910 
911 	binarye = image_find_option(IMAGE_CFG_BINARY);
912 	if (binarye) {
913 		int ret;
914 		struct stat s;
915 
916 		ret = stat(binarye->binary.file, &s);
917 		if (ret < 0) {
918 			char cwd[PATH_MAX];
919 			char *dir = cwd;
920 
921 			memset(cwd, 0, sizeof(cwd));
922 			if (!getcwd(cwd, sizeof(cwd))) {
923 				dir = "current working directory";
924 				perror("getcwd() failed");
925 			}
926 
927 			fprintf(stderr,
928 				"Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
929 				"This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
930 				"image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
931 				binarye->binary.file, dir);
932 			return 0;
933 		}
934 
935 		headersz += sizeof(struct opt_hdr_v1) +
936 			s.st_size +
937 			(binarye->binary.nargs + 2) * sizeof(uint32_t);
938 		if (hasext)
939 			*hasext = 1;
940 	}
941 
942 #if defined(CONFIG_KWB_SECURE)
943 	if (image_get_csk_index() >= 0) {
944 		headersz += sizeof(struct secure_hdr_v1);
945 		if (hasext)
946 			*hasext = 1;
947 	}
948 #endif
949 
950 #if defined(CONFIG_SYS_U_BOOT_OFFS)
951 	if (headersz > CONFIG_SYS_U_BOOT_OFFS) {
952 		fprintf(stderr,
953 			"Error: Image header (incl. SPL image) too big!\n");
954 		fprintf(stderr, "header=0x%x CONFIG_SYS_U_BOOT_OFFS=0x%x!\n",
955 			(int)headersz, CONFIG_SYS_U_BOOT_OFFS);
956 		fprintf(stderr, "Increase CONFIG_SYS_U_BOOT_OFFS!\n");
957 		return 0;
958 	}
959 
960 	headersz = CONFIG_SYS_U_BOOT_OFFS;
961 #endif
962 
963 	/*
964 	 * The payload should be aligned on some reasonable
965 	 * boundary
966 	 */
967 	return ALIGN_SUP(headersz, 4096);
968 }
969 
970 int add_binary_header_v1(uint8_t *cur)
971 {
972 	struct image_cfg_element *binarye;
973 	struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)cur;
974 	uint32_t *args;
975 	size_t binhdrsz;
976 	struct stat s;
977 	int argi;
978 	FILE *bin;
979 	int ret;
980 
981 	binarye = image_find_option(IMAGE_CFG_BINARY);
982 
983 	if (!binarye)
984 		return 0;
985 
986 	hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
987 
988 	bin = fopen(binarye->binary.file, "r");
989 	if (!bin) {
990 		fprintf(stderr, "Cannot open binary file %s\n",
991 			binarye->binary.file);
992 		return -1;
993 	}
994 
995 	if (fstat(fileno(bin), &s)) {
996 		fprintf(stderr, "Cannot stat binary file %s\n",
997 			binarye->binary.file);
998 		goto err_close;
999 	}
1000 
1001 	binhdrsz = sizeof(struct opt_hdr_v1) +
1002 		(binarye->binary.nargs + 2) * sizeof(uint32_t) +
1003 		s.st_size;
1004 
1005 	/*
1006 	 * The size includes the binary image size, rounded
1007 	 * up to a 4-byte boundary. Plus 4 bytes for the
1008 	 * next-header byte and 3-byte alignment at the end.
1009 	 */
1010 	binhdrsz = ALIGN_SUP(binhdrsz, 4) + 4;
1011 	hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF);
1012 	hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
1013 
1014 	cur += sizeof(struct opt_hdr_v1);
1015 
1016 	args = (uint32_t *)cur;
1017 	*args = cpu_to_le32(binarye->binary.nargs);
1018 	args++;
1019 	for (argi = 0; argi < binarye->binary.nargs; argi++)
1020 		args[argi] = cpu_to_le32(binarye->binary.args[argi]);
1021 
1022 	cur += (binarye->binary.nargs + 1) * sizeof(uint32_t);
1023 
1024 	ret = fread(cur, s.st_size, 1, bin);
1025 	if (ret != 1) {
1026 		fprintf(stderr,
1027 			"Could not read binary image %s\n",
1028 			binarye->binary.file);
1029 		goto err_close;
1030 	}
1031 
1032 	fclose(bin);
1033 
1034 	cur += ALIGN_SUP(s.st_size, 4);
1035 
1036 	/*
1037 	 * For now, we don't support more than one binary
1038 	 * header, and no other header types are
1039 	 * supported. So, the binary header is necessarily the
1040 	 * last one
1041 	 */
1042 	*((uint32_t *)cur) = 0x00000000;
1043 
1044 	cur += sizeof(uint32_t);
1045 
1046 	return 0;
1047 
1048 err_close:
1049 	fclose(bin);
1050 
1051 	return -1;
1052 }
1053 
1054 #if defined(CONFIG_KWB_SECURE)
1055 
1056 int export_pub_kak_hash(RSA *kak, struct secure_hdr_v1 *secure_hdr)
1057 {
1058 	FILE *hashf;
1059 	int res;
1060 
1061 	hashf = fopen("pub_kak_hash.txt", "w");
1062 
1063 	res = kwb_export_pubkey(kak, &secure_hdr->kak, hashf, "KAK");
1064 
1065 	fclose(hashf);
1066 
1067 	return res < 0 ? 1 : 0;
1068 }
1069 
1070 int kwb_sign_csk_with_kak(struct image_tool_params *params,
1071 			  struct secure_hdr_v1 *secure_hdr, RSA *csk)
1072 {
1073 	RSA *kak = NULL;
1074 	RSA *kak_pub = NULL;
1075 	int csk_idx = image_get_csk_index();
1076 	struct sig_v1 tmp_sig;
1077 
1078 	if (csk_idx >= 16) {
1079 		fprintf(stderr, "Invalid CSK index %d\n", csk_idx);
1080 		return 1;
1081 	}
1082 
1083 	if (kwb_load_kak(params, &kak) < 0)
1084 		return 1;
1085 
1086 	if (export_pub_kak_hash(kak, secure_hdr))
1087 		return 1;
1088 
1089 	if (kwb_import_pubkey(&kak_pub, &secure_hdr->kak, "KAK") < 0)
1090 		return 1;
1091 
1092 	if (kwb_export_pubkey(csk, &secure_hdr->csk[csk_idx], NULL, "CSK") < 0)
1093 		return 1;
1094 
1095 	if (kwb_sign_and_verify(kak, &secure_hdr->csk,
1096 				sizeof(secure_hdr->csk) +
1097 				sizeof(secure_hdr->csksig),
1098 				&tmp_sig, "CSK") < 0)
1099 		return 1;
1100 
1101 	if (kwb_verify(kak_pub, &secure_hdr->csk,
1102 		       sizeof(secure_hdr->csk) +
1103 		       sizeof(secure_hdr->csksig),
1104 		       &tmp_sig, "CSK (2)") < 0)
1105 		return 1;
1106 
1107 	secure_hdr->csksig = tmp_sig;
1108 
1109 	return 0;
1110 }
1111 
1112 int add_secure_header_v1(struct image_tool_params *params, uint8_t *ptr,
1113 			 int payloadsz, size_t headersz, uint8_t *image,
1114 			 struct secure_hdr_v1 *secure_hdr)
1115 {
1116 	struct image_cfg_element *e_jtagdelay;
1117 	struct image_cfg_element *e_boxid;
1118 	struct image_cfg_element *e_flashid;
1119 	RSA *csk = NULL;
1120 	unsigned char *image_ptr;
1121 	size_t image_size;
1122 	struct sig_v1 tmp_sig;
1123 	bool specialized_img = image_get_spezialized_img();
1124 
1125 	kwb_msg("Create secure header content\n");
1126 
1127 	e_jtagdelay = image_find_option(IMAGE_CFG_JTAG_DELAY);
1128 	e_boxid = image_find_option(IMAGE_CFG_BOX_ID);
1129 	e_flashid = image_find_option(IMAGE_CFG_FLASH_ID);
1130 
1131 	if (kwb_load_csk(params, &csk) < 0)
1132 		return 1;
1133 
1134 	secure_hdr->headertype = OPT_HDR_V1_SECURE_TYPE;
1135 	secure_hdr->headersz_msb = 0;
1136 	secure_hdr->headersz_lsb = cpu_to_le16(sizeof(struct secure_hdr_v1));
1137 	if (e_jtagdelay)
1138 		secure_hdr->jtag_delay = e_jtagdelay->jtag_delay;
1139 	if (e_boxid && specialized_img)
1140 		secure_hdr->boxid = cpu_to_le32(e_boxid->boxid);
1141 	if (e_flashid && specialized_img)
1142 		secure_hdr->flashid = cpu_to_le32(e_flashid->flashid);
1143 
1144 	if (kwb_sign_csk_with_kak(params, secure_hdr, csk))
1145 		return 1;
1146 
1147 	image_ptr = ptr + headersz;
1148 	image_size = payloadsz - headersz;
1149 
1150 	if (kwb_sign_and_verify(csk, image_ptr, image_size,
1151 				&secure_hdr->imgsig, "image") < 0)
1152 		return 1;
1153 
1154 	if (kwb_sign_and_verify(csk, image, headersz, &tmp_sig, "header") < 0)
1155 		return 1;
1156 
1157 	secure_hdr->hdrsig = tmp_sig;
1158 
1159 	kwb_dump_fuse_cmds(secure_hdr);
1160 
1161 	return 0;
1162 }
1163 #endif
1164 
1165 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
1166 			     uint8_t *ptr, int payloadsz)
1167 {
1168 	struct image_cfg_element *e;
1169 	struct main_hdr_v1 *main_hdr;
1170 #if defined(CONFIG_KWB_SECURE)
1171 	struct secure_hdr_v1 *secure_hdr = NULL;
1172 #endif
1173 	size_t headersz;
1174 	uint8_t *image, *cur;
1175 	int hasext = 0;
1176 	uint8_t *next_ext = NULL;
1177 
1178 	/*
1179 	 * Calculate the size of the header and the size of the
1180 	 * payload
1181 	 */
1182 	headersz = image_headersz_v1(&hasext);
1183 	if (headersz == 0)
1184 		return NULL;
1185 
1186 	image = malloc(headersz);
1187 	if (!image) {
1188 		fprintf(stderr, "Cannot allocate memory for image\n");
1189 		return NULL;
1190 	}
1191 
1192 	memset(image, 0, headersz);
1193 
1194 	main_hdr = (struct main_hdr_v1 *)image;
1195 	cur = image;
1196 	cur += sizeof(struct main_hdr_v1);
1197 	next_ext = &main_hdr->ext;
1198 
1199 	/* Fill the main header */
1200 	main_hdr->blocksize    =
1201 		cpu_to_le32(payloadsz - headersz + sizeof(uint32_t));
1202 	main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1203 	main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1204 	main_hdr->destaddr     = cpu_to_le32(params->addr)
1205 				 - sizeof(image_header_t);
1206 	main_hdr->execaddr     = cpu_to_le32(params->ep);
1207 	main_hdr->srcaddr      = cpu_to_le32(headersz);
1208 	main_hdr->ext          = hasext;
1209 	main_hdr->version      = 1;
1210 	e = image_find_option(IMAGE_CFG_BOOT_FROM);
1211 	if (e)
1212 		main_hdr->blockid = e->bootfrom;
1213 	e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1214 	if (e)
1215 		main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1216 	e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1217 	if (e)
1218 		main_hdr->nandbadblklocation = e->nandbadblklocation;
1219 	e = image_find_option(IMAGE_CFG_BAUDRATE);
1220 	if (e)
1221 		main_hdr->options = baudrate_to_option(e->baudrate);
1222 	e = image_find_option(IMAGE_CFG_DEBUG);
1223 	if (e)
1224 		main_hdr->flags = e->debug ? 0x1 : 0;
1225 
1226 #if defined(CONFIG_KWB_SECURE)
1227 	if (image_get_csk_index() >= 0) {
1228 		/*
1229 		 * only reserve the space here; we fill the header later since
1230 		 * we need the header to be complete to compute the signatures
1231 		 */
1232 		secure_hdr = (struct secure_hdr_v1 *)cur;
1233 		cur += sizeof(struct secure_hdr_v1);
1234 		next_ext = &secure_hdr->next;
1235 	}
1236 #endif
1237 	*next_ext = 1;
1238 
1239 	if (add_binary_header_v1(cur))
1240 		return NULL;
1241 
1242 #if defined(CONFIG_KWB_SECURE)
1243 	if (secure_hdr && add_secure_header_v1(params, ptr, payloadsz,
1244 					       headersz, image, secure_hdr))
1245 		return NULL;
1246 #endif
1247 
1248 	/* Calculate and set the header checksum */
1249 	main_hdr->checksum = image_checksum8(main_hdr, headersz);
1250 
1251 	*imagesz = headersz;
1252 	return image;
1253 }
1254 
1255 int recognize_keyword(char *keyword)
1256 {
1257 	int kw_id;
1258 
1259 	for (kw_id = 1; kw_id < IMAGE_CFG_COUNT; ++kw_id)
1260 		if (!strcmp(keyword, id_strs[kw_id]))
1261 			return kw_id;
1262 
1263 	return 0;
1264 }
1265 
1266 static int image_create_config_parse_oneline(char *line,
1267 					     struct image_cfg_element *el)
1268 {
1269 	char *keyword, *saveptr, *value1, *value2;
1270 	char delimiters[] = " \t";
1271 	int keyword_id, ret, argi;
1272 	char *unknown_msg = "Ignoring unknown line '%s'\n";
1273 
1274 	keyword = strtok_r(line, delimiters, &saveptr);
1275 	keyword_id = recognize_keyword(keyword);
1276 
1277 	if (!keyword_id) {
1278 		fprintf(stderr, unknown_msg, line);
1279 		return 0;
1280 	}
1281 
1282 	el->type = keyword_id;
1283 
1284 	value1 = strtok_r(NULL, delimiters, &saveptr);
1285 
1286 	if (!value1) {
1287 		fprintf(stderr, "Parameter missing in line '%s'\n", line);
1288 		return -1;
1289 	}
1290 
1291 	switch (keyword_id) {
1292 	case IMAGE_CFG_VERSION:
1293 		el->version = atoi(value1);
1294 		break;
1295 	case IMAGE_CFG_BOOT_FROM:
1296 		ret = image_boot_mode_id(value1);
1297 
1298 		if (ret < 0) {
1299 			fprintf(stderr, "Invalid boot media '%s'\n", value1);
1300 			return -1;
1301 		}
1302 		el->bootfrom = ret;
1303 		break;
1304 	case IMAGE_CFG_NAND_BLKSZ:
1305 		el->nandblksz = strtoul(value1, NULL, 16);
1306 		break;
1307 	case IMAGE_CFG_NAND_BADBLK_LOCATION:
1308 		el->nandbadblklocation = strtoul(value1, NULL, 16);
1309 		break;
1310 	case IMAGE_CFG_NAND_ECC_MODE:
1311 		ret = image_nand_ecc_mode_id(value1);
1312 
1313 		if (ret < 0) {
1314 			fprintf(stderr, "Invalid NAND ECC mode '%s'\n", value1);
1315 			return -1;
1316 		}
1317 		el->nandeccmode = ret;
1318 		break;
1319 	case IMAGE_CFG_NAND_PAGESZ:
1320 		el->nandpagesz = strtoul(value1, NULL, 16);
1321 		break;
1322 	case IMAGE_CFG_BINARY:
1323 		argi = 0;
1324 
1325 		el->binary.file = strdup(value1);
1326 		while (1) {
1327 			char *value = strtok_r(NULL, delimiters, &saveptr);
1328 
1329 			if (!value)
1330 				break;
1331 			el->binary.args[argi] = strtoul(value, NULL, 16);
1332 			argi++;
1333 			if (argi >= BINARY_MAX_ARGS) {
1334 				fprintf(stderr,
1335 					"Too many arguments for BINARY\n");
1336 				return -1;
1337 			}
1338 		}
1339 		el->binary.nargs = argi;
1340 		break;
1341 	case IMAGE_CFG_DATA:
1342 		value2 = strtok_r(NULL, delimiters, &saveptr);
1343 
1344 		if (!value1 || !value2) {
1345 			fprintf(stderr,
1346 				"Invalid number of arguments for DATA\n");
1347 			return -1;
1348 		}
1349 
1350 		el->regdata.raddr = strtoul(value1, NULL, 16);
1351 		el->regdata.rdata = strtoul(value2, NULL, 16);
1352 		break;
1353 	case IMAGE_CFG_BAUDRATE:
1354 		el->baudrate = strtoul(value1, NULL, 10);
1355 		break;
1356 	case IMAGE_CFG_DEBUG:
1357 		el->debug = strtoul(value1, NULL, 10);
1358 		break;
1359 	case IMAGE_CFG_KAK:
1360 		el->key_name = strdup(value1);
1361 		break;
1362 	case IMAGE_CFG_CSK:
1363 		el->key_name = strdup(value1);
1364 		break;
1365 	case IMAGE_CFG_CSK_INDEX:
1366 		el->csk_idx = strtol(value1, NULL, 0);
1367 		break;
1368 	case IMAGE_CFG_JTAG_DELAY:
1369 		el->jtag_delay = strtoul(value1, NULL, 0);
1370 		break;
1371 	case IMAGE_CFG_BOX_ID:
1372 		el->boxid = strtoul(value1, NULL, 0);
1373 		break;
1374 	case IMAGE_CFG_FLASH_ID:
1375 		el->flashid = strtoul(value1, NULL, 0);
1376 		break;
1377 	case IMAGE_CFG_SEC_SPECIALIZED_IMG:
1378 		el->sec_specialized_img = true;
1379 		break;
1380 	case IMAGE_CFG_SEC_COMMON_IMG:
1381 		el->sec_specialized_img = false;
1382 		break;
1383 	case IMAGE_CFG_SEC_BOOT_DEV:
1384 		el->sec_boot_dev = strtoul(value1, NULL, 0);
1385 		break;
1386 	case IMAGE_CFG_SEC_FUSE_DUMP:
1387 		el->name = strdup(value1);
1388 		break;
1389 	default:
1390 		fprintf(stderr, unknown_msg, line);
1391 	}
1392 
1393 	return 0;
1394 }
1395 
1396 /*
1397  * Parse the configuration file 'fcfg' into the array of configuration
1398  * elements 'image_cfg', and return the number of configuration
1399  * elements in 'cfgn'.
1400  */
1401 static int image_create_config_parse(FILE *fcfg)
1402 {
1403 	int ret;
1404 	int cfgi = 0;
1405 
1406 	/* Parse the configuration file */
1407 	while (!feof(fcfg)) {
1408 		char *line;
1409 		char buf[256];
1410 
1411 		/* Read the current line */
1412 		memset(buf, 0, sizeof(buf));
1413 		line = fgets(buf, sizeof(buf), fcfg);
1414 		if (!line)
1415 			break;
1416 
1417 		/* Ignore useless lines */
1418 		if (line[0] == '\n' || line[0] == '#')
1419 			continue;
1420 
1421 		/* Strip final newline */
1422 		if (line[strlen(line) - 1] == '\n')
1423 			line[strlen(line) - 1] = 0;
1424 
1425 		/* Parse the current line */
1426 		ret = image_create_config_parse_oneline(line,
1427 							&image_cfg[cfgi]);
1428 		if (ret)
1429 			return ret;
1430 
1431 		cfgi++;
1432 
1433 		if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
1434 			fprintf(stderr,
1435 				"Too many configuration elements in .cfg file\n");
1436 			return -1;
1437 		}
1438 	}
1439 
1440 	cfgn = cfgi;
1441 	return 0;
1442 }
1443 
1444 static int image_get_version(void)
1445 {
1446 	struct image_cfg_element *e;
1447 
1448 	e = image_find_option(IMAGE_CFG_VERSION);
1449 	if (!e)
1450 		return -1;
1451 
1452 	return e->version;
1453 }
1454 
1455 static int image_version_file(const char *input)
1456 {
1457 	FILE *fcfg;
1458 	int version;
1459 	int ret;
1460 
1461 	fcfg = fopen(input, "r");
1462 	if (!fcfg) {
1463 		fprintf(stderr, "Could not open input file %s\n", input);
1464 		return -1;
1465 	}
1466 
1467 	image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1468 			   sizeof(struct image_cfg_element));
1469 	if (!image_cfg) {
1470 		fprintf(stderr, "Cannot allocate memory\n");
1471 		fclose(fcfg);
1472 		return -1;
1473 	}
1474 
1475 	memset(image_cfg, 0,
1476 	       IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1477 	rewind(fcfg);
1478 
1479 	ret = image_create_config_parse(fcfg);
1480 	fclose(fcfg);
1481 	if (ret) {
1482 		free(image_cfg);
1483 		return -1;
1484 	}
1485 
1486 	version = image_get_version();
1487 	/* Fallback to version 0 is no version is provided in the cfg file */
1488 	if (version == -1)
1489 		version = 0;
1490 
1491 	free(image_cfg);
1492 
1493 	return version;
1494 }
1495 
1496 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
1497 				struct image_tool_params *params)
1498 {
1499 	FILE *fcfg;
1500 	void *image = NULL;
1501 	int version;
1502 	size_t headersz = 0;
1503 	uint32_t checksum;
1504 	int ret;
1505 	int size;
1506 
1507 	fcfg = fopen(params->imagename, "r");
1508 	if (!fcfg) {
1509 		fprintf(stderr, "Could not open input file %s\n",
1510 			params->imagename);
1511 		exit(EXIT_FAILURE);
1512 	}
1513 
1514 	image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1515 			   sizeof(struct image_cfg_element));
1516 	if (!image_cfg) {
1517 		fprintf(stderr, "Cannot allocate memory\n");
1518 		fclose(fcfg);
1519 		exit(EXIT_FAILURE);
1520 	}
1521 
1522 	memset(image_cfg, 0,
1523 	       IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1524 	rewind(fcfg);
1525 
1526 	ret = image_create_config_parse(fcfg);
1527 	fclose(fcfg);
1528 	if (ret) {
1529 		free(image_cfg);
1530 		exit(EXIT_FAILURE);
1531 	}
1532 
1533 	/* The MVEBU BootROM does not allow non word aligned payloads */
1534 	sbuf->st_size = ALIGN_SUP(sbuf->st_size, 4);
1535 
1536 	version = image_get_version();
1537 	switch (version) {
1538 		/*
1539 		 * Fallback to version 0 if no version is provided in the
1540 		 * cfg file
1541 		 */
1542 	case -1:
1543 	case 0:
1544 		image = image_create_v0(&headersz, params, sbuf->st_size);
1545 		break;
1546 
1547 	case 1:
1548 		image = image_create_v1(&headersz, params, ptr, sbuf->st_size);
1549 		break;
1550 
1551 	default:
1552 		fprintf(stderr, "Unsupported version %d\n", version);
1553 		free(image_cfg);
1554 		exit(EXIT_FAILURE);
1555 	}
1556 
1557 	if (!image) {
1558 		fprintf(stderr, "Could not create image\n");
1559 		free(image_cfg);
1560 		exit(EXIT_FAILURE);
1561 	}
1562 
1563 	free(image_cfg);
1564 
1565 	/* Build and add image checksum header */
1566 	checksum =
1567 		cpu_to_le32(image_checksum32((uint32_t *)ptr, sbuf->st_size));
1568 	size = write(ifd, &checksum, sizeof(uint32_t));
1569 	if (size != sizeof(uint32_t)) {
1570 		fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
1571 			params->cmdname, size, params->imagefile);
1572 		exit(EXIT_FAILURE);
1573 	}
1574 
1575 	sbuf->st_size += sizeof(uint32_t);
1576 
1577 	/* Finally copy the header into the image area */
1578 	memcpy(ptr, image, headersz);
1579 
1580 	free(image);
1581 }
1582 
1583 static void kwbimage_print_header(const void *ptr)
1584 {
1585 	struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1586 
1587 	printf("Image Type:   MVEBU Boot from %s Image\n",
1588 	       image_boot_mode_name(mhdr->blockid));
1589 	printf("Image version:%d\n", image_version((void *)ptr));
1590 	printf("Data Size:    ");
1591 	genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
1592 	printf("Load Address: %08x\n", mhdr->destaddr);
1593 	printf("Entry Point:  %08x\n", mhdr->execaddr);
1594 }
1595 
1596 static int kwbimage_check_image_types(uint8_t type)
1597 {
1598 	if (type == IH_TYPE_KWBIMAGE)
1599 		return EXIT_SUCCESS;
1600 
1601 	return EXIT_FAILURE;
1602 }
1603 
1604 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
1605 				  struct image_tool_params *params)
1606 {
1607 	struct main_hdr_v0 *main_hdr;
1608 	uint8_t checksum;
1609 
1610 	main_hdr = (struct main_hdr_v0 *)ptr;
1611 	checksum = image_checksum8(ptr,
1612 				   sizeof(struct main_hdr_v0)
1613 				   - sizeof(uint8_t));
1614 	if (checksum != main_hdr->checksum)
1615 		return -FDT_ERR_BADSTRUCTURE;
1616 
1617 	/* Only version 0 extended header has checksum */
1618 	if (image_version((void *)ptr) == 0) {
1619 		struct ext_hdr_v0 *ext_hdr;
1620 
1621 		ext_hdr = (struct ext_hdr_v0 *)
1622 				(ptr + sizeof(struct main_hdr_v0));
1623 		checksum = image_checksum8(ext_hdr,
1624 					   sizeof(struct ext_hdr_v0)
1625 					   - sizeof(uint8_t));
1626 		if (checksum != ext_hdr->checksum)
1627 			return -FDT_ERR_BADSTRUCTURE;
1628 	}
1629 
1630 	return 0;
1631 }
1632 
1633 static int kwbimage_generate(struct image_tool_params *params,
1634 			     struct image_type_params *tparams)
1635 {
1636 	int alloc_len;
1637 	void *hdr;
1638 	int version = 0;
1639 
1640 	version = image_version_file(params->imagename);
1641 	if (version == 0) {
1642 		alloc_len = sizeof(struct main_hdr_v0) +
1643 			sizeof(struct ext_hdr_v0);
1644 	} else {
1645 		alloc_len = image_headersz_v1(NULL);
1646 	}
1647 
1648 	hdr = malloc(alloc_len);
1649 	if (!hdr) {
1650 		fprintf(stderr, "%s: malloc return failure: %s\n",
1651 			params->cmdname, strerror(errno));
1652 		exit(EXIT_FAILURE);
1653 	}
1654 
1655 	memset(hdr, 0, alloc_len);
1656 	tparams->header_size = alloc_len;
1657 	tparams->hdr = hdr;
1658 
1659 	/*
1660 	 * The resulting image needs to be 4-byte aligned. At least
1661 	 * the Marvell hdrparser tool complains if its unaligned.
1662 	 * By returning 1 here in this function, called via
1663 	 * tparams->vrec_header() in mkimage.c, mkimage will
1664 	 * automatically pad the the resulting image to a 4-byte
1665 	 * size if necessary.
1666 	 */
1667 	return 1;
1668 }
1669 
1670 /*
1671  * Report Error if xflag is set in addition to default
1672  */
1673 static int kwbimage_check_params(struct image_tool_params *params)
1674 {
1675 	if (!strlen(params->imagename)) {
1676 		char *msg = "Configuration file for kwbimage creation omitted";
1677 
1678 		fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg);
1679 		return CFG_INVALID;
1680 	}
1681 
1682 	return (params->dflag && (params->fflag || params->lflag)) ||
1683 		(params->fflag && (params->dflag || params->lflag)) ||
1684 		(params->lflag && (params->dflag || params->fflag)) ||
1685 		(params->xflag) || !(strlen(params->imagename));
1686 }
1687 
1688 /*
1689  * kwbimage type parameters definition
1690  */
1691 U_BOOT_IMAGE_TYPE(
1692 	kwbimage,
1693 	"Marvell MVEBU Boot Image support",
1694 	0,
1695 	NULL,
1696 	kwbimage_check_params,
1697 	kwbimage_verify_header,
1698 	kwbimage_print_header,
1699 	kwbimage_set_header,
1700 	NULL,
1701 	kwbimage_check_image_types,
1702 	NULL,
1703 	kwbimage_generate
1704 );
1705