xref: /openbmc/u-boot/tools/imx8image.c (revision a873bff7)
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 
imx8image_check_params(struct image_tool_params * params)22 int imx8image_check_params(struct image_tool_params *params)
23 {
24 	return 0;
25 }
26 
imx8image_set_header(void * ptr,struct stat * sbuf,int ifd,struct image_tool_params * params)27 static void imx8image_set_header(void *ptr, struct stat *sbuf, int ifd,
28 				 struct image_tool_params *params)
29 {
30 }
31 
imx8image_print_header(const void * ptr)32 static void imx8image_print_header(const void *ptr)
33 {
34 }
35 
imx8image_check_image_types(uint8_t type)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 
parse_cfg_cmd(image_t * param_stack,int32_t cmd,char * token,char * name,int lineno)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 
parse_cfg_fld(image_t * param_stack,int32_t * cmd,char * token,char * name,int lineno,int fld)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 
parse_cfg_file(image_t * param_stack,char * name)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 
check_file(struct stat * sbuf,char * filename)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 
copy_file_aligned(int ifd,const char * datafile,int offset,int align)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 
copy_file(int ifd,const char * datafile,int pad,int offset)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 	uint64_t 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 
read_dcd_offset(char * filename)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 
set_image_hash(boot_img_t * img,char * filename,uint32_t hash_type)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 
set_image_array_entry(flash_header_v3_t * container,soc_type_t soc,const image_t * image_stack,uint32_t offset,uint32_t size,char * tmp_filename,bool dcd_skip)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,
559 				"Error: invalid AP core id: %" PRIu64 "\n",
560 				core);
561 			exit(EXIT_FAILURE);
562 		}
563 		img->hab_flags |= IMG_TYPE_EXEC;
564 		/* On B0, only core id = 4 is valid */
565 		img->hab_flags |= CORE_CA53 << BOOT_IMG_FLAGS_CORE_SHIFT;
566 		tmp_name = "AP";
567 		img->dst = entry;
568 		img->entry = entry;
569 		img->meta = meta;
570 		custom_partition = 0;
571 		break;
572 	case M40:
573 	case M41:
574 		if (core == 0) {
575 			core = CORE_CM4_0;
576 			meta = IMAGE_M4_0_DEFAULT_META(custom_partition);
577 		} else if (core == 1) {
578 			core = CORE_CM4_1;
579 			meta = IMAGE_M4_1_DEFAULT_META(custom_partition);
580 		} else {
581 			fprintf(stderr,
582 				"Error: invalid m4 core id: %" PRIu64 "\n",
583 				core);
584 			exit(EXIT_FAILURE);
585 		}
586 		img->hab_flags |= IMG_TYPE_EXEC;
587 		img->hab_flags |= core << BOOT_IMG_FLAGS_CORE_SHIFT;
588 		tmp_name = "M4";
589 		if ((entry & 0x7) != 0) {
590 			fprintf(stderr, "\n\nWarning: M4 Destination address is not 8 byte aligned\n\n");
591 			exit(EXIT_FAILURE);
592 		}
593 		img->dst = entry;
594 		img->entry = entry;
595 		img->meta = meta;
596 		custom_partition = 0;
597 		break;
598 	case DATA:
599 		img->hab_flags |= IMG_TYPE_DATA;
600 		img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT;
601 		tmp_name = "DATA";
602 		img->dst = entry;
603 		break;
604 	case MSG_BLOCK:
605 		img->hab_flags |= IMG_TYPE_DATA;
606 		img->hab_flags |= CORE_CA35 << BOOT_IMG_FLAGS_CORE_SHIFT;
607 		img->meta = core << BOOT_IMG_META_MU_RID_SHIFT;
608 		tmp_name = "MSG_BLOCK";
609 		img->dst = entry;
610 		break;
611 	case SCFW:
612 		img->hab_flags |= scfw_flags & 0xFFFF0000;
613 		img->hab_flags |= IMG_TYPE_EXEC;
614 		img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
615 		tmp_name = "SCFW";
616 		img->dst = 0x1FFE0000;
617 		img->entry = 0x1FFE0000;
618 
619 		/* Lets add the DCD now */
620 		if (!dcd_skip) {
621 			container->num_images++;
622 			img = &container->img[container->num_images];
623 			img->hab_flags |= IMG_TYPE_DCD_DDR;
624 			img->hab_flags |= CORE_SC << BOOT_IMG_FLAGS_CORE_SHIFT;
625 			set_image_hash(img, "/dev/null",
626 				       IMAGE_HASH_ALGO_DEFAULT);
627 			img->offset = offset + img->size;
628 			img->entry = read_dcd_offset(tmp_filename);
629 			img->dst = img->entry - 1;
630 		}
631 		break;
632 	default:
633 		fprintf(stderr, "unrecognized image type (%d)\n", type);
634 		exit(EXIT_FAILURE);
635 	}
636 
637 	fprintf(stdout, "%s file_offset = 0x%x size = 0x%x\n", tmp_name, offset, size);
638 
639 	container->num_images++;
640 }
641 
set_container(flash_header_v3_t * container,uint16_t sw_version,uint32_t alignment,uint32_t flags,uint16_t fuse_version)642 void set_container(flash_header_v3_t *container,  uint16_t sw_version,
643 		   uint32_t alignment, uint32_t flags, uint16_t fuse_version)
644 {
645 	container->sig_blk_hdr.tag = 0x90;
646 	container->sig_blk_hdr.length = sizeof(sig_blk_hdr_t);
647 	container->sw_version = sw_version;
648 	container->padding = alignment;
649 	container->fuse_version = fuse_version;
650 	container->flags = flags;
651 	fprintf(stdout, "container flags: 0x%x\n", container->flags);
652 }
653 
get_container_image_start_pos(image_t * image_stack,uint32_t align)654 static int get_container_image_start_pos(image_t *image_stack, uint32_t align)
655 {
656 	image_t *img_sp = image_stack;
657 	/*8K total container header*/
658 	int file_off = CONTAINER_IMAGE_ARRAY_START_OFFSET;
659 	FILE *fd = NULL;
660 	flash_header_v3_t header;
661 	int ret;
662 
663 	while (img_sp->option != NO_IMG) {
664 		if (img_sp->option == APPEND) {
665 			fd = fopen(img_sp->filename, "r");
666 			if (!fd) {
667 				fprintf(stderr, "Fail open first container file %s\n", img_sp->filename);
668 				exit(EXIT_FAILURE);
669 			}
670 
671 			ret = fread(&header, sizeof(header), 1, fd);
672 			if (ret != 1) {
673 				printf("Failure Read header %d\n", ret);
674 				exit(EXIT_FAILURE);
675 			}
676 
677 			fclose(fd);
678 
679 			if (header.tag != IVT_HEADER_TAG_B0) {
680 				fprintf(stderr, "header tag mismatched \n");
681 				exit(EXIT_FAILURE);
682 			} else {
683 				file_off +=
684 					header.img[header.num_images - 1].size;
685 				file_off = ALIGN(file_off, align);
686 			}
687 		}
688 
689 		img_sp++;
690 	}
691 
692 	return file_off;
693 }
694 
set_imx_hdr_v3(imx_header_v3_t * imxhdr,uint32_t cont_id)695 static void set_imx_hdr_v3(imx_header_v3_t *imxhdr, uint32_t cont_id)
696 {
697 	flash_header_v3_t *fhdr_v3 = &imxhdr->fhdr[cont_id];
698 
699 	/* Set magic number, Only >= B0 supported */
700 	fhdr_v3->tag = IVT_HEADER_TAG_B0;
701 	fhdr_v3->version = IVT_VERSION_B0;
702 }
703 
flatten_container_header(imx_header_v3_t * imx_header,uint8_t containers_count,uint32_t * size_out,uint32_t file_offset)704 static uint8_t *flatten_container_header(imx_header_v3_t *imx_header,
705 					 uint8_t containers_count,
706 					 uint32_t *size_out,
707 					 uint32_t file_offset)
708 {
709 	uint8_t *flat = NULL;
710 	uint8_t *ptr = NULL;
711 	uint16_t size = 0;
712 	int i, j;
713 
714 	/* Compute size of all container headers */
715 	for (i = 0; i < containers_count; i++) {
716 		flash_header_v3_t *container = &imx_header->fhdr[i];
717 
718 		container->sig_blk_offset = HEADER_IMG_ARRAY_OFFSET +
719 			container->num_images * IMG_ARRAY_ENTRY_SIZE;
720 
721 		container->length = HEADER_IMG_ARRAY_OFFSET +
722 			(IMG_ARRAY_ENTRY_SIZE * container->num_images) +
723 			sizeof(sig_blk_hdr_t);
724 
725 		/* Print info needed by CST to sign the container header */
726 		fprintf(stdout, "CST: CONTAINER %d offset: 0x%x\n",
727 			i, file_offset + size);
728 		fprintf(stdout, "CST: CONTAINER %d: Signature Block: offset is at 0x%x\n", i,
729 			file_offset + size + container->length -
730 			SIGNATURE_BLOCK_HEADER_LENGTH);
731 
732 		size += ALIGN(container->length, container->padding);
733 	}
734 
735 	flat = calloc(size, sizeof(uint8_t));
736 	if (!flat) {
737 		fprintf(stderr, "Failed to allocate memory (%d)\n", size);
738 		exit(EXIT_FAILURE);
739 	}
740 
741 	ptr = flat;
742 	*size_out = size;
743 
744 	for (i = 0; i < containers_count; i++) {
745 		flash_header_v3_t *container = &imx_header->fhdr[i];
746 		uint32_t container_start_offset = ptr - flat;
747 
748 		/* Append container header */
749 		append(ptr, container, HEADER_IMG_ARRAY_OFFSET);
750 
751 		/* Adjust images offset to start from container headers start */
752 		for (j = 0; j < container->num_images; j++) {
753 			container->img[j].offset -=
754 				container_start_offset + file_offset;
755 		}
756 		/* Append each image array entry */
757 		for (j = 0; j < container->num_images; j++)
758 			append(ptr, &container->img[j], sizeof(boot_img_t));
759 
760 		append(ptr, &container->sig_blk_hdr, sizeof(sig_blk_hdr_t));
761 
762 		/* Padding for container (if necessary) */
763 		ptr += ALIGN(container->length, container->padding) -
764 			container->length;
765 	}
766 
767 	return flat;
768 }
769 
build_container(soc_type_t soc,uint32_t sector_size,bool emmc_fastboot,image_t * image_stack,bool dcd_skip,uint8_t fuse_version,uint16_t sw_version,int ofd)770 static int build_container(soc_type_t soc, uint32_t sector_size,
771 			   bool emmc_fastboot, image_t *image_stack,
772 			   bool dcd_skip, uint8_t fuse_version,
773 			   uint16_t sw_version, int ofd)
774 {
775 	static imx_header_v3_t imx_header;
776 	image_t *img_sp = image_stack;
777 	int file_off;
778 	uint8_t *tmp;
779 	struct stat sbuf;
780 	char *tmp_filename = NULL;
781 	uint32_t size = 0;
782 	uint32_t file_padding = 0;
783 	int ret;
784 
785 	int container = -1;
786 	int cont_img_count = 0; /* indexes to arrange the container */
787 
788 	memset((char *)&imx_header, 0, sizeof(imx_header_v3_t));
789 
790 	if (!image_stack) {
791 		fprintf(stderr, "Empty image stack ");
792 		exit(EXIT_FAILURE);
793 	}
794 
795 	if (soc == QX)
796 		fprintf(stdout, "Platform:\ti.MX8QXP B0\n");
797 	else if (soc == QM)
798 		fprintf(stdout, "Platform:\ti.MX8QM B0\n");
799 
800 	set_imx_hdr_v3(&imx_header, 0);
801 	set_imx_hdr_v3(&imx_header, 1);
802 
803 	file_off = get_container_image_start_pos(image_stack, sector_size);
804 	fprintf(stdout, "container image offset (aligned):%x\n", file_off);
805 
806 	/* step through image stack and generate the header */
807 	img_sp = image_stack;
808 
809 	/* stop once we reach null terminator */
810 	while (img_sp->option != NO_IMG) {
811 		switch (img_sp->option) {
812 		case AP:
813 		case M40:
814 		case M41:
815 		case SCFW:
816 		case DATA:
817 		case MSG_BLOCK:
818 			if (container < 0) {
819 				fprintf(stderr, "No container found\n");
820 				exit(EXIT_FAILURE);
821 			}
822 			check_file(&sbuf, img_sp->filename);
823 			tmp_filename = img_sp->filename;
824 			set_image_array_entry(&imx_header.fhdr[container],
825 					      soc, img_sp, file_off,
826 					      ALIGN(sbuf.st_size, sector_size),
827 					      tmp_filename, dcd_skip);
828 			img_sp->src = file_off;
829 
830 			file_off += ALIGN(sbuf.st_size, sector_size);
831 			cont_img_count++;
832 			break;
833 
834 		case SECO:
835 			if (container < 0) {
836 				fprintf(stderr, "No container found\n");
837 				exit(EXIT_FAILURE);
838 			}
839 			check_file(&sbuf, img_sp->filename);
840 			tmp_filename = img_sp->filename;
841 			set_image_array_entry(&imx_header.fhdr[container],
842 					      soc,
843 					      img_sp,
844 					      file_off,
845 					      sbuf.st_size,
846 					      tmp_filename, dcd_skip);
847 			img_sp->src = file_off;
848 
849 			file_off += sbuf.st_size;
850 			cont_img_count++;
851 			break;
852 
853 		case NEW_CONTAINER:
854 			container++;
855 			set_container(&imx_header.fhdr[container], sw_version,
856 				      CONTAINER_ALIGNMENT,
857 				      CONTAINER_FLAGS_DEFAULT,
858 				      fuse_version);
859 			/* reset img count when moving to new container */
860 			cont_img_count = 0;
861 			scfw_flags = 0;
862 			break;
863 
864 		case APPEND:
865 			/*
866 			 * nothing to do here, the container is appended
867 			 * in the output
868 			 */
869 			break;
870 		case FLAG:
871 			/*
872 			 * override the flags for scfw in current container
873 			 * mask off bottom 16 bits.
874 			 */
875 			scfw_flags = img_sp->entry & 0xFFFF0000;
876 			break;
877 		case FILEOFF:
878 			if (file_off > img_sp->dst) {
879 				fprintf(stderr, "FILEOFF address less than current file offset!!!\n");
880 				exit(EXIT_FAILURE);
881 			}
882 			if (img_sp->dst != ALIGN(img_sp->dst, sector_size)) {
883 				fprintf(stderr, "FILEOFF address is not aligned to sector size!!!\n");
884 				exit(EXIT_FAILURE);
885 			}
886 			file_off = img_sp->dst;
887 			break;
888 		case PARTITION:
889 			/*
890 			 * keep custom partition until next executable image
891 			 * use a global var for default behaviour
892 			 */
893 			custom_partition = img_sp->entry;
894 			break;
895 		default:
896 			fprintf(stderr, "unrecognized option in input stack (%d)\n", img_sp->option);
897 			exit(EXIT_FAILURE);
898 		}
899 		img_sp++; /* advance index */
900 	}
901 
902 	/* Append container (if specified) */
903 	img_sp = image_stack;
904 	do {
905 		if (img_sp->option == APPEND) {
906 			copy_file(ofd, img_sp->filename, 0, 0);
907 			file_padding += FIRST_CONTAINER_HEADER_LENGTH;
908 		}
909 		img_sp++;
910 	} while (img_sp->option != NO_IMG);
911 
912 	/* Add padding or skip appended container */
913 	ret = lseek(ofd, file_padding, SEEK_SET);
914 	if (ret < 0) {
915 		fprintf(stderr, "%s: lseek error %s\n",
916 			__func__, strerror(errno));
917 		exit(EXIT_FAILURE);
918 	}
919 
920 	if (container >= 0) {
921 		/* Note: Image offset are not contained in the image */
922 		tmp = flatten_container_header(&imx_header, container + 1,
923 					       &size, file_padding);
924 		/* Write image header */
925 		if (write(ofd, tmp, size) != size) {
926 			fprintf(stderr, "error writing image hdr\n");
927 			exit(EXIT_FAILURE);
928 		}
929 
930 		/* Clean-up memory used by the headers */
931 		free(tmp);
932 	}
933 
934 	/*
935 	 * step through the image stack again this time copying
936 	 * images to final bin, stop once we reach null terminator.
937 	 */
938 	img_sp = image_stack;
939 	while (img_sp->option != NO_IMG) {
940 		if (img_sp->option == M40 || img_sp->option == M41 ||
941 		    img_sp->option == AP || img_sp->option == DATA ||
942 		    img_sp->option == SCD || img_sp->option == SCFW ||
943 		    img_sp->option == SECO || img_sp->option == MSG_BLOCK) {
944 			copy_file_aligned(ofd, img_sp->filename, img_sp->src,
945 					  sector_size);
946 		}
947 		img_sp++;
948 	}
949 
950 	return 0;
951 }
952 
imx8image_copy_image(int outfd,struct image_tool_params * mparams)953 int imx8image_copy_image(int outfd, struct image_tool_params *mparams)
954 {
955 	image_t *img_sp = param_stack;
956 
957 	/*
958 	 * SECO FW is a container image, this is to calculate the
959 	 * 2nd container offset.
960 	 */
961 	fprintf(stdout, "parsing %s\n", mparams->imagename);
962 	parse_cfg_file(img_sp, mparams->imagename);
963 
964 	if (sector_size == 0) {
965 		fprintf(stderr, "Wrong sector size\n");
966 		exit(EXIT_FAILURE);
967 	}
968 
969 	fprintf(stdout, "CONTAINER Sector size:\t%08x\n", sector_size);
970 	fprintf(stdout, "CONTAINER FUSE VERSION:\t0x%02x\n", fuse_version);
971 	fprintf(stdout, "CONTAINER SW VERSION:\t0x%04x\n", sw_version);
972 
973 	build_container(soc, sector_size, emmc_fastboot,
974 			img_sp, false, fuse_version, sw_version, outfd);
975 
976 	return 0;
977 }
978 
979 /*
980  * imx8image parameters
981  */
982 U_BOOT_IMAGE_TYPE(
983 	imx8image,
984 	"NXP i.MX8 Boot Image support",
985 	0,
986 	NULL,
987 	imx8image_check_params,
988 	NULL,
989 	imx8image_print_header,
990 	imx8image_set_header,
991 	NULL,
992 	imx8image_check_image_types,
993 	NULL,
994 	NULL
995 );
996