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