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 uint8_t *image; 234 int has_ext = 0; 235 236 /* 237 * Calculate the size of the header and the size of the 238 * payload 239 */ 240 headersz = sizeof(struct main_hdr_v0); 241 242 if (image_count_options(IMAGE_CFG_DATA) > 0) { 243 has_ext = 1; 244 headersz += sizeof(struct ext_hdr_v0); 245 } 246 247 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) { 248 fprintf(stderr, "More than one payload, not possible\n"); 249 return NULL; 250 } 251 252 image = malloc(headersz); 253 if (!image) { 254 fprintf(stderr, "Cannot allocate memory for image\n"); 255 return NULL; 256 } 257 258 memset(image, 0, headersz); 259 260 main_hdr = (struct main_hdr_v0 *)image; 261 262 /* Fill in the main header */ 263 main_hdr->blocksize = 264 cpu_to_le32(payloadsz + sizeof(uint32_t) - headersz); 265 main_hdr->srcaddr = cpu_to_le32(headersz); 266 main_hdr->ext = has_ext; 267 main_hdr->destaddr = cpu_to_le32(params->addr); 268 main_hdr->execaddr = cpu_to_le32(params->ep); 269 270 e = image_find_option(IMAGE_CFG_BOOT_FROM); 271 if (e) 272 main_hdr->blockid = e->bootfrom; 273 e = image_find_option(IMAGE_CFG_NAND_ECC_MODE); 274 if (e) 275 main_hdr->nandeccmode = e->nandeccmode; 276 e = image_find_option(IMAGE_CFG_NAND_PAGESZ); 277 if (e) 278 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz); 279 main_hdr->checksum = image_checksum8(image, 280 sizeof(struct main_hdr_v0)); 281 282 /* Generate the ext header */ 283 if (has_ext) { 284 struct ext_hdr_v0 *ext_hdr; 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(int *hasext) 312 { 313 struct image_cfg_element *binarye; 314 size_t headersz; 315 316 /* 317 * Calculate the size of the header and the size of the 318 * payload 319 */ 320 headersz = sizeof(struct main_hdr_v1); 321 322 if (image_count_options(IMAGE_CFG_BINARY) > 1) { 323 fprintf(stderr, "More than one binary blob, not supported\n"); 324 return 0; 325 } 326 327 if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) { 328 fprintf(stderr, "More than one payload, not possible\n"); 329 return 0; 330 } 331 332 binarye = image_find_option(IMAGE_CFG_BINARY); 333 if (binarye) { 334 int ret; 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 uint8_t *image, *cur; 389 int hasext = 0; 390 391 /* 392 * Calculate the size of the header and the size of the 393 * payload 394 */ 395 headersz = image_headersz_v1(&hasext); 396 if (headersz == 0) 397 return NULL; 398 399 image = malloc(headersz); 400 if (!image) { 401 fprintf(stderr, "Cannot allocate memory for image\n"); 402 return NULL; 403 } 404 405 memset(image, 0, headersz); 406 407 main_hdr = (struct main_hdr_v1 *)image; 408 cur = image + sizeof(struct main_hdr_v1); 409 410 /* Fill the main header */ 411 main_hdr->blocksize = 412 cpu_to_le32(payloadsz - headersz + sizeof(uint32_t)); 413 main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF); 414 main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16; 415 main_hdr->destaddr = cpu_to_le32(params->addr) 416 - sizeof(image_header_t); 417 main_hdr->execaddr = cpu_to_le32(params->ep); 418 main_hdr->srcaddr = cpu_to_le32(headersz); 419 main_hdr->ext = hasext; 420 main_hdr->version = 1; 421 e = image_find_option(IMAGE_CFG_BOOT_FROM); 422 if (e) 423 main_hdr->blockid = e->bootfrom; 424 e = image_find_option(IMAGE_CFG_NAND_BLKSZ); 425 if (e) 426 main_hdr->nandblocksize = e->nandblksz / (64 * 1024); 427 e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION); 428 if (e) 429 main_hdr->nandbadblklocation = e->nandbadblklocation; 430 e = image_find_option(IMAGE_CFG_BAUDRATE); 431 if (e) 432 main_hdr->options = baudrate_to_option(e->baudrate); 433 e = image_find_option(IMAGE_CFG_DEBUG); 434 if (e) 435 main_hdr->flags = e->debug ? 0x1 : 0; 436 437 binarye = image_find_option(IMAGE_CFG_BINARY); 438 if (binarye) { 439 struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)cur; 440 uint32_t *args; 441 size_t binhdrsz; 442 struct stat s; 443 int argi; 444 FILE *bin; 445 int ret; 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 = (uint32_t *)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 uint8_t checksum; 821 822 main_hdr = (struct main_hdr_v0 *)ptr; 823 checksum = image_checksum8(ptr, 824 sizeof(struct main_hdr_v0) 825 - sizeof(uint8_t)); 826 if (checksum != main_hdr->checksum) 827 return -FDT_ERR_BADSTRUCTURE; 828 829 /* Only version 0 extended header has checksum */ 830 if (image_version((void *)ptr) == 0) { 831 struct ext_hdr_v0 *ext_hdr; 832 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(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