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