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 el->type = IMAGE_CFG_BOOT_FROM; 558 el->bootfrom = image_boot_mode_id(value); 559 if (el->bootfrom < 0) { 560 fprintf(stderr, 561 "Invalid boot media '%s'\n", value); 562 return -1; 563 } 564 } else if (!strcmp(keyword, "NAND_BLKSZ")) { 565 char *value = strtok_r(NULL, deliminiters, &saveptr); 566 el->type = IMAGE_CFG_NAND_BLKSZ; 567 el->nandblksz = strtoul(value, NULL, 16); 568 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) { 569 char *value = strtok_r(NULL, deliminiters, &saveptr); 570 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION; 571 el->nandbadblklocation = 572 strtoul(value, NULL, 16); 573 } else if (!strcmp(keyword, "NAND_ECC_MODE")) { 574 char *value = strtok_r(NULL, deliminiters, &saveptr); 575 el->type = IMAGE_CFG_NAND_ECC_MODE; 576 el->nandeccmode = image_nand_ecc_mode_id(value); 577 if (el->nandeccmode < 0) { 578 fprintf(stderr, 579 "Invalid NAND ECC mode '%s'\n", value); 580 return -1; 581 } 582 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) { 583 char *value = strtok_r(NULL, deliminiters, &saveptr); 584 el->type = IMAGE_CFG_NAND_PAGESZ; 585 el->nandpagesz = strtoul(value, NULL, 16); 586 } else if (!strcmp(keyword, "BINARY")) { 587 char *value = strtok_r(NULL, deliminiters, &saveptr); 588 int argi = 0; 589 590 el->type = IMAGE_CFG_BINARY; 591 el->binary.file = strdup(value); 592 while (1) { 593 value = strtok_r(NULL, deliminiters, &saveptr); 594 if (!value) 595 break; 596 el->binary.args[argi] = strtoul(value, NULL, 16); 597 argi++; 598 if (argi >= BINARY_MAX_ARGS) { 599 fprintf(stderr, 600 "Too many argument for binary\n"); 601 return -1; 602 } 603 } 604 el->binary.nargs = argi; 605 } else if (!strcmp(keyword, "DATA")) { 606 char *value1 = strtok_r(NULL, deliminiters, &saveptr); 607 char *value2 = strtok_r(NULL, deliminiters, &saveptr); 608 609 if (!value1 || !value2) { 610 fprintf(stderr, 611 "Invalid number of arguments for DATA\n"); 612 return -1; 613 } 614 615 el->type = IMAGE_CFG_DATA; 616 el->regdata.raddr = strtoul(value1, NULL, 16); 617 el->regdata.rdata = strtoul(value2, NULL, 16); 618 } else { 619 fprintf(stderr, "Ignoring unknown line '%s'\n", line); 620 } 621 622 return 0; 623 } 624 625 /* 626 * Parse the configuration file 'fcfg' into the array of configuration 627 * elements 'image_cfg', and return the number of configuration 628 * elements in 'cfgn'. 629 */ 630 static int image_create_config_parse(FILE *fcfg) 631 { 632 int ret; 633 int cfgi = 0; 634 635 /* Parse the configuration file */ 636 while (!feof(fcfg)) { 637 char *line; 638 char buf[256]; 639 640 /* Read the current line */ 641 memset(buf, 0, sizeof(buf)); 642 line = fgets(buf, sizeof(buf), fcfg); 643 if (!line) 644 break; 645 646 /* Ignore useless lines */ 647 if (line[0] == '\n' || line[0] == '#') 648 continue; 649 650 /* Strip final newline */ 651 if (line[strlen(line) - 1] == '\n') 652 line[strlen(line) - 1] = 0; 653 654 /* Parse the current line */ 655 ret = image_create_config_parse_oneline(line, 656 &image_cfg[cfgi]); 657 if (ret) 658 return ret; 659 660 cfgi++; 661 662 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) { 663 fprintf(stderr, 664 "Too many configuration elements in .cfg file\n"); 665 return -1; 666 } 667 } 668 669 cfgn = cfgi; 670 return 0; 671 } 672 673 static int image_get_version(void) 674 { 675 struct image_cfg_element *e; 676 677 e = image_find_option(IMAGE_CFG_VERSION); 678 if (!e) 679 return -1; 680 681 return e->version; 682 } 683 684 static int image_version_file(const char *input) 685 { 686 FILE *fcfg; 687 int version; 688 int ret; 689 690 fcfg = fopen(input, "r"); 691 if (!fcfg) { 692 fprintf(stderr, "Could not open input file %s\n", input); 693 return -1; 694 } 695 696 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 697 sizeof(struct image_cfg_element)); 698 if (!image_cfg) { 699 fprintf(stderr, "Cannot allocate memory\n"); 700 fclose(fcfg); 701 return -1; 702 } 703 704 memset(image_cfg, 0, 705 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 706 rewind(fcfg); 707 708 ret = image_create_config_parse(fcfg); 709 fclose(fcfg); 710 if (ret) { 711 free(image_cfg); 712 return -1; 713 } 714 715 version = image_get_version(); 716 /* Fallback to version 0 is no version is provided in the cfg file */ 717 if (version == -1) 718 version = 0; 719 720 free(image_cfg); 721 722 return version; 723 } 724 725 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd, 726 struct image_tool_params *params) 727 { 728 FILE *fcfg; 729 void *image = NULL; 730 int version; 731 size_t headersz; 732 uint32_t checksum; 733 int ret; 734 int size; 735 736 fcfg = fopen(params->imagename, "r"); 737 if (!fcfg) { 738 fprintf(stderr, "Could not open input file %s\n", 739 params->imagename); 740 exit(EXIT_FAILURE); 741 } 742 743 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 744 sizeof(struct image_cfg_element)); 745 if (!image_cfg) { 746 fprintf(stderr, "Cannot allocate memory\n"); 747 fclose(fcfg); 748 exit(EXIT_FAILURE); 749 } 750 751 memset(image_cfg, 0, 752 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 753 rewind(fcfg); 754 755 ret = image_create_config_parse(fcfg); 756 fclose(fcfg); 757 if (ret) { 758 free(image_cfg); 759 exit(EXIT_FAILURE); 760 } 761 762 version = image_get_version(); 763 switch (version) { 764 /* 765 * Fallback to version 0 if no version is provided in the 766 * cfg file 767 */ 768 case -1: 769 case 0: 770 image = image_create_v0(&headersz, params, sbuf->st_size); 771 break; 772 773 case 1: 774 image = image_create_v1(&headersz, params, sbuf->st_size); 775 break; 776 777 default: 778 fprintf(stderr, "Unsupported version %d\n", version); 779 free(image_cfg); 780 exit(EXIT_FAILURE); 781 } 782 783 if (!image) { 784 fprintf(stderr, "Could not create image\n"); 785 free(image_cfg); 786 exit(EXIT_FAILURE); 787 } 788 789 free(image_cfg); 790 791 /* Build and add image checksum header */ 792 checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size); 793 size = write(ifd, &checksum, sizeof(uint32_t)); 794 if (size != sizeof(uint32_t)) { 795 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n", 796 params->cmdname, size, params->imagefile); 797 exit(EXIT_FAILURE); 798 } 799 800 sbuf->st_size += sizeof(uint32_t); 801 802 /* Finally copy the header into the image area */ 803 memcpy(ptr, image, headersz); 804 805 free(image); 806 } 807 808 static void kwbimage_print_header(const void *ptr) 809 { 810 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr; 811 812 printf("Image Type: MVEBU Boot from %s Image\n", 813 image_boot_mode_name(mhdr->blockid)); 814 printf("Image version:%d\n", image_version((void *)ptr)); 815 printf("Data Size: "); 816 genimg_print_size(mhdr->blocksize - sizeof(uint32_t)); 817 printf("Load Address: %08x\n", mhdr->destaddr); 818 printf("Entry Point: %08x\n", mhdr->execaddr); 819 } 820 821 static int kwbimage_check_image_types(uint8_t type) 822 { 823 if (type == IH_TYPE_KWBIMAGE) 824 return EXIT_SUCCESS; 825 else 826 return EXIT_FAILURE; 827 } 828 829 static int kwbimage_verify_header(unsigned char *ptr, int image_size, 830 struct image_tool_params *params) 831 { 832 struct main_hdr_v0 *main_hdr; 833 struct ext_hdr_v0 *ext_hdr; 834 uint8_t checksum; 835 836 main_hdr = (void *)ptr; 837 checksum = image_checksum8(ptr, 838 sizeof(struct main_hdr_v0) 839 - sizeof(uint8_t)); 840 if (checksum != main_hdr->checksum) 841 return -FDT_ERR_BADSTRUCTURE; 842 843 /* Only version 0 extended header has checksum */ 844 if (image_version((void *)ptr) == 0) { 845 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0); 846 checksum = image_checksum8(ext_hdr, 847 sizeof(struct ext_hdr_v0) 848 - sizeof(uint8_t)); 849 if (checksum != ext_hdr->checksum) 850 return -FDT_ERR_BADSTRUCTURE; 851 } 852 853 return 0; 854 } 855 856 static int kwbimage_generate(struct image_tool_params *params, 857 struct image_type_params *tparams) 858 { 859 int alloc_len; 860 void *hdr; 861 int version = 0; 862 863 version = image_version_file(params->imagename); 864 if (version == 0) { 865 alloc_len = sizeof(struct main_hdr_v0) + 866 sizeof(struct ext_hdr_v0); 867 } else { 868 alloc_len = image_headersz_v1(params, NULL); 869 } 870 871 hdr = malloc(alloc_len); 872 if (!hdr) { 873 fprintf(stderr, "%s: malloc return failure: %s\n", 874 params->cmdname, strerror(errno)); 875 exit(EXIT_FAILURE); 876 } 877 878 memset(hdr, 0, alloc_len); 879 tparams->header_size = alloc_len; 880 tparams->hdr = hdr; 881 882 return 0; 883 } 884 885 /* 886 * Report Error if xflag is set in addition to default 887 */ 888 static int kwbimage_check_params(struct image_tool_params *params) 889 { 890 if (!strlen(params->imagename)) { 891 fprintf(stderr, "Error:%s - Configuration file not specified, " 892 "it is needed for kwbimage generation\n", 893 params->cmdname); 894 return CFG_INVALID; 895 } 896 897 return (params->dflag && (params->fflag || params->lflag)) || 898 (params->fflag && (params->dflag || params->lflag)) || 899 (params->lflag && (params->dflag || params->fflag)) || 900 (params->xflag) || !(strlen(params->imagename)); 901 } 902 903 /* 904 * kwbimage type parameters definition 905 */ 906 static struct image_type_params kwbimage_params = { 907 .name = "Marvell MVEBU Boot Image support", 908 .header_size = 0, /* no fixed header size */ 909 .hdr = NULL, 910 .vrec_header = kwbimage_generate, 911 .check_image_type = kwbimage_check_image_types, 912 .verify_header = kwbimage_verify_header, 913 .print_header = kwbimage_print_header, 914 .set_header = kwbimage_set_header, 915 .check_params = kwbimage_check_params, 916 }; 917 918 void init_kwb_image_type (void) 919 { 920 register_image_type(&kwbimage_params); 921 } 922