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