1 /*
2 * Image manipulator for Marvell SoCs
3 * supports Kirkwood, Dove, Armada 370, and Armada XP
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 and secure
11 * headers in v1 images
12 */
13
14 #include "imagetool.h"
15 #include <limits.h>
16 #include <image.h>
17 #include <stdint.h>
18 #include "kwbimage.h"
19
20 #define ALIGN_SUP(x, a) (((x) + (a - 1)) & ~(a - 1))
21
22 /* Structure of the main header, version 0 (Kirkwood, Dove) */
23 struct main_hdr_v0 {
24 uint8_t blockid; /*0 */
25 uint8_t nandeccmode; /*1 */
26 uint16_t nandpagesize; /*2-3 */
27 uint32_t blocksize; /*4-7 */
28 uint32_t rsvd1; /*8-11 */
29 uint32_t srcaddr; /*12-15 */
30 uint32_t destaddr; /*16-19 */
31 uint32_t execaddr; /*20-23 */
32 uint8_t satapiomode; /*24 */
33 uint8_t rsvd3; /*25 */
34 uint16_t ddrinitdelay; /*26-27 */
35 uint16_t rsvd2; /*28-29 */
36 uint8_t ext; /*30 */
37 uint8_t checksum; /*31 */
38 };
39
40 struct ext_hdr_v0_reg {
41 uint32_t raddr;
42 uint32_t rdata;
43 };
44
45 #define EXT_HDR_V0_REG_COUNT ((0x1dc - 0x20) / sizeof(struct ext_hdr_v0_reg))
46
47 struct ext_hdr_v0 {
48 uint32_t offset;
49 uint8_t reserved[0x20 - sizeof(uint32_t)];
50 struct ext_hdr_v0_reg rcfg[EXT_HDR_V0_REG_COUNT];
51 uint8_t reserved2[7];
52 uint8_t checksum;
53 };
54
55 /* Structure of the main header, version 1 (Armada 370, Armada XP) */
56 struct main_hdr_v1 {
57 uint8_t blockid; /* 0 */
58 uint8_t reserved1; /* 1 */
59 uint16_t reserved2; /* 2-3 */
60 uint32_t blocksize; /* 4-7 */
61 uint8_t version; /* 8 */
62 uint8_t headersz_msb; /* 9 */
63 uint16_t headersz_lsb; /* A-B */
64 uint32_t srcaddr; /* C-F */
65 uint32_t destaddr; /* 10-13 */
66 uint32_t execaddr; /* 14-17 */
67 uint8_t reserved3; /* 18 */
68 uint8_t nandblocksize; /* 19 */
69 uint8_t nandbadblklocation; /* 1A */
70 uint8_t reserved4; /* 1B */
71 uint16_t reserved5; /* 1C-1D */
72 uint8_t ext; /* 1E */
73 uint8_t checksum; /* 1F */
74 };
75
76 /*
77 * Header for the optional headers, version 1 (Armada 370, Armada XP)
78 */
79 struct opt_hdr_v1 {
80 uint8_t headertype;
81 uint8_t headersz_msb;
82 uint16_t headersz_lsb;
83 char data[0];
84 };
85
86 /*
87 * Various values for the opt_hdr_v1->headertype field, describing the
88 * different types of optional headers. The "secure" header contains
89 * informations related to secure boot (encryption keys, etc.). The
90 * "binary" header contains ARM binary code to be executed prior to
91 * executing the main payload (usually the bootloader). This is
92 * typically used to execute DDR3 training code. The "register" header
93 * allows to describe a set of (address, value) tuples that are
94 * generally used to configure the DRAM controller.
95 */
96 #define OPT_HDR_V1_SECURE_TYPE 0x1
97 #define OPT_HDR_V1_BINARY_TYPE 0x2
98 #define OPT_HDR_V1_REGISTER_TYPE 0x3
99
100 #define KWBHEADER_V1_SIZE(hdr) \
101 (((hdr)->headersz_msb << 16) | (hdr)->headersz_lsb)
102
103 static struct image_cfg_element *image_cfg;
104 static int cfgn;
105
106 struct boot_mode {
107 unsigned int id;
108 const char *name;
109 };
110
111 struct boot_mode boot_modes[] = {
112 { 0x4D, "i2c" },
113 { 0x5A, "spi" },
114 { 0x8B, "nand" },
115 { 0x78, "sata" },
116 { 0x9C, "pex" },
117 { 0x69, "uart" },
118 {},
119 };
120
121 struct nand_ecc_mode {
122 unsigned int id;
123 const char *name;
124 };
125
126 struct nand_ecc_mode nand_ecc_modes[] = {
127 { 0x00, "default" },
128 { 0x01, "hamming" },
129 { 0x02, "rs" },
130 { 0x03, "disabled" },
131 {},
132 };
133
134 /* Used to identify an undefined execution or destination address */
135 #define ADDR_INVALID ((uint32_t)-1)
136
137 #define BINARY_MAX_ARGS 8
138
139 /* In-memory representation of a line of the configuration file */
140 struct image_cfg_element {
141 enum {
142 IMAGE_CFG_VERSION = 0x1,
143 IMAGE_CFG_BOOT_FROM,
144 IMAGE_CFG_DEST_ADDR,
145 IMAGE_CFG_EXEC_ADDR,
146 IMAGE_CFG_NAND_BLKSZ,
147 IMAGE_CFG_NAND_BADBLK_LOCATION,
148 IMAGE_CFG_NAND_ECC_MODE,
149 IMAGE_CFG_NAND_PAGESZ,
150 IMAGE_CFG_BINARY,
151 IMAGE_CFG_PAYLOAD,
152 IMAGE_CFG_DATA,
153 } type;
154 union {
155 unsigned int version;
156 unsigned int bootfrom;
157 struct {
158 const char *file;
159 unsigned int args[BINARY_MAX_ARGS];
160 unsigned int nargs;
161 } binary;
162 const char *payload;
163 unsigned int dstaddr;
164 unsigned int execaddr;
165 unsigned int nandblksz;
166 unsigned int nandbadblklocation;
167 unsigned int nandeccmode;
168 unsigned int nandpagesz;
169 struct ext_hdr_v0_reg regdata;
170 };
171 };
172
173 #define IMAGE_CFG_ELEMENT_MAX 256
174
175 /*
176 * Byte 8 of the image header contains the version number. In the v0
177 * header, byte 8 was reserved, and always set to 0. In the v1 header,
178 * byte 8 has been changed to a proper field, set to 1.
179 */
image_version(void * header)180 static unsigned int image_version(void *header)
181 {
182 unsigned char *ptr = header;
183 return ptr[8];
184 }
185
186 /*
187 * Utility functions to manipulate boot mode and ecc modes (convert
188 * them back and forth between description strings and the
189 * corresponding numerical identifiers).
190 */
191
image_boot_mode_name(unsigned int id)192 static const char *image_boot_mode_name(unsigned int id)
193 {
194 int i;
195 for (i = 0; boot_modes[i].name; i++)
196 if (boot_modes[i].id == id)
197 return boot_modes[i].name;
198 return NULL;
199 }
200
image_boot_mode_id(const char * boot_mode_name)201 int image_boot_mode_id(const char *boot_mode_name)
202 {
203 int i;
204 for (i = 0; boot_modes[i].name; i++)
205 if (!strcmp(boot_modes[i].name, boot_mode_name))
206 return boot_modes[i].id;
207
208 return -1;
209 }
210
image_nand_ecc_mode_id(const char * nand_ecc_mode_name)211 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
212 {
213 int i;
214 for (i = 0; nand_ecc_modes[i].name; i++)
215 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
216 return nand_ecc_modes[i].id;
217 return -1;
218 }
219
220 static struct image_cfg_element *
image_find_option(unsigned int optiontype)221 image_find_option(unsigned int optiontype)
222 {
223 int i;
224
225 for (i = 0; i < cfgn; i++) {
226 if (image_cfg[i].type == optiontype)
227 return &image_cfg[i];
228 }
229
230 return NULL;
231 }
232
233 static unsigned int
image_count_options(unsigned int optiontype)234 image_count_options(unsigned int optiontype)
235 {
236 int i;
237 unsigned int count = 0;
238
239 for (i = 0; i < cfgn; i++)
240 if (image_cfg[i].type == optiontype)
241 count++;
242
243 return count;
244 }
245
246 /*
247 * Compute a 8-bit checksum of a memory area. This algorithm follows
248 * the requirements of the Marvell SoC BootROM specifications.
249 */
image_checksum8(void * start,uint32_t len)250 static uint8_t image_checksum8(void *start, uint32_t len)
251 {
252 uint8_t csum = 0;
253 uint8_t *p = start;
254
255 /* check len and return zero checksum if invalid */
256 if (!len)
257 return 0;
258
259 do {
260 csum += *p;
261 p++;
262 } while (--len);
263
264 return csum;
265 }
266
image_checksum32(void * start,uint32_t len)267 static uint32_t image_checksum32(void *start, uint32_t len)
268 {
269 uint32_t csum = 0;
270 uint32_t *p = start;
271
272 /* check len and return zero checksum if invalid */
273 if (!len)
274 return 0;
275
276 if (len % sizeof(uint32_t)) {
277 fprintf(stderr, "Length %d is not in multiple of %zu\n",
278 len, sizeof(uint32_t));
279 return 0;
280 }
281
282 do {
283 csum += *p;
284 p++;
285 len -= sizeof(uint32_t);
286 } while (len > 0);
287
288 return csum;
289 }
290
image_create_v0(size_t * imagesz,struct image_tool_params * params,int payloadsz)291 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
292 int payloadsz)
293 {
294 struct image_cfg_element *e;
295 size_t headersz;
296 struct main_hdr_v0 *main_hdr;
297 struct ext_hdr_v0 *ext_hdr;
298 void *image;
299 int has_ext = 0;
300
301 /*
302 * Calculate the size of the header and the size of the
303 * payload
304 */
305 headersz = sizeof(struct main_hdr_v0);
306
307 if (image_count_options(IMAGE_CFG_DATA) > 0) {
308 has_ext = 1;
309 headersz += sizeof(struct ext_hdr_v0);
310 }
311
312 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
313 fprintf(stderr, "More than one payload, not possible\n");
314 return NULL;
315 }
316
317 image = malloc(headersz);
318 if (!image) {
319 fprintf(stderr, "Cannot allocate memory for image\n");
320 return NULL;
321 }
322
323 memset(image, 0, headersz);
324
325 main_hdr = image;
326
327 /* Fill in the main header */
328 main_hdr->blocksize = payloadsz + sizeof(uint32_t) - headersz;
329 main_hdr->srcaddr = headersz;
330 main_hdr->ext = has_ext;
331 main_hdr->destaddr = params->addr;
332 main_hdr->execaddr = params->ep;
333
334 e = image_find_option(IMAGE_CFG_BOOT_FROM);
335 if (e)
336 main_hdr->blockid = e->bootfrom;
337 e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
338 if (e)
339 main_hdr->nandeccmode = e->nandeccmode;
340 e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
341 if (e)
342 main_hdr->nandpagesize = e->nandpagesz;
343 main_hdr->checksum = image_checksum8(image,
344 sizeof(struct main_hdr_v0));
345
346 /* Generate the ext header */
347 if (has_ext) {
348 int cfgi, datai;
349
350 ext_hdr = image + sizeof(struct main_hdr_v0);
351 ext_hdr->offset = 0x40;
352
353 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
354 e = &image_cfg[cfgi];
355 if (e->type != IMAGE_CFG_DATA)
356 continue;
357
358 ext_hdr->rcfg[datai].raddr = e->regdata.raddr;
359 ext_hdr->rcfg[datai].rdata = e->regdata.rdata;
360 datai++;
361 }
362
363 ext_hdr->checksum = image_checksum8(ext_hdr,
364 sizeof(struct ext_hdr_v0));
365 }
366
367 *imagesz = headersz;
368 return image;
369 }
370
image_headersz_v1(struct image_tool_params * params,int * hasext)371 static size_t image_headersz_v1(struct image_tool_params *params,
372 int *hasext)
373 {
374 struct image_cfg_element *binarye;
375 size_t headersz;
376 int ret;
377
378 /*
379 * Calculate the size of the header and the size of the
380 * payload
381 */
382 headersz = sizeof(struct main_hdr_v1);
383
384 if (image_count_options(IMAGE_CFG_BINARY) > 1) {
385 fprintf(stderr, "More than one binary blob, not supported\n");
386 return 0;
387 }
388
389 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
390 fprintf(stderr, "More than one payload, not possible\n");
391 return 0;
392 }
393
394 binarye = image_find_option(IMAGE_CFG_BINARY);
395 if (binarye) {
396 struct stat s;
397
398 ret = stat(binarye->binary.file, &s);
399 if (ret < 0) {
400 char cwd[PATH_MAX];
401 char *dir = cwd;
402
403 memset(cwd, 0, sizeof(cwd));
404 if (!getcwd(cwd, sizeof(cwd))) {
405 dir = "current working directory";
406 perror("getcwd() failed");
407 }
408
409 fprintf(stderr,
410 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
411 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
412 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
413 binarye->binary.file, dir);
414 return 0;
415 }
416
417 headersz += s.st_size +
418 binarye->binary.nargs * sizeof(unsigned int);
419 if (hasext)
420 *hasext = 1;
421 }
422
423 #if defined(CONFIG_SYS_SPI_U_BOOT_OFFS)
424 if (headersz > CONFIG_SYS_SPI_U_BOOT_OFFS) {
425 fprintf(stderr, "Error: Image header (incl. SPL image) too big!\n");
426 fprintf(stderr, "header=0x%x CONFIG_SYS_SPI_U_BOOT_OFFS=0x%x!\n",
427 (int)headersz, CONFIG_SYS_SPI_U_BOOT_OFFS);
428 fprintf(stderr, "Increase CONFIG_SYS_SPI_U_BOOT_OFFS!\n");
429 return 0;
430 } else {
431 headersz = CONFIG_SYS_SPI_U_BOOT_OFFS;
432 }
433 #endif
434
435 /*
436 * The payload should be aligned on some reasonable
437 * boundary
438 */
439 return ALIGN_SUP(headersz, 4096);
440 }
441
image_create_v1(size_t * imagesz,struct image_tool_params * params,int payloadsz)442 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
443 int payloadsz)
444 {
445 struct image_cfg_element *e, *binarye;
446 struct main_hdr_v1 *main_hdr;
447 size_t headersz;
448 void *image, *cur;
449 int hasext = 0;
450 int ret;
451
452 /*
453 * Calculate the size of the header and the size of the
454 * payload
455 */
456 headersz = image_headersz_v1(params, &hasext);
457 if (headersz == 0)
458 return NULL;
459
460 image = malloc(headersz);
461 if (!image) {
462 fprintf(stderr, "Cannot allocate memory for image\n");
463 return NULL;
464 }
465
466 memset(image, 0, headersz);
467
468 cur = main_hdr = image;
469 cur += sizeof(struct main_hdr_v1);
470
471 /* Fill the main header */
472 main_hdr->blocksize = payloadsz - headersz + sizeof(uint32_t);
473 main_hdr->headersz_lsb = headersz & 0xFFFF;
474 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
475 main_hdr->destaddr = params->addr;
476 main_hdr->execaddr = params->ep;
477 main_hdr->srcaddr = headersz;
478 main_hdr->ext = hasext;
479 main_hdr->version = 1;
480 e = image_find_option(IMAGE_CFG_BOOT_FROM);
481 if (e)
482 main_hdr->blockid = e->bootfrom;
483 e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
484 if (e)
485 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
486 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
487 if (e)
488 main_hdr->nandbadblklocation = e->nandbadblklocation;
489
490 binarye = image_find_option(IMAGE_CFG_BINARY);
491 if (binarye) {
492 struct opt_hdr_v1 *hdr = cur;
493 unsigned int *args;
494 size_t binhdrsz;
495 struct stat s;
496 int argi;
497 FILE *bin;
498
499 hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
500
501 bin = fopen(binarye->binary.file, "r");
502 if (!bin) {
503 fprintf(stderr, "Cannot open binary file %s\n",
504 binarye->binary.file);
505 return NULL;
506 }
507
508 fstat(fileno(bin), &s);
509
510 binhdrsz = sizeof(struct opt_hdr_v1) +
511 (binarye->binary.nargs + 1) * sizeof(unsigned int) +
512 s.st_size;
513 binhdrsz = ALIGN_SUP(binhdrsz, 32);
514 hdr->headersz_lsb = binhdrsz & 0xFFFF;
515 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
516
517 cur += sizeof(struct opt_hdr_v1);
518
519 args = cur;
520 *args = binarye->binary.nargs;
521 args++;
522 for (argi = 0; argi < binarye->binary.nargs; argi++)
523 args[argi] = binarye->binary.args[argi];
524
525 cur += (binarye->binary.nargs + 1) * sizeof(unsigned int);
526
527 ret = fread(cur, s.st_size, 1, bin);
528 if (ret != 1) {
529 fprintf(stderr,
530 "Could not read binary image %s\n",
531 binarye->binary.file);
532 return NULL;
533 }
534
535 fclose(bin);
536
537 cur += s.st_size;
538
539 /*
540 * For now, we don't support more than one binary
541 * header, and no other header types are
542 * supported. So, the binary header is necessarily the
543 * last one
544 */
545 *((unsigned char *)cur) = 0;
546
547 cur += sizeof(uint32_t);
548 }
549
550 /* Calculate and set the header checksum */
551 main_hdr->checksum = image_checksum8(main_hdr, headersz);
552
553 *imagesz = headersz;
554 return image;
555 }
556
image_create_config_parse_oneline(char * line,struct image_cfg_element * el)557 static int image_create_config_parse_oneline(char *line,
558 struct image_cfg_element *el)
559 {
560 char *keyword, *saveptr;
561 char deliminiters[] = " \t";
562
563 keyword = strtok_r(line, deliminiters, &saveptr);
564 if (!strcmp(keyword, "VERSION")) {
565 char *value = strtok_r(NULL, deliminiters, &saveptr);
566 el->type = IMAGE_CFG_VERSION;
567 el->version = atoi(value);
568 } else if (!strcmp(keyword, "BOOT_FROM")) {
569 char *value = strtok_r(NULL, deliminiters, &saveptr);
570 int ret = image_boot_mode_id(value);
571 if (ret < 0) {
572 fprintf(stderr,
573 "Invalid boot media '%s'\n", value);
574 return -1;
575 }
576 el->type = IMAGE_CFG_BOOT_FROM;
577 el->bootfrom = ret;
578 } else if (!strcmp(keyword, "NAND_BLKSZ")) {
579 char *value = strtok_r(NULL, deliminiters, &saveptr);
580 el->type = IMAGE_CFG_NAND_BLKSZ;
581 el->nandblksz = strtoul(value, NULL, 16);
582 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) {
583 char *value = strtok_r(NULL, deliminiters, &saveptr);
584 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION;
585 el->nandbadblklocation =
586 strtoul(value, NULL, 16);
587 } else if (!strcmp(keyword, "NAND_ECC_MODE")) {
588 char *value = strtok_r(NULL, deliminiters, &saveptr);
589 int ret = image_nand_ecc_mode_id(value);
590 if (ret < 0) {
591 fprintf(stderr,
592 "Invalid NAND ECC mode '%s'\n", value);
593 return -1;
594 }
595 el->type = IMAGE_CFG_NAND_ECC_MODE;
596 el->nandeccmode = ret;
597 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) {
598 char *value = strtok_r(NULL, deliminiters, &saveptr);
599 el->type = IMAGE_CFG_NAND_PAGESZ;
600 el->nandpagesz = strtoul(value, NULL, 16);
601 } else if (!strcmp(keyword, "BINARY")) {
602 char *value = strtok_r(NULL, deliminiters, &saveptr);
603 int argi = 0;
604
605 el->type = IMAGE_CFG_BINARY;
606 el->binary.file = strdup(value);
607 while (1) {
608 value = strtok_r(NULL, deliminiters, &saveptr);
609 if (!value)
610 break;
611 el->binary.args[argi] = strtoul(value, NULL, 16);
612 argi++;
613 if (argi >= BINARY_MAX_ARGS) {
614 fprintf(stderr,
615 "Too many argument for binary\n");
616 return -1;
617 }
618 }
619 el->binary.nargs = argi;
620 } else if (!strcmp(keyword, "DATA")) {
621 char *value1 = strtok_r(NULL, deliminiters, &saveptr);
622 char *value2 = strtok_r(NULL, deliminiters, &saveptr);
623
624 if (!value1 || !value2) {
625 fprintf(stderr,
626 "Invalid number of arguments for DATA\n");
627 return -1;
628 }
629
630 el->type = IMAGE_CFG_DATA;
631 el->regdata.raddr = strtoul(value1, NULL, 16);
632 el->regdata.rdata = strtoul(value2, NULL, 16);
633 } else {
634 fprintf(stderr, "Ignoring unknown line '%s'\n", line);
635 }
636
637 return 0;
638 }
639
640 /*
641 * Parse the configuration file 'fcfg' into the array of configuration
642 * elements 'image_cfg', and return the number of configuration
643 * elements in 'cfgn'.
644 */
image_create_config_parse(FILE * fcfg)645 static int image_create_config_parse(FILE *fcfg)
646 {
647 int ret;
648 int cfgi = 0;
649
650 /* Parse the configuration file */
651 while (!feof(fcfg)) {
652 char *line;
653 char buf[256];
654
655 /* Read the current line */
656 memset(buf, 0, sizeof(buf));
657 line = fgets(buf, sizeof(buf), fcfg);
658 if (!line)
659 break;
660
661 /* Ignore useless lines */
662 if (line[0] == '\n' || line[0] == '#')
663 continue;
664
665 /* Strip final newline */
666 if (line[strlen(line) - 1] == '\n')
667 line[strlen(line) - 1] = 0;
668
669 /* Parse the current line */
670 ret = image_create_config_parse_oneline(line,
671 &image_cfg[cfgi]);
672 if (ret)
673 return ret;
674
675 cfgi++;
676
677 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
678 fprintf(stderr,
679 "Too many configuration elements in .cfg file\n");
680 return -1;
681 }
682 }
683
684 cfgn = cfgi;
685 return 0;
686 }
687
image_get_version(void)688 static int image_get_version(void)
689 {
690 struct image_cfg_element *e;
691
692 e = image_find_option(IMAGE_CFG_VERSION);
693 if (!e)
694 return -1;
695
696 return e->version;
697 }
698
image_version_file(const char * input)699 static int image_version_file(const char *input)
700 {
701 FILE *fcfg;
702 int version;
703 int ret;
704
705 fcfg = fopen(input, "r");
706 if (!fcfg) {
707 fprintf(stderr, "Could not open input file %s\n", input);
708 return -1;
709 }
710
711 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
712 sizeof(struct image_cfg_element));
713 if (!image_cfg) {
714 fprintf(stderr, "Cannot allocate memory\n");
715 fclose(fcfg);
716 return -1;
717 }
718
719 memset(image_cfg, 0,
720 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
721 rewind(fcfg);
722
723 ret = image_create_config_parse(fcfg);
724 fclose(fcfg);
725 if (ret) {
726 free(image_cfg);
727 return -1;
728 }
729
730 version = image_get_version();
731 /* Fallback to version 0 is no version is provided in the cfg file */
732 if (version == -1)
733 version = 0;
734
735 free(image_cfg);
736
737 return version;
738 }
739
kwbimage_set_header(void * ptr,struct stat * sbuf,int ifd,struct image_tool_params * params)740 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
741 struct image_tool_params *params)
742 {
743 FILE *fcfg;
744 void *image = NULL;
745 int version;
746 size_t headersz = 0;
747 uint32_t checksum;
748 int ret;
749 int size;
750
751 fcfg = fopen(params->imagename, "r");
752 if (!fcfg) {
753 fprintf(stderr, "Could not open input file %s\n",
754 params->imagename);
755 exit(EXIT_FAILURE);
756 }
757
758 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
759 sizeof(struct image_cfg_element));
760 if (!image_cfg) {
761 fprintf(stderr, "Cannot allocate memory\n");
762 fclose(fcfg);
763 exit(EXIT_FAILURE);
764 }
765
766 memset(image_cfg, 0,
767 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
768 rewind(fcfg);
769
770 ret = image_create_config_parse(fcfg);
771 fclose(fcfg);
772 if (ret) {
773 free(image_cfg);
774 exit(EXIT_FAILURE);
775 }
776
777 version = image_get_version();
778 switch (version) {
779 /*
780 * Fallback to version 0 if no version is provided in the
781 * cfg file
782 */
783 case -1:
784 case 0:
785 image = image_create_v0(&headersz, params, sbuf->st_size);
786 break;
787
788 case 1:
789 image = image_create_v1(&headersz, params, sbuf->st_size);
790 break;
791
792 default:
793 fprintf(stderr, "Unsupported version %d\n", version);
794 free(image_cfg);
795 exit(EXIT_FAILURE);
796 }
797
798 if (!image) {
799 fprintf(stderr, "Could not create image\n");
800 free(image_cfg);
801 exit(EXIT_FAILURE);
802 }
803
804 free(image_cfg);
805
806 /* Build and add image checksum header */
807 checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size);
808 size = write(ifd, &checksum, sizeof(uint32_t));
809 if (size != sizeof(uint32_t)) {
810 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
811 params->cmdname, size, params->imagefile);
812 exit(EXIT_FAILURE);
813 }
814
815 sbuf->st_size += sizeof(uint32_t);
816
817 /* Finally copy the header into the image area */
818 memcpy(ptr, image, headersz);
819
820 free(image);
821 }
822
kwbimage_print_header(const void * ptr)823 static void kwbimage_print_header(const void *ptr)
824 {
825 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
826
827 printf("Image Type: MVEBU Boot from %s Image\n",
828 image_boot_mode_name(mhdr->blockid));
829 printf("Image version:%d\n", image_version((void *)ptr));
830 printf("Data Size: ");
831 genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
832 printf("Load Address: %08x\n", mhdr->destaddr);
833 printf("Entry Point: %08x\n", mhdr->execaddr);
834 }
835
kwbimage_check_image_types(uint8_t type)836 static int kwbimage_check_image_types(uint8_t type)
837 {
838 if (type == IH_TYPE_KWBIMAGE)
839 return EXIT_SUCCESS;
840 else
841 return EXIT_FAILURE;
842 }
843
kwbimage_verify_header(unsigned char * ptr,int image_size,struct image_tool_params * params)844 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
845 struct image_tool_params *params)
846 {
847 struct main_hdr_v0 *main_hdr;
848 struct ext_hdr_v0 *ext_hdr;
849 uint8_t checksum;
850
851 main_hdr = (void *)ptr;
852 checksum = image_checksum8(ptr,
853 sizeof(struct main_hdr_v0)
854 - sizeof(uint8_t));
855 if (checksum != main_hdr->checksum)
856 return -FDT_ERR_BADSTRUCTURE;
857
858 /* Only version 0 extended header has checksum */
859 if (image_version((void *)ptr) == 0) {
860 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0);
861 checksum = image_checksum8(ext_hdr,
862 sizeof(struct ext_hdr_v0)
863 - sizeof(uint8_t));
864 if (checksum != ext_hdr->checksum)
865 return -FDT_ERR_BADSTRUCTURE;
866 }
867
868 return 0;
869 }
870
kwbimage_generate(struct image_tool_params * params,struct image_type_params * tparams)871 static int kwbimage_generate(struct image_tool_params *params,
872 struct image_type_params *tparams)
873 {
874 int alloc_len;
875 void *hdr;
876 int version = 0;
877
878 version = image_version_file(params->imagename);
879 if (version == 0) {
880 alloc_len = sizeof(struct main_hdr_v0) +
881 sizeof(struct ext_hdr_v0);
882 } else {
883 alloc_len = image_headersz_v1(params, NULL);
884 }
885
886 hdr = malloc(alloc_len);
887 if (!hdr) {
888 fprintf(stderr, "%s: malloc return failure: %s\n",
889 params->cmdname, strerror(errno));
890 exit(EXIT_FAILURE);
891 }
892
893 memset(hdr, 0, alloc_len);
894 tparams->header_size = alloc_len;
895 tparams->hdr = hdr;
896
897 return 0;
898 }
899
900 /*
901 * Report Error if xflag is set in addition to default
902 */
kwbimage_check_params(struct image_tool_params * params)903 static int kwbimage_check_params(struct image_tool_params *params)
904 {
905 if (!strlen(params->imagename)) {
906 fprintf(stderr, "Error:%s - Configuration file not specified, "
907 "it is needed for kwbimage generation\n",
908 params->cmdname);
909 return CFG_INVALID;
910 }
911
912 return (params->dflag && (params->fflag || params->lflag)) ||
913 (params->fflag && (params->dflag || params->lflag)) ||
914 (params->lflag && (params->dflag || params->fflag)) ||
915 (params->xflag) || !(strlen(params->imagename));
916 }
917
918 /*
919 * kwbimage type parameters definition
920 */
921 U_BOOT_IMAGE_TYPE(
922 kwbimage,
923 "Marvell MVEBU Boot Image support",
924 0,
925 NULL,
926 kwbimage_check_params,
927 kwbimage_verify_header,
928 kwbimage_print_header,
929 kwbimage_set_header,
930 NULL,
931 kwbimage_check_image_types,
932 NULL,
933 kwbimage_generate
934 );
935