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