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                 binhdrsz = ALIGN_SUP(binhdrsz, 32);
 502                 hdr->headersz_lsb = binhdrsz & 0xFFFF;
 503                 hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
 504
 505                 cur += sizeof(struct opt_hdr_v1);
 506
 507                 args = cur;
 508                 *args = binarye->binary.nargs;
 509                 args++;
 510                 for (argi = 0; argi < binarye->binary.nargs; argi++)
 511                         args[argi] = binarye->binary.args[argi];
 512
 513                 cur += (binarye->binary.nargs + 1) * sizeof(unsigned int);
 514
 515                 ret = fread(cur, s.st_size, 1, bin);
 516                 if (ret != 1) {
 517                         fprintf(stderr,
 518                                 "Could not read binary image %s\n",
 519                                 binarye->binary.file);
 520                         return NULL;
 521                 }
 522
 523                 fclose(bin);
 524
 525                 cur += s.st_size;
 526
 527                 /*
 528                  * For now, we don't support more than one binary
 529                  * header, and no other header types are
 530                  * supported. So, the binary header is necessarily the
 531                  * last one
 532                  */
 533                 *((unsigned char *)cur) = 0;
 534
 535                 cur += sizeof(uint32_t);
 536         }
 537
 538         /* Calculate and set the header checksum */
 539         main_hdr->checksum = image_checksum8(main_hdr, headersz);
 540
 541         *imagesz = headersz;
 542         return image;
 543 }
 544
 545 static int image_create_config_parse_oneline(char *line,
 546                                              struct image_cfg_element *el)
 547 {
 548         char *keyword, *saveptr;
 549         char deliminiters[] = " \t";
 550
 551         keyword = strtok_r(line, deliminiters, &saveptr);
 552         if (!strcmp(keyword, "VERSION")) {
 553                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 554                 el->type = IMAGE_CFG_VERSION;
 555                 el->version = atoi(value);
 556         } else if (!strcmp(keyword, "BOOT_FROM")) {
 557                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 558                 int ret = image_boot_mode_id(value);
 559                 if (ret < 0) {
 560                         fprintf(stderr,
 561                                 "Invalid boot media '%s'\n", value);
 562                         return -1;
 563                 }
 564                 el->type = IMAGE_CFG_BOOT_FROM;
 565                 el->bootfrom = ret;
 566         } else if (!strcmp(keyword, "NAND_BLKSZ")) {
 567                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 568                 el->type = IMAGE_CFG_NAND_BLKSZ;
 569                 el->nandblksz = strtoul(value, NULL, 16);
 570         } else if (!strcmp(keyword, "NAND_BADBLK_LOCATION")) {
 571                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 572                 el->type = IMAGE_CFG_NAND_BADBLK_LOCATION;
 573                 el->nandbadblklocation =
 574                         strtoul(value, NULL, 16);
 575         } else if (!strcmp(keyword, "NAND_ECC_MODE")) {
 576                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 577                 int ret = image_nand_ecc_mode_id(value);
 578                 if (ret < 0) {
 579                         fprintf(stderr,
 580                                 "Invalid NAND ECC mode '%s'\n", value);
 581                         return -1;
 582                 }
 583                 el->type = IMAGE_CFG_NAND_ECC_MODE;
 584                 el->nandeccmode = ret;
 585         } else if (!strcmp(keyword, "NAND_PAGE_SIZE")) {
 586                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 587                 el->type = IMAGE_CFG_NAND_PAGESZ;
 588                 el->nandpagesz = strtoul(value, NULL, 16);
 589         } else if (!strcmp(keyword, "BINARY")) {
 590                 char *value = strtok_r(NULL, deliminiters, &saveptr);
 591                 int argi = 0;
 592
 593                 el->type = IMAGE_CFG_BINARY;
 594                 el->binary.file = strdup(value);
 595                 while (1) {
 596                         value = strtok_r(NULL, deliminiters, &saveptr);
 597                         if (!value)
 598                                 break;
 599                         el->binary.args[argi] = strtoul(value, NULL, 16);
 600                         argi++;
 601                         if (argi >= BINARY_MAX_ARGS) {
 602                                 fprintf(stderr,
 603                                         "Too many argument for binary\n");
 604                                 return -1;
 605                         }
 606                 }
 607                 el->binary.nargs = argi;
 608         } else if (!strcmp(keyword, "DATA")) {
 609                 char *value1 = strtok_r(NULL, deliminiters, &saveptr);
 610                 char *value2 = strtok_r(NULL, deliminiters, &saveptr);
 611
 612                 if (!value1 || !value2) {
 613                         fprintf(stderr,
 614                                 "Invalid number of arguments for DATA\n");
 615                         return -1;
 616                 }
 617
 618                 el->type = IMAGE_CFG_DATA;
 619                 el->regdata.raddr = strtoul(value1, NULL, 16);
 620                 el->regdata.rdata = strtoul(value2, NULL, 16);
 621         } else {
 622                 fprintf(stderr, "Ignoring unknown line '%s'\n", line);
 623         }
 624
 625         return 0;
 626 }
 627
 628 /*
 629  * Parse the configuration file 'fcfg' into the array of configuration
 630  * elements 'image_cfg', and return the number of configuration
 631  * elements in 'cfgn'.
 632  */
 633 static int image_create_config_parse(FILE *fcfg)
 634 {
 635         int ret;
 636         int cfgi = 0;
 637
 638         /* Parse the configuration file */
 639         while (!feof(fcfg)) {
 640                 char *line;
 641                 char buf[256];
 642
 643                 /* Read the current line */
 644                 memset(buf, 0, sizeof(buf));
 645                 line = fgets(buf, sizeof(buf), fcfg);
 646                 if (!line)
 647                         break;
 648
 649                 /* Ignore useless lines */
 650                 if (line[0] == '\n' || line[0] == '#')
 651                         continue;
 652
 653                 /* Strip final newline */
 654                 if (line[strlen(line) - 1] == '\n')
 655                         line[strlen(line) - 1] = 0;
 656
 657                 /* Parse the current line */
 658                 ret = image_create_config_parse_oneline(line,
 659                                                         &image_cfg[cfgi]);
 660                 if (ret)
 661                         return ret;
 662
 663                 cfgi++;
 664
 665                 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
 666                         fprintf(stderr,
 667                                 "Too many configuration elements in .cfg file\n");
 668                         return -1;
 669                 }
 670         }
 671
 672         cfgn = cfgi;
 673         return 0;
 674 }
 675
 676 static int image_get_version(void)
 677 {
 678         struct image_cfg_element *e;
 679
 680         e = image_find_option(IMAGE_CFG_VERSION);
 681         if (!e)
 682                 return -1;
 683
 684         return e->version;
 685 }
 686
 687 static int image_version_file(const char *input)
 688 {
 689         FILE *fcfg;
 690         int version;
 691         int ret;
 692
 693         fcfg = fopen(input, "r");
 694         if (!fcfg) {
 695                 fprintf(stderr, "Could not open input file %s\n", input);
 696                 return -1;
 697         }
 698
 699         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
 700                            sizeof(struct image_cfg_element));
 701         if (!image_cfg) {
 702                 fprintf(stderr, "Cannot allocate memory\n");
 703                 fclose(fcfg);
 704                 return -1;
 705         }
 706
 707         memset(image_cfg, 0,
 708                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
 709         rewind(fcfg);
 710
 711         ret = image_create_config_parse(fcfg);
 712         fclose(fcfg);
 713         if (ret) {
 714                 free(image_cfg);
 715                 return -1;
 716         }
 717
 718         version = image_get_version();
 719         /* Fallback to version 0 is no version is provided in the cfg file */
 720         if (version == -1)
 721                 version = 0;
 722
 723         free(image_cfg);
 724
 725         return version;
 726 }
 727
 728 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
 729                                 struct image_tool_params *params)
 730 {
 731         FILE *fcfg;
 732         void *image = NULL;
 733         int version;
 734         size_t headersz = 0;
 735         uint32_t checksum;
 736         int ret;
 737         int size;
 738
 739         fcfg = fopen(params->imagename, "r");
 740         if (!fcfg) {
 741                 fprintf(stderr, "Could not open input file %s\n",
 742                         params->imagename);
 743                 exit(EXIT_FAILURE);
 744         }
 745
 746         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
 747                            sizeof(struct image_cfg_element));
 748         if (!image_cfg) {
 749                 fprintf(stderr, "Cannot allocate memory\n");
 750                 fclose(fcfg);
 751                 exit(EXIT_FAILURE);
 752         }
 753
 754         memset(image_cfg, 0,
 755                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
 756         rewind(fcfg);
 757
 758         ret = image_create_config_parse(fcfg);
 759         fclose(fcfg);
 760         if (ret) {
 761                 free(image_cfg);
 762                 exit(EXIT_FAILURE);
 763         }
 764
 765         version = image_get_version();
 766         switch (version) {
 767                 /*
 768                  * Fallback to version 0 if no version is provided in the
 769                  * cfg file
 770                  */
 771         case -1:
 772         case 0:
 773                 image = image_create_v0(&headersz, params, sbuf->st_size);
 774                 break;
 775
 776         case 1:
 777                 image = image_create_v1(&headersz, params, sbuf->st_size);
 778                 break;
 779
 780         default:
 781                 fprintf(stderr, "Unsupported version %d\n", version);
 782                 free(image_cfg);
 783                 exit(EXIT_FAILURE);
 784         }
 785
 786         if (!image) {
 787                 fprintf(stderr, "Could not create image\n");
 788                 free(image_cfg);
 789                 exit(EXIT_FAILURE);
 790         }
 791
 792         free(image_cfg);
 793
 794         /* Build and add image checksum header */
 795         checksum = image_checksum32((uint32_t *)ptr, sbuf->st_size);
 796         size = write(ifd, &checksum, sizeof(uint32_t));
 797         if (size != sizeof(uint32_t)) {
 798                 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
 799                         params->cmdname, size, params->imagefile);
 800                 exit(EXIT_FAILURE);
 801         }
 802
 803         sbuf->st_size += sizeof(uint32_t);
 804
 805         /* Finally copy the header into the image area */
 806         memcpy(ptr, image, headersz);
 807
 808         free(image);
 809 }
 810
 811 static void kwbimage_print_header(const void *ptr)
 812 {
 813         struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
 814
 815         printf("Image Type:   MVEBU Boot from %s Image\n",
 816                image_boot_mode_name(mhdr->blockid));
 817         printf("Image version:%d\n", image_version((void *)ptr));
 818         printf("Data Size:    ");
 819         genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
 820         printf("Load Address: %08x\n", mhdr->destaddr);
 821         printf("Entry Point:  %08x\n", mhdr->execaddr);
 822 }
 823
 824 static int kwbimage_check_image_types(uint8_t type)
 825 {
 826         if (type == IH_TYPE_KWBIMAGE)
 827                 return EXIT_SUCCESS;
 828         else
 829                 return EXIT_FAILURE;
 830 }
 831
 832 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
 833                                   struct image_tool_params *params)
 834 {
 835         struct main_hdr_v0 *main_hdr;
 836         struct ext_hdr_v0 *ext_hdr;
 837         uint8_t checksum;
 838
 839         main_hdr = (void *)ptr;
 840         checksum = image_checksum8(ptr,
 841                                    sizeof(struct main_hdr_v0)
 842                                    - sizeof(uint8_t));
 843         if (checksum != main_hdr->checksum)
 844                 return -FDT_ERR_BADSTRUCTURE;
 845
 846         /* Only version 0 extended header has checksum */
 847         if (image_version((void *)ptr) == 0) {
 848                 ext_hdr = (void *)ptr + sizeof(struct main_hdr_v0);
 849                 checksum = image_checksum8(ext_hdr,
 850                                            sizeof(struct ext_hdr_v0)
 851                                            - sizeof(uint8_t));
 852                 if (checksum != ext_hdr->checksum)
 853                         return -FDT_ERR_BADSTRUCTURE;
 854         }
 855
 856         return 0;
 857 }
 858
 859 static int kwbimage_generate(struct image_tool_params *params,
 860                              struct image_type_params *tparams)
 861 {
 862         int alloc_len;
 863         void *hdr;
 864         int version = 0;
 865
 866         version = image_version_file(params->imagename);
 867         if (version == 0) {
 868                 alloc_len = sizeof(struct main_hdr_v0) +
 869                         sizeof(struct ext_hdr_v0);
 870         } else {
 871                 alloc_len = image_headersz_v1(params, NULL);
 872 #if defined(CONFIG_SYS_SPI_U_BOOT_OFFS)
 873                 if (alloc_len > CONFIG_SYS_SPI_U_BOOT_OFFS) {
 874                         fprintf(stderr, "Error: Image header (incl. SPL image) too big!\n");
 875                         fprintf(stderr, "header=0x%x CONFIG_SYS_SPI_U_BOOT_OFFS=0x%x!\n",
 876                                 alloc_len, CONFIG_SYS_SPI_U_BOOT_OFFS);
 877                         fprintf(stderr, "Increase CONFIG_SYS_SPI_U_BOOT_OFFS!\n");
 878                 } else {
 879                         alloc_len = CONFIG_SYS_SPI_U_BOOT_OFFS;
 880                 }
 881 #endif
 882         }
 883
 884         hdr = malloc(alloc_len);
 885         if (!hdr) {
 886                 fprintf(stderr, "%s: malloc return failure: %s\n",
 887                         params->cmdname, strerror(errno));
 888                 exit(EXIT_FAILURE);
 889         }
 890
 891         memset(hdr, 0, alloc_len);
 892         tparams->header_size = alloc_len;
 893         tparams->hdr = hdr;
 894
 895         return 0;
 896 }
 897
 898 /*
 899  * Report Error if xflag is set in addition to default
 900  */
 901 static int kwbimage_check_params(struct image_tool_params *params)
 902 {
 903         if (!strlen(params->imagename)) {
 904                 fprintf(stderr, "Error:%s - Configuration file not specified, "
 905                         "it is needed for kwbimage generation\n",
 906                         params->cmdname);
 907                 return CFG_INVALID;
 908         }
 909
 910         return (params->dflag && (params->fflag || params->lflag)) ||
 911                 (params->fflag && (params->dflag || params->lflag)) ||
 912                 (params->lflag && (params->dflag || params->fflag)) ||
 913                 (params->xflag) || !(strlen(params->imagename));
 914 }
 915
 916 /*
 917  * kwbimage type parameters definition
 918  */
 919 U_BOOT_IMAGE_TYPE(
 920         kwbimage,
 921         "Marvell MVEBU Boot Image support",
 922         0,
 923         NULL,
 924         kwbimage_check_params,
 925         kwbimage_verify_header,
 926         kwbimage_print_header,
 927         kwbimage_set_header,
 928         NULL,
 929         kwbimage_check_image_types,
 930         NULL,
 931         kwbimage_generate
 932 );