tools/kwbimage.c

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