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