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 */ 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 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 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 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 * 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 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 */ 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 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 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 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 /* 424 * The payload should be aligned on some reasonable 425 * boundary 426 */ 427 return ALIGN_SUP(headersz, 4096); 428 } 429 430 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params, 431 int payloadsz) 432 { 433 struct image_cfg_element *e, *binarye; 434 struct main_hdr_v1 *main_hdr; 435 size_t headersz; 436 void *image, *cur; 437 int hasext = 0; 438 int ret; 439 440 /* 441 * Calculate the size of the header and the size of the 442 * payload 443 */ 444 headersz = image_headersz_v1(params, &hasext); 445 if (headersz == 0) 446 return NULL; 447 448 image = malloc(headersz); 449 if (!image) { 450 fprintf(stderr, "Cannot allocate memory for image\n"); 451 return NULL; 452 } 453 454 memset(image, 0, headersz); 455 456 cur = main_hdr = image; 457 cur += sizeof(struct main_hdr_v1); 458 459 /* Fill the main header */ 460 main_hdr->blocksize = payloadsz - headersz + sizeof(uint32_t); 461 main_hdr->headersz_lsb = headersz & 0xFFFF; 462 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16; 463 main_hdr->destaddr = params->addr; 464 main_hdr->execaddr = params->ep; 465 main_hdr->srcaddr = headersz; 466 main_hdr->ext = hasext; 467 main_hdr->version = 1; 468 e = image_find_option(IMAGE_CFG_BOOT_FROM); 469 if (e) 470 main_hdr->blockid = e->bootfrom; 471 e = image_find_option(IMAGE_CFG_NAND_BLKSZ); 472 if (e) 473 main_hdr->nandblocksize = e->nandblksz / (64 * 1024); 474 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION); 475 if (e) 476 main_hdr->nandbadblklocation = e->nandbadblklocation; 477 478 binarye = image_find_option(IMAGE_CFG_BINARY); 479 if (binarye) { 480 struct opt_hdr_v1 *hdr = cur; 481 unsigned int *args; 482 size_t binhdrsz; 483 struct stat s; 484 int argi; 485 FILE *bin; 486 487 hdr->headertype = OPT_HDR_V1_BINARY_TYPE; 488 489 bin = fopen(binarye->binary.file, "r"); 490 if (!bin) { 491 fprintf(stderr, "Cannot open binary file %s\n", 492 binarye->binary.file); 493 return NULL; 494 } 495 496 fstat(fileno(bin), &s); 497 498 binhdrsz = sizeof(struct opt_hdr_v1) + 499 (binarye->binary.nargs + 1) * sizeof(unsigned int) + 500 s.st_size; 501 hdr->headersz_lsb = binhdrsz & 0xFFFF; 502 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16; 503 504 cur += sizeof(struct opt_hdr_v1); 505 506 args = cur; 507 *args = binarye->binary.nargs; 508 args++; 509 for (argi = 0; argi < binarye->binary.nargs; argi++) 510 args[argi] = binarye->binary.args[argi]; 511 512 cur += (binarye->binary.nargs + 1) * sizeof(unsigned int); 513 514 ret = fread(cur, s.st_size, 1, bin); 515 if (ret != 1) { 516 fprintf(stderr, 517 "Could not read binary image %s\n", 518 binarye->binary.file); 519 return NULL; 520 } 521 522 fclose(bin); 523 524 cur += s.st_size; 525 526 /* 527 * For now, we don't support more than one binary 528 * header, and no other header types are 529 * supported. So, the binary header is necessarily the 530 * last one 531 */ 532 *((unsigned char *)cur) = 0; 533 534 cur += sizeof(uint32_t); 535 } 536 537 /* Calculate and set the header checksum */ 538 main_hdr->checksum = image_checksum8(main_hdr, headersz); 539 540 *imagesz = headersz; 541 return image; 542 } 543 544 static int image_create_config_parse_oneline(char *line, 545 struct image_cfg_element *el) 546 { 547 char *keyword, *saveptr; 548 char deliminiters[] = " \t"; 549 550 keyword = strtok_r(line, deliminiters, &saveptr); 551 if (!strcmp(keyword, "VERSION")) { 552 char *value = strtok_r(NULL, deliminiters, &saveptr); 553 el->type = IMAGE_CFG_VERSION; 554 el->version = atoi(value); 555 } else if (!strcmp(keyword, "BOOT_FROM")) { 556 char *value = strtok_r(NULL, deliminiters, &saveptr); 557 int ret = image_boot_mode_id(value); 558 if (ret < 0) { 559 fprintf(stderr, 560 "Invalid boot media '%s'\n", value); 561 return -1; 562 } 563 el->type = IMAGE_CFG_BOOT_FROM; 564 el->bootfrom = ret; 565 } else if (!strcmp(keyword, "NAND_BLKSZ")) { 566 char *value = strtok_r(NULL, deliminiters, &saveptr); 567 el->type = IMAGE_CFG_NAND_BLKSZ; 568 el->nandblksz = strtoul(value, NULL, 16); 569 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) { 570 char *value = strtok_r(NULL, deliminiters, &saveptr); 571 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION; 572 el->nandbadblklocation = 573 strtoul(value, NULL, 16); 574 } else if (!strcmp(keyword, "NAND_ECC_MODE")) { 575 char *value = strtok_r(NULL, deliminiters, &saveptr); 576 int ret = image_nand_ecc_mode_id(value); 577 if (ret < 0) { 578 fprintf(stderr, 579 "Invalid NAND ECC mode '%s'\n", value); 580 return -1; 581 } 582 el->type = IMAGE_CFG_NAND_ECC_MODE; 583 el->nandeccmode = ret; 584 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) { 585 char *value = strtok_r(NULL, deliminiters, &saveptr); 586 el->type = IMAGE_CFG_NAND_PAGESZ; 587 el->nandpagesz = strtoul(value, NULL, 16); 588 } else if (!strcmp(keyword, "BINARY")) { 589 char *value = strtok_r(NULL, deliminiters, &saveptr); 590 int argi = 0; 591 592 el->type = IMAGE_CFG_BINARY; 593 el->binary.file = strdup(value); 594 while (1) { 595 value = strtok_r(NULL, deliminiters, &saveptr); 596 if (!value) 597 break; 598 el->binary.args[argi] = strtoul(value, NULL, 16); 599 argi++; 600 if (argi >= BINARY_MAX_ARGS) { 601 fprintf(stderr, 602 "Too many argument for binary\n"); 603 return -1; 604 } 605 } 606 el->binary.nargs = argi; 607 } else if (!strcmp(keyword, "DATA")) { 608 char *value1 = strtok_r(NULL, deliminiters, &saveptr); 609 char *value2 = strtok_r(NULL, deliminiters, &saveptr); 610 611 if (!value1 || !value2) { 612 fprintf(stderr, 613 "Invalid number of arguments for DATA\n"); 614 return -1; 615 } 616 617 el->type = IMAGE_CFG_DATA; 618 el->regdata.raddr = strtoul(value1, NULL, 16); 619 el->regdata.rdata = strtoul(value2, NULL, 16); 620 } else { 621 fprintf(stderr, "Ignoring unknown line '%s'\n", line); 622 } 623 624 return 0; 625 } 626 627 /* 628 * Parse the configuration file 'fcfg' into the array of configuration 629 * elements 'image_cfg', and return the number of configuration 630 * elements in 'cfgn'. 631 */ 632 static int image_create_config_parse(FILE *fcfg) 633 { 634 int ret; 635 int cfgi = 0; 636 637 /* Parse the configuration file */ 638 while (!feof(fcfg)) { 639 char *line; 640 char buf[256]; 641 642 /* Read the current line */ 643 memset(buf, 0, sizeof(buf)); 644 line = fgets(buf, sizeof(buf), fcfg); 645 if (!line) 646 break; 647 648 /* Ignore useless lines */ 649 if (line[0] == '\n' || line[0] == '#') 650 continue; 651 652 /* Strip final newline */ 653 if (line[strlen(line) - 1] == '\n') 654 line[strlen(line) - 1] = 0; 655 656 /* Parse the current line */ 657 ret = image_create_config_parse_oneline(line, 658 &image_cfg[cfgi]); 659 if (ret) 660 return ret; 661 662 cfgi++; 663 664 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) { 665 fprintf(stderr, 666 "Too many configuration elements in .cfg file\n"); 667 return -1; 668 } 669 } 670 671 cfgn = cfgi; 672 return 0; 673 } 674 675 static int image_get_version(void) 676 { 677 struct image_cfg_element *e; 678 679 e = image_find_option(IMAGE_CFG_VERSION); 680 if (!e) 681 return -1; 682 683 return e->version; 684 } 685 686 static int image_version_file(const char *input) 687 { 688 FILE *fcfg; 689 int version; 690 int ret; 691 692 fcfg = fopen(input, "r"); 693 if (!fcfg) { 694 fprintf(stderr, "Could not open input file %s\n", input); 695 return -1; 696 } 697 698 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 699 sizeof(struct image_cfg_element)); 700 if (!image_cfg) { 701 fprintf(stderr, "Cannot allocate memory\n"); 702 fclose(fcfg); 703 return -1; 704 } 705 706 memset(image_cfg, 0, 707 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 708 rewind(fcfg); 709 710 ret = image_create_config_parse(fcfg); 711 fclose(fcfg); 712 if (ret) { 713 free(image_cfg); 714 return -1; 715 } 716 717 version = image_get_version(); 718 /* Fallback to version 0 is no version is provided in the cfg file */ 719 if (version == -1) 720 version = 0; 721 722 free(image_cfg); 723 724 return version; 725 } 726 727 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd, 728 struct image_tool_params *params) 729 { 730 FILE *fcfg; 731 void *image = NULL; 732 int version; 733 size_t headersz = 0; 734 uint32_t checksum; 735 int ret; 736 int size; 737 738 fcfg = fopen(params->imagename, "r"); 739 if (!fcfg) { 740 fprintf(stderr, "Could not open input file %s\n", 741 params->imagename); 742 exit(EXIT_FAILURE); 743 } 744 745 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 746 sizeof(struct image_cfg_element)); 747 if (!image_cfg) { 748 fprintf(stderr, "Cannot allocate memory\n"); 749 fclose(fcfg); 750 exit(EXIT_FAILURE); 751 } 752 753 memset(image_cfg, 0, 754 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 755 rewind(fcfg); 756 757 ret = image_create_config_parse(fcfg); 758 fclose(fcfg); 759 if (ret) { 760 free(image_cfg); 761 exit(EXIT_FAILURE); 762 } 763 764 version = image_get_version(); 765 switch (version) { 766 /* 767 * Fallback to version 0 if no version is provided in the 768 * cfg file 769 */ 770 case -1: 771 case 0: 772 image = image_create_v0(&headersz, params, sbuf->st_size); 773 break; 774 775 case 1: 776 image = image_create_v1(&headersz, params, sbuf->st_size); 777 break; 778 779 default: 780 fprintf(stderr, "Unsupported version %d\n", version); 781 free(image_cfg); 782 exit(EXIT_FAILURE); 783 } 784 785 if (!image) { 786 fprintf(stderr, "Could not create image\n"); 787 free(image_cfg); 788 exit(EXIT_FAILURE); 789 } 790 791 free(image_cfg); 792 793 /* Build and add image checksum header */ 794 checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size); 795 size = write(ifd, &checksum, sizeof(uint32_t)); 796 if (size != sizeof(uint32_t)) { 797 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n", 798 params->cmdname, size, params->imagefile); 799 exit(EXIT_FAILURE); 800 } 801 802 sbuf->st_size += sizeof(uint32_t); 803 804 /* Finally copy the header into the image area */ 805 memcpy(ptr, image, headersz); 806 807 free(image); 808 } 809 810 static void kwbimage_print_header(const void *ptr) 811 { 812 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr; 813 814 printf("Image Type: MVEBU Boot from %s Image\n", 815 image_boot_mode_name(mhdr->blockid)); 816 printf("Image version:%d\n", image_version((void *)ptr)); 817 printf("Data Size: "); 818 genimg_print_size(mhdr->blocksize - sizeof(uint32_t)); 819 printf("Load Address: %08x\n", mhdr->destaddr); 820 printf("Entry Point: %08x\n", mhdr->execaddr); 821 } 822 823 static int kwbimage_check_image_types(uint8_t type) 824 { 825 if (type == IH_TYPE_KWBIMAGE) 826 return EXIT_SUCCESS; 827 else 828 return EXIT_FAILURE; 829 } 830 831 static int kwbimage_verify_header(unsigned char *ptr, int image_size, 832 struct image_tool_params *params) 833 { 834 struct main_hdr_v0 *main_hdr; 835 struct ext_hdr_v0 *ext_hdr; 836 uint8_t checksum; 837 838 main_hdr = (void *)ptr; 839 checksum = image_checksum8(ptr, 840 sizeof(struct main_hdr_v0) 841 - sizeof(uint8_t)); 842 if (checksum != main_hdr->checksum) 843 return -FDT_ERR_BADSTRUCTURE; 844 845 /* Only version 0 extended header has checksum */ 846 if (image_version((void *)ptr) == 0) { 847 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0); 848 checksum = image_checksum8(ext_hdr, 849 sizeof(struct ext_hdr_v0) 850 - sizeof(uint8_t)); 851 if (checksum != ext_hdr->checksum) 852 return -FDT_ERR_BADSTRUCTURE; 853 } 854 855 return 0; 856 } 857 858 static int kwbimage_generate(struct image_tool_params *params, 859 struct image_type_params *tparams) 860 { 861 int alloc_len; 862 void *hdr; 863 int version = 0; 864 865 version = image_version_file(params->imagename); 866 if (version == 0) { 867 alloc_len = sizeof(struct main_hdr_v0) + 868 sizeof(struct ext_hdr_v0); 869 } else { 870 alloc_len = image_headersz_v1(params, NULL); 871 #if defined(CONFIG_SYS_SPI_U_BOOT_OFFS) 872 if (alloc_len > CONFIG_SYS_SPI_U_BOOT_OFFS) { 873 fprintf(stderr, "Error: Image header (incl. SPL image) too big!\n"); 874 fprintf(stderr, "header=0x%x CONFIG_SYS_SPI_U_BOOT_OFFS=0x%x!\n", 875 alloc_len, CONFIG_SYS_SPI_U_BOOT_OFFS); 876 fprintf(stderr, "Increase CONFIG_SYS_SPI_U_BOOT_OFFS!\n"); 877 } else { 878 alloc_len = CONFIG_SYS_SPI_U_BOOT_OFFS; 879 } 880 #endif 881 } 882 883 hdr = malloc(alloc_len); 884 if (!hdr) { 885 fprintf(stderr, "%s: malloc return failure: %s\n", 886 params->cmdname, strerror(errno)); 887 exit(EXIT_FAILURE); 888 } 889 890 memset(hdr, 0, alloc_len); 891 tparams->header_size = alloc_len; 892 tparams->hdr = hdr; 893 894 return 0; 895 } 896 897 /* 898 * Report Error if xflag is set in addition to default 899 */ 900 static int kwbimage_check_params(struct image_tool_params *params) 901 { 902 if (!strlen(params->imagename)) { 903 fprintf(stderr, "Error:%s - Configuration file not specified, " 904 "it is needed for kwbimage generation\n", 905 params->cmdname); 906 return CFG_INVALID; 907 } 908 909 return (params->dflag && (params->fflag || params->lflag)) || 910 (params->fflag && (params->dflag || params->lflag)) || 911 (params->lflag && (params->dflag || params->fflag)) || 912 (params->xflag) || !(strlen(params->imagename)); 913 } 914 915 /* 916 * kwbimage type parameters definition 917 */ 918 U_BOOT_IMAGE_TYPE( 919 kwbimage, 920 "Marvell MVEBU Boot Image support", 921 0, 922 NULL, 923 kwbimage_check_params, 924 kwbimage_verify_header, 925 kwbimage_print_header, 926 kwbimage_set_header, 927 NULL, 928 kwbimage_check_image_types, 929 NULL, 930 kwbimage_generate 931 ); 932