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 uint8_t *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 = (struct main_hdr_v0 *)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 = (struct ext_hdr_v0 *) 288 (image + sizeof(struct main_hdr_v0)); 289 ext_hdr->offset = cpu_to_le32(0x40); 290 291 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) { 292 e = &image_cfg[cfgi]; 293 if (e->type != IMAGE_CFG_DATA) 294 continue; 295 296 ext_hdr->rcfg[datai].raddr = 297 cpu_to_le32(e->regdata.raddr); 298 ext_hdr->rcfg[datai].rdata = 299 cpu_to_le32(e->regdata.rdata); 300 datai++; 301 } 302 303 ext_hdr->checksum = image_checksum8(ext_hdr, 304 sizeof(struct ext_hdr_v0)); 305 } 306 307 *imagesz = headersz; 308 return image; 309 } 310 311 static size_t image_headersz_v1(struct image_tool_params *params, 312 int *hasext) 313 { 314 struct image_cfg_element *binarye; 315 size_t headersz; 316 int ret; 317 318 /* 319 * Calculate the size of the header and the size of the 320 * payload 321 */ 322 headersz = sizeof(struct main_hdr_v1); 323 324 if (image_count_options(IMAGE_CFG_BINARY) > 1) { 325 fprintf(stderr, "More than one binary blob, not supported\n"); 326 return 0; 327 } 328 329 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) { 330 fprintf(stderr, "More than one payload, not possible\n"); 331 return 0; 332 } 333 334 binarye = image_find_option(IMAGE_CFG_BINARY); 335 if (binarye) { 336 struct stat s; 337 338 ret = stat(binarye->binary.file, &s); 339 if (ret < 0) { 340 char cwd[PATH_MAX]; 341 char *dir = cwd; 342 343 memset(cwd, 0, sizeof(cwd)); 344 if (!getcwd(cwd, sizeof(cwd))) { 345 dir = "current working directory"; 346 perror("getcwd() failed"); 347 } 348 349 fprintf(stderr, 350 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n" 351 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n" 352 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n", 353 binarye->binary.file, dir); 354 return 0; 355 } 356 357 headersz += sizeof(struct opt_hdr_v1) + 358 s.st_size + 359 (binarye->binary.nargs + 2) * sizeof(uint32_t); 360 if (hasext) 361 *hasext = 1; 362 } 363 364 #if defined(CONFIG_SYS_U_BOOT_OFFS) 365 if (headersz > CONFIG_SYS_U_BOOT_OFFS) { 366 fprintf(stderr, 367 "Error: Image header (incl. SPL image) too big!\n"); 368 fprintf(stderr, "header=0x%x CONFIG_SYS_U_BOOT_OFFS=0x%x!\n", 369 (int)headersz, CONFIG_SYS_U_BOOT_OFFS); 370 fprintf(stderr, "Increase CONFIG_SYS_U_BOOT_OFFS!\n"); 371 return 0; 372 } 373 headersz = CONFIG_SYS_U_BOOT_OFFS; 374 #endif 375 376 /* 377 * The payload should be aligned on some reasonable 378 * boundary 379 */ 380 return ALIGN_SUP(headersz, 4096); 381 } 382 383 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params, 384 int payloadsz) 385 { 386 struct image_cfg_element *e, *binarye; 387 struct main_hdr_v1 *main_hdr; 388 size_t headersz; 389 uint8_t *image, *cur; 390 int hasext = 0; 391 int ret; 392 393 /* 394 * Calculate the size of the header and the size of the 395 * payload 396 */ 397 headersz = image_headersz_v1(params, &hasext); 398 if (headersz == 0) 399 return NULL; 400 401 image = malloc(headersz); 402 if (!image) { 403 fprintf(stderr, "Cannot allocate memory for image\n"); 404 return NULL; 405 } 406 407 memset(image, 0, headersz); 408 409 main_hdr = (struct main_hdr_v1 *)image; 410 cur = image + sizeof(struct main_hdr_v1); 411 412 /* Fill the main header */ 413 main_hdr->blocksize = 414 cpu_to_le32(payloadsz - headersz + sizeof(uint32_t)); 415 main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF); 416 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16; 417 main_hdr->destaddr = cpu_to_le32(params->addr) 418 - sizeof(image_header_t); 419 main_hdr->execaddr = cpu_to_le32(params->ep); 420 main_hdr->srcaddr = cpu_to_le32(headersz); 421 main_hdr->ext = hasext; 422 main_hdr->version = 1; 423 e = image_find_option(IMAGE_CFG_BOOT_FROM); 424 if (e) 425 main_hdr->blockid = e->bootfrom; 426 e = image_find_option(IMAGE_CFG_NAND_BLKSZ); 427 if (e) 428 main_hdr->nandblocksize = e->nandblksz / (64 * 1024); 429 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION); 430 if (e) 431 main_hdr->nandbadblklocation = e->nandbadblklocation; 432 e = image_find_option(IMAGE_CFG_BAUDRATE); 433 if (e) 434 main_hdr->options = baudrate_to_option(e->baudrate); 435 e = image_find_option(IMAGE_CFG_DEBUG); 436 if (e) 437 main_hdr->flags = e->debug ? 0x1 : 0; 438 439 binarye = image_find_option(IMAGE_CFG_BINARY); 440 if (binarye) { 441 struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)cur; 442 uint32_t *args; 443 size_t binhdrsz; 444 struct stat s; 445 int argi; 446 FILE *bin; 447 448 hdr->headertype = OPT_HDR_V1_BINARY_TYPE; 449 450 bin = fopen(binarye->binary.file, "r"); 451 if (!bin) { 452 fprintf(stderr, "Cannot open binary file %s\n", 453 binarye->binary.file); 454 return NULL; 455 } 456 457 fstat(fileno(bin), &s); 458 459 binhdrsz = sizeof(struct opt_hdr_v1) + 460 (binarye->binary.nargs + 2) * sizeof(uint32_t) + 461 s.st_size; 462 463 /* 464 * The size includes the binary image size, rounded 465 * up to a 4-byte boundary. Plus 4 bytes for the 466 * next-header byte and 3-byte alignment at the end. 467 */ 468 binhdrsz = ALIGN_SUP(binhdrsz, 4) + 4; 469 hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF); 470 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16; 471 472 cur += sizeof(struct opt_hdr_v1); 473 474 args = (uint32_t *)cur; 475 *args = cpu_to_le32(binarye->binary.nargs); 476 args++; 477 for (argi = 0; argi < binarye->binary.nargs; argi++) 478 args[argi] = cpu_to_le32(binarye->binary.args[argi]); 479 480 cur += (binarye->binary.nargs + 1) * sizeof(uint32_t); 481 482 ret = fread(cur, s.st_size, 1, bin); 483 if (ret != 1) { 484 fprintf(stderr, 485 "Could not read binary image %s\n", 486 binarye->binary.file); 487 return NULL; 488 } 489 490 fclose(bin); 491 492 cur += ALIGN_SUP(s.st_size, 4); 493 494 /* 495 * For now, we don't support more than one binary 496 * header, and no other header types are 497 * supported. So, the binary header is necessarily the 498 * last one 499 */ 500 *((uint32_t *)cur) = 0x00000000; 501 502 cur += sizeof(uint32_t); 503 } 504 505 /* Calculate and set the header checksum */ 506 main_hdr->checksum = image_checksum8(main_hdr, headersz); 507 508 *imagesz = headersz; 509 return image; 510 } 511 512 static int image_create_config_parse_oneline(char *line, 513 struct image_cfg_element *el) 514 { 515 char *keyword, *saveptr; 516 char deliminiters[] = " \t"; 517 518 keyword = strtok_r(line, deliminiters, &saveptr); 519 if (!strcmp(keyword, "VERSION")) { 520 char *value = strtok_r(NULL, deliminiters, &saveptr); 521 522 el->type = IMAGE_CFG_VERSION; 523 el->version = atoi(value); 524 } else if (!strcmp(keyword, "BOOT_FROM")) { 525 char *value = strtok_r(NULL, deliminiters, &saveptr); 526 int ret = image_boot_mode_id(value); 527 528 if (ret < 0) { 529 fprintf(stderr, 530 "Invalid boot media '%s'\n", value); 531 return -1; 532 } 533 el->type = IMAGE_CFG_BOOT_FROM; 534 el->bootfrom = ret; 535 } else if (!strcmp(keyword, "NAND_BLKSZ")) { 536 char *value = strtok_r(NULL, deliminiters, &saveptr); 537 538 el->type = IMAGE_CFG_NAND_BLKSZ; 539 el->nandblksz = strtoul(value, NULL, 16); 540 } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) { 541 char *value = strtok_r(NULL, deliminiters, &saveptr); 542 543 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION; 544 el->nandbadblklocation = 545 strtoul(value, NULL, 16); 546 } else if (!strcmp(keyword, "NAND_ECC_MODE")) { 547 char *value = strtok_r(NULL, deliminiters, &saveptr); 548 int ret = image_nand_ecc_mode_id(value); 549 550 if (ret < 0) { 551 fprintf(stderr, 552 "Invalid NAND ECC mode '%s'\n", value); 553 return -1; 554 } 555 el->type = IMAGE_CFG_NAND_ECC_MODE; 556 el->nandeccmode = ret; 557 } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) { 558 char *value = strtok_r(NULL, deliminiters, &saveptr); 559 560 el->type = IMAGE_CFG_NAND_PAGESZ; 561 el->nandpagesz = strtoul(value, NULL, 16); 562 } else if (!strcmp(keyword, "BINARY")) { 563 char *value = strtok_r(NULL, deliminiters, &saveptr); 564 int argi = 0; 565 566 el->type = IMAGE_CFG_BINARY; 567 el->binary.file = strdup(value); 568 while (1) { 569 value = strtok_r(NULL, deliminiters, &saveptr); 570 if (!value) 571 break; 572 el->binary.args[argi] = strtoul(value, NULL, 16); 573 argi++; 574 if (argi >= BINARY_MAX_ARGS) { 575 fprintf(stderr, 576 "Too many argument for binary\n"); 577 return -1; 578 } 579 } 580 el->binary.nargs = argi; 581 } else if (!strcmp(keyword, "DATA")) { 582 char *value1 = strtok_r(NULL, deliminiters, &saveptr); 583 char *value2 = strtok_r(NULL, deliminiters, &saveptr); 584 585 if (!value1 || !value2) { 586 fprintf(stderr, 587 "Invalid number of arguments for DATA\n"); 588 return -1; 589 } 590 591 el->type = IMAGE_CFG_DATA; 592 el->regdata.raddr = strtoul(value1, NULL, 16); 593 el->regdata.rdata = strtoul(value2, NULL, 16); 594 } else if (!strcmp(keyword, "BAUDRATE")) { 595 char *value = strtok_r(NULL, deliminiters, &saveptr); 596 el->type = IMAGE_CFG_BAUDRATE; 597 el->baudrate = strtoul(value, NULL, 10); 598 } else if (!strcmp(keyword, "DEBUG")) { 599 char *value = strtok_r(NULL, deliminiters, &saveptr); 600 el->type = IMAGE_CFG_DEBUG; 601 el->debug = strtoul(value, NULL, 10); 602 } else { 603 fprintf(stderr, "Ignoring unknown line '%s'\n", line); 604 } 605 606 return 0; 607 } 608 609 /* 610 * Parse the configuration file 'fcfg' into the array of configuration 611 * elements 'image_cfg', and return the number of configuration 612 * elements in 'cfgn'. 613 */ 614 static int image_create_config_parse(FILE *fcfg) 615 { 616 int ret; 617 int cfgi = 0; 618 619 /* Parse the configuration file */ 620 while (!feof(fcfg)) { 621 char *line; 622 char buf[256]; 623 624 /* Read the current line */ 625 memset(buf, 0, sizeof(buf)); 626 line = fgets(buf, sizeof(buf), fcfg); 627 if (!line) 628 break; 629 630 /* Ignore useless lines */ 631 if (line[0] == '\n' || line[0] == '#') 632 continue; 633 634 /* Strip final newline */ 635 if (line[strlen(line) - 1] == '\n') 636 line[strlen(line) - 1] = 0; 637 638 /* Parse the current line */ 639 ret = image_create_config_parse_oneline(line, 640 &image_cfg[cfgi]); 641 if (ret) 642 return ret; 643 644 cfgi++; 645 646 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) { 647 fprintf(stderr, 648 "Too many configuration elements in .cfg file\n"); 649 return -1; 650 } 651 } 652 653 cfgn = cfgi; 654 return 0; 655 } 656 657 static int image_get_version(void) 658 { 659 struct image_cfg_element *e; 660 661 e = image_find_option(IMAGE_CFG_VERSION); 662 if (!e) 663 return -1; 664 665 return e->version; 666 } 667 668 static int image_version_file(const char *input) 669 { 670 FILE *fcfg; 671 int version; 672 int ret; 673 674 fcfg = fopen(input, "r"); 675 if (!fcfg) { 676 fprintf(stderr, "Could not open input file %s\n", input); 677 return -1; 678 } 679 680 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 681 sizeof(struct image_cfg_element)); 682 if (!image_cfg) { 683 fprintf(stderr, "Cannot allocate memory\n"); 684 fclose(fcfg); 685 return -1; 686 } 687 688 memset(image_cfg, 0, 689 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 690 rewind(fcfg); 691 692 ret = image_create_config_parse(fcfg); 693 fclose(fcfg); 694 if (ret) { 695 free(image_cfg); 696 return -1; 697 } 698 699 version = image_get_version(); 700 /* Fallback to version 0 is no version is provided in the cfg file */ 701 if (version == -1) 702 version = 0; 703 704 free(image_cfg); 705 706 return version; 707 } 708 709 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd, 710 struct image_tool_params *params) 711 { 712 FILE *fcfg; 713 void *image = NULL; 714 int version; 715 size_t headersz = 0; 716 uint32_t checksum; 717 int ret; 718 int size; 719 720 fcfg = fopen(params->imagename, "r"); 721 if (!fcfg) { 722 fprintf(stderr, "Could not open input file %s\n", 723 params->imagename); 724 exit(EXIT_FAILURE); 725 } 726 727 image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX * 728 sizeof(struct image_cfg_element)); 729 if (!image_cfg) { 730 fprintf(stderr, "Cannot allocate memory\n"); 731 fclose(fcfg); 732 exit(EXIT_FAILURE); 733 } 734 735 memset(image_cfg, 0, 736 IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element)); 737 rewind(fcfg); 738 739 ret = image_create_config_parse(fcfg); 740 fclose(fcfg); 741 if (ret) { 742 free(image_cfg); 743 exit(EXIT_FAILURE); 744 } 745 746 /* The MVEBU BootROM does not allow non word aligned payloads */ 747 sbuf->st_size = ALIGN_SUP(sbuf->st_size, 4); 748 749 version = image_get_version(); 750 switch (version) { 751 /* 752 * Fallback to version 0 if no version is provided in the 753 * cfg file 754 */ 755 case -1: 756 case 0: 757 image = image_create_v0(&headersz, params, sbuf->st_size); 758 break; 759 760 case 1: 761 image = image_create_v1(&headersz, params, sbuf->st_size); 762 break; 763 764 default: 765 fprintf(stderr, "Unsupported version %d\n", version); 766 free(image_cfg); 767 exit(EXIT_FAILURE); 768 } 769 770 if (!image) { 771 fprintf(stderr, "Could not create image\n"); 772 free(image_cfg); 773 exit(EXIT_FAILURE); 774 } 775 776 free(image_cfg); 777 778 /* Build and add image checksum header */ 779 checksum = 780 cpu_to_le32(image_checksum32((uint32_t *)ptr, sbuf->st_size)); 781 size = write(ifd, &checksum, sizeof(uint32_t)); 782 if (size != sizeof(uint32_t)) { 783 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n", 784 params->cmdname, size, params->imagefile); 785 exit(EXIT_FAILURE); 786 } 787 788 sbuf->st_size += sizeof(uint32_t); 789 790 /* Finally copy the header into the image area */ 791 memcpy(ptr, image, headersz); 792 793 free(image); 794 } 795 796 static void kwbimage_print_header(const void *ptr) 797 { 798 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr; 799 800 printf("Image Type: MVEBU Boot from %s Image\n", 801 image_boot_mode_name(mhdr->blockid)); 802 printf("Image version:%d\n", image_version((void *)ptr)); 803 printf("Data Size: "); 804 genimg_print_size(mhdr->blocksize - sizeof(uint32_t)); 805 printf("Load Address: %08x\n", mhdr->destaddr); 806 printf("Entry Point: %08x\n", mhdr->execaddr); 807 } 808 809 static int kwbimage_check_image_types(uint8_t type) 810 { 811 if (type == IH_TYPE_KWBIMAGE) 812 return EXIT_SUCCESS; 813 814 return EXIT_FAILURE; 815 } 816 817 static int kwbimage_verify_header(unsigned char *ptr, int image_size, 818 struct image_tool_params *params) 819 { 820 struct main_hdr_v0 *main_hdr; 821 struct ext_hdr_v0 *ext_hdr; 822 uint8_t checksum; 823 824 main_hdr = (struct main_hdr_v0 *)ptr; 825 checksum = image_checksum8(ptr, 826 sizeof(struct main_hdr_v0) 827 - sizeof(uint8_t)); 828 if (checksum != main_hdr->checksum) 829 return -FDT_ERR_BADSTRUCTURE; 830 831 /* Only version 0 extended header has checksum */ 832 if (image_version((void *)ptr) == 0) { 833 ext_hdr = (struct ext_hdr_v0 *) 834 (ptr + sizeof(struct main_hdr_v0)); 835 checksum = image_checksum8(ext_hdr, 836 sizeof(struct ext_hdr_v0) 837 - sizeof(uint8_t)); 838 if (checksum != ext_hdr->checksum) 839 return -FDT_ERR_BADSTRUCTURE; 840 } 841 842 return 0; 843 } 844 845 static int kwbimage_generate(struct image_tool_params *params, 846 struct image_type_params *tparams) 847 { 848 int alloc_len; 849 void *hdr; 850 int version = 0; 851 852 version = image_version_file(params->imagename); 853 if (version == 0) { 854 alloc_len = sizeof(struct main_hdr_v0) + 855 sizeof(struct ext_hdr_v0); 856 } else { 857 alloc_len = image_headersz_v1(params, NULL); 858 } 859 860 hdr = malloc(alloc_len); 861 if (!hdr) { 862 fprintf(stderr, "%s: malloc return failure: %s\n", 863 params->cmdname, strerror(errno)); 864 exit(EXIT_FAILURE); 865 } 866 867 memset(hdr, 0, alloc_len); 868 tparams->header_size = alloc_len; 869 tparams->hdr = hdr; 870 871 /* 872 * The resulting image needs to be 4-byte aligned. At least 873 * the Marvell hdrparser tool complains if its unaligned. 874 * By returning 1 here in this function, called via 875 * tparams->vrec_header() in mkimage.c, mkimage will 876 * automatically pad the the resulting image to a 4-byte 877 * size if necessary. 878 */ 879 return 1; 880 } 881 882 /* 883 * Report Error if xflag is set in addition to default 884 */ 885 static int kwbimage_check_params(struct image_tool_params *params) 886 { 887 if (!strlen(params->imagename)) { 888 char *msg = "Configuration file for kwbimage creation omitted"; 889 890 fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg); 891 return CFG_INVALID; 892 } 893 894 return (params->dflag && (params->fflag || params->lflag)) || 895 (params->fflag && (params->dflag || params->lflag)) || 896 (params->lflag && (params->dflag || params->fflag)) || 897 (params->xflag) || !(strlen(params->imagename)); 898 } 899 900 /* 901 * kwbimage type parameters definition 902 */ 903 U_BOOT_IMAGE_TYPE( 904 kwbimage, 905 "Marvell MVEBU Boot Image support", 906 0, 907 NULL, 908 kwbimage_check_params, 909 kwbimage_verify_header, 910 kwbimage_print_header, 911 kwbimage_set_header, 912 NULL, 913 kwbimage_check_image_types, 914 NULL, 915 kwbimage_generate 916 ); 917