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