tools/kwbimage.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Image manipulator for Marvell SoCs
   4  *  supports Kirkwood, Dove, Armada 370, Armada XP, Armada 375, Armada 38x and
   5  *  Armada 39x
   6  *
   7  * (C) Copyright 2013 Thomas Petazzoni
   8  * <thomas.petazzoni@free-electrons.com>
   9  *
  10  * (C) Copyright 2022 Pali Rohár <pali@kernel.org>
  11  */
  12
  13 #define OPENSSL_API_COMPAT 0x10101000L
  14
  15 #include "imagetool.h"
  16 #include <limits.h>
  17 #include <image.h>
  18 #include <stdarg.h>
  19 #include <stdint.h>
  20 #include "kwbimage.h"
  21
  22 #include <openssl/bn.h>
  23 #include <openssl/rsa.h>
  24 #include <openssl/pem.h>
  25 #include <openssl/err.h>
  26 #include <openssl/evp.h>
  27
  28 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
  29     (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
  30 static void RSA_get0_key(const RSA *r,
  31                  const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
  32 {
  33    if (n != NULL)
  34        *n = r->n;
  35    if (e != NULL)
  36        *e = r->e;
  37    if (d != NULL)
  38        *d = r->d;
  39 }
  40
  41 #elif !defined(LIBRESSL_VERSION_NUMBER)
  42 void EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
  43 {
  44         EVP_MD_CTX_reset(ctx);
  45 }
  46 #endif
  47
  48 /* fls - find last (most-significant) bit set in 4-bit integer */
  49 static inline int fls4(int num)
  50 {
  51         if (num & 0x8)
  52                 return 4;
  53         else if (num & 0x4)
  54                 return 3;
  55         else if (num & 0x2)
  56                 return 2;
  57         else if (num & 0x1)
  58                 return 1;
  59         else
  60                 return 0;
  61 }
  62
  63 static struct image_cfg_element *image_cfg;
  64 static int cfgn;
  65 static int verbose_mode;
  66
  67 struct boot_mode {
  68         unsigned int id;
  69         const char *name;
  70 };
  71
  72 /*
  73  * SHA2-256 hash
  74  */
  75 struct hash_v1 {
  76         uint8_t hash[32];
  77 };
  78
  79 struct boot_mode boot_modes[] = {
  80         { IBR_HDR_I2C_ID, "i2c"  },
  81         { IBR_HDR_SPI_ID, "spi"  },
  82         { IBR_HDR_NAND_ID, "nand" },
  83         { IBR_HDR_SATA_ID, "sata" },
  84         { IBR_HDR_PEX_ID, "pex"  },
  85         { IBR_HDR_UART_ID, "uart" },
  86         { IBR_HDR_SDIO_ID, "sdio" },
  87         {},
  88 };
  89
  90 struct nand_ecc_mode {
  91         unsigned int id;
  92         const char *name;
  93 };
  94
  95 struct nand_ecc_mode nand_ecc_modes[] = {
  96         { IBR_HDR_ECC_DEFAULT, "default" },
  97         { IBR_HDR_ECC_FORCED_HAMMING, "hamming" },
  98         { IBR_HDR_ECC_FORCED_RS, "rs" },
  99         { IBR_HDR_ECC_DISABLED, "disabled" },
 100         {},
 101 };
 102
 103 /* Used to identify an undefined execution or destination address */
 104 #define ADDR_INVALID ((uint32_t)-1)
 105
 106 #define BINARY_MAX_ARGS 255
 107
 108 /* In-memory representation of a line of the configuration file */
 109
 110 enum image_cfg_type {
 111         IMAGE_CFG_VERSION = 0x1,
 112         IMAGE_CFG_BOOT_FROM,
 113         IMAGE_CFG_DEST_ADDR,
 114         IMAGE_CFG_EXEC_ADDR,
 115         IMAGE_CFG_NAND_BLKSZ,
 116         IMAGE_CFG_NAND_BADBLK_LOCATION,
 117         IMAGE_CFG_NAND_ECC_MODE,
 118         IMAGE_CFG_NAND_PAGESZ,
 119         IMAGE_CFG_CPU,
 120         IMAGE_CFG_BINARY,
 121         IMAGE_CFG_DATA,
 122         IMAGE_CFG_DATA_DELAY,
 123         IMAGE_CFG_BAUDRATE,
 124         IMAGE_CFG_UART_PORT,
 125         IMAGE_CFG_UART_MPP,
 126         IMAGE_CFG_DEBUG,
 127         IMAGE_CFG_KAK,
 128         IMAGE_CFG_CSK,
 129         IMAGE_CFG_CSK_INDEX,
 130         IMAGE_CFG_JTAG_DELAY,
 131         IMAGE_CFG_BOX_ID,
 132         IMAGE_CFG_FLASH_ID,
 133         IMAGE_CFG_SEC_COMMON_IMG,
 134         IMAGE_CFG_SEC_SPECIALIZED_IMG,
 135         IMAGE_CFG_SEC_BOOT_DEV,
 136         IMAGE_CFG_SEC_FUSE_DUMP,
 137
 138         IMAGE_CFG_COUNT
 139 } type;
 140
 141 static const char * const id_strs[] = {
 142         [IMAGE_CFG_VERSION] = "VERSION",
 143         [IMAGE_CFG_BOOT_FROM] = "BOOT_FROM",
 144         [IMAGE_CFG_DEST_ADDR] = "DEST_ADDR",
 145         [IMAGE_CFG_EXEC_ADDR] = "EXEC_ADDR",
 146         [IMAGE_CFG_NAND_BLKSZ] = "NAND_BLKSZ",
 147         [IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
 148         [IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
 149         [IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
 150         [IMAGE_CFG_CPU] = "CPU",
 151         [IMAGE_CFG_BINARY] = "BINARY",
 152         [IMAGE_CFG_DATA] = "DATA",
 153         [IMAGE_CFG_DATA_DELAY] = "DATA_DELAY",
 154         [IMAGE_CFG_BAUDRATE] = "BAUDRATE",
 155         [IMAGE_CFG_UART_PORT] = "UART_PORT",
 156         [IMAGE_CFG_UART_MPP] = "UART_MPP",
 157         [IMAGE_CFG_DEBUG] = "DEBUG",
 158         [IMAGE_CFG_KAK] = "KAK",
 159         [IMAGE_CFG_CSK] = "CSK",
 160         [IMAGE_CFG_CSK_INDEX] = "CSK_INDEX",
 161         [IMAGE_CFG_JTAG_DELAY] = "JTAG_DELAY",
 162         [IMAGE_CFG_BOX_ID] = "BOX_ID",
 163         [IMAGE_CFG_FLASH_ID] = "FLASH_ID",
 164         [IMAGE_CFG_SEC_COMMON_IMG] = "SEC_COMMON_IMG",
 165         [IMAGE_CFG_SEC_SPECIALIZED_IMG] = "SEC_SPECIALIZED_IMG",
 166         [IMAGE_CFG_SEC_BOOT_DEV] = "SEC_BOOT_DEV",
 167         [IMAGE_CFG_SEC_FUSE_DUMP] = "SEC_FUSE_DUMP"
 168 };
 169
 170 struct image_cfg_element {
 171         enum image_cfg_type type;
 172         union {
 173                 unsigned int version;
 174                 unsigned int cpu_sheeva;
 175                 unsigned int bootfrom;
 176                 struct {
 177                         const char *file;
 178                         unsigned int loadaddr;
 179                         unsigned int args[BINARY_MAX_ARGS];
 180                         unsigned int nargs;
 181                 } binary;
 182                 unsigned int dstaddr;
 183                 unsigned int execaddr;
 184                 unsigned int nandblksz;
 185                 unsigned int nandbadblklocation;
 186                 unsigned int nandeccmode;
 187                 unsigned int nandpagesz;
 188                 struct ext_hdr_v0_reg regdata;
 189                 unsigned int regdata_delay;
 190                 unsigned int baudrate;
 191                 unsigned int uart_port;
 192                 unsigned int uart_mpp;
 193                 unsigned int debug;
 194                 const char *key_name;
 195                 int csk_idx;
 196                 uint8_t jtag_delay;
 197                 uint32_t boxid;
 198                 uint32_t flashid;
 199                 bool sec_specialized_img;
 200                 unsigned int sec_boot_dev;
 201                 const char *name;
 202         };
 203 };
 204
 205 #define IMAGE_CFG_ELEMENT_MAX 256
 206
 207 /*
 208  * Utility functions to manipulate boot mode and ecc modes (convert
 209  * them back and forth between description strings and the
 210  * corresponding numerical identifiers).
 211  */
 212
 213 static const char *image_boot_mode_name(unsigned int id)
 214 {
 215         int i;
 216
 217         for (i = 0; boot_modes[i].name; i++)
 218                 if (boot_modes[i].id == id)
 219                         return boot_modes[i].name;
 220         return NULL;
 221 }
 222
 223 static int image_boot_mode_id(const char *boot_mode_name)
 224 {
 225         int i;
 226
 227         for (i = 0; boot_modes[i].name; i++)
 228                 if (!strcmp(boot_modes[i].name, boot_mode_name))
 229                         return boot_modes[i].id;
 230
 231         return -1;
 232 }
 233
 234 static const char *image_nand_ecc_mode_name(unsigned int id)
 235 {
 236         int i;
 237
 238         for (i = 0; nand_ecc_modes[i].name; i++)
 239                 if (nand_ecc_modes[i].id == id)
 240                         return nand_ecc_modes[i].name;
 241
 242         return NULL;
 243 }
 244
 245 static int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
 246 {
 247         int i;
 248
 249         for (i = 0; nand_ecc_modes[i].name; i++)
 250                 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
 251                         return nand_ecc_modes[i].id;
 252         return -1;
 253 }
 254
 255 static struct image_cfg_element *
 256 image_find_option(unsigned int optiontype)
 257 {
 258         int i;
 259
 260         for (i = 0; i < cfgn; i++) {
 261                 if (image_cfg[i].type == optiontype)
 262                         return &image_cfg[i];
 263         }
 264
 265         return NULL;
 266 }
 267
 268 static unsigned int
 269 image_count_options(unsigned int optiontype)
 270 {
 271         int i;
 272         unsigned int count = 0;
 273
 274         for (i = 0; i < cfgn; i++)
 275                 if (image_cfg[i].type == optiontype)
 276                         count++;
 277
 278         return count;
 279 }
 280
 281 static int image_get_csk_index(void)
 282 {
 283         struct image_cfg_element *e;
 284
 285         e = image_find_option(IMAGE_CFG_CSK_INDEX);
 286         if (!e)
 287                 return -1;
 288
 289         return e->csk_idx;
 290 }
 291
 292 static bool image_get_spezialized_img(void)
 293 {
 294         struct image_cfg_element *e;
 295
 296         e = image_find_option(IMAGE_CFG_SEC_SPECIALIZED_IMG);
 297         if (!e)
 298                 return false;
 299
 300         return e->sec_specialized_img;
 301 }
 302
 303 static int image_get_bootfrom(void)
 304 {
 305         struct image_cfg_element *e;
 306
 307         e = image_find_option(IMAGE_CFG_BOOT_FROM);
 308         if (!e)
 309                 /* fallback to SPI if no BOOT_FROM is not provided */
 310                 return IBR_HDR_SPI_ID;
 311
 312         return e->bootfrom;
 313 }
 314
 315 static int image_is_cpu_sheeva(void)
 316 {
 317         struct image_cfg_element *e;
 318
 319         e = image_find_option(IMAGE_CFG_CPU);
 320         if (!e)
 321                 return 0;
 322
 323         return e->cpu_sheeva;
 324 }
 325
 326 /*
 327  * Compute a 8-bit checksum of a memory area. This algorithm follows
 328  * the requirements of the Marvell SoC BootROM specifications.
 329  */
 330 static uint8_t image_checksum8(void *start, uint32_t len)
 331 {
 332         uint8_t csum = 0;
 333         uint8_t *p = start;
 334
 335         /* check len and return zero checksum if invalid */
 336         if (!len)
 337                 return 0;
 338
 339         do {
 340                 csum += *p;
 341                 p++;
 342         } while (--len);
 343
 344         return csum;
 345 }
 346
 347 /*
 348  * Verify checksum over a complete header that includes the checksum field.
 349  * Return 1 when OK, otherwise 0.
 350  */
 351 static int main_hdr_checksum_ok(void *hdr)
 352 {
 353         /* Offsets of checksum in v0 and v1 headers are the same */
 354         struct main_hdr_v0 *main_hdr = (struct main_hdr_v0 *)hdr;
 355         uint8_t checksum;
 356
 357         checksum = image_checksum8(hdr, kwbheader_size_for_csum(hdr));
 358         /* Calculated checksum includes the header checksum field. Compensate
 359          * for that.
 360          */
 361         checksum -= main_hdr->checksum;
 362
 363         return checksum == main_hdr->checksum;
 364 }
 365
 366 static uint32_t image_checksum32(void *start, uint32_t len)
 367 {
 368         uint32_t csum = 0;
 369         uint32_t *p = start;
 370
 371         /* check len and return zero checksum if invalid */
 372         if (!len)
 373                 return 0;
 374
 375         if (len % sizeof(uint32_t)) {
 376                 fprintf(stderr, "Length %d is not in multiple of %zu\n",
 377                         len, sizeof(uint32_t));
 378                 return 0;
 379         }
 380
 381         do {
 382                 csum += *p;
 383                 p++;
 384                 len -= sizeof(uint32_t);
 385         } while (len > 0);
 386
 387         return csum;
 388 }
 389
 390 static unsigned int options_to_baudrate(uint8_t options)
 391 {
 392         switch (options & 0x7) {
 393         case MAIN_HDR_V1_OPT_BAUD_2400:
 394                 return 2400;
 395         case MAIN_HDR_V1_OPT_BAUD_4800:
 396                 return 4800;
 397         case MAIN_HDR_V1_OPT_BAUD_9600:
 398                 return 9600;
 399         case MAIN_HDR_V1_OPT_BAUD_19200:
 400                 return 19200;
 401         case MAIN_HDR_V1_OPT_BAUD_38400:
 402                 return 38400;
 403         case MAIN_HDR_V1_OPT_BAUD_57600:
 404                 return 57600;
 405         case MAIN_HDR_V1_OPT_BAUD_115200:
 406                 return 115200;
 407         case MAIN_HDR_V1_OPT_BAUD_DEFAULT:
 408         default:
 409                 return 0;
 410         }
 411 }
 412
 413 static uint8_t baudrate_to_option(unsigned int baudrate)
 414 {
 415         switch (baudrate) {
 416         case 2400:
 417                 return MAIN_HDR_V1_OPT_BAUD_2400;
 418         case 4800:
 419                 return MAIN_HDR_V1_OPT_BAUD_4800;
 420         case 9600:
 421                 return MAIN_HDR_V1_OPT_BAUD_9600;
 422         case 19200:
 423                 return MAIN_HDR_V1_OPT_BAUD_19200;
 424         case 38400:
 425                 return MAIN_HDR_V1_OPT_BAUD_38400;
 426         case 57600:
 427                 return MAIN_HDR_V1_OPT_BAUD_57600;
 428         case 115200:
 429                 return MAIN_HDR_V1_OPT_BAUD_115200;
 430         default:
 431                 return MAIN_HDR_V1_OPT_BAUD_DEFAULT;
 432         }
 433 }
 434
 435 static void kwb_msg(const char *fmt, ...)
 436 {
 437         if (verbose_mode) {
 438                 va_list ap;
 439
 440                 va_start(ap, fmt);
 441                 vfprintf(stdout, fmt, ap);
 442                 va_end(ap);
 443         }
 444 }
 445
 446 static int openssl_err(const char *msg)
 447 {
 448         unsigned long ssl_err = ERR_get_error();
 449
 450         fprintf(stderr, "%s", msg);
 451         fprintf(stderr, ": %s\n",
 452                 ERR_error_string(ssl_err, 0));
 453
 454         return -1;
 455 }
 456
 457 static int kwb_load_rsa_key(const char *keydir, const char *name, RSA **p_rsa)
 458 {
 459         char path[PATH_MAX];
 460         RSA *rsa;
 461         FILE *f;
 462
 463         if (!keydir)
 464                 keydir = ".";
 465
 466         snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
 467         f = fopen(path, "r");
 468         if (!f) {
 469                 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
 470                         path, strerror(errno));
 471                 return -ENOENT;
 472         }
 473
 474         rsa = PEM_read_RSAPrivateKey(f, 0, NULL, "");
 475         if (!rsa) {
 476                 openssl_err("Failure reading private key");
 477                 fclose(f);
 478                 return -EPROTO;
 479         }
 480         fclose(f);
 481         *p_rsa = rsa;
 482
 483         return 0;
 484 }
 485
 486 static int kwb_load_cfg_key(struct image_tool_params *params,
 487                             unsigned int cfg_option, const char *key_name,
 488                             RSA **p_key)
 489 {
 490         struct image_cfg_element *e_key;
 491         RSA *key;
 492         int res;
 493
 494         *p_key = NULL;
 495
 496         e_key = image_find_option(cfg_option);
 497         if (!e_key) {
 498                 fprintf(stderr, "%s not configured\n", key_name);
 499                 return -ENOENT;
 500         }
 501
 502         res = kwb_load_rsa_key(params->keydir, e_key->key_name, &key);
 503         if (res < 0) {
 504                 fprintf(stderr, "Failed to load %s\n", key_name);
 505                 return -ENOENT;
 506         }
 507
 508         *p_key = key;
 509
 510         return 0;
 511 }
 512
 513 static int kwb_load_kak(struct image_tool_params *params, RSA **p_kak)
 514 {
 515         return kwb_load_cfg_key(params, IMAGE_CFG_KAK, "KAK", p_kak);
 516 }
 517
 518 static int kwb_load_csk(struct image_tool_params *params, RSA **p_csk)
 519 {
 520         return kwb_load_cfg_key(params, IMAGE_CFG_CSK, "CSK", p_csk);
 521 }
 522
 523 static int kwb_compute_pubkey_hash(struct pubkey_der_v1 *pk,
 524                                    struct hash_v1 *hash)
 525 {
 526         EVP_MD_CTX *ctx;
 527         unsigned int key_size;
 528         unsigned int hash_size;
 529         int ret = 0;
 530
 531         if (!pk || !hash || pk->key[0] != 0x30 || pk->key[1] != 0x82)
 532                 return -EINVAL;
 533
 534         key_size = (pk->key[2] << 8) + pk->key[3] + 4;
 535
 536         ctx = EVP_MD_CTX_create();
 537         if (!ctx)
 538                 return openssl_err("EVP context creation failed");
 539
 540         EVP_MD_CTX_init(ctx);
 541         if (!EVP_DigestInit(ctx, EVP_sha256())) {
 542                 ret = openssl_err("Digest setup failed");
 543                 goto hash_err_ctx;
 544         }
 545
 546         if (!EVP_DigestUpdate(ctx, pk->key, key_size)) {
 547                 ret = openssl_err("Hashing data failed");
 548                 goto hash_err_ctx;
 549         }
 550
 551         if (!EVP_DigestFinal(ctx, hash->hash, &hash_size)) {
 552                 ret = openssl_err("Could not obtain hash");
 553                 goto hash_err_ctx;
 554         }
 555
 556         EVP_MD_CTX_cleanup(ctx);
 557
 558 hash_err_ctx:
 559         EVP_MD_CTX_destroy(ctx);
 560         return ret;
 561 }
 562
 563 static int kwb_import_pubkey(RSA **key, struct pubkey_der_v1 *src, char *keyname)
 564 {
 565         RSA *rsa;
 566         const unsigned char *ptr;
 567
 568         if (!key || !src)
 569                 goto fail;
 570
 571         ptr = src->key;
 572         rsa = d2i_RSAPublicKey(key, &ptr, sizeof(src->key));
 573         if (!rsa) {
 574                 openssl_err("error decoding public key");
 575                 goto fail;
 576         }
 577
 578         return 0;
 579 fail:
 580         fprintf(stderr, "Failed to decode %s pubkey\n", keyname);
 581         return -EINVAL;
 582 }
 583
 584 static int kwb_export_pubkey(RSA *key, struct pubkey_der_v1 *dst, FILE *hashf,
 585                              char *keyname)
 586 {
 587         int size_exp, size_mod, size_seq;
 588         const BIGNUM *key_e, *key_n;
 589         uint8_t *cur;
 590         char *errmsg = "Failed to encode %s\n";
 591
 592         RSA_get0_key(key, NULL, &key_e, NULL);
 593         RSA_get0_key(key, &key_n, NULL, NULL);
 594
 595         if (!key || !key_e || !key_n || !dst) {
 596                 fprintf(stderr, "export pk failed: (%p, %p, %p, %p)",
 597                         key, key_e, key_n, dst);
 598                 fprintf(stderr, errmsg, keyname);
 599                 return -EINVAL;
 600         }
 601
 602         /*
 603          * According to the specs, the key should be PKCS#1 DER encoded.
 604          * But unfortunately the really required encoding seems to be different;
 605          * it violates DER...! (But it still conformes to BER.)
 606          * (Length always in long form w/ 2 byte length code; no leading zero
 607          * when MSB of first byte is set...)
 608          * So we cannot use the encoding func provided by OpenSSL and have to
 609          * do the encoding manually.
 610          */
 611
 612         size_exp = BN_num_bytes(key_e);
 613         size_mod = BN_num_bytes(key_n);
 614         size_seq = 4 + size_mod + 4 + size_exp;
 615
 616         if (size_mod > 256) {
 617                 fprintf(stderr, "export pk failed: wrong mod size: %d\n",
 618                         size_mod);
 619                 fprintf(stderr, errmsg, keyname);
 620                 return -EINVAL;
 621         }
 622
 623         if (4 + size_seq > sizeof(dst->key)) {
 624                 fprintf(stderr, "export pk failed: seq too large (%d, %zu)\n",
 625                         4 + size_seq, sizeof(dst->key));
 626                 fprintf(stderr, errmsg, keyname);
 627                 return -ENOBUFS;
 628         }
 629
 630         cur = dst->key;
 631
 632         /* PKCS#1 (RFC3447) RSAPublicKey structure */
 633         *cur++ = 0x30;          /* SEQUENCE */
 634         *cur++ = 0x82;
 635         *cur++ = (size_seq >> 8) & 0xFF;
 636         *cur++ = size_seq & 0xFF;
 637         /* Modulus */
 638         *cur++ = 0x02;          /* INTEGER */
 639         *cur++ = 0x82;
 640         *cur++ = (size_mod >> 8) & 0xFF;
 641         *cur++ = size_mod & 0xFF;
 642         BN_bn2bin(key_n, cur);
 643         cur += size_mod;
 644         /* Exponent */
 645         *cur++ = 0x02;          /* INTEGER */
 646         *cur++ = 0x82;
 647         *cur++ = (size_exp >> 8) & 0xFF;
 648         *cur++ = size_exp & 0xFF;
 649         BN_bn2bin(key_e, cur);
 650
 651         if (hashf) {
 652                 struct hash_v1 pk_hash;
 653                 int i;
 654                 int ret = 0;
 655
 656                 ret = kwb_compute_pubkey_hash(dst, &pk_hash);
 657                 if (ret < 0) {
 658                         fprintf(stderr, errmsg, keyname);
 659                         return ret;
 660                 }
 661
 662                 fprintf(hashf, "SHA256 = ");
 663                 for (i = 0 ; i < sizeof(pk_hash.hash); ++i)
 664                         fprintf(hashf, "%02X", pk_hash.hash[i]);
 665                 fprintf(hashf, "\n");
 666         }
 667
 668         return 0;
 669 }
 670
 671 static int kwb_sign(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 672                     char *signame)
 673 {
 674         EVP_PKEY *evp_key;
 675         EVP_MD_CTX *ctx;
 676         unsigned int sig_size;
 677         int size;
 678         int ret = 0;
 679
 680         evp_key = EVP_PKEY_new();
 681         if (!evp_key)
 682                 return openssl_err("EVP_PKEY object creation failed");
 683
 684         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 685                 ret = openssl_err("EVP key setup failed");
 686                 goto err_key;
 687         }
 688
 689         size = EVP_PKEY_size(evp_key);
 690         if (size > sizeof(sig->sig)) {
 691                 fprintf(stderr, "Buffer to small for signature (%d bytes)\n",
 692                         size);
 693                 ret = -ENOBUFS;
 694                 goto err_key;
 695         }
 696
 697         ctx = EVP_MD_CTX_create();
 698         if (!ctx) {
 699                 ret = openssl_err("EVP context creation failed");
 700                 goto err_key;
 701         }
 702         EVP_MD_CTX_init(ctx);
 703         if (!EVP_SignInit(ctx, EVP_sha256())) {
 704                 ret = openssl_err("Signer setup failed");
 705                 goto err_ctx;
 706         }
 707
 708         if (!EVP_SignUpdate(ctx, data, datasz)) {
 709                 ret = openssl_err("Signing data failed");
 710                 goto err_ctx;
 711         }
 712
 713         if (!EVP_SignFinal(ctx, sig->sig, &sig_size, evp_key)) {
 714                 ret = openssl_err("Could not obtain signature");
 715                 goto err_ctx;
 716         }
 717
 718         EVP_MD_CTX_cleanup(ctx);
 719         EVP_MD_CTX_destroy(ctx);
 720         EVP_PKEY_free(evp_key);
 721
 722         return 0;
 723
 724 err_ctx:
 725         EVP_MD_CTX_destroy(ctx);
 726 err_key:
 727         EVP_PKEY_free(evp_key);
 728         fprintf(stderr, "Failed to create %s signature\n", signame);
 729         return ret;
 730 }
 731
 732 static int kwb_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 733                       char *signame)
 734 {
 735         EVP_PKEY *evp_key;
 736         EVP_MD_CTX *ctx;
 737         int size;
 738         int ret = 0;
 739
 740         evp_key = EVP_PKEY_new();
 741         if (!evp_key)
 742                 return openssl_err("EVP_PKEY object creation failed");
 743
 744         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 745                 ret = openssl_err("EVP key setup failed");
 746                 goto err_key;
 747         }
 748
 749         size = EVP_PKEY_size(evp_key);
 750         if (size > sizeof(sig->sig)) {
 751                 fprintf(stderr, "Invalid signature size (%d bytes)\n",
 752                         size);
 753                 ret = -EINVAL;
 754                 goto err_key;
 755         }
 756
 757         ctx = EVP_MD_CTX_create();
 758         if (!ctx) {
 759                 ret = openssl_err("EVP context creation failed");
 760                 goto err_key;
 761         }
 762         EVP_MD_CTX_init(ctx);
 763         if (!EVP_VerifyInit(ctx, EVP_sha256())) {
 764                 ret = openssl_err("Verifier setup failed");
 765                 goto err_ctx;
 766         }
 767
 768         if (!EVP_VerifyUpdate(ctx, data, datasz)) {
 769                 ret = openssl_err("Hashing data failed");
 770                 goto err_ctx;
 771         }
 772
 773         if (EVP_VerifyFinal(ctx, sig->sig, sizeof(sig->sig), evp_key) != 1) {
 774                 ret = openssl_err("Could not verify signature");
 775                 goto err_ctx;
 776         }
 777
 778         EVP_MD_CTX_cleanup(ctx);
 779         EVP_MD_CTX_destroy(ctx);
 780         EVP_PKEY_free(evp_key);
 781
 782         return 0;
 783
 784 err_ctx:
 785         EVP_MD_CTX_destroy(ctx);
 786 err_key:
 787         EVP_PKEY_free(evp_key);
 788         fprintf(stderr, "Failed to verify %s signature\n", signame);
 789         return ret;
 790 }
 791
 792 static int kwb_sign_and_verify(RSA *key, void *data, int datasz,
 793                                struct sig_v1 *sig, char *signame)
 794 {
 795         if (kwb_sign(key, data, datasz, sig, signame) < 0)
 796                 return -1;
 797
 798         if (kwb_verify(key, data, datasz, sig, signame) < 0)
 799                 return -1;
 800
 801         return 0;
 802 }
 803
 804
 805 static int kwb_dump_fuse_cmds_38x(FILE *out, struct secure_hdr_v1 *sec_hdr)
 806 {
 807         struct hash_v1 kak_pub_hash;
 808         struct image_cfg_element *e;
 809         unsigned int fuse_line;
 810         int i, idx;
 811         uint8_t *ptr;
 812         uint32_t val;
 813         int ret = 0;
 814
 815         if (!out || !sec_hdr)
 816                 return -EINVAL;
 817
 818         ret = kwb_compute_pubkey_hash(&sec_hdr->kak, &kak_pub_hash);
 819         if (ret < 0)
 820                 goto done;
 821
 822         fprintf(out, "# burn KAK pub key hash\n");
 823         ptr = kak_pub_hash.hash;
 824         for (fuse_line = 26; fuse_line <= 30; ++fuse_line) {
 825                 fprintf(out, "fuse prog -y %u 0 ", fuse_line);
 826
 827                 for (i = 4; i-- > 0;)
 828                         fprintf(out, "%02hx", (ushort)ptr[i]);
 829                 ptr += 4;
 830                 fprintf(out, " 00");
 831
 832                 if (fuse_line < 30) {
 833                         for (i = 3; i-- > 0;)
 834                                 fprintf(out, "%02hx", (ushort)ptr[i]);
 835                         ptr += 3;
 836                 } else {
 837                         fprintf(out, "000000");
 838                 }
 839
 840                 fprintf(out, " 1\n");
 841         }
 842
 843         fprintf(out, "# burn CSK selection\n");
 844
 845         idx = image_get_csk_index();
 846         if (idx < 0 || idx > 15) {
 847                 ret = -EINVAL;
 848                 goto done;
 849         }
 850         if (idx > 0) {
 851                 for (fuse_line = 31; fuse_line < 31 + idx; ++fuse_line)
 852                         fprintf(out, "fuse prog -y %u 0 00000001 00000000 1\n",
 853                                 fuse_line);
 854         } else {
 855                 fprintf(out, "# CSK index is 0; no mods needed\n");
 856         }
 857
 858         e = image_find_option(IMAGE_CFG_BOX_ID);
 859         if (e) {
 860                 fprintf(out, "# set box ID\n");
 861                 fprintf(out, "fuse prog -y 48 0 %08x 00000000 1\n", e->boxid);
 862         }
 863
 864         e = image_find_option(IMAGE_CFG_FLASH_ID);
 865         if (e) {
 866                 fprintf(out, "# set flash ID\n");
 867                 fprintf(out, "fuse prog -y 47 0 %08x 00000000 1\n", e->flashid);
 868         }
 869
 870         fprintf(out, "# enable secure mode ");
 871         fprintf(out, "(must be the last fuse line written)\n");
 872
 873         val = 1;
 874         e = image_find_option(IMAGE_CFG_SEC_BOOT_DEV);
 875         if (!e) {
 876                 fprintf(stderr, "ERROR: secured mode boot device not given\n");
 877                 ret = -EINVAL;
 878                 goto done;
 879         }
 880
 881         if (e->sec_boot_dev > 0xff) {
 882                 fprintf(stderr, "ERROR: secured mode boot device invalid\n");
 883                 ret = -EINVAL;
 884                 goto done;
 885         }
 886
 887         val |= (e->sec_boot_dev << 8);
 888
 889         fprintf(out, "fuse prog -y 24 0 %08x 0103e0a9 1\n", val);
 890
 891         fprintf(out, "# lock (unused) fuse lines (0-23)s\n");
 892         for (fuse_line = 0; fuse_line < 24; ++fuse_line)
 893                 fprintf(out, "fuse prog -y %u 2 1\n", fuse_line);
 894
 895         fprintf(out, "# OK, that's all :-)\n");
 896
 897 done:
 898         return ret;
 899 }
 900
 901 static int kwb_dump_fuse_cmds(struct secure_hdr_v1 *sec_hdr)
 902 {
 903         int ret = 0;
 904         struct image_cfg_element *e;
 905
 906         e = image_find_option(IMAGE_CFG_SEC_FUSE_DUMP);
 907         if (!e)
 908                 return 0;
 909
 910         if (!strcmp(e->name, "a38x")) {
 911                 FILE *out = fopen("kwb_fuses_a38x.txt", "w+");
 912
 913                 if (!out) {
 914                         fprintf(stderr, "Couldn't open eFuse settings: '%s': %s\n",
 915                                 "kwb_fuses_a38x.txt", strerror(errno));
 916                         return -ENOENT;
 917                 }
 918
 919                 kwb_dump_fuse_cmds_38x(out, sec_hdr);
 920                 fclose(out);
 921                 goto done;
 922         }
 923
 924         ret = -ENOSYS;
 925
 926 done:
 927         return ret;
 928 }
 929
 930 static size_t image_headersz_align(size_t headersz, uint8_t blockid)
 931 {
 932         /*
 933          * Header needs to be 4-byte aligned, which is already ensured by code
 934          * above. Moreover UART images must have header aligned to 128 bytes
 935          * (xmodem block size), NAND images to 256 bytes (ECC calculation),
 936          * and SATA and SDIO images to 512 bytes (storage block size).
 937          * Note that SPI images do not have to have header size aligned
 938          * to 256 bytes because it is possible to read from SPI storage from
 939          * any offset (read offset does not have to be aligned to block size).
 940          */
 941         if (blockid == IBR_HDR_UART_ID)
 942                 return ALIGN(headersz, 128);
 943         else if (blockid == IBR_HDR_NAND_ID)
 944                 return ALIGN(headersz, 256);
 945         else if (blockid == IBR_HDR_SATA_ID || blockid == IBR_HDR_SDIO_ID)
 946                 return ALIGN(headersz, 512);
 947         else
 948                 return headersz;
 949 }
 950
 951 static size_t image_headersz_v0(int *hasext)
 952 {
 953         size_t headersz;
 954
 955         headersz = sizeof(struct main_hdr_v0);
 956         if (image_count_options(IMAGE_CFG_DATA) > 0) {
 957                 headersz += sizeof(struct ext_hdr_v0);
 958                 if (hasext)
 959                         *hasext = 1;
 960         }
 961
 962         return image_headersz_align(headersz, image_get_bootfrom());
 963 }
 964
 965 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
 966                              int payloadsz)
 967 {
 968         struct image_cfg_element *e;
 969         size_t headersz;
 970         struct main_hdr_v0 *main_hdr;
 971         uint8_t *image;
 972         int has_ext = 0;
 973
 974         /*
 975          * Calculate the size of the header and the size of the
 976          * payload
 977          */
 978         headersz = image_headersz_v0(&has_ext);
 979
 980         image = malloc(headersz);
 981         if (!image) {
 982                 fprintf(stderr, "Cannot allocate memory for image\n");
 983                 return NULL;
 984         }
 985
 986         memset(image, 0, headersz);
 987
 988         main_hdr = (struct main_hdr_v0 *)image;
 989
 990         /* Fill in the main header */
 991         main_hdr->blocksize =
 992                 cpu_to_le32(payloadsz);
 993         main_hdr->srcaddr   = cpu_to_le32(headersz);
 994         main_hdr->ext       = has_ext;
 995         main_hdr->version   = 0;
 996         main_hdr->destaddr  = cpu_to_le32(params->addr);
 997         main_hdr->execaddr  = cpu_to_le32(params->ep);
 998         main_hdr->blockid   = image_get_bootfrom();
 999
1000         e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
1001         if (e)
1002                 main_hdr->nandeccmode = e->nandeccmode;
1003         e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1004         if (e)
1005                 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1006         e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
1007         if (e)
1008                 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
1009         e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1010         if (e)
1011                 main_hdr->nandbadblklocation = e->nandbadblklocation;
1012         main_hdr->checksum = image_checksum8(image,
1013                                              sizeof(struct main_hdr_v0));
1014
1015         /*
1016          * For SATA srcaddr is specified in number of sectors.
1017          * This expects the sector size to be 512 bytes.
1018          * Header size is already aligned.
1019          */
1020         if (main_hdr->blockid == IBR_HDR_SATA_ID)
1021                 main_hdr->srcaddr = cpu_to_le32(headersz / 512);
1022
1023         /* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
1024         if (main_hdr->blockid == IBR_HDR_PEX_ID)
1025                 main_hdr->srcaddr = cpu_to_le32(0xFFFFFFFF);
1026
1027         /* Generate the ext header */
1028         if (has_ext) {
1029                 struct ext_hdr_v0 *ext_hdr;
1030                 int cfgi, datai;
1031
1032                 ext_hdr = (struct ext_hdr_v0 *)
1033                                 (image + sizeof(struct main_hdr_v0));
1034                 ext_hdr->offset = cpu_to_le32(0x40);
1035
1036                 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
1037                         e = &image_cfg[cfgi];
1038                         if (e->type != IMAGE_CFG_DATA)
1039                                 continue;
1040
1041                         ext_hdr->rcfg[datai].raddr =
1042                                 cpu_to_le32(e->regdata.raddr);
1043                         ext_hdr->rcfg[datai].rdata =
1044                                 cpu_to_le32(e->regdata.rdata);
1045                         datai++;
1046                 }
1047
1048                 ext_hdr->checksum = image_checksum8(ext_hdr,
1049                                                     sizeof(struct ext_hdr_v0));
1050         }
1051
1052         *imagesz = headersz;
1053         return image;
1054 }
1055
1056 static size_t image_headersz_v1(int *hasext)
1057 {
1058         struct image_cfg_element *e;
1059         unsigned int count;
1060         size_t headersz;
1061         int cpu_sheeva;
1062         struct stat s;
1063         int cfgi;
1064         int ret;
1065
1066         /*
1067          * Calculate the size of the header and the size of the
1068          * payload
1069          */
1070         headersz = sizeof(struct main_hdr_v1);
1071
1072         if (image_get_csk_index() >= 0) {
1073                 headersz += sizeof(struct secure_hdr_v1);
1074                 if (hasext)
1075                         *hasext = 1;
1076         }
1077
1078         cpu_sheeva = image_is_cpu_sheeva();
1079
1080         count = 0;
1081         for (cfgi = 0; cfgi < cfgn; cfgi++) {
1082                 e = &image_cfg[cfgi];
1083
1084                 if (e->type == IMAGE_CFG_DATA)
1085                         count++;
1086
1087                 if (e->type == IMAGE_CFG_DATA_DELAY ||
1088                     (e->type == IMAGE_CFG_BINARY && count > 0)) {
1089                         headersz += sizeof(struct register_set_hdr_v1) + 8 * count + 4;
1090                         count = 0;
1091                 }
1092
1093                 if (e->type != IMAGE_CFG_BINARY)
1094                         continue;
1095
1096                 ret = stat(e->binary.file, &s);
1097                 if (ret < 0) {
1098                         char cwd[PATH_MAX];
1099                         char *dir = cwd;
1100
1101                         memset(cwd, 0, sizeof(cwd));
1102                         if (!getcwd(cwd, sizeof(cwd))) {
1103                                 dir = "current working directory";
1104                                 perror("getcwd() failed");
1105                         }
1106
1107                         fprintf(stderr,
1108                                 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
1109                                 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
1110                                 "image for your board. Use 'dumpimage -T kwbimage -p 1' to extract it from an existing image.\n",
1111                                 e->binary.file, dir);
1112                         return 0;
1113                 }
1114
1115                 headersz += sizeof(struct opt_hdr_v1) + sizeof(uint32_t) +
1116                         (e->binary.nargs) * sizeof(uint32_t);
1117
1118                 if (e->binary.loadaddr) {
1119                         /*
1120                          * BootROM loads kwbimage header (in which the
1121                          * executable code is also stored) to address
1122                          * 0x40004000 or 0x40000000. Thus there is
1123                          * restriction for the load address of the N-th
1124                          * BINARY image.
1125                          */
1126                         unsigned int base_addr, low_addr, high_addr;
1127
1128                         base_addr = cpu_sheeva ? 0x40004000 : 0x40000000;
1129                         low_addr = base_addr + headersz;
1130                         high_addr = low_addr +
1131                                     (BINARY_MAX_ARGS - e->binary.nargs) * sizeof(uint32_t);
1132
1133                         if (cpu_sheeva && e->binary.loadaddr % 16) {
1134                                 fprintf(stderr,
1135                                         "Invalid LOAD_ADDRESS 0x%08x for BINARY %s with %d args.\n"
1136                                         "Address for CPU SHEEVA must be 16-byte aligned.\n",
1137                                         e->binary.loadaddr, e->binary.file, e->binary.nargs);
1138                                 return 0;
1139                         }
1140
1141                         if (e->binary.loadaddr % 4 || e->binary.loadaddr < low_addr ||
1142                             e->binary.loadaddr > high_addr) {
1143                                 fprintf(stderr,
1144                                         "Invalid LOAD_ADDRESS 0x%08x for BINARY %s with %d args.\n"
1145                                         "Address must be 4-byte aligned and in range 0x%08x-0x%08x.\n",
1146                                         e->binary.loadaddr, e->binary.file,
1147                                         e->binary.nargs, low_addr, high_addr);
1148                                 return 0;
1149                         }
1150                         headersz = e->binary.loadaddr - base_addr;
1151                 } else if (cpu_sheeva) {
1152                         headersz = ALIGN(headersz, 16);
1153                 } else {
1154                         headersz = ALIGN(headersz, 4);
1155                 }
1156
1157                 headersz += ALIGN(s.st_size, 4) + sizeof(uint32_t);
1158                 if (hasext)
1159                         *hasext = 1;
1160         }
1161
1162         if (count > 0)
1163                 headersz += sizeof(struct register_set_hdr_v1) + 8 * count + 4;
1164
1165         return image_headersz_align(headersz, image_get_bootfrom());
1166 }
1167
1168 static int add_binary_header_v1(uint8_t **cur, uint8_t **next_ext,
1169                                 struct image_cfg_element *binarye,
1170                                 struct main_hdr_v1 *main_hdr)
1171 {
1172         struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)*cur;
1173         uint32_t base_addr;
1174         uint32_t add_args;
1175         uint32_t offset;
1176         uint32_t *args;
1177         size_t binhdrsz;
1178         int cpu_sheeva;
1179         struct stat s;
1180         int argi;
1181         FILE *bin;
1182         int ret;
1183
1184         hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
1185
1186         bin = fopen(binarye->binary.file, "r");
1187         if (!bin) {
1188                 fprintf(stderr, "Cannot open binary file %s\n",
1189                         binarye->binary.file);
1190                 return -1;
1191         }
1192
1193         if (fstat(fileno(bin), &s)) {
1194                 fprintf(stderr, "Cannot stat binary file %s\n",
1195                         binarye->binary.file);
1196                 goto err_close;
1197         }
1198
1199         *cur += sizeof(struct opt_hdr_v1);
1200
1201         args = (uint32_t *)*cur;
1202         *args = cpu_to_le32(binarye->binary.nargs);
1203         args++;
1204         for (argi = 0; argi < binarye->binary.nargs; argi++)
1205                 args[argi] = cpu_to_le32(binarye->binary.args[argi]);
1206
1207         *cur += (binarye->binary.nargs + 1) * sizeof(uint32_t);
1208
1209         /*
1210          * ARM executable code inside the BIN header on platforms with Sheeva
1211          * CPU (A370 and AXP) must always be aligned with the 128-bit boundary.
1212          * In the case when this code is not position independent (e.g. ARM
1213          * SPL), it must be placed at fixed load and execute address.
1214          * This requirement can be met by inserting dummy arguments into
1215          * BIN header, if needed.
1216          */
1217         cpu_sheeva = image_is_cpu_sheeva();
1218         base_addr = cpu_sheeva ? 0x40004000 : 0x40000000;
1219         offset = *cur - (uint8_t *)main_hdr;
1220         if (binarye->binary.loadaddr)
1221                 add_args = (binarye->binary.loadaddr - base_addr - offset) / sizeof(uint32_t);
1222         else if (cpu_sheeva)
1223                 add_args = ((16 - offset % 16) % 16) / sizeof(uint32_t);
1224         else
1225                 add_args = 0;
1226         if (add_args) {
1227                 *(args - 1) = cpu_to_le32(binarye->binary.nargs + add_args);
1228                 *cur += add_args * sizeof(uint32_t);
1229         }
1230
1231         ret = fread(*cur, s.st_size, 1, bin);
1232         if (ret != 1) {
1233                 fprintf(stderr,
1234                         "Could not read binary image %s\n",
1235                         binarye->binary.file);
1236                 goto err_close;
1237         }
1238
1239         fclose(bin);
1240
1241         *cur += ALIGN(s.st_size, 4);
1242
1243         *((uint32_t *)*cur) = 0x00000000;
1244         **next_ext = 1;
1245         *next_ext = *cur;
1246
1247         *cur += sizeof(uint32_t);
1248
1249         binhdrsz = sizeof(struct opt_hdr_v1) +
1250                 (binarye->binary.nargs + add_args + 2) * sizeof(uint32_t) +
1251                 ALIGN(s.st_size, 4);
1252         hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF);
1253         hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
1254
1255         return 0;
1256
1257 err_close:
1258         fclose(bin);
1259
1260         return -1;
1261 }
1262
1263 static int export_pub_kak_hash(RSA *kak, struct secure_hdr_v1 *secure_hdr)
1264 {
1265         FILE *hashf;
1266         int res;
1267
1268         hashf = fopen("pub_kak_hash.txt", "w");
1269         if (!hashf) {
1270                 fprintf(stderr, "Couldn't open hash file: '%s': %s\n",
1271                         "pub_kak_hash.txt", strerror(errno));
1272                 return 1;
1273         }
1274
1275         res = kwb_export_pubkey(kak, &secure_hdr->kak, hashf, "KAK");
1276
1277         fclose(hashf);
1278
1279         return res < 0 ? 1 : 0;
1280 }
1281
1282 static int kwb_sign_csk_with_kak(struct image_tool_params *params,
1283                                  struct secure_hdr_v1 *secure_hdr, RSA *csk)
1284 {
1285         RSA *kak = NULL;
1286         RSA *kak_pub = NULL;
1287         int csk_idx = image_get_csk_index();
1288         struct sig_v1 tmp_sig;
1289
1290         if (csk_idx < 0 || csk_idx > 15) {
1291                 fprintf(stderr, "Invalid CSK index %d\n", csk_idx);
1292                 return 1;
1293         }
1294
1295         if (kwb_load_kak(params, &kak) < 0)
1296                 return 1;
1297
1298         if (export_pub_kak_hash(kak, secure_hdr))
1299                 return 1;
1300
1301         if (kwb_import_pubkey(&kak_pub, &secure_hdr->kak, "KAK") < 0)
1302                 return 1;
1303
1304         if (kwb_export_pubkey(csk, &secure_hdr->csk[csk_idx], NULL, "CSK") < 0)
1305                 return 1;
1306
1307         if (kwb_sign_and_verify(kak, &secure_hdr->csk,
1308                                 sizeof(secure_hdr->csk) +
1309                                 sizeof(secure_hdr->csksig),
1310                                 &tmp_sig, "CSK") < 0)
1311                 return 1;
1312
1313         if (kwb_verify(kak_pub, &secure_hdr->csk,
1314                        sizeof(secure_hdr->csk) +
1315                        sizeof(secure_hdr->csksig),
1316                        &tmp_sig, "CSK (2)") < 0)
1317                 return 1;
1318
1319         secure_hdr->csksig = tmp_sig;
1320
1321         return 0;
1322 }
1323
1324 static int add_secure_header_v1(struct image_tool_params *params, uint8_t *ptr,
1325                                 int payloadsz, size_t headersz, uint8_t *image,
1326                                 struct secure_hdr_v1 *secure_hdr)
1327 {
1328         struct image_cfg_element *e_jtagdelay;
1329         struct image_cfg_element *e_boxid;
1330         struct image_cfg_element *e_flashid;
1331         RSA *csk = NULL;
1332         unsigned char *image_ptr;
1333         size_t image_size;
1334         struct sig_v1 tmp_sig;
1335         bool specialized_img = image_get_spezialized_img();
1336
1337         kwb_msg("Create secure header content\n");
1338
1339         e_jtagdelay = image_find_option(IMAGE_CFG_JTAG_DELAY);
1340         e_boxid = image_find_option(IMAGE_CFG_BOX_ID);
1341         e_flashid = image_find_option(IMAGE_CFG_FLASH_ID);
1342
1343         if (kwb_load_csk(params, &csk) < 0)
1344                 return 1;
1345
1346         secure_hdr->headertype = OPT_HDR_V1_SECURE_TYPE;
1347         secure_hdr->headersz_msb = 0;
1348         secure_hdr->headersz_lsb = cpu_to_le16(sizeof(struct secure_hdr_v1));
1349         if (e_jtagdelay)
1350                 secure_hdr->jtag_delay = e_jtagdelay->jtag_delay;
1351         if (e_boxid && specialized_img)
1352                 secure_hdr->boxid = cpu_to_le32(e_boxid->boxid);
1353         if (e_flashid && specialized_img)
1354                 secure_hdr->flashid = cpu_to_le32(e_flashid->flashid);
1355
1356         if (kwb_sign_csk_with_kak(params, secure_hdr, csk))
1357                 return 1;
1358
1359         image_ptr = ptr + headersz;
1360         image_size = payloadsz - headersz;
1361
1362         if (kwb_sign_and_verify(csk, image_ptr, image_size,
1363                                 &secure_hdr->imgsig, "image") < 0)
1364                 return 1;
1365
1366         if (kwb_sign_and_verify(csk, image, headersz, &tmp_sig, "header") < 0)
1367                 return 1;
1368
1369         secure_hdr->hdrsig = tmp_sig;
1370
1371         kwb_dump_fuse_cmds(secure_hdr);
1372
1373         return 0;
1374 }
1375
1376 static void finish_register_set_header_v1(uint8_t **cur, uint8_t **next_ext,
1377                                           struct register_set_hdr_v1 *register_set_hdr,
1378                                           int *datai, uint8_t delay)
1379 {
1380         int size = sizeof(struct register_set_hdr_v1) + 8 * (*datai) + 4;
1381
1382         register_set_hdr->headertype = OPT_HDR_V1_REGISTER_TYPE;
1383         register_set_hdr->headersz_lsb = cpu_to_le16(size & 0xFFFF);
1384         register_set_hdr->headersz_msb = size >> 16;
1385         register_set_hdr->data[*datai].last_entry.delay = delay;
1386         *cur += size;
1387         **next_ext = 1;
1388         *next_ext = &register_set_hdr->data[*datai].last_entry.next;
1389         *datai = 0;
1390 }
1391
1392 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
1393                              uint8_t *ptr, int payloadsz)
1394 {
1395         struct image_cfg_element *e;
1396         struct main_hdr_v1 *main_hdr;
1397         struct opt_hdr_v1 *ohdr;
1398         struct register_set_hdr_v1 *register_set_hdr;
1399         struct secure_hdr_v1 *secure_hdr = NULL;
1400         size_t headersz;
1401         uint8_t *image, *cur;
1402         int hasext = 0;
1403         uint8_t *next_ext = NULL;
1404         int cfgi, datai;
1405         uint8_t delay;
1406
1407         /*
1408          * Calculate the size of the header and the size of the
1409          * payload
1410          */
1411         headersz = image_headersz_v1(&hasext);
1412         if (headersz == 0)
1413                 return NULL;
1414
1415         image = malloc(headersz);
1416         if (!image) {
1417                 fprintf(stderr, "Cannot allocate memory for image\n");
1418                 return NULL;
1419         }
1420
1421         memset(image, 0, headersz);
1422
1423         main_hdr = (struct main_hdr_v1 *)image;
1424         cur = image;
1425         cur += sizeof(struct main_hdr_v1);
1426         next_ext = &main_hdr->ext;
1427
1428         /* Fill the main header */
1429         main_hdr->blocksize    =
1430                 cpu_to_le32(payloadsz);
1431         main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1432         main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1433         main_hdr->destaddr     = cpu_to_le32(params->addr);
1434         main_hdr->execaddr     = cpu_to_le32(params->ep);
1435         main_hdr->srcaddr      = cpu_to_le32(headersz);
1436         main_hdr->ext          = hasext;
1437         main_hdr->version      = 1;
1438         main_hdr->blockid      = image_get_bootfrom();
1439
1440         e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1441         if (e)
1442                 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1443         e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
1444         if (e)
1445                 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
1446         e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1447         if (e)
1448                 main_hdr->nandbadblklocation = e->nandbadblklocation;
1449         e = image_find_option(IMAGE_CFG_BAUDRATE);
1450         if (e)
1451                 main_hdr->options |= baudrate_to_option(e->baudrate);
1452         e = image_find_option(IMAGE_CFG_UART_PORT);
1453         if (e)
1454                 main_hdr->options |= (e->uart_port & 3) << 3;
1455         e = image_find_option(IMAGE_CFG_UART_MPP);
1456         if (e)
1457                 main_hdr->options |= (e->uart_mpp & 7) << 5;
1458         e = image_find_option(IMAGE_CFG_DEBUG);
1459         if (e)
1460                 main_hdr->flags = e->debug ? 0x1 : 0;
1461
1462         /*
1463          * For SATA srcaddr is specified in number of sectors.
1464          * This expects the sector size to be 512 bytes.
1465          * Header size is already aligned.
1466          */
1467         if (main_hdr->blockid == IBR_HDR_SATA_ID)
1468                 main_hdr->srcaddr = cpu_to_le32(headersz / 512);
1469
1470         /* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
1471         if (main_hdr->blockid == IBR_HDR_PEX_ID)
1472                 main_hdr->srcaddr = cpu_to_le32(0xFFFFFFFF);
1473
1474         if (image_get_csk_index() >= 0) {
1475                 /*
1476                  * only reserve the space here; we fill the header later since
1477                  * we need the header to be complete to compute the signatures
1478                  */
1479                 secure_hdr = (struct secure_hdr_v1 *)cur;
1480                 cur += sizeof(struct secure_hdr_v1);
1481                 *next_ext = 1;
1482                 next_ext = &secure_hdr->next;
1483         }
1484
1485         datai = 0;
1486         for (cfgi = 0; cfgi < cfgn; cfgi++) {
1487                 e = &image_cfg[cfgi];
1488                 if (e->type != IMAGE_CFG_DATA &&
1489                     e->type != IMAGE_CFG_DATA_DELAY &&
1490                     e->type != IMAGE_CFG_BINARY)
1491                         continue;
1492
1493                 if (datai == 0)
1494                         register_set_hdr = (struct register_set_hdr_v1 *)cur;
1495
1496                 /* If delay is not specified, use the smallest possible value. */
1497                 if (e->type == IMAGE_CFG_DATA_DELAY)
1498                         delay = e->regdata_delay;
1499                 else
1500                         delay = REGISTER_SET_HDR_OPT_DELAY_MS(0);
1501
1502                 /*
1503                  * DATA_DELAY command is the last entry in the register set
1504                  * header and BINARY command inserts new binary header.
1505                  * Therefore BINARY command requires to finish register set
1506                  * header if some DATA command was specified. And DATA_DELAY
1507                  * command automatically finish register set header even when
1508                  * there was no DATA command.
1509                  */
1510                 if (e->type == IMAGE_CFG_DATA_DELAY ||
1511                     (e->type == IMAGE_CFG_BINARY && datai != 0))
1512                         finish_register_set_header_v1(&cur, &next_ext, register_set_hdr,
1513                                                       &datai, delay);
1514
1515                 if (e->type == IMAGE_CFG_DATA) {
1516                         register_set_hdr->data[datai].entry.address =
1517                                 cpu_to_le32(e->regdata.raddr);
1518                         register_set_hdr->data[datai].entry.value =
1519                                 cpu_to_le32(e->regdata.rdata);
1520                         datai++;
1521                 }
1522
1523                 if (e->type == IMAGE_CFG_BINARY) {
1524                         if (add_binary_header_v1(&cur, &next_ext, e, main_hdr))
1525                                 return NULL;
1526                 }
1527         }
1528         if (datai != 0) {
1529                 /* Set delay to the smallest possible value. */
1530                 delay = REGISTER_SET_HDR_OPT_DELAY_MS(0);
1531                 finish_register_set_header_v1(&cur, &next_ext, register_set_hdr,
1532                                               &datai, delay);
1533         }
1534
1535         if (secure_hdr && add_secure_header_v1(params, ptr, payloadsz + headersz,
1536                                                headersz, image, secure_hdr))
1537                 return NULL;
1538
1539         *imagesz = headersz;
1540
1541         /* Fill the real header size without padding into the main header */
1542         headersz = sizeof(*main_hdr);
1543         for_each_opt_hdr_v1 (ohdr, main_hdr)
1544                 headersz += opt_hdr_v1_size(ohdr);
1545         main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1546         main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1547
1548         /* Calculate and set the header checksum */
1549         main_hdr->checksum = image_checksum8(main_hdr, headersz);
1550
1551         return image;
1552 }
1553
1554 static int recognize_keyword(char *keyword)
1555 {
1556         int kw_id;
1557
1558         for (kw_id = 1; kw_id < IMAGE_CFG_COUNT; ++kw_id)
1559                 if (!strcmp(keyword, id_strs[kw_id]))
1560                         return kw_id;
1561
1562         return 0;
1563 }
1564
1565 static int image_create_config_parse_oneline(char *line,
1566                                              struct image_cfg_element *el)
1567 {
1568         char *keyword, *saveptr, *value1, *value2;
1569         char delimiters[] = " \t";
1570         int keyword_id, ret, argi;
1571         char *unknown_msg = "Ignoring unknown line '%s'\n";
1572
1573         keyword = strtok_r(line, delimiters, &saveptr);
1574         keyword_id = recognize_keyword(keyword);
1575
1576         if (!keyword_id) {
1577                 fprintf(stderr, unknown_msg, line);
1578                 return 0;
1579         }
1580
1581         el->type = keyword_id;
1582
1583         value1 = strtok_r(NULL, delimiters, &saveptr);
1584
1585         if (!value1) {
1586                 fprintf(stderr, "Parameter missing in line '%s'\n", line);
1587                 return -1;
1588         }
1589
1590         switch (keyword_id) {
1591         case IMAGE_CFG_VERSION:
1592                 el->version = atoi(value1);
1593                 break;
1594         case IMAGE_CFG_CPU:
1595                 if (strcmp(value1, "FEROCEON") == 0)
1596                         el->cpu_sheeva = 0;
1597                 else if (strcmp(value1, "SHEEVA") == 0)
1598                         el->cpu_sheeva = 1;
1599                 else if (strcmp(value1, "A9") == 0)
1600                         el->cpu_sheeva = 0;
1601                 else {
1602                         fprintf(stderr, "Invalid CPU %s\n", value1);
1603                         return -1;
1604                 }
1605                 break;
1606         case IMAGE_CFG_BOOT_FROM:
1607                 ret = image_boot_mode_id(value1);
1608
1609                 if (ret < 0) {
1610                         fprintf(stderr, "Invalid boot media '%s'\n", value1);
1611                         return -1;
1612                 }
1613                 el->bootfrom = ret;
1614                 break;
1615         case IMAGE_CFG_NAND_BLKSZ:
1616                 el->nandblksz = strtoul(value1, NULL, 16);
1617                 break;
1618         case IMAGE_CFG_NAND_BADBLK_LOCATION:
1619                 el->nandbadblklocation = strtoul(value1, NULL, 16);
1620                 break;
1621         case IMAGE_CFG_NAND_ECC_MODE:
1622                 ret = image_nand_ecc_mode_id(value1);
1623
1624                 if (ret < 0) {
1625                         fprintf(stderr, "Invalid NAND ECC mode '%s'\n", value1);
1626                         return -1;
1627                 }
1628                 el->nandeccmode = ret;
1629                 break;
1630         case IMAGE_CFG_NAND_PAGESZ:
1631                 el->nandpagesz = strtoul(value1, NULL, 16);
1632                 break;
1633         case IMAGE_CFG_BINARY:
1634                 argi = 0;
1635
1636                 el->binary.file = strdup(value1);
1637                 while (1) {
1638                         char *value = strtok_r(NULL, delimiters, &saveptr);
1639                         char *endptr;
1640
1641                         if (!value)
1642                                 break;
1643
1644                         if (!strcmp(value, "LOAD_ADDRESS")) {
1645                                 value = strtok_r(NULL, delimiters, &saveptr);
1646                                 if (!value) {
1647                                         fprintf(stderr,
1648                                                 "Missing address argument for BINARY LOAD_ADDRESS\n");
1649                                         return -1;
1650                                 }
1651                                 el->binary.loadaddr = strtoul(value, &endptr, 16);
1652                                 if (*endptr) {
1653                                         fprintf(stderr,
1654                                                 "Invalid argument '%s' for BINARY LOAD_ADDRESS\n",
1655                                                 value);
1656                                         return -1;
1657                                 }
1658                                 value = strtok_r(NULL, delimiters, &saveptr);
1659                                 if (value) {
1660                                         fprintf(stderr,
1661                                                 "Unexpected argument '%s' after BINARY LOAD_ADDRESS\n",
1662                                                 value);
1663                                         return -1;
1664                                 }
1665                                 break;
1666                         }
1667
1668                         el->binary.args[argi] = strtoul(value, &endptr, 16);
1669                         if (*endptr) {
1670                                 fprintf(stderr, "Invalid argument '%s' for BINARY\n", value);
1671                                 return -1;
1672                         }
1673                         argi++;
1674                         if (argi >= BINARY_MAX_ARGS) {
1675                                 fprintf(stderr,
1676                                         "Too many arguments for BINARY\n");
1677                                 return -1;
1678                         }
1679                 }
1680                 el->binary.nargs = argi;
1681                 break;
1682         case IMAGE_CFG_DATA:
1683                 value2 = strtok_r(NULL, delimiters, &saveptr);
1684
1685                 if (!value1 || !value2) {
1686                         fprintf(stderr,
1687                                 "Invalid number of arguments for DATA\n");
1688                         return -1;
1689                 }
1690
1691                 el->regdata.raddr = strtoul(value1, NULL, 16);
1692                 el->regdata.rdata = strtoul(value2, NULL, 16);
1693                 break;
1694         case IMAGE_CFG_DATA_DELAY:
1695                 if (!strcmp(value1, "SDRAM_SETUP"))
1696                         el->regdata_delay = REGISTER_SET_HDR_OPT_DELAY_SDRAM_SETUP;
1697                 else
1698                         el->regdata_delay = REGISTER_SET_HDR_OPT_DELAY_MS(strtoul(value1, NULL, 10));
1699                 if (el->regdata_delay > 255) {
1700                         fprintf(stderr, "Maximal DATA_DELAY is 255\n");
1701                         return -1;
1702                 }
1703                 break;
1704         case IMAGE_CFG_BAUDRATE:
1705                 el->baudrate = strtoul(value1, NULL, 10);
1706                 break;
1707         case IMAGE_CFG_UART_PORT:
1708                 el->uart_port = strtoul(value1, NULL, 16);
1709                 break;
1710         case IMAGE_CFG_UART_MPP:
1711                 el->uart_mpp = strtoul(value1, NULL, 16);
1712                 break;
1713         case IMAGE_CFG_DEBUG:
1714                 el->debug = strtoul(value1, NULL, 10);
1715                 break;
1716         case IMAGE_CFG_KAK:
1717                 el->key_name = strdup(value1);
1718                 break;
1719         case IMAGE_CFG_CSK:
1720                 el->key_name = strdup(value1);
1721                 break;
1722         case IMAGE_CFG_CSK_INDEX:
1723                 el->csk_idx = strtol(value1, NULL, 0);
1724                 break;
1725         case IMAGE_CFG_JTAG_DELAY:
1726                 el->jtag_delay = strtoul(value1, NULL, 0);
1727                 break;
1728         case IMAGE_CFG_BOX_ID:
1729                 el->boxid = strtoul(value1, NULL, 0);
1730                 break;
1731         case IMAGE_CFG_FLASH_ID:
1732                 el->flashid = strtoul(value1, NULL, 0);
1733                 break;
1734         case IMAGE_CFG_SEC_SPECIALIZED_IMG:
1735                 el->sec_specialized_img = true;
1736                 break;
1737         case IMAGE_CFG_SEC_COMMON_IMG:
1738                 el->sec_specialized_img = false;
1739                 break;
1740         case IMAGE_CFG_SEC_BOOT_DEV:
1741                 el->sec_boot_dev = strtoul(value1, NULL, 0);
1742                 break;
1743         case IMAGE_CFG_SEC_FUSE_DUMP:
1744                 el->name = strdup(value1);
1745                 break;
1746         default:
1747                 fprintf(stderr, unknown_msg, line);
1748         }
1749
1750         return 0;
1751 }
1752
1753 /*
1754  * Parse the configuration file 'fcfg' into the array of configuration
1755  * elements 'image_cfg', and return the number of configuration
1756  * elements in 'cfgn'.
1757  */
1758 static int image_create_config_parse(FILE *fcfg)
1759 {
1760         int ret;
1761         int cfgi = 0;
1762
1763         /* Parse the configuration file */
1764         while (!feof(fcfg)) {
1765                 char *line;
1766                 char buf[256];
1767
1768                 /* Read the current line */
1769                 memset(buf, 0, sizeof(buf));
1770                 line = fgets(buf, sizeof(buf), fcfg);
1771                 if (!line)
1772                         break;
1773
1774                 /* Ignore useless lines */
1775                 if (line[0] == '\n' || line[0] == '#')
1776                         continue;
1777
1778                 /* Strip final newline */
1779                 if (line[strlen(line) - 1] == '\n')
1780                         line[strlen(line) - 1] = 0;
1781
1782                 /* Parse the current line */
1783                 ret = image_create_config_parse_oneline(line,
1784                                                         &image_cfg[cfgi]);
1785                 if (ret)
1786                         return ret;
1787
1788                 cfgi++;
1789
1790                 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
1791                         fprintf(stderr,
1792                                 "Too many configuration elements in .cfg file\n");
1793                         return -1;
1794                 }
1795         }
1796
1797         cfgn = cfgi;
1798         return 0;
1799 }
1800
1801 static int image_get_version(void)
1802 {
1803         struct image_cfg_element *e;
1804
1805         e = image_find_option(IMAGE_CFG_VERSION);
1806         if (!e)
1807                 return -1;
1808
1809         return e->version;
1810 }
1811
1812 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
1813                                 struct image_tool_params *params)
1814 {
1815         FILE *fcfg;
1816         void *image = NULL;
1817         int version;
1818         size_t headersz = 0;
1819         size_t datasz;
1820         uint32_t checksum;
1821         struct stat s;
1822         int ret;
1823
1824         /*
1825          * Do not use sbuf->st_size as it contains size with padding.
1826          * We need original image data size, so stat original file.
1827          */
1828         if (stat(params->datafile, &s)) {
1829                 fprintf(stderr, "Could not stat data file %s: %s\n",
1830                         params->datafile, strerror(errno));
1831                 exit(EXIT_FAILURE);
1832         }
1833         datasz = ALIGN(s.st_size, 4);
1834
1835         fcfg = fopen(params->imagename, "r");
1836         if (!fcfg) {
1837                 fprintf(stderr, "Could not open input file %s\n",
1838                         params->imagename);
1839                 exit(EXIT_FAILURE);
1840         }
1841
1842         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1843                            sizeof(struct image_cfg_element));
1844         if (!image_cfg) {
1845                 fprintf(stderr, "Cannot allocate memory\n");
1846                 fclose(fcfg);
1847                 exit(EXIT_FAILURE);
1848         }
1849
1850         memset(image_cfg, 0,
1851                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1852         rewind(fcfg);
1853
1854         ret = image_create_config_parse(fcfg);
1855         fclose(fcfg);
1856         if (ret) {
1857                 free(image_cfg);
1858                 exit(EXIT_FAILURE);
1859         }
1860
1861         version = image_get_version();
1862         switch (version) {
1863                 /*
1864                  * Fallback to version 0 if no version is provided in the
1865                  * cfg file
1866                  */
1867         case -1:
1868         case 0:
1869                 image = image_create_v0(&headersz, params, datasz + 4);
1870                 break;
1871
1872         case 1:
1873                 image = image_create_v1(&headersz, params, ptr, datasz + 4);
1874                 break;
1875
1876         default:
1877                 fprintf(stderr, "Unsupported version %d\n", version);
1878                 free(image_cfg);
1879                 exit(EXIT_FAILURE);
1880         }
1881
1882         if (!image) {
1883                 fprintf(stderr, "Could not create image\n");
1884                 free(image_cfg);
1885                 exit(EXIT_FAILURE);
1886         }
1887
1888         free(image_cfg);
1889
1890         /* Build and add image data checksum */
1891         checksum = cpu_to_le32(image_checksum32((uint8_t *)ptr + headersz,
1892                                                 datasz));
1893         memcpy((uint8_t *)ptr + headersz + datasz, &checksum, sizeof(uint32_t));
1894
1895         /* Finally copy the header into the image area */
1896         memcpy(ptr, image, headersz);
1897
1898         free(image);
1899 }
1900
1901 static void kwbimage_print_header(const void *ptr)
1902 {
1903         struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1904         struct bin_hdr_v0 *bhdr;
1905         struct opt_hdr_v1 *ohdr;
1906
1907         printf("Image Type:   MVEBU Boot from %s Image\n",
1908                image_boot_mode_name(mhdr->blockid));
1909         printf("Image version:%d\n", kwbimage_version(ptr));
1910
1911         for_each_opt_hdr_v1 (ohdr, mhdr) {
1912                 if (ohdr->headertype == OPT_HDR_V1_BINARY_TYPE) {
1913                         printf("BIN Img Size: ");
1914                         genimg_print_size(opt_hdr_v1_size(ohdr) - 12 -
1915                                           4 * ohdr->data[0]);
1916                         printf("BIN Img Offs: %08x\n",
1917                                 (unsigned)((uint8_t *)ohdr - (uint8_t *)mhdr) +
1918                                 8 + 4 * ohdr->data[0]);
1919                 }
1920         }
1921
1922         for_each_bin_hdr_v0(bhdr, mhdr) {
1923                 printf("BIN Img Size: ");
1924                 genimg_print_size(le32_to_cpu(bhdr->size));
1925                 printf("BIN Img Addr: %08x\n", le32_to_cpu(bhdr->destaddr));
1926                 printf("BIN Img Entr: %08x\n", le32_to_cpu(bhdr->execaddr));
1927         }
1928
1929         printf("Data Size:    ");
1930         genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
1931         printf("Load Address: %08x\n", mhdr->destaddr);
1932         printf("Entry Point:  %08x\n", mhdr->execaddr);
1933 }
1934
1935 static int kwbimage_check_image_types(uint8_t type)
1936 {
1937         if (type == IH_TYPE_KWBIMAGE)
1938                 return EXIT_SUCCESS;
1939
1940         return EXIT_FAILURE;
1941 }
1942
1943 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
1944                                   struct image_tool_params *params)
1945 {
1946         size_t header_size = kwbheader_size(ptr);
1947         uint8_t blockid;
1948         uint32_t offset;
1949         uint32_t size;
1950         uint8_t csum;
1951
1952         if (header_size > 192*1024)
1953                 return -FDT_ERR_BADSTRUCTURE;
1954
1955         if (header_size > image_size)
1956                 return -FDT_ERR_BADSTRUCTURE;
1957
1958         if (!main_hdr_checksum_ok(ptr))
1959                 return -FDT_ERR_BADSTRUCTURE;
1960
1961         /* Only version 0 extended header has checksum */
1962         if (kwbimage_version(ptr) == 0) {
1963                 struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1964                 struct ext_hdr_v0 *ext_hdr;
1965                 struct bin_hdr_v0 *bhdr;
1966
1967                 for_each_ext_hdr_v0(ext_hdr, ptr) {
1968                         csum = image_checksum8(ext_hdr, sizeof(*ext_hdr) - 1);
1969                         if (csum != ext_hdr->checksum)
1970                                 return -FDT_ERR_BADSTRUCTURE;
1971                 }
1972
1973                 for_each_bin_hdr_v0(bhdr, ptr) {
1974                         csum = image_checksum8(bhdr, (uint8_t *)&bhdr->checksum - (uint8_t *)bhdr - 1);
1975                         if (csum != bhdr->checksum)
1976                                 return -FDT_ERR_BADSTRUCTURE;
1977
1978                         if (bhdr->offset > sizeof(*bhdr) || bhdr->offset % 4 != 0)
1979                                 return -FDT_ERR_BADSTRUCTURE;
1980
1981                         if (bhdr->offset + bhdr->size + 4 > sizeof(*bhdr) || bhdr->size % 4 != 0)
1982                                 return -FDT_ERR_BADSTRUCTURE;
1983
1984                         if (image_checksum32((uint8_t *)bhdr + bhdr->offset, bhdr->size) !=
1985                             *(uint32_t *)((uint8_t *)bhdr + bhdr->offset + bhdr->size))
1986                                 return -FDT_ERR_BADSTRUCTURE;
1987                 }
1988
1989                 blockid = mhdr->blockid;
1990                 offset = le32_to_cpu(mhdr->srcaddr);
1991                 size = le32_to_cpu(mhdr->blocksize);
1992         } else if (kwbimage_version(ptr) == 1) {
1993                 struct main_hdr_v1 *mhdr = (struct main_hdr_v1 *)ptr;
1994                 const uint8_t *mhdr_end;
1995                 struct opt_hdr_v1 *ohdr;
1996
1997                 mhdr_end = (uint8_t *)mhdr + header_size;
1998                 for_each_opt_hdr_v1 (ohdr, ptr)
1999                         if (!opt_hdr_v1_valid_size(ohdr, mhdr_end))
2000                                 return -FDT_ERR_BADSTRUCTURE;
2001
2002                 blockid = mhdr->blockid;
2003                 offset = le32_to_cpu(mhdr->srcaddr);
2004                 size = le32_to_cpu(mhdr->blocksize);
2005         } else {
2006                 return -FDT_ERR_BADSTRUCTURE;
2007         }
2008
2009         /*
2010          * For SATA srcaddr is specified in number of sectors.
2011          * This expects that sector size is 512 bytes.
2012          */
2013         if (blockid == IBR_HDR_SATA_ID)
2014                 offset *= 512;
2015
2016         /*
2017          * For PCIe srcaddr is always set to 0xFFFFFFFF.
2018          * This expects that data starts after all headers.
2019          */
2020         if (blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
2021                 offset = header_size;
2022
2023         if (offset > image_size || offset % 4 != 0)
2024                 return -FDT_ERR_BADSTRUCTURE;
2025
2026         if (size < 4 || offset + size > image_size || size % 4 != 0)
2027                 return -FDT_ERR_BADSTRUCTURE;
2028
2029         if (image_checksum32(ptr + offset, size - 4) !=
2030             *(uint32_t *)(ptr + offset + size - 4))
2031                 return -FDT_ERR_BADSTRUCTURE;
2032
2033         return 0;
2034 }
2035
2036 static int kwbimage_generate(struct image_tool_params *params,
2037                              struct image_type_params *tparams)
2038 {
2039         FILE *fcfg;
2040         struct stat s;
2041         int alloc_len;
2042         int bootfrom;
2043         int version;
2044         void *hdr;
2045         int ret;
2046
2047         fcfg = fopen(params->imagename, "r");
2048         if (!fcfg) {
2049                 fprintf(stderr, "Could not open input file %s\n",
2050                         params->imagename);
2051                 exit(EXIT_FAILURE);
2052         }
2053
2054         if (stat(params->datafile, &s)) {
2055                 fprintf(stderr, "Could not stat data file %s: %s\n",
2056                         params->datafile, strerror(errno));
2057                 exit(EXIT_FAILURE);
2058         }
2059
2060         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
2061                            sizeof(struct image_cfg_element));
2062         if (!image_cfg) {
2063                 fprintf(stderr, "Cannot allocate memory\n");
2064                 fclose(fcfg);
2065                 exit(EXIT_FAILURE);
2066         }
2067
2068         memset(image_cfg, 0,
2069                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
2070         rewind(fcfg);
2071
2072         ret = image_create_config_parse(fcfg);
2073         fclose(fcfg);
2074         if (ret) {
2075                 free(image_cfg);
2076                 exit(EXIT_FAILURE);
2077         }
2078
2079         bootfrom = image_get_bootfrom();
2080         version = image_get_version();
2081         switch (version) {
2082                 /*
2083                  * Fallback to version 0 if no version is provided in the
2084                  * cfg file
2085                  */
2086         case -1:
2087         case 0:
2088                 alloc_len = image_headersz_v0(NULL);
2089                 break;
2090
2091         case 1:
2092                 alloc_len = image_headersz_v1(NULL);
2093                 if (!alloc_len) {
2094                         free(image_cfg);
2095                         exit(EXIT_FAILURE);
2096                 }
2097                 if (alloc_len > 192*1024) {
2098                         fprintf(stderr, "Header is too big (%u bytes), maximal kwbimage header size is %u bytes\n", alloc_len, 192*1024);
2099                         free(image_cfg);
2100                         exit(EXIT_FAILURE);
2101                 }
2102                 break;
2103
2104         default:
2105                 fprintf(stderr, "Unsupported version %d\n", version);
2106                 free(image_cfg);
2107                 exit(EXIT_FAILURE);
2108         }
2109
2110         free(image_cfg);
2111
2112         hdr = malloc(alloc_len);
2113         if (!hdr) {
2114                 fprintf(stderr, "%s: malloc return failure: %s\n",
2115                         params->cmdname, strerror(errno));
2116                 exit(EXIT_FAILURE);
2117         }
2118
2119         memset(hdr, 0, alloc_len);
2120         tparams->header_size = alloc_len;
2121         tparams->hdr = hdr;
2122
2123         /*
2124          * The resulting image needs to be 4-byte aligned. At least
2125          * the Marvell hdrparser tool complains if its unaligned.
2126          * After the image data is stored 4-byte checksum.
2127          * Final UART image must be aligned to 128 bytes.
2128          * Final SPI and NAND images must be aligned to 256 bytes.
2129          * Final SATA and SDIO images must be aligned to 512 bytes.
2130          */
2131         if (bootfrom == IBR_HDR_SPI_ID || bootfrom == IBR_HDR_NAND_ID)
2132                 return 4 + (256 - (alloc_len + s.st_size + 4) % 256) % 256;
2133         else if (bootfrom == IBR_HDR_SATA_ID || bootfrom == IBR_HDR_SDIO_ID)
2134                 return 4 + (512 - (alloc_len + s.st_size + 4) % 512) % 512;
2135         else if (bootfrom == IBR_HDR_UART_ID)
2136                 return 4 + (128 - (alloc_len + s.st_size + 4) % 128) % 128;
2137         else
2138                 return 4 + (4 - s.st_size % 4) % 4;
2139 }
2140
2141 static int kwbimage_generate_config(void *ptr, struct image_tool_params *params)
2142 {
2143         struct main_hdr_v0 *mhdr0 = (struct main_hdr_v0 *)ptr;
2144         struct main_hdr_v1 *mhdr = (struct main_hdr_v1 *)ptr;
2145         size_t header_size = kwbheader_size(ptr);
2146         struct register_set_hdr_v1 *regset_hdr;
2147         struct ext_hdr_v0_reg *regdata;
2148         struct ext_hdr_v0 *ehdr0;
2149         struct bin_hdr_v0 *bhdr0;
2150         struct opt_hdr_v1 *ohdr;
2151         int params_count;
2152         unsigned offset;
2153         int is_v0_ext;
2154         int cur_idx;
2155         int version;
2156         FILE *f;
2157         int i;
2158
2159         f = fopen(params->outfile, "w");
2160         if (!f) {
2161                 fprintf(stderr, "Can't open \"%s\": %s\n", params->outfile, strerror(errno));
2162                 return -1;
2163         }
2164
2165         version = kwbimage_version(ptr);
2166
2167         is_v0_ext = 0;
2168         if (version == 0) {
2169                 if (mhdr0->ext > 1 || mhdr0->bin ||
2170                     ((ehdr0 = ext_hdr_v0_first(ptr)) &&
2171                      (ehdr0->match_addr || ehdr0->match_mask || ehdr0->match_value)))
2172                         is_v0_ext = 1;
2173         }
2174
2175         if (version != 0)
2176                 fprintf(f, "VERSION %d\n", version);
2177
2178         fprintf(f, "BOOT_FROM %s\n", image_boot_mode_name(mhdr->blockid) ?: "<unknown>");
2179
2180         if (version == 0 && mhdr->blockid == IBR_HDR_NAND_ID)
2181                 fprintf(f, "NAND_ECC_MODE %s\n", image_nand_ecc_mode_name(mhdr0->nandeccmode));
2182
2183         if (mhdr->blockid == IBR_HDR_NAND_ID)
2184                 fprintf(f, "NAND_PAGE_SIZE 0x%x\n", (unsigned)mhdr->nandpagesize);
2185
2186         if (version != 0 && mhdr->blockid == IBR_HDR_NAND_ID)
2187                 fprintf(f, "NAND_BLKSZ 0x%x\n", (unsigned)mhdr->nandblocksize);
2188
2189         if (mhdr->blockid == IBR_HDR_NAND_ID && (mhdr->nandbadblklocation != 0 || is_v0_ext))
2190                 fprintf(f, "NAND_BADBLK_LOCATION 0x%x\n", (unsigned)mhdr->nandbadblklocation);
2191
2192         if (version == 0 && mhdr->blockid == IBR_HDR_SATA_ID)
2193                 fprintf(f, "SATA_PIO_MODE %u\n", (unsigned)mhdr0->satapiomode);
2194
2195         /*
2196          * Addresses and sizes which are specified by mkimage command line
2197          * arguments and not in kwbimage config file
2198          */
2199
2200         if (version != 0)
2201                 fprintf(f, "#HEADER_SIZE 0x%x\n",
2202                         ((unsigned)mhdr->headersz_msb << 8) | le16_to_cpu(mhdr->headersz_lsb));
2203
2204         fprintf(f, "#SRC_ADDRESS 0x%x\n", le32_to_cpu(mhdr->srcaddr));
2205         fprintf(f, "#BLOCK_SIZE 0x%x\n", le32_to_cpu(mhdr->blocksize));
2206         fprintf(f, "#DEST_ADDRESS 0x%08x\n", le32_to_cpu(mhdr->destaddr));
2207         fprintf(f, "#EXEC_ADDRESS 0x%08x\n", le32_to_cpu(mhdr->execaddr));
2208
2209         if (version != 0) {
2210                 if (options_to_baudrate(mhdr->options))
2211                         fprintf(f, "BAUDRATE %u\n", options_to_baudrate(mhdr->options));
2212                 if (options_to_baudrate(mhdr->options) ||
2213                     ((mhdr->options >> 3) & 0x3) || ((mhdr->options >> 5) & 0x7)) {
2214                         fprintf(f, "UART_PORT %u\n", (unsigned)((mhdr->options >> 3) & 0x3));
2215                         fprintf(f, "UART_MPP 0x%x\n", (unsigned)((mhdr->options >> 5) & 0x7));
2216                 }
2217                 if (mhdr->flags & 0x1)
2218                         fprintf(f, "DEBUG 1\n");
2219         }
2220
2221         cur_idx = 1;
2222         for_each_opt_hdr_v1(ohdr, ptr) {
2223                 if (ohdr->headertype == OPT_HDR_V1_SECURE_TYPE) {
2224                         fprintf(f, "#SECURE_HEADER\n");
2225                 } else if (ohdr->headertype == OPT_HDR_V1_BINARY_TYPE) {
2226                         fprintf(f, "BINARY binary%d.bin", cur_idx);
2227                         for (i = 0; i < ohdr->data[0]; i++)
2228                                 fprintf(f, " 0x%x", le32_to_cpu(((uint32_t *)ohdr->data)[i + 1]));
2229                         offset = (unsigned)((uint8_t *)ohdr - (uint8_t *)mhdr) + 8 + 4 * ohdr->data[0];
2230                         fprintf(f, " LOAD_ADDRESS 0x%08x\n", 0x40000000 + offset);
2231                         fprintf(f, " # for CPU SHEEVA: LOAD_ADDRESS 0x%08x\n", 0x40004000 + offset);
2232                         cur_idx++;
2233                 } else if (ohdr->headertype == OPT_HDR_V1_REGISTER_TYPE) {
2234                         regset_hdr = (struct register_set_hdr_v1 *)ohdr;
2235                         for (i = 0;
2236                              i < opt_hdr_v1_size(ohdr) - sizeof(struct opt_hdr_v1) -
2237                                  sizeof(regset_hdr->data[0].last_entry);
2238                              i++)
2239                                 fprintf(f, "DATA 0x%08x 0x%08x\n",
2240                                         le32_to_cpu(regset_hdr->data[i].entry.address),
2241                                         le32_to_cpu(regset_hdr->data[i].entry.value));
2242                         if (opt_hdr_v1_size(ohdr) - sizeof(struct opt_hdr_v1) >=
2243                             sizeof(regset_hdr->data[0].last_entry)) {
2244                                 if (regset_hdr->data[0].last_entry.delay)
2245                                         fprintf(f, "DATA_DELAY %u\n",
2246                                                 (unsigned)regset_hdr->data[0].last_entry.delay);
2247                                 else
2248                                         fprintf(f, "DATA_DELAY SDRAM_SETUP\n");
2249                         }
2250                 }
2251         }
2252
2253         if (version == 0 && !is_v0_ext && le16_to_cpu(mhdr0->ddrinitdelay))
2254                 fprintf(f, "DDR_INIT_DELAY %u\n", (unsigned)le16_to_cpu(mhdr0->ddrinitdelay));
2255
2256         for_each_ext_hdr_v0(ehdr0, ptr) {
2257                 if (is_v0_ext) {
2258                         fprintf(f, "\nMATCH ADDRESS 0x%08x MASK 0x%08x VALUE 0x%08x\n",
2259                                 le32_to_cpu(ehdr0->match_addr),
2260                                 le32_to_cpu(ehdr0->match_mask),
2261                                 le32_to_cpu(ehdr0->match_value));
2262                         if (ehdr0->rsvd1[0] || ehdr0->rsvd1[1] || ehdr0->rsvd1[2] ||
2263                             ehdr0->rsvd1[3] || ehdr0->rsvd1[4] || ehdr0->rsvd1[5] ||
2264                             ehdr0->rsvd1[6] || ehdr0->rsvd1[7])
2265                                 fprintf(f, "#DDR_RSVD1 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
2266                                         ehdr0->rsvd1[0], ehdr0->rsvd1[1], ehdr0->rsvd1[2],
2267                                         ehdr0->rsvd1[3], ehdr0->rsvd1[4], ehdr0->rsvd1[5],
2268                                         ehdr0->rsvd1[6], ehdr0->rsvd1[7]);
2269                         if (ehdr0->rsvd2[0] || ehdr0->rsvd2[1] || ehdr0->rsvd2[2] ||
2270                             ehdr0->rsvd2[3] || ehdr0->rsvd2[4] || ehdr0->rsvd2[5] ||
2271                             ehdr0->rsvd2[6])
2272                                 fprintf(f, "#DDR_RSVD2 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
2273                                         ehdr0->rsvd2[0], ehdr0->rsvd2[1], ehdr0->rsvd2[2],
2274                                         ehdr0->rsvd2[3], ehdr0->rsvd2[4], ehdr0->rsvd2[5],
2275                                         ehdr0->rsvd2[6]);
2276                         if (ehdr0->ddrwritetype)
2277                                 fprintf(f, "DDR_WRITE_TYPE %u\n", (unsigned)ehdr0->ddrwritetype);
2278                         if (ehdr0->ddrresetmpp)
2279                                 fprintf(f, "DDR_RESET_MPP 0x%x\n", (unsigned)ehdr0->ddrresetmpp);
2280                         if (ehdr0->ddrclkenmpp)
2281                                 fprintf(f, "DDR_CLKEN_MPP 0x%x\n", (unsigned)ehdr0->ddrclkenmpp);
2282                         if (ehdr0->ddrinitdelay)
2283                                 fprintf(f, "DDR_INIT_DELAY %u\n", (unsigned)ehdr0->ddrinitdelay);
2284                 }
2285
2286                 if (ehdr0->offset) {
2287                         for (regdata = (struct ext_hdr_v0_reg *)((uint8_t *)ptr + ehdr0->offset);
2288                              (uint8_t *)regdata < (uint8_t *)ptr + header_size &&
2289                              (regdata->raddr || regdata->rdata);
2290                              regdata++)
2291                                 fprintf(f, "DATA 0x%08x 0x%08x\n", le32_to_cpu(regdata->raddr),
2292                                         le32_to_cpu(regdata->rdata));
2293                         if ((uint8_t *)regdata != (uint8_t *)ptr + ehdr0->offset)
2294                                 fprintf(f, "DATA 0x0 0x0\n");
2295                 }
2296
2297                 if (le32_to_cpu(ehdr0->enddelay))
2298                         fprintf(f, "DATA_DELAY %u\n", le32_to_cpu(ehdr0->enddelay));
2299                 else if (is_v0_ext)
2300                         fprintf(f, "DATA_DELAY SDRAM_SETUP\n");
2301         }
2302
2303         cur_idx = 1;
2304         for_each_bin_hdr_v0(bhdr0, ptr) {
2305                 fprintf(f, "\nMATCH ADDRESS 0x%08x MASK 0x%08x VALUE 0x%08x\n",
2306                         le32_to_cpu(bhdr0->match_addr),
2307                         le32_to_cpu(bhdr0->match_mask),
2308                         le32_to_cpu(bhdr0->match_value));
2309
2310                 fprintf(f, "BINARY binary%d.bin", cur_idx);
2311                 params_count = fls4(bhdr0->params_flags & 0xF);
2312                 for (i = 0; i < params_count; i++)
2313                         fprintf(f, " 0x%x", (bhdr0->params[i] & (1 << i)) ? bhdr0->params[i] : 0);
2314                 fprintf(f, " LOAD_ADDRESS 0x%08x", le32_to_cpu(bhdr0->destaddr));
2315                 fprintf(f, " EXEC_ADDRESS 0x%08x", le32_to_cpu(bhdr0->execaddr));
2316                 fprintf(f, "\n");
2317
2318                 fprintf(f, "#BINARY_OFFSET 0x%x\n", le32_to_cpu(bhdr0->offset));
2319                 fprintf(f, "#BINARY_SIZE 0x%x\n", le32_to_cpu(bhdr0->size));
2320
2321                 if (bhdr0->rsvd1)
2322                         fprintf(f, "#BINARY_RSVD1 0x%x\n", (unsigned)bhdr0->rsvd1);
2323                 if (bhdr0->rsvd2)
2324                         fprintf(f, "#BINARY_RSVD2 0x%x\n", (unsigned)bhdr0->rsvd2);
2325
2326                 cur_idx++;
2327         }
2328
2329         /* Undocumented reserved fields */
2330
2331         if (version == 0 && (mhdr0->rsvd1[0] || mhdr0->rsvd1[1] || mhdr0->rsvd1[2]))
2332                 fprintf(f, "#RSVD1 0x%x 0x%x 0x%x\n", (unsigned)mhdr0->rsvd1[0],
2333                         (unsigned)mhdr0->rsvd1[1], (unsigned)mhdr0->rsvd1[2]);
2334
2335         if (version == 0 && le16_to_cpu(mhdr0->rsvd2))
2336                 fprintf(f, "#RSVD2 0x%x\n", (unsigned)le16_to_cpu(mhdr0->rsvd2));
2337
2338         if (version != 0 && mhdr->reserved4)
2339                 fprintf(f, "#RESERVED4 0x%x\n", (unsigned)mhdr->reserved4);
2340
2341         if (version != 0 && mhdr->reserved5)
2342                 fprintf(f, "#RESERVED5 0x%x\n", (unsigned)le16_to_cpu(mhdr->reserved5));
2343
2344         fclose(f);
2345
2346         return 0;
2347 }
2348
2349 static int kwbimage_extract_subimage(void *ptr, struct image_tool_params *params)
2350 {
2351         struct main_hdr_v1 *mhdr = (struct main_hdr_v1 *)ptr;
2352         size_t header_size = kwbheader_size(ptr);
2353         struct bin_hdr_v0 *bhdr;
2354         struct opt_hdr_v1 *ohdr;
2355         int idx = params->pflag;
2356         int cur_idx;
2357         uint32_t offset;
2358         ulong image;
2359         ulong size;
2360
2361         /* Generate kwbimage config file when '-p -1' is specified */
2362         if (idx == -1)
2363                 return kwbimage_generate_config(ptr, params);
2364
2365         image = 0;
2366         size = 0;
2367
2368         if (idx == 0) {
2369                 /* Extract data image when -p is not specified or when '-p 0' is specified */
2370                 offset = le32_to_cpu(mhdr->srcaddr);
2371
2372                 if (mhdr->blockid == IBR_HDR_SATA_ID)
2373                         offset *= 512;
2374
2375                 if (mhdr->blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
2376                         offset = header_size;
2377
2378                 image = (ulong)((uint8_t *)ptr + offset);
2379                 size = le32_to_cpu(mhdr->blocksize) - 4;
2380         } else {
2381                 /* Extract N-th binary header executabe image when other '-p N' is specified */
2382                 cur_idx = 1;
2383                 for_each_opt_hdr_v1(ohdr, ptr) {
2384                         if (ohdr->headertype != OPT_HDR_V1_BINARY_TYPE)
2385                                 continue;
2386
2387                         if (idx == cur_idx) {
2388                                 image = (ulong)&ohdr->data[4 + 4 * ohdr->data[0]];
2389                                 size = opt_hdr_v1_size(ohdr) - 12 - 4 * ohdr->data[0];
2390                                 break;
2391                         }
2392
2393                         ++cur_idx;
2394                 }
2395                 for_each_bin_hdr_v0(bhdr, ptr) {
2396                         if (idx == cur_idx) {
2397                                 image = (ulong)bhdr + bhdr->offset;
2398                                 size = bhdr->size;
2399                                 break;
2400                         }
2401                         ++cur_idx;
2402                 }
2403
2404                 if (!image) {
2405                         fprintf(stderr, "Argument -p %d is invalid\n", idx);
2406                         fprintf(stderr, "Available subimages:\n");
2407                         fprintf(stderr, " -p -1  - kwbimage config file\n");
2408                         fprintf(stderr, " -p 0   - data image\n");
2409                         if (cur_idx - 1 > 0)
2410                                 fprintf(stderr, " -p N   - Nth binary header image (totally: %d)\n",
2411                                         cur_idx - 1);
2412                         return -1;
2413                 }
2414         }
2415
2416         return imagetool_save_subimage(params->outfile, image, size);
2417 }
2418
2419 /*
2420  * Report Error if xflag is set in addition to default
2421  */
2422 static int kwbimage_check_params(struct image_tool_params *params)
2423 {
2424         if (!params->lflag && !params->iflag && !params->pflag &&
2425             (!params->imagename || !strlen(params->imagename))) {
2426                 char *msg = "Configuration file for kwbimage creation omitted";
2427
2428                 fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg);
2429                 return 1;
2430         }
2431
2432         return (params->dflag && (params->fflag || params->lflag)) ||
2433                 (params->fflag && (params->dflag || params->lflag)) ||
2434                 (params->lflag && (params->dflag || params->fflag)) ||
2435                 (params->xflag);
2436 }
2437
2438 /*
2439  * kwbimage type parameters definition
2440  */
2441 U_BOOT_IMAGE_TYPE(
2442         kwbimage,
2443         "Marvell MVEBU Boot Image support",
2444         0,
2445         NULL,
2446         kwbimage_check_params,
2447         kwbimage_verify_header,
2448         kwbimage_print_header,
2449         kwbimage_set_header,
2450         kwbimage_extract_subimage,
2451         kwbimage_check_image_types,
2452         NULL,
2453         kwbimage_generate
2454 );