xref: /openbmc/u-boot/tools/imx8image.c (revision 1bad5e14)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright 2018 NXP
4  *
5  * Peng Fan <peng.fan@nxp.com>
6  */
7 
8 #include "imx8image.h"
9 
10 static int p_idx;
11 static int sector_size;
12 static soc_type_t soc;
13 static int container = -1;
14 static int32_t core_type = CFG_CORE_INVALID;
15 static bool emmc_fastboot;
16 static image_t param_stack[IMG_STACK_SIZE];
17 static uint8_t fuse_version;
18 static uint16_t sw_version;
19 static uint32_t custom_partition;
20 static uint32_t scfw_flags;
21 
22 int imx8image_check_params(struct image_tool_params *params)
23 {
24 	return 0;
25 }
26 
27 static void imx8image_set_header(void *ptr, struct stat *sbuf, int ifd,
28 				 struct image_tool_params *params)
29 {
30 }
31 
32 static void imx8image_print_header(const void *ptr)
33 {
34 }
35 
36 static int imx8image_check_image_types(uint8_t type)
37 {
38 	return (type == IH_TYPE_IMX8IMAGE) ? EXIT_SUCCESS : EXIT_FAILURE;
39 }
40 
41 static table_entry_t imx8image_cmds[] = {
42 	{CMD_BOOT_FROM,         "BOOT_FROM",            "boot command",	      },
43 	{CMD_FUSE_VERSION,      "FUSE_VERSION",         "fuse version",	      },
44 	{CMD_SW_VERSION,        "SW_VERSION",           "sw version",	      },
45 	{CMD_MSG_BLOCK,         "MSG_BLOCK",            "msg block",	      },
46 	{CMD_FILEOFF,           "FILEOFF",              "fileoff",	      },
47 	{CMD_FLAG,              "FLAG",                 "flag",	      },
48 	{CMD_APPEND,            "APPEND",               "append a container", },
49 	{CMD_PARTITION,         "PARTITION",            "new partition",      },
50 	{CMD_SOC_TYPE,          "SOC_TYPE",             "soc type",           },
51 	{CMD_CONTAINER,         "CONTAINER",            "new container",      },
52 	{CMD_IMAGE,             "IMAGE",                "new image",          },
53 	{CMD_DATA,              "DATA",                 "new data",           },
54 	{-1,                    "",                     "",	              },
55 };
56 
57 static table_entry_t imx8image_core_entries[] = {
58 	{CFG_SCU,	"SCU",			"scu core",	},
59 	{CFG_M40,	"M40",			"M4 core 0",	},
60 	{CFG_M41,	"M41",			"M4 core 1",	},
61 	{CFG_A35,	"A35",			"A35 core",	},
62 	{CFG_A53,	"A53",			"A53 core",	},
63 	{CFG_A72,	"A72",			"A72 core",	},
64 	{-1,		"",			"",		},
65 };
66 
67 static table_entry_t imx8image_sector_size[] = {
68 	{0x400,		"sd",			"sd/emmc",},
69 	{0x400,		"emmc_fastboot",	"emmc fastboot",},
70 	{0x400,		"fspi",			"flexspi",	},
71 	{0x1000,	"nand_4k",		"nand 4K",	},
72 	{0x2000,	"nand_8k",		"nand 8K",	},
73 	{0x4000,	"nand_16k",		"nand 16K",	},
74 	{-1,		"",			"Invalid",	},
75 };
76 
77 static void parse_cfg_cmd(image_t *param_stack, int32_t cmd, char *token,
78 			  char *name, int lineno)
79 {
80 	switch (cmd) {
81 	case CMD_BOOT_FROM:
82 		sector_size = get_table_entry_id(imx8image_sector_size,
83 						 "imximage boot option",
84 						 token);
85 		if (!strncmp("emmc_fastboot", token, 13))
86 			emmc_fastboot = true;
87 		break;
88 	case CMD_FUSE_VERSION:
89 		fuse_version = (uint8_t)(strtoll(token, NULL, 0) & 0xFF);
90 		break;
91 	case CMD_SW_VERSION:
92 		sw_version = (uint8_t)(strtoll(token, NULL, 0) & 0xFFFF);
93 		break;
94 	case CMD_FILEOFF:
95 		param_stack[p_idx].option = FILEOFF;
96 		param_stack[p_idx++].dst = (uint32_t)strtoll(token, NULL, 0);
97 		break;
98 	case CMD_MSG_BLOCK:
99 		param_stack[p_idx].option = MSG_BLOCK;
100 		param_stack[p_idx].filename = token;
101 		break;
102 	case CMD_FLAG:
103 		param_stack[p_idx].option = FLAG;
104 		param_stack[p_idx++].entry = (uint32_t)strtoll(token, NULL, 0);
105 		break;
106 	case CMD_APPEND:
107 		param_stack[p_idx].option = APPEND;
108 		param_stack[p_idx++].filename = token;
109 		break;
110 	case CMD_PARTITION:
111 		param_stack[p_idx].option = PARTITION;
112 		param_stack[p_idx++].entry = (uint32_t)strtoll(token, NULL, 0);
113 		break;
114 	case CMD_SOC_TYPE:
115 		if (!strncmp(token, "IMX8QX", 6)) {
116 			soc = QX;
117 		} else if (!strncmp(token, "IMX8QM", 6)) {
118 			soc = QM;
119 		} else {
120 			fprintf(stderr, "Unknown CMD_SOC_TYPE");
121 			exit(EXIT_FAILURE);
122 		}
123 		break;
124 	case CMD_IMAGE:
125 	case CMD_DATA:
126 		core_type = get_table_entry_id(imx8image_core_entries,
127 					       "imx8image core entries",
128 					       token);
129 		if (core_type < 0) {
130 			fprintf(stderr, "Wrong IMAGE core_type %s\n", token);
131 			exit(EXIT_FAILURE);
132 		}
133 		break;
134 	default:
135 		break;
136 	}
137 }
138 
139 static void parse_cfg_fld(image_t *param_stack, int32_t *cmd, char *token,
140 			  char *name, int lineno, int fld)
141 {
142 	switch (fld) {
143 	case CFG_COMMAND:
144 		*cmd = get_table_entry_id(imx8image_cmds, "imx8image cmds",
145 					  token);
146 		if (*cmd < 0) {
147 			fprintf(stderr, "Error: %s[%d] - Invalid command (%s)\n", name, lineno, token);
148 			exit(EXIT_FAILURE);
149 		}
150 
151 		if (*cmd == CMD_CONTAINER) {
152 			fprintf(stdout, "New Container: \t%d\n", ++container);
153 			param_stack[p_idx++].option = NEW_CONTAINER;
154 		}
155 		break;
156 	case CFG_CORE_TYPE:
157 		parse_cfg_cmd(param_stack, *cmd, token, name, lineno);
158 		break;
159 	case CFG_IMAGE_NAME:
160 		if (*cmd == CMD_MSG_BLOCK) {
161 			if (!strncmp(token, "fuse", 4)) {
162 				param_stack[p_idx].ext = SC_R_OTP;
163 			} else if (!strncmp(token, "debug", 5)) {
164 				param_stack[p_idx].ext = SC_R_DEBUG;
165 			} else if (!strncmp(token, "field", 5)) {
166 				param_stack[p_idx].ext = SC_R_ROM_0;
167 			} else {
168 				fprintf(stderr, "MSG type not found %s\n", token);
169 				exit(EXIT_FAILURE);
170 			}
171 			break;
172 		}
173 		switch (core_type) {
174 		case CFG_SCU:
175 			param_stack[p_idx].option = SCFW;
176 			param_stack[p_idx++].filename = token;
177 			break;
178 		case CFG_M40:
179 			param_stack[p_idx].option = M40;
180 			param_stack[p_idx].ext = 0;
181 			param_stack[p_idx].filename = token;
182 			break;
183 		case CFG_M41:
184 			param_stack[p_idx].option = M41;
185 			param_stack[p_idx].ext = 1;
186 			param_stack[p_idx].filename = token;
187 			break;
188 		case CFG_A35:
189 			param_stack[p_idx].ext = CORE_CA35;
190 			param_stack[p_idx].option =
191 				(*cmd == CMD_DATA) ? DATA : AP;
192 			param_stack[p_idx].filename = token;
193 			break;
194 		case CFG_A53:
195 			param_stack[p_idx].ext = CORE_CA53;
196 			param_stack[p_idx].option =
197 				(*cmd == CMD_DATA) ? DATA : AP;
198 			param_stack[p_idx].filename = token;
199 			break;
200 		case CFG_A72:
201 			param_stack[p_idx].ext = CORE_CA72;
202 			param_stack[p_idx].option =
203 				(*cmd == CMD_DATA) ? DATA : AP;
204 			param_stack[p_idx].filename = token;
205 			break;
206 		}
207 		break;
208 	case CFG_LOAD_ADDR:
209 		if (*cmd == CMD_MSG_BLOCK) {
210 			param_stack[p_idx++].entry =
211 				(uint32_t)strtoll(token, NULL, 0);
212 			break;
213 		}
214 		switch (core_type) {
215 		case CFG_SCU:
216 			break;
217 		case CFG_M40:
218 		case CFG_M41:
219 		case CFG_A35:
220 		case CFG_A53:
221 		case CFG_A72:
222 			param_stack[p_idx++].entry =
223 				(uint32_t)strtoll(token, NULL, 0);
224 			break;
225 		}
226 	default:
227 		break;
228 	}
229 }
230 
231 static uint32_t parse_cfg_file(image_t *param_stack, char *name)
232 {
233 	FILE *fd = NULL;
234 	char *line = NULL;
235 	char *token, *saveptr1, *saveptr2;
236 	int lineno = 0;
237 	int fld;
238 	size_t len;
239 	int32_t cmd;
240 
241 	fd = fopen(name, "r");
242 	if (fd == 0) {
243 		fprintf(stderr, "Error: %s - Can't open cfg file\n", name);
244 		exit(EXIT_FAILURE);
245 	}
246 
247 	/*
248 	 * Very simple parsing, line starting with # are comments
249 	 * and are dropped
250 	 */
251 	while ((getline(&line, &len, fd)) > 0) {
252 		lineno++;
253 
254 		token = strtok_r(line, "\r\n", &saveptr1);
255 		if (!token)
256 			continue;
257 
258 		/* Check inside the single line */
259 		for (fld = CFG_COMMAND, cmd = CFG_INVALID,
260 		     line = token; ; line = NULL, fld++) {
261 			token = strtok_r(line, " \t", &saveptr2);
262 			if (!token)
263 				break;
264 
265 			/* Drop all text starting with '#' as comments */
266 			if (token[0] == '#')
267 				break;
268 
269 			parse_cfg_fld(param_stack, &cmd, token, name, lineno,
270 				      fld);
271 		}
272 	}
273 
274 	return 0;
275 }
276 
277 static void check_file(struct stat *sbuf, char *filename)
278 {
279 	int tmp_fd  = open(filename, O_RDONLY | O_BINARY);
280 
281 	if (tmp_fd < 0) {
282 		fprintf(stderr, "%s: Can't open: %s\n",
283 			filename, strerror(errno));
284 		exit(EXIT_FAILURE);
285 	}
286 
287 	if (fstat(tmp_fd, sbuf) < 0) {
288 		fprintf(stderr, "%s: Can't stat: %s\n",
289 			filename, strerror(errno));
290 		exit(EXIT_FAILURE);
291 	}
292 
293 	close(tmp_fd);
294 }
295 
296 static void copy_file_aligned(int ifd, const char *datafile, int offset,
297 			      int align)
298 {
299 	int dfd;
300 	struct stat sbuf;
301 	unsigned char *ptr;
302 	uint8_t zeros[0x4000];
303 	int size;
304 	int ret;
305 
306 	if (align > 0x4000) {
307 		fprintf(stderr, "Wrong alignment requested %d\n", align);
308 		exit(EXIT_FAILURE);
309 	}
310 
311 	memset(zeros, 0, sizeof(zeros));
312 
313 	dfd = open(datafile, O_RDONLY | O_BINARY);
314 	if (dfd < 0) {
315 		fprintf(stderr, "Can't open %s: %s\n",
316 			datafile, strerror(errno));
317 		exit(EXIT_FAILURE);
318 	}
319 
320 	if (fstat(dfd, &sbuf) < 0) {
321 		fprintf(stderr, "Can't stat %s: %s\n",
322 			datafile, strerror(errno));
323 		exit(EXIT_FAILURE);
324 	}
325 
326 	if (sbuf.st_size == 0)
327 		goto close;
328 
329 	ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
330 	if (ptr == MAP_FAILED) {
331 		fprintf(stderr, "Can't read %s: %s\n",
332 			datafile, strerror(errno));
333 		exit(EXIT_FAILURE);
334 	}
335 
336 	size = sbuf.st_size;
337 	ret = lseek(ifd, offset, SEEK_SET);
338 	if (ret < 0) {
339 		fprintf(stderr, "%s: lseek error %s\n",
340 			__func__, strerror(errno));
341 		exit(EXIT_FAILURE);
342 	}
343 
344 	if (write(ifd, ptr, size) != size) {
345 		fprintf(stderr, "Write error %s\n", strerror(errno));
346 		exit(EXIT_FAILURE);
347 	}
348 
349 	align = ALIGN(size, align) - size;
350 
351 	if (write(ifd, (char *)&zeros, align) != align) {
352 		fprintf(stderr, "Write error: %s\n", strerror(errno));
353 		exit(EXIT_FAILURE);
354 	}
355 
356 	munmap((void *)ptr, sbuf.st_size);
357 close:
358 	close(dfd);
359 }
360 
361 static void copy_file (int ifd, const char *datafile, int pad, int offset)
362 {
363 	int dfd;
364 	struct stat sbuf;
365 	unsigned char *ptr;
366 	int tail;
367 	int zero = 0;
368 	uint8_t zeros[4096];
369 	int size, ret;
370 
371 	memset(zeros, 0, sizeof(zeros));
372 
373 	dfd = open(datafile, O_RDONLY | O_BINARY);
374 	if (dfd < 0) {
375 		fprintf(stderr, "Can't open %s: %s\n",
376 			datafile, strerror(errno));
377 		exit(EXIT_FAILURE);
378 	}
379 
380 	if (fstat(dfd, &sbuf) < 0) {
381 		fprintf(stderr, "Can't stat %s: %s\n",
382 			datafile, strerror(errno));
383 		exit(EXIT_FAILURE);
384 	}
385 
386 	if (sbuf.st_size == 0)
387 		goto close;
388 
389 	ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
390 	if (ptr == MAP_FAILED) {
391 		fprintf(stderr, "Can't read %s: %s\n",
392 			datafile, strerror(errno));
393 		exit(EXIT_FAILURE);
394 	}
395 
396 	size = sbuf.st_size;
397 	ret = lseek(ifd, offset, SEEK_SET);
398 	if (ret < 0) {
399 		fprintf(stderr, "%s: lseek error %s\n",
400 			__func__, strerror(errno));
401 		exit(EXIT_FAILURE);
402 	}
403 
404 	if (write(ifd, ptr, size) != size) {
405 		fprintf(stderr, "Write error %s\n",
406 			strerror(errno));
407 		exit(EXIT_FAILURE);
408 	}
409 
410 	tail = size % 4;
411 	pad = pad - size;
412 	if (pad == 1 && tail != 0) {
413 		if (write(ifd, (char *)&zero, 4 - tail) != 4 - tail) {
414 			fprintf(stderr, "Write error on %s\n",
415 				strerror(errno));
416 			exit(EXIT_FAILURE);
417 		}
418 	} else if (pad > 1) {
419 		while (pad > 0) {
420 			int todo = sizeof(zeros);
421 
422 			if (todo > pad)
423 				todo = pad;
424 			if (write(ifd, (char *)&zeros, todo) != todo) {
425 				fprintf(stderr, "Write error: %s\n",
426 					strerror(errno));
427 				exit(EXIT_FAILURE);
428 			}
429 			pad -= todo;
430 		}
431 	}
432 
433 	munmap((void *)ptr, sbuf.st_size);
434 close:
435 	close(dfd);
436 }
437 
438 uint64_t read_dcd_offset(char *filename)
439 {
440 	int dfd;
441 	struct stat sbuf;
442 	uint8_t *ptr;
443 	uint64_t offset = 0;
444 
445 	dfd = open(filename, O_RDONLY | O_BINARY);
446 	if (dfd < 0) {
447 		fprintf(stderr, "Can't open %s: %s\n", filename, strerror(errno));
448 		exit(EXIT_FAILURE);
449 	}
450 
451 	if (fstat(dfd, &sbuf) < 0) {
452 		fprintf(stderr, "Can't stat %s: %s\n", filename, strerror(errno));
453 		exit(EXIT_FAILURE);
454 	}
455 
456 	ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0);
457 	if (ptr == MAP_FAILED) {
458 		fprintf(stderr, "Can't read %s: %s\n", filename, strerror(errno));
459 		exit(EXIT_FAILURE);
460 	}
461 
462 	offset = *(uint32_t *)(ptr + DCD_ENTRY_ADDR_IN_SCFW);
463 
464 	munmap((void *)ptr, sbuf.st_size);
465 	close(dfd);
466 
467 	return offset;
468 }
469 
470 static void set_image_hash(boot_img_t *img, char *filename, uint32_t hash_type)
471 {
472 	FILE *fp = NULL;
473 	char sha_command[512];
474 	char hash[2 * HASH_MAX_LEN + 1];
475 	int i, ret;
476 
477 	if (img->size == 0)
478 		sprintf(sha_command, "sha%dsum /dev/null", hash_type);
479 	else
480 		sprintf(sha_command, "dd if=/dev/zero of=tmp_pad bs=%d count=1;\
481 			dd if=\'%s\' of=tmp_pad conv=notrunc;\
482 			sha%dsum tmp_pad; rm -f tmp_pad",
483 			img->size, filename, hash_type);
484 
485 	switch (hash_type) {
486 	case HASH_TYPE_SHA_256:
487 		img->hab_flags |= IMG_FLAG_HASH_SHA256;
488 		break;
489 	case HASH_TYPE_SHA_384:
490 		img->hab_flags |= IMG_FLAG_HASH_SHA384;
491 		break;
492 	case HASH_TYPE_SHA_512:
493 		img->hab_flags |= IMG_FLAG_HASH_SHA512;
494 		break;
495 	default:
496 		fprintf(stderr, "Wrong hash type selected (%d) !!!\n\n",
497 			hash_type);
498 		exit(EXIT_FAILURE);
499 		break;
500 	}
501 	memset(img->hash, 0, HASH_MAX_LEN);
502 
503 	fp = popen(sha_command, "r");
504 	if (!fp) {
505 		fprintf(stderr, "Failed to run command hash\n");
506 		exit(EXIT_FAILURE);
507 	}
508 
509 	if (!fgets(hash, hash_type / 4 + 1, fp)) {
510 		fprintf(stderr, "Failed to hash file: %s\n", filename);
511 		exit(EXIT_FAILURE);
512 	}
513 
514 	for (i = 0; i < strlen(hash) / 2; i++) {
515 		ret = sscanf(hash + 2 * i, "%02hhx", &img->hash[i]);
516 		if (ret < 0) {
517 			fprintf(stderr, "Failed sscanf hash: %d\n", ret);
518 			exit(EXIT_FAILURE);
519 		}
520 	}
521 
522 	pclose(fp);
523 }
524 
525 static void set_image_array_entry(flash_header_v3_t *container,
526 				  soc_type_t soc, const image_t *image_stack,
527 				  uint32_t offset, uint32_t size,
528 				  char *tmp_filename, bool dcd_skip)
529 {
530 	uint64_t entry = image_stack->entry;
531 	uint64_t core = image_stack->ext;
532 	uint32_t meta;
533 	char *tmp_name = "";
534 	option_type_t type = image_stack->option;
535 	boot_img_t *img = &container->img[container->num_images];
536 
537 	img->offset = offset;  /* Is re-adjusted later */
538 	img->size = size;
539 
540 	set_image_hash(img, tmp_filename, IMAGE_HASH_ALGO_DEFAULT);
541 
542 	switch (type) {
543 	case SECO:
544 		img->hab_flags |= IMG_TYPE_SECO;
545 		img->hab_flags |= CORE_SECO << BOOT_IMG_FLAGS_CORE_SHIFT;
546 		tmp_name = "SECO";
547 		img->dst = 0x20C00000;
548 		img->entry = 0x20000000;
549 		break;
550 	case AP:
551 		if (soc == QX && core == CORE_CA35) {
552 			meta = IMAGE_A35_DEFAULT_META(custom_partition);
553 		} else if (soc == QM && core == CORE_CA53) {
554 			meta = IMAGE_A53_DEFAULT_META(custom_partition);
555 		} else if (soc == QM && core == CORE_CA72) {
556 			meta = IMAGE_A72_DEFAULT_META(custom_partition);
557 		} else {
558 			fprintf(stderr, "Error: invalid AP core id: %lu\n",
559 				core);
560 			exit(EXIT_FAILURE);
561 		}
562 		img->hab_flags |= IMG_TYPE_EXEC;
563 		/* On B0, only core id = 4 is valid */
564 		img->hab_flags |= CORE_CA53 << BOOT_IMG_FLAGS_CORE_SHIFT;
565 		tmp_name = "AP";
566 		img->dst = entry;
567 		img->entry = entry;
568 		img->meta = meta;
569 		custom_partition = 0;
570 		break;
571 	case M40:
572 	case M41:
573 		if (core == 0) {
574 			core = CORE_CM4_0;
575 			meta = IMAGE_M4_0_DEFAULT_META(custom_partition);
576 		} else if (core == 1) {
577 			core = CORE_CM4_1;
578 			meta = IMAGE_M4_1_DEFAULT_META(custom_partition);
579 		} else {
580 			fprintf(stderr, "Error: invalid m4 core id: %lu\n", core);
581 			exit(EXIT_FAILURE);
582 		}
583 		img->hab_flags |= IMG_TYPE_EXEC;
584 		img->hab_flags |= core << BOOT_IMG_FLAGS_CORE_SHIFT;
585 		tmp_name = "M4";
586 		if ((entry & 0x7) != 0) {
587 			fprintf(stderr, "\n\nWarning: M4 Destination address is not 8 byte aligned\n\n");
588 			exit(EXIT_FAILURE);
589 		}
590 		img->dst = entry;
591 		img->entry = entry;
592 		img->meta = meta;
593 		custom_partition = 0;
594 		break;
595 	case DATA:
596 		img->hab_flags |= IMG_TYPE_DATA;
597 		img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT;
598 		tmp_name = "DATA";
599 		img->dst = entry;
600 		break;
601 	case MSG_BLOCK:
602 		img->hab_flags |= IMG_TYPE_DATA;
603 		img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT;
604 		img->meta = core << BOOT_IMG_META_MU_RID_SHIFT;
605 		tmp_name = "MSG_BLOCK";
606 		img->dst = entry;
607 		break;
608 	case SCFW:
609 		img->hab_flags |= scfw_flags & 0xFFFF0000;
610 		img->hab_flags |= IMG_TYPE_EXEC;
611 		img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
612 		tmp_name = "SCFW";
613 		img->dst = 0x1FFE0000;
614 		img->entry = 0x1FFE0000;
615 
616 		/* Lets add the DCD now */
617 		if (!dcd_skip) {
618 			container->num_images++;
619 			img = &container->img[container->num_images];
620 			img->hab_flags |= IMG_TYPE_DCD_DDR;
621 			img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
622 			set_image_hash(img, "/dev/null",
623 				       IMAGE_HASH_ALGO_DEFAULT);
624 			img->offset = offset + img->size;
625 			img->entry = read_dcd_offset(tmp_filename);
626 			img->dst = img->entry - 1;
627 		}
628 		break;
629 	default:
630 		fprintf(stderr, "unrecognized image type (%d)\n", type);
631 		exit(EXIT_FAILURE);
632 	}
633 
634 	fprintf(stdout, "%s file_offset = 0x%x size = 0x%x\n", tmp_name, offset, size);
635 
636 	container->num_images++;
637 }
638 
639 void set_container(flash_header_v3_t *container,  uint16_t sw_version,
640 		   uint32_t alignment, uint32_t flags, uint16_t fuse_version)
641 {
642 	container->sig_blk_hdr.tag = 0x90;
643 	container->sig_blk_hdr.length = sizeof(sig_blk_hdr_t);
644 	container->sw_version = sw_version;
645 	container->padding = alignment;
646 	container->fuse_version = fuse_version;
647 	container->flags = flags;
648 	fprintf(stdout, "container flags: 0x%x\n", container->flags);
649 }
650 
651 static int get_container_image_start_pos(image_t *image_stack, uint32_t align)
652 {
653 	image_t *img_sp = image_stack;
654 	/*8K total container header*/
655 	int file_off = CONTAINER_IMAGE_ARRAY_START_OFFSET;
656 	FILE *fd = NULL;
657 	flash_header_v3_t header;
658 	int ret;
659 
660 	while (img_sp->option != NO_IMG) {
661 		if (img_sp->option == APPEND) {
662 			fd = fopen(img_sp->filename, "r");
663 			if (!fd) {
664 				fprintf(stderr, "Fail open first container file %s\n", img_sp->filename);
665 				exit(EXIT_FAILURE);
666 			}
667 
668 			ret = fread(&header, sizeof(header), 1, fd);
669 			if (ret != 1) {
670 				printf("Failure Read header %d\n", ret);
671 				exit(EXIT_FAILURE);
672 			}
673 
674 			fclose(fd);
675 
676 			if (header.tag != IVT_HEADER_TAG_B0) {
677 				fprintf(stderr, "header tag missmatched \n");
678 				exit(EXIT_FAILURE);
679 			} else {
680 				file_off +=
681 					header.img[header.num_images - 1].size;
682 				file_off = ALIGN(file_off, align);
683 			}
684 		}
685 
686 		img_sp++;
687 	}
688 
689 	return file_off;
690 }
691 
692 static void set_imx_hdr_v3(imx_header_v3_t *imxhdr, uint32_t cont_id)
693 {
694 	flash_header_v3_t *fhdr_v3 = &imxhdr->fhdr[cont_id];
695 
696 	/* Set magic number, Only >= B0 supported */
697 	fhdr_v3->tag = IVT_HEADER_TAG_B0;
698 	fhdr_v3->version = IVT_VERSION_B0;
699 }
700 
701 static uint8_t *flatten_container_header(imx_header_v3_t *imx_header,
702 					 uint8_t containers_count,
703 					 uint32_t *size_out,
704 					 uint32_t file_offset)
705 {
706 	uint8_t *flat = NULL;
707 	uint8_t *ptr = NULL;
708 	uint16_t size = 0;
709 	int i, j;
710 
711 	/* Compute size of all container headers */
712 	for (i = 0; i < containers_count; i++) {
713 		flash_header_v3_t *container = &imx_header->fhdr[i];
714 
715 		container->sig_blk_offset = HEADER_IMG_ARRAY_OFFSET +
716 			container->num_images * IMG_ARRAY_ENTRY_SIZE;
717 
718 		container->length = HEADER_IMG_ARRAY_OFFSET +
719 			(IMG_ARRAY_ENTRY_SIZE * container->num_images) +
720 			sizeof(sig_blk_hdr_t);
721 
722 		/* Print info needed by CST to sign the container header */
723 		fprintf(stdout, "CST: CONTAINER %d offset: 0x%x\n",
724 			i, file_offset + size);
725 		fprintf(stdout, "CST: CONTAINER %d: Signature Block: offset is at 0x%x\n", i,
726 			file_offset + size + container->length -
727 			SIGNATURE_BLOCK_HEADER_LENGTH);
728 
729 		size += ALIGN(container->length, container->padding);
730 	}
731 
732 	flat = calloc(size, sizeof(uint8_t));
733 	if (!flat) {
734 		fprintf(stderr, "Failed to allocate memory (%d)\n", size);
735 		exit(EXIT_FAILURE);
736 	}
737 
738 	ptr = flat;
739 	*size_out = size;
740 
741 	for (i = 0; i < containers_count; i++) {
742 		flash_header_v3_t *container = &imx_header->fhdr[i];
743 		uint32_t container_start_offset = ptr - flat;
744 
745 		/* Append container header */
746 		append(ptr, container, HEADER_IMG_ARRAY_OFFSET);
747 
748 		/* Adjust images offset to start from container headers start */
749 		for (j = 0; j < container->num_images; j++) {
750 			container->img[j].offset -=
751 				container_start_offset + file_offset;
752 		}
753 		/* Append each image array entry */
754 		for (j = 0; j < container->num_images; j++)
755 			append(ptr, &container->img[j], sizeof(boot_img_t));
756 
757 		append(ptr, &container->sig_blk_hdr, sizeof(sig_blk_hdr_t));
758 
759 		/* Padding for container (if necessary) */
760 		ptr += ALIGN(container->length, container->padding) -
761 			container->length;
762 	}
763 
764 	return flat;
765 }
766 
767 static int build_container(soc_type_t soc, uint32_t sector_size,
768 			   bool emmc_fastboot, image_t *image_stack,
769 			   bool dcd_skip, uint8_t fuse_version,
770 			   uint16_t sw_version, int ofd)
771 {
772 	static imx_header_v3_t imx_header;
773 	image_t *img_sp = image_stack;
774 	int file_off;
775 	uint8_t *tmp;
776 	struct stat sbuf;
777 	char *tmp_filename = NULL;
778 	uint32_t size = 0;
779 	uint32_t file_padding = 0;
780 	int ret;
781 
782 	int container = -1;
783 	int cont_img_count = 0; /* indexes to arrange the container */
784 
785 	memset((char *)&imx_header, 0, sizeof(imx_header_v3_t));
786 
787 	if (!image_stack) {
788 		fprintf(stderr, "Empty image stack ");
789 		exit(EXIT_FAILURE);
790 	}
791 
792 	if (soc == QX)
793 		fprintf(stdout, "Platform:\ti.MX8QXP B0\n");
794 	else if (soc == QM)
795 		fprintf(stdout, "Platform:\ti.MX8QM B0\n");
796 
797 	set_imx_hdr_v3(&imx_header, 0);
798 	set_imx_hdr_v3(&imx_header, 1);
799 
800 	file_off = get_container_image_start_pos(image_stack, sector_size);
801 	fprintf(stdout, "container image offset (aligned):%x\n", file_off);
802 
803 	/* step through image stack and generate the header */
804 	img_sp = image_stack;
805 
806 	/* stop once we reach null terminator */
807 	while (img_sp->option != NO_IMG) {
808 		switch (img_sp->option) {
809 		case AP:
810 		case M40:
811 		case M41:
812 		case SCFW:
813 		case DATA:
814 		case MSG_BLOCK:
815 			if (container < 0) {
816 				fprintf(stderr, "No container found\n");
817 				exit(EXIT_FAILURE);
818 			}
819 			check_file(&sbuf, img_sp->filename);
820 			tmp_filename = img_sp->filename;
821 			set_image_array_entry(&imx_header.fhdr[container],
822 					      soc, img_sp, file_off,
823 					      ALIGN(sbuf.st_size, sector_size),
824 					      tmp_filename, dcd_skip);
825 			img_sp->src = file_off;
826 
827 			file_off += ALIGN(sbuf.st_size, sector_size);
828 			cont_img_count++;
829 			break;
830 
831 		case SECO:
832 			if (container < 0) {
833 				fprintf(stderr, "No container found\n");
834 				exit(EXIT_FAILURE);
835 			}
836 			check_file(&sbuf, img_sp->filename);
837 			tmp_filename = img_sp->filename;
838 			set_image_array_entry(&imx_header.fhdr[container],
839 					      soc,
840 					      img_sp,
841 					      file_off,
842 					      sbuf.st_size,
843 					      tmp_filename, dcd_skip);
844 			img_sp->src = file_off;
845 
846 			file_off += sbuf.st_size;
847 			cont_img_count++;
848 			break;
849 
850 		case NEW_CONTAINER:
851 			container++;
852 			set_container(&imx_header.fhdr[container], sw_version,
853 				      CONTAINER_ALIGNMENT,
854 				      CONTAINER_FLAGS_DEFAULT,
855 				      fuse_version);
856 			/* reset img count when moving to new container */
857 			cont_img_count = 0;
858 			scfw_flags = 0;
859 			break;
860 
861 		case APPEND:
862 			/*
863 			 * nothing to do here, the container is appended
864 			 * in the output
865 			 */
866 			break;
867 		case FLAG:
868 			/*
869 			 * override the flags for scfw in current container
870 			 * mask off bottom 16 bits.
871 			 */
872 			scfw_flags = img_sp->entry & 0xFFFF0000;
873 			break;
874 		case FILEOFF:
875 			if (file_off > img_sp->dst) {
876 				fprintf(stderr, "FILEOFF address less than current file offset!!!\n");
877 				exit(EXIT_FAILURE);
878 			}
879 			if (img_sp->dst != ALIGN(img_sp->dst, sector_size)) {
880 				fprintf(stderr, "FILEOFF address is not aligned to sector size!!!\n");
881 				exit(EXIT_FAILURE);
882 			}
883 			file_off = img_sp->dst;
884 			break;
885 		case PARTITION:
886 			/*
887 			 * keep custom partition until next executable image
888 			 * use a global var for default behaviour
889 			 */
890 			custom_partition = img_sp->entry;
891 			break;
892 		default:
893 			fprintf(stderr, "unrecognized option in input stack (%d)\n", img_sp->option);
894 			exit(EXIT_FAILURE);
895 		}
896 		img_sp++; /* advance index */
897 	}
898 
899 	/* Append container (if specified) */
900 	img_sp = image_stack;
901 	do {
902 		if (img_sp->option == APPEND) {
903 			copy_file(ofd, img_sp->filename, 0, 0);
904 			file_padding += FIRST_CONTAINER_HEADER_LENGTH;
905 		}
906 		img_sp++;
907 	} while (img_sp->option != NO_IMG);
908 
909 	/* Add padding or skip appended container */
910 	ret = lseek(ofd, file_padding, SEEK_SET);
911 	if (ret < 0) {
912 		fprintf(stderr, "%s: lseek error %s\n",
913 			__func__, strerror(errno));
914 		exit(EXIT_FAILURE);
915 	}
916 
917 	if (container >= 0) {
918 		/* Note: Image offset are not contained in the image */
919 		tmp = flatten_container_header(&imx_header, container + 1,
920 					       &size, file_padding);
921 		/* Write image header */
922 		if (write(ofd, tmp, size) != size) {
923 			fprintf(stderr, "error writing image hdr\n");
924 			exit(EXIT_FAILURE);
925 		}
926 
927 		/* Clean-up memory used by the headers */
928 		free(tmp);
929 	}
930 
931 	/*
932 	 * step through the image stack again this time copying
933 	 * images to final bin, stop once we reach null terminator.
934 	 */
935 	img_sp = image_stack;
936 	while (img_sp->option != NO_IMG) {
937 		if (img_sp->option == M40 || img_sp->option == M41 ||
938 		    img_sp->option == AP || img_sp->option == DATA ||
939 		    img_sp->option == SCD || img_sp->option == SCFW ||
940 		    img_sp->option == SECO || img_sp->option == MSG_BLOCK) {
941 			copy_file_aligned(ofd, img_sp->filename, img_sp->src,
942 					  sector_size);
943 		}
944 		img_sp++;
945 	}
946 
947 	return 0;
948 }
949 
950 int imx8image_copy_image(int outfd, struct image_tool_params *mparams)
951 {
952 	image_t *img_sp = param_stack;
953 
954 	/*
955 	 * SECO FW is a container image, this is to calculate the
956 	 * 2nd container offset.
957 	 */
958 	fprintf(stdout, "parsing %s\n", mparams->imagename);
959 	parse_cfg_file(img_sp, mparams->imagename);
960 
961 	if (sector_size == 0) {
962 		fprintf(stderr, "Wrong sector size\n");
963 		exit(EXIT_FAILURE);
964 	}
965 
966 	fprintf(stdout, "CONTAINER Sector size:\t%08x\n", sector_size);
967 	fprintf(stdout, "CONTAINER FUSE VERSION:\t0x%02x\n", fuse_version);
968 	fprintf(stdout, "CONTAINER SW VERSION:\t0x%04x\n", sw_version);
969 
970 	build_container(soc, sector_size, emmc_fastboot,
971 			img_sp, false, fuse_version, sw_version, outfd);
972 
973 	return 0;
974 }
975 
976 /*
977  * imx8image parameters
978  */
979 U_BOOT_IMAGE_TYPE(
980 	imx8image,
981 	"NXP i.MX8 Boot Image support",
982 	0,
983 	NULL,
984 	imx8image_check_params,
985 	NULL,
986 	imx8image_print_header,
987 	imx8image_set_header,
988 	NULL,
989 	imx8image_check_image_types,
990 	NULL,
991 	NULL
992 );
993