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