tools/kwbimage.c

   1 /*
   2  * Image manipulator for Marvell SoCs
   3  *  supports Kirkwood, Dove, Armada 370, Armada XP, and Armada 38x
   4  *
   5  * (C) Copyright 2013 Thomas Petazzoni
   6  * <thomas.petazzoni@free-electrons.com>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  *
  10  * Not implemented: support for the register headers in v1 images
  11  */
  12
  13 #include "imagetool.h"
  14 #include <limits.h>
  15 #include <image.h>
  16 #include <stdarg.h>
  17 #include <stdint.h>
  18 #include "kwbimage.h"
  19
  20 #ifdef CONFIG_KWB_SECURE
  21 #include <openssl/rsa.h>
  22 #include <openssl/pem.h>
  23 #include <openssl/err.h>
  24 #include <openssl/evp.h>
  25 #endif
  26
  27 static struct image_cfg_element *image_cfg;
  28 static int cfgn;
  29 #ifdef CONFIG_KWB_SECURE
  30 static int verbose_mode;
  31 #endif
  32
  33 struct boot_mode {
  34         unsigned int id;
  35         const char *name;
  36 };
  37
  38 /*
  39  * SHA2-256 hash
  40  */
  41 struct hash_v1 {
  42         uint8_t hash[32];
  43 };
  44
  45 struct boot_mode boot_modes[] = {
  46         { 0x4D, "i2c"  },
  47         { 0x5A, "spi"  },
  48         { 0x8B, "nand" },
  49         { 0x78, "sata" },
  50         { 0x9C, "pex"  },
  51         { 0x69, "uart" },
  52         { 0xAE, "sdio" },
  53         {},
  54 };
  55
  56 struct nand_ecc_mode {
  57         unsigned int id;
  58         const char *name;
  59 };
  60
  61 struct nand_ecc_mode nand_ecc_modes[] = {
  62         { 0x00, "default" },
  63         { 0x01, "hamming" },
  64         { 0x02, "rs" },
  65         { 0x03, "disabled" },
  66         {},
  67 };
  68
  69 /* Used to identify an undefined execution or destination address */
  70 #define ADDR_INVALID ((uint32_t)-1)
  71
  72 #define BINARY_MAX_ARGS 8
  73
  74 /* In-memory representation of a line of the configuration file */
  75
  76 enum image_cfg_type {
  77         IMAGE_CFG_VERSION = 0x1,
  78         IMAGE_CFG_BOOT_FROM,
  79         IMAGE_CFG_DEST_ADDR,
  80         IMAGE_CFG_EXEC_ADDR,
  81         IMAGE_CFG_NAND_BLKSZ,
  82         IMAGE_CFG_NAND_BADBLK_LOCATION,
  83         IMAGE_CFG_NAND_ECC_MODE,
  84         IMAGE_CFG_NAND_PAGESZ,
  85         IMAGE_CFG_BINARY,
  86         IMAGE_CFG_PAYLOAD,
  87         IMAGE_CFG_DATA,
  88         IMAGE_CFG_BAUDRATE,
  89         IMAGE_CFG_DEBUG,
  90         IMAGE_CFG_KAK,
  91         IMAGE_CFG_CSK,
  92         IMAGE_CFG_CSK_INDEX,
  93         IMAGE_CFG_JTAG_DELAY,
  94         IMAGE_CFG_BOX_ID,
  95         IMAGE_CFG_FLASH_ID,
  96         IMAGE_CFG_SEC_COMMON_IMG,
  97         IMAGE_CFG_SEC_SPECIALIZED_IMG,
  98         IMAGE_CFG_SEC_BOOT_DEV,
  99         IMAGE_CFG_SEC_FUSE_DUMP,
 100
 101         IMAGE_CFG_COUNT
 102 } type;
 103
 104 static const char * const id_strs[] = {
 105         [IMAGE_CFG_VERSION] = "VERSION",
 106         [IMAGE_CFG_BOOT_FROM] = "BOOT_FROM",
 107         [IMAGE_CFG_DEST_ADDR] = "DEST_ADDR",
 108         [IMAGE_CFG_EXEC_ADDR] = "EXEC_ADDR",
 109         [IMAGE_CFG_NAND_BLKSZ] = "NAND_BLKSZ",
 110         [IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
 111         [IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
 112         [IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
 113         [IMAGE_CFG_BINARY] = "BINARY",
 114         [IMAGE_CFG_PAYLOAD] = "PAYLOAD",
 115         [IMAGE_CFG_DATA] = "DATA",
 116         [IMAGE_CFG_BAUDRATE] = "BAUDRATE",
 117         [IMAGE_CFG_DEBUG] = "DEBUG",
 118         [IMAGE_CFG_KAK] = "KAK",
 119         [IMAGE_CFG_CSK] = "CSK",
 120         [IMAGE_CFG_CSK_INDEX] = "CSK_INDEX",
 121         [IMAGE_CFG_JTAG_DELAY] = "JTAG_DELAY",
 122         [IMAGE_CFG_BOX_ID] = "BOX_ID",
 123         [IMAGE_CFG_FLASH_ID] = "FLASH_ID",
 124         [IMAGE_CFG_SEC_COMMON_IMG] = "SEC_COMMON_IMG",
 125         [IMAGE_CFG_SEC_SPECIALIZED_IMG] = "SEC_SPECIALIZED_IMG",
 126         [IMAGE_CFG_SEC_BOOT_DEV] = "SEC_BOOT_DEV",
 127         [IMAGE_CFG_SEC_FUSE_DUMP] = "SEC_FUSE_DUMP"
 128 };
 129
 130 struct image_cfg_element {
 131         enum image_cfg_type type;
 132         union {
 133                 unsigned int version;
 134                 unsigned int bootfrom;
 135                 struct {
 136                         const char *file;
 137                         unsigned int args[BINARY_MAX_ARGS];
 138                         unsigned int nargs;
 139                 } binary;
 140                 const char *payload;
 141                 unsigned int dstaddr;
 142                 unsigned int execaddr;
 143                 unsigned int nandblksz;
 144                 unsigned int nandbadblklocation;
 145                 unsigned int nandeccmode;
 146                 unsigned int nandpagesz;
 147                 struct ext_hdr_v0_reg regdata;
 148                 unsigned int baudrate;
 149                 unsigned int debug;
 150                 const char *key_name;
 151                 int csk_idx;
 152                 uint8_t jtag_delay;
 153                 uint32_t boxid;
 154                 uint32_t flashid;
 155                 bool sec_specialized_img;
 156                 unsigned int sec_boot_dev;
 157                 const char *name;
 158         };
 159 };
 160
 161 #define IMAGE_CFG_ELEMENT_MAX 256
 162
 163 /*
 164  * Utility functions to manipulate boot mode and ecc modes (convert
 165  * them back and forth between description strings and the
 166  * corresponding numerical identifiers).
 167  */
 168
 169 static const char *image_boot_mode_name(unsigned int id)
 170 {
 171         int i;
 172
 173         for (i = 0; boot_modes[i].name; i++)
 174                 if (boot_modes[i].id == id)
 175                         return boot_modes[i].name;
 176         return NULL;
 177 }
 178
 179 int image_boot_mode_id(const char *boot_mode_name)
 180 {
 181         int i;
 182
 183         for (i = 0; boot_modes[i].name; i++)
 184                 if (!strcmp(boot_modes[i].name, boot_mode_name))
 185                         return boot_modes[i].id;
 186
 187         return -1;
 188 }
 189
 190 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
 191 {
 192         int i;
 193
 194         for (i = 0; nand_ecc_modes[i].name; i++)
 195                 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
 196                         return nand_ecc_modes[i].id;
 197         return -1;
 198 }
 199
 200 static struct image_cfg_element *
 201 image_find_option(unsigned int optiontype)
 202 {
 203         int i;
 204
 205         for (i = 0; i < cfgn; i++) {
 206                 if (image_cfg[i].type == optiontype)
 207                         return &image_cfg[i];
 208         }
 209
 210         return NULL;
 211 }
 212
 213 static unsigned int
 214 image_count_options(unsigned int optiontype)
 215 {
 216         int i;
 217         unsigned int count = 0;
 218
 219         for (i = 0; i < cfgn; i++)
 220                 if (image_cfg[i].type == optiontype)
 221                         count++;
 222
 223         return count;
 224 }
 225
 226 #if defined(CONFIG_KWB_SECURE)
 227
 228 static int image_get_csk_index(void)
 229 {
 230         struct image_cfg_element *e;
 231
 232         e = image_find_option(IMAGE_CFG_CSK_INDEX);
 233         if (!e)
 234                 return -1;
 235
 236         return e->csk_idx;
 237 }
 238
 239 static bool image_get_spezialized_img(void)
 240 {
 241         struct image_cfg_element *e;
 242
 243         e = image_find_option(IMAGE_CFG_SEC_SPECIALIZED_IMG);
 244         if (!e)
 245                 return false;
 246
 247         return e->sec_specialized_img;
 248 }
 249
 250 #endif
 251
 252 /*
 253  * Compute a 8-bit checksum of a memory area. This algorithm follows
 254  * the requirements of the Marvell SoC BootROM specifications.
 255  */
 256 static uint8_t image_checksum8(void *start, uint32_t len)
 257 {
 258         uint8_t csum = 0;
 259         uint8_t *p = start;
 260
 261         /* check len and return zero checksum if invalid */
 262         if (!len)
 263                 return 0;
 264
 265         do {
 266                 csum += *p;
 267                 p++;
 268         } while (--len);
 269
 270         return csum;
 271 }
 272
 273 static uint32_t image_checksum32(void *start, uint32_t len)
 274 {
 275         uint32_t csum = 0;
 276         uint32_t *p = start;
 277
 278         /* check len and return zero checksum if invalid */
 279         if (!len)
 280                 return 0;
 281
 282         if (len % sizeof(uint32_t)) {
 283                 fprintf(stderr, "Length %d is not in multiple of %zu\n",
 284                         len, sizeof(uint32_t));
 285                 return 0;
 286         }
 287
 288         do {
 289                 csum += *p;
 290                 p++;
 291                 len -= sizeof(uint32_t);
 292         } while (len > 0);
 293
 294         return csum;
 295 }
 296
 297 static uint8_t baudrate_to_option(unsigned int baudrate)
 298 {
 299         switch (baudrate) {
 300         case 2400:
 301                 return MAIN_HDR_V1_OPT_BAUD_2400;
 302         case 4800:
 303                 return MAIN_HDR_V1_OPT_BAUD_4800;
 304         case 9600:
 305                 return MAIN_HDR_V1_OPT_BAUD_9600;
 306         case 19200:
 307                 return MAIN_HDR_V1_OPT_BAUD_19200;
 308         case 38400:
 309                 return MAIN_HDR_V1_OPT_BAUD_38400;
 310         case 57600:
 311                 return MAIN_HDR_V1_OPT_BAUD_57600;
 312         case 115200:
 313                 return MAIN_HDR_V1_OPT_BAUD_115200;
 314         default:
 315                 return MAIN_HDR_V1_OPT_BAUD_DEFAULT;
 316         }
 317 }
 318
 319 #if defined(CONFIG_KWB_SECURE)
 320 static void kwb_msg(const char *fmt, ...)
 321 {
 322         if (verbose_mode) {
 323                 va_list ap;
 324
 325                 va_start(ap, fmt);
 326                 vfprintf(stdout, fmt, ap);
 327                 va_end(ap);
 328         }
 329 }
 330
 331 static int openssl_err(const char *msg)
 332 {
 333         unsigned long ssl_err = ERR_get_error();
 334
 335         fprintf(stderr, "%s", msg);
 336         fprintf(stderr, ": %s\n",
 337                 ERR_error_string(ssl_err, 0));
 338
 339         return -1;
 340 }
 341
 342 static int kwb_load_rsa_key(const char *keydir, const char *name, RSA **p_rsa)
 343 {
 344         char path[PATH_MAX];
 345         RSA *rsa;
 346         FILE *f;
 347
 348         if (!keydir)
 349                 keydir = ".";
 350
 351         snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
 352         f = fopen(path, "r");
 353         if (!f) {
 354                 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
 355                         path, strerror(errno));
 356                 return -ENOENT;
 357         }
 358
 359         rsa = PEM_read_RSAPrivateKey(f, 0, NULL, "");
 360         if (!rsa) {
 361                 openssl_err("Failure reading private key");
 362                 fclose(f);
 363                 return -EPROTO;
 364         }
 365         fclose(f);
 366         *p_rsa = rsa;
 367
 368         return 0;
 369 }
 370
 371 static int kwb_load_cfg_key(struct image_tool_params *params,
 372                             unsigned int cfg_option, const char *key_name,
 373                             RSA **p_key)
 374 {
 375         struct image_cfg_element *e_key;
 376         RSA *key;
 377         int res;
 378
 379         *p_key = NULL;
 380
 381         e_key = image_find_option(cfg_option);
 382         if (!e_key) {
 383                 fprintf(stderr, "%s not configured\n", key_name);
 384                 return -ENOENT;
 385         }
 386
 387         res = kwb_load_rsa_key(params->keydir, e_key->key_name, &key);
 388         if (res < 0) {
 389                 fprintf(stderr, "Failed to load %s\n", key_name);
 390                 return -ENOENT;
 391         }
 392
 393         *p_key = key;
 394
 395         return 0;
 396 }
 397
 398 static int kwb_load_kak(struct image_tool_params *params, RSA **p_kak)
 399 {
 400         return kwb_load_cfg_key(params, IMAGE_CFG_KAK, "KAK", p_kak);
 401 }
 402
 403 static int kwb_load_csk(struct image_tool_params *params, RSA **p_csk)
 404 {
 405         return kwb_load_cfg_key(params, IMAGE_CFG_CSK, "CSK", p_csk);
 406 }
 407
 408 static int kwb_compute_pubkey_hash(struct pubkey_der_v1 *pk,
 409                                    struct hash_v1 *hash)
 410 {
 411         EVP_MD_CTX *ctx;
 412         unsigned int key_size;
 413         unsigned int hash_size;
 414         int ret = 0;
 415
 416         if (!pk || !hash || pk->key[0] != 0x30 || pk->key[1] != 0x82)
 417                 return -EINVAL;
 418
 419         key_size = (pk->key[2] << 8) + pk->key[3] + 4;
 420
 421         ctx = EVP_MD_CTX_create();
 422         if (!ctx)
 423                 return openssl_err("EVP context creation failed");
 424
 425         EVP_MD_CTX_init(ctx);
 426         if (!EVP_DigestInit(ctx, EVP_sha256())) {
 427                 ret = openssl_err("Digest setup failed");
 428                 goto hash_err_ctx;
 429         }
 430
 431         if (!EVP_DigestUpdate(ctx, pk->key, key_size)) {
 432                 ret = openssl_err("Hashing data failed");
 433                 goto hash_err_ctx;
 434         }
 435
 436         if (!EVP_DigestFinal(ctx, hash->hash, &hash_size)) {
 437                 ret = openssl_err("Could not obtain hash");
 438                 goto hash_err_ctx;
 439         }
 440
 441         EVP_MD_CTX_cleanup(ctx);
 442
 443 hash_err_ctx:
 444         EVP_MD_CTX_destroy(ctx);
 445         return ret;
 446 }
 447
 448 static int kwb_import_pubkey(RSA **key, struct pubkey_der_v1 *src, char *keyname)
 449 {
 450         RSA *rsa;
 451         const unsigned char *ptr;
 452
 453         if (!key || !src)
 454                 goto fail;
 455
 456         ptr = src->key;
 457         rsa = d2i_RSAPublicKey(key, &ptr, sizeof(src->key));
 458         if (!rsa) {
 459                 openssl_err("error decoding public key");
 460                 goto fail;
 461         }
 462
 463         return 0;
 464 fail:
 465         fprintf(stderr, "Failed to decode %s pubkey\n", keyname);
 466         return -EINVAL;
 467 }
 468
 469 static int kwb_export_pubkey(RSA *key, struct pubkey_der_v1 *dst, FILE *hashf,
 470                              char *keyname)
 471 {
 472         int size_exp, size_mod, size_seq;
 473         uint8_t *cur;
 474         char *errmsg = "Failed to encode %s\n";
 475
 476         if (!key || !key->e || !key->n || !dst) {
 477                 fprintf(stderr, "export pk failed: (%p, %p, %p, %p)",
 478                         key, key->e, key->n, dst);
 479                 fprintf(stderr, errmsg, keyname);
 480                 return -EINVAL;
 481         }
 482
 483         /*
 484          * According to the specs, the key should be PKCS#1 DER encoded.
 485          * But unfortunately the really required encoding seems to be different;
 486          * it violates DER...! (But it still conformes to BER.)
 487          * (Length always in long form w/ 2 byte length code; no leading zero
 488          * when MSB of first byte is set...)
 489          * So we cannot use the encoding func provided by OpenSSL and have to
 490          * do the encoding manually.
 491          */
 492
 493         size_exp = BN_num_bytes(key->e);
 494         size_mod = BN_num_bytes(key->n);
 495         size_seq = 4 + size_mod + 4 + size_exp;
 496
 497         if (size_mod > 256) {
 498                 fprintf(stderr, "export pk failed: wrong mod size: %d\n",
 499                         size_mod);
 500                 fprintf(stderr, errmsg, keyname);
 501                 return -EINVAL;
 502         }
 503
 504         if (4 + size_seq > sizeof(dst->key)) {
 505                 fprintf(stderr, "export pk failed: seq too large (%d, %lu)\n",
 506                         4 + size_seq, sizeof(dst->key));
 507                 fprintf(stderr, errmsg, keyname);
 508                 return -ENOBUFS;
 509         }
 510
 511         cur = dst->key;
 512
 513         /* PKCS#1 (RFC3447) RSAPublicKey structure */
 514         *cur++ = 0x30;          /* SEQUENCE */
 515         *cur++ = 0x82;
 516         *cur++ = (size_seq >> 8) & 0xFF;
 517         *cur++ = size_seq & 0xFF;
 518         /* Modulus */
 519         *cur++ = 0x02;          /* INTEGER */
 520         *cur++ = 0x82;
 521         *cur++ = (size_mod >> 8) & 0xFF;
 522         *cur++ = size_mod & 0xFF;
 523         BN_bn2bin(key->n, cur);
 524         cur += size_mod;
 525         /* Exponent */
 526         *cur++ = 0x02;          /* INTEGER */
 527         *cur++ = 0x82;
 528         *cur++ = (size_exp >> 8) & 0xFF;
 529         *cur++ = size_exp & 0xFF;
 530         BN_bn2bin(key->e, cur);
 531
 532         if (hashf) {
 533                 struct hash_v1 pk_hash;
 534                 int i;
 535                 int ret = 0;
 536
 537                 ret = kwb_compute_pubkey_hash(dst, &pk_hash);
 538                 if (ret < 0) {
 539                         fprintf(stderr, errmsg, keyname);
 540                         return ret;
 541                 }
 542
 543                 fprintf(hashf, "SHA256 = ");
 544                 for (i = 0 ; i < sizeof(pk_hash.hash); ++i)
 545                         fprintf(hashf, "%02X", pk_hash.hash[i]);
 546                 fprintf(hashf, "\n");
 547         }
 548
 549         return 0;
 550 }
 551
 552 int kwb_sign(RSA *key, void *data, int datasz, struct sig_v1 *sig, char *signame)
 553 {
 554         EVP_PKEY *evp_key;
 555         EVP_MD_CTX *ctx;
 556         unsigned int sig_size;
 557         int size;
 558         int ret = 0;
 559
 560         evp_key = EVP_PKEY_new();
 561         if (!evp_key)
 562                 return openssl_err("EVP_PKEY object creation failed");
 563
 564         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 565                 ret = openssl_err("EVP key setup failed");
 566                 goto err_key;
 567         }
 568
 569         size = EVP_PKEY_size(evp_key);
 570         if (size > sizeof(sig->sig)) {
 571                 fprintf(stderr, "Buffer to small for signature (%d bytes)\n",
 572                         size);
 573                 ret = -ENOBUFS;
 574                 goto err_key;
 575         }
 576
 577         ctx = EVP_MD_CTX_create();
 578         if (!ctx) {
 579                 ret = openssl_err("EVP context creation failed");
 580                 goto err_key;
 581         }
 582         EVP_MD_CTX_init(ctx);
 583         if (!EVP_SignInit(ctx, EVP_sha256())) {
 584                 ret = openssl_err("Signer setup failed");
 585                 goto err_ctx;
 586         }
 587
 588         if (!EVP_SignUpdate(ctx, data, datasz)) {
 589                 ret = openssl_err("Signing data failed");
 590                 goto err_ctx;
 591         }
 592
 593         if (!EVP_SignFinal(ctx, sig->sig, &sig_size, evp_key)) {
 594                 ret = openssl_err("Could not obtain signature");
 595                 goto err_ctx;
 596         }
 597
 598         EVP_MD_CTX_cleanup(ctx);
 599         EVP_MD_CTX_destroy(ctx);
 600         EVP_PKEY_free(evp_key);
 601
 602         return 0;
 603
 604 err_ctx:
 605         EVP_MD_CTX_destroy(ctx);
 606 err_key:
 607         EVP_PKEY_free(evp_key);
 608         fprintf(stderr, "Failed to create %s signature\n", signame);
 609         return ret;
 610 }
 611
 612 int kwb_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 613                char *signame)
 614 {
 615         EVP_PKEY *evp_key;
 616         EVP_MD_CTX *ctx;
 617         int size;
 618         int ret = 0;
 619
 620         evp_key = EVP_PKEY_new();
 621         if (!evp_key)
 622                 return openssl_err("EVP_PKEY object creation failed");
 623
 624         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 625                 ret = openssl_err("EVP key setup failed");
 626                 goto err_key;
 627         }
 628
 629         size = EVP_PKEY_size(evp_key);
 630         if (size > sizeof(sig->sig)) {
 631                 fprintf(stderr, "Invalid signature size (%d bytes)\n",
 632                         size);
 633                 ret = -EINVAL;
 634                 goto err_key;
 635         }
 636
 637         ctx = EVP_MD_CTX_create();
 638         if (!ctx) {
 639                 ret = openssl_err("EVP context creation failed");
 640                 goto err_key;
 641         }
 642         EVP_MD_CTX_init(ctx);
 643         if (!EVP_VerifyInit(ctx, EVP_sha256())) {
 644                 ret = openssl_err("Verifier setup failed");
 645                 goto err_ctx;
 646         }
 647
 648         if (!EVP_VerifyUpdate(ctx, data, datasz)) {
 649                 ret = openssl_err("Hashing data failed");
 650                 goto err_ctx;
 651         }
 652
 653         if (!EVP_VerifyFinal(ctx, sig->sig, sizeof(sig->sig), evp_key)) {
 654                 ret = openssl_err("Could not verify signature");
 655                 goto err_ctx;
 656         }
 657
 658         EVP_MD_CTX_cleanup(ctx);
 659         EVP_MD_CTX_destroy(ctx);
 660         EVP_PKEY_free(evp_key);
 661
 662         return 0;
 663
 664 err_ctx:
 665         EVP_MD_CTX_destroy(ctx);
 666 err_key:
 667         EVP_PKEY_free(evp_key);
 668         fprintf(stderr, "Failed to verify %s signature\n", signame);
 669         return ret;
 670 }
 671
 672 int kwb_sign_and_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 673                         char *signame)
 674 {
 675         if (kwb_sign(key, data, datasz, sig, signame) < 0)
 676                 return -1;
 677
 678         if (kwb_verify(key, data, datasz, sig, signame) < 0)
 679                 return -1;
 680
 681         return 0;
 682 }
 683
 684
 685 int kwb_dump_fuse_cmds_38x(FILE *out, struct secure_hdr_v1 *sec_hdr)
 686 {
 687         struct hash_v1 kak_pub_hash;
 688         struct image_cfg_element *e;
 689         unsigned int fuse_line;
 690         int i, idx;
 691         uint8_t *ptr;
 692         uint32_t val;
 693         int ret = 0;
 694
 695         if (!out || !sec_hdr)
 696                 return -EINVAL;
 697
 698         ret = kwb_compute_pubkey_hash(&sec_hdr->kak, &kak_pub_hash);
 699         if (ret < 0)
 700                 goto done;
 701
 702         fprintf(out, "# burn KAK pub key hash\n");
 703         ptr = kak_pub_hash.hash;
 704         for (fuse_line = 26; fuse_line <= 30; ++fuse_line) {
 705                 fprintf(out, "fuse prog -y %u 0 ", fuse_line);
 706
 707                 for (i = 4; i-- > 0;)
 708                         fprintf(out, "%02hx", (ushort)ptr[i]);
 709                 ptr += 4;
 710                 fprintf(out, " 00");
 711
 712                 if (fuse_line < 30) {
 713                         for (i = 3; i-- > 0;)
 714                                 fprintf(out, "%02hx", (ushort)ptr[i]);
 715                         ptr += 3;
 716                 } else {
 717                         fprintf(out, "000000");
 718                 }
 719
 720                 fprintf(out, " 1\n");
 721         }
 722
 723         fprintf(out, "# burn CSK selection\n");
 724
 725         idx = image_get_csk_index();
 726         if (idx < 0 || idx > 15) {
 727                 ret = -EINVAL;
 728                 goto done;
 729         }
 730         if (idx > 0) {
 731                 for (fuse_line = 31; fuse_line < 31 + idx; ++fuse_line)
 732                         fprintf(out, "fuse prog -y %u 0 00000001 00000000 1\n",
 733                                 fuse_line);
 734         } else {
 735                 fprintf(out, "# CSK index is 0; no mods needed\n");
 736         }
 737
 738         e = image_find_option(IMAGE_CFG_BOX_ID);
 739         if (e) {
 740                 fprintf(out, "# set box ID\n");
 741                 fprintf(out, "fuse prog -y 48 0 %08x 00000000 1\n", e->boxid);
 742         }
 743
 744         e = image_find_option(IMAGE_CFG_FLASH_ID);
 745         if (e) {
 746                 fprintf(out, "# set flash ID\n");
 747                 fprintf(out, "fuse prog -y 47 0 %08x 00000000 1\n", e->flashid);
 748         }
 749
 750         fprintf(out, "# enable secure mode ");
 751         fprintf(out, "(must be the last fuse line written)\n");
 752
 753         val = 1;
 754         e = image_find_option(IMAGE_CFG_SEC_BOOT_DEV);
 755         if (!e) {
 756                 fprintf(stderr, "ERROR: secured mode boot device not given\n");
 757                 ret = -EINVAL;
 758                 goto done;
 759         }
 760
 761         if (e->sec_boot_dev > 0xff) {
 762                 fprintf(stderr, "ERROR: secured mode boot device invalid\n");
 763                 ret = -EINVAL;
 764                 goto done;
 765         }
 766
 767         val |= (e->sec_boot_dev << 8);
 768
 769         fprintf(out, "fuse prog -y 24 0 %08x 0103e0a9 1\n", val);
 770
 771         fprintf(out, "# lock (unused) fuse lines (0-23)s\n");
 772         for (fuse_line = 0; fuse_line < 24; ++fuse_line)
 773                 fprintf(out, "fuse prog -y %u 2 1\n", fuse_line);
 774
 775         fprintf(out, "# OK, that's all :-)\n");
 776
 777 done:
 778         return ret;
 779 }
 780
 781 static int kwb_dump_fuse_cmds(struct secure_hdr_v1 *sec_hdr)
 782 {
 783         int ret = 0;
 784         struct image_cfg_element *e;
 785
 786         e = image_find_option(IMAGE_CFG_SEC_FUSE_DUMP);
 787         if (!e)
 788                 return 0;
 789
 790         if (!strcmp(e->name, "a38x")) {
 791                 FILE *out = fopen("kwb_fuses_a38x.txt", "w+");
 792
 793                 kwb_dump_fuse_cmds_38x(out, sec_hdr);
 794                 fclose(out);
 795                 goto done;
 796         }
 797
 798         ret = -ENOSYS;
 799
 800 done:
 801         return ret;
 802 }
 803
 804 #endif
 805
 806 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
 807                              int payloadsz)
 808 {
 809         struct image_cfg_element *e;
 810         size_t headersz;
 811         struct main_hdr_v0 *main_hdr;
 812         uint8_t *image;
 813         int has_ext = 0;
 814
 815         /*
 816          * Calculate the size of the header and the size of the
 817          * payload
 818          */
 819         headersz  = sizeof(struct main_hdr_v0);
 820
 821         if (image_count_options(IMAGE_CFG_DATA) > 0) {
 822                 has_ext = 1;
 823                 headersz += sizeof(struct ext_hdr_v0);
 824         }
 825
 826         if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
 827                 fprintf(stderr, "More than one payload, not possible\n");
 828                 return NULL;
 829         }
 830
 831         image = malloc(headersz);
 832         if (!image) {
 833                 fprintf(stderr, "Cannot allocate memory for image\n");
 834                 return NULL;
 835         }
 836
 837         memset(image, 0, headersz);
 838
 839         main_hdr = (struct main_hdr_v0 *)image;
 840
 841         /* Fill in the main header */
 842         main_hdr->blocksize =
 843                 cpu_to_le32(payloadsz + sizeof(uint32_t) - headersz);
 844         main_hdr->srcaddr   = cpu_to_le32(headersz);
 845         main_hdr->ext       = has_ext;
 846         main_hdr->destaddr  = cpu_to_le32(params->addr);
 847         main_hdr->execaddr  = cpu_to_le32(params->ep);
 848
 849         e = image_find_option(IMAGE_CFG_BOOT_FROM);
 850         if (e)
 851                 main_hdr->blockid = e->bootfrom;
 852         e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
 853         if (e)
 854                 main_hdr->nandeccmode = e->nandeccmode;
 855         e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
 856         if (e)
 857                 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
 858         main_hdr->checksum = image_checksum8(image,
 859                                              sizeof(struct main_hdr_v0));
 860
 861         /* Generate the ext header */
 862         if (has_ext) {
 863                 struct ext_hdr_v0 *ext_hdr;
 864                 int cfgi, datai;
 865
 866                 ext_hdr = (struct ext_hdr_v0 *)
 867                                 (image + sizeof(struct main_hdr_v0));
 868                 ext_hdr->offset = cpu_to_le32(0x40);
 869
 870                 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
 871                         e = &image_cfg[cfgi];
 872                         if (e->type != IMAGE_CFG_DATA)
 873                                 continue;
 874
 875                         ext_hdr->rcfg[datai].raddr =
 876                                 cpu_to_le32(e->regdata.raddr);
 877                         ext_hdr->rcfg[datai].rdata =
 878                                 cpu_to_le32(e->regdata.rdata);
 879                         datai++;
 880                 }
 881
 882                 ext_hdr->checksum = image_checksum8(ext_hdr,
 883                                                     sizeof(struct ext_hdr_v0));
 884         }
 885
 886         *imagesz = headersz;
 887         return image;
 888 }
 889
 890 static size_t image_headersz_v1(int *hasext)
 891 {
 892         struct image_cfg_element *binarye;
 893         size_t headersz;
 894
 895         /*
 896          * Calculate the size of the header and the size of the
 897          * payload
 898          */
 899         headersz = sizeof(struct main_hdr_v1);
 900
 901         if (image_count_options(IMAGE_CFG_BINARY) > 1) {
 902                 fprintf(stderr, "More than one binary blob, not supported\n");
 903                 return 0;
 904         }
 905
 906         if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
 907                 fprintf(stderr, "More than one payload, not possible\n");
 908                 return 0;
 909         }
 910
 911         binarye = image_find_option(IMAGE_CFG_BINARY);
 912         if (binarye) {
 913                 int ret;
 914                 struct stat s;
 915
 916                 ret = stat(binarye->binary.file, &s);
 917                 if (ret < 0) {
 918                         char cwd[PATH_MAX];
 919                         char *dir = cwd;
 920
 921                         memset(cwd, 0, sizeof(cwd));
 922                         if (!getcwd(cwd, sizeof(cwd))) {
 923                                 dir = "current working directory";
 924                                 perror("getcwd() failed");
 925                         }
 926
 927                         fprintf(stderr,
 928                                 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
 929                                 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
 930                                 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
 931                                 binarye->binary.file, dir);
 932                         return 0;
 933                 }
 934
 935                 headersz += sizeof(struct opt_hdr_v1) +
 936                         s.st_size +
 937                         (binarye->binary.nargs + 2) * sizeof(uint32_t);
 938                 if (hasext)
 939                         *hasext = 1;
 940         }
 941
 942 #if defined(CONFIG_KWB_SECURE)
 943         if (image_get_csk_index() >= 0) {
 944                 headersz += sizeof(struct secure_hdr_v1);
 945                 if (hasext)
 946                         *hasext = 1;
 947         }
 948 #endif
 949
 950 #if defined(CONFIG_SYS_U_BOOT_OFFS)
 951         if (headersz > CONFIG_SYS_U_BOOT_OFFS) {
 952                 fprintf(stderr,
 953                         "Error: Image header (incl. SPL image) too big!\n");
 954                 fprintf(stderr, "header=0x%x CONFIG_SYS_U_BOOT_OFFS=0x%x!\n",
 955                         (int)headersz, CONFIG_SYS_U_BOOT_OFFS);
 956                 fprintf(stderr, "Increase CONFIG_SYS_U_BOOT_OFFS!\n");
 957                 return 0;
 958         }
 959
 960         headersz = CONFIG_SYS_U_BOOT_OFFS;
 961 #endif
 962
 963         /*
 964          * The payload should be aligned on some reasonable
 965          * boundary
 966          */
 967         return ALIGN_SUP(headersz, 4096);
 968 }
 969
 970 int add_binary_header_v1(uint8_t *cur)
 971 {
 972         struct image_cfg_element *binarye;
 973         struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)cur;
 974         uint32_t *args;
 975         size_t binhdrsz;
 976         struct stat s;
 977         int argi;
 978         FILE *bin;
 979         int ret;
 980
 981         binarye = image_find_option(IMAGE_CFG_BINARY);
 982
 983         if (!binarye)
 984                 return 0;
 985
 986         hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
 987
 988         bin = fopen(binarye->binary.file, "r");
 989         if (!bin) {
 990                 fprintf(stderr, "Cannot open binary file %s\n",
 991                         binarye->binary.file);
 992                 return -1;
 993         }
 994
 995         fstat(fileno(bin), &s);
 996
 997         binhdrsz = sizeof(struct opt_hdr_v1) +
 998                 (binarye->binary.nargs + 2) * sizeof(uint32_t) +
 999                 s.st_size;
1000
1001         /*
1002          * The size includes the binary image size, rounded
1003          * up to a 4-byte boundary. Plus 4 bytes for the
1004          * next-header byte and 3-byte alignment at the end.
1005          */
1006         binhdrsz = ALIGN_SUP(binhdrsz, 4) + 4;
1007         hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF);
1008         hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
1009
1010         cur += sizeof(struct opt_hdr_v1);
1011
1012         args = (uint32_t *)cur;
1013         *args = cpu_to_le32(binarye->binary.nargs);
1014         args++;
1015         for (argi = 0; argi < binarye->binary.nargs; argi++)
1016                 args[argi] = cpu_to_le32(binarye->binary.args[argi]);
1017
1018         cur += (binarye->binary.nargs + 1) * sizeof(uint32_t);
1019
1020         ret = fread(cur, s.st_size, 1, bin);
1021         if (ret != 1) {
1022                 fprintf(stderr,
1023                         "Could not read binary image %s\n",
1024                         binarye->binary.file);
1025                 return -1;
1026         }
1027
1028         fclose(bin);
1029
1030         cur += ALIGN_SUP(s.st_size, 4);
1031
1032         /*
1033          * For now, we don't support more than one binary
1034          * header, and no other header types are
1035          * supported. So, the binary header is necessarily the
1036          * last one
1037          */
1038         *((uint32_t *)cur) = 0x00000000;
1039
1040         cur += sizeof(uint32_t);
1041
1042         return 0;
1043 }
1044
1045 #if defined(CONFIG_KWB_SECURE)
1046
1047 int export_pub_kak_hash(RSA *kak, struct secure_hdr_v1 *secure_hdr)
1048 {
1049         FILE *hashf;
1050         int res;
1051
1052         hashf = fopen("pub_kak_hash.txt", "w");
1053
1054         res = kwb_export_pubkey(kak, &secure_hdr->kak, hashf, "KAK");
1055
1056         fclose(hashf);
1057
1058         return res < 0 ? 1 : 0;
1059 }
1060
1061 int kwb_sign_csk_with_kak(struct image_tool_params *params,
1062                           struct secure_hdr_v1 *secure_hdr, RSA *csk)
1063 {
1064         RSA *kak = NULL;
1065         RSA *kak_pub = NULL;
1066         int csk_idx = image_get_csk_index();
1067         struct sig_v1 tmp_sig;
1068
1069         if (csk_idx >= 16) {
1070                 fprintf(stderr, "Invalid CSK index %d\n", csk_idx);
1071                 return 1;
1072         }
1073
1074         if (kwb_load_kak(params, &kak) < 0)
1075                 return 1;
1076
1077         if (export_pub_kak_hash(kak, secure_hdr))
1078                 return 1;
1079
1080         if (kwb_import_pubkey(&kak_pub, &secure_hdr->kak, "KAK") < 0)
1081                 return 1;
1082
1083         if (kwb_export_pubkey(csk, &secure_hdr->csk[csk_idx], NULL, "CSK") < 0)
1084                 return 1;
1085
1086         if (kwb_sign_and_verify(kak, &secure_hdr->csk,
1087                                 sizeof(secure_hdr->csk) +
1088                                 sizeof(secure_hdr->csksig),
1089                                 &tmp_sig, "CSK") < 0)
1090                 return 1;
1091
1092         if (kwb_verify(kak_pub, &secure_hdr->csk,
1093                        sizeof(secure_hdr->csk) +
1094                        sizeof(secure_hdr->csksig),
1095                        &tmp_sig, "CSK (2)") < 0)
1096                 return 1;
1097
1098         secure_hdr->csksig = tmp_sig;
1099
1100         return 0;
1101 }
1102
1103 int add_secure_header_v1(struct image_tool_params *params, uint8_t *ptr,
1104                          int payloadsz, size_t headersz, uint8_t *image,
1105                          struct secure_hdr_v1 *secure_hdr)
1106 {
1107         struct image_cfg_element *e_jtagdelay;
1108         struct image_cfg_element *e_boxid;
1109         struct image_cfg_element *e_flashid;
1110         RSA *csk = NULL;
1111         unsigned char *image_ptr;
1112         size_t image_size;
1113         struct sig_v1 tmp_sig;
1114         bool specialized_img = image_get_spezialized_img();
1115
1116         kwb_msg("Create secure header content\n");
1117
1118         e_jtagdelay = image_find_option(IMAGE_CFG_JTAG_DELAY);
1119         e_boxid = image_find_option(IMAGE_CFG_BOX_ID);
1120         e_flashid = image_find_option(IMAGE_CFG_FLASH_ID);
1121
1122         if (kwb_load_csk(params, &csk) < 0)
1123                 return 1;
1124
1125         secure_hdr->headertype = OPT_HDR_V1_SECURE_TYPE;
1126         secure_hdr->headersz_msb = 0;
1127         secure_hdr->headersz_lsb = cpu_to_le16(sizeof(struct secure_hdr_v1));
1128         if (e_jtagdelay)
1129                 secure_hdr->jtag_delay = e_jtagdelay->jtag_delay;
1130         if (e_boxid && specialized_img)
1131                 secure_hdr->boxid = cpu_to_le32(e_boxid->boxid);
1132         if (e_flashid && specialized_img)
1133                 secure_hdr->flashid = cpu_to_le32(e_flashid->flashid);
1134
1135         if (kwb_sign_csk_with_kak(params, secure_hdr, csk))
1136                 return 1;
1137
1138         image_ptr = ptr + headersz;
1139         image_size = payloadsz - headersz;
1140
1141         if (kwb_sign_and_verify(csk, image_ptr, image_size,
1142                                 &secure_hdr->imgsig, "image") < 0)
1143                 return 1;
1144
1145         if (kwb_sign_and_verify(csk, image, headersz, &tmp_sig, "header") < 0)
1146                 return 1;
1147
1148         secure_hdr->hdrsig = tmp_sig;
1149
1150         kwb_dump_fuse_cmds(secure_hdr);
1151
1152         return 0;
1153 }
1154 #endif
1155
1156 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
1157                              uint8_t *ptr, int payloadsz)
1158 {
1159         struct image_cfg_element *e;
1160         struct main_hdr_v1 *main_hdr;
1161 #if defined(CONFIG_KWB_SECURE)
1162         struct secure_hdr_v1 *secure_hdr = NULL;
1163 #endif
1164         size_t headersz;
1165         uint8_t *image, *cur;
1166         int hasext = 0;
1167         uint8_t *next_ext = NULL;
1168
1169         /*
1170          * Calculate the size of the header and the size of the
1171          * payload
1172          */
1173         headersz = image_headersz_v1(&hasext);
1174         if (headersz == 0)
1175                 return NULL;
1176
1177         image = malloc(headersz);
1178         if (!image) {
1179                 fprintf(stderr, "Cannot allocate memory for image\n");
1180                 return NULL;
1181         }
1182
1183         memset(image, 0, headersz);
1184
1185         main_hdr = (struct main_hdr_v1 *)image;
1186         cur = image;
1187         cur += sizeof(struct main_hdr_v1);
1188         next_ext = &main_hdr->ext;
1189
1190         /* Fill the main header */
1191         main_hdr->blocksize    =
1192                 cpu_to_le32(payloadsz - headersz + sizeof(uint32_t));
1193         main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1194         main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1195         main_hdr->destaddr     = cpu_to_le32(params->addr)
1196                                  - sizeof(image_header_t);
1197         main_hdr->execaddr     = cpu_to_le32(params->ep);
1198         main_hdr->srcaddr      = cpu_to_le32(headersz);
1199         main_hdr->ext          = hasext;
1200         main_hdr->version      = 1;
1201         e = image_find_option(IMAGE_CFG_BOOT_FROM);
1202         if (e)
1203                 main_hdr->blockid = e->bootfrom;
1204         e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1205         if (e)
1206                 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1207         e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1208         if (e)
1209                 main_hdr->nandbadblklocation = e->nandbadblklocation;
1210         e = image_find_option(IMAGE_CFG_BAUDRATE);
1211         if (e)
1212                 main_hdr->options = baudrate_to_option(e->baudrate);
1213         e = image_find_option(IMAGE_CFG_DEBUG);
1214         if (e)
1215                 main_hdr->flags = e->debug ? 0x1 : 0;
1216
1217 #if defined(CONFIG_KWB_SECURE)
1218         if (image_get_csk_index() >= 0) {
1219                 /*
1220                  * only reserve the space here; we fill the header later since
1221                  * we need the header to be complete to compute the signatures
1222                  */
1223                 secure_hdr = (struct secure_hdr_v1 *)cur;
1224                 cur += sizeof(struct secure_hdr_v1);
1225                 next_ext = &secure_hdr->next;
1226         }
1227 #endif
1228         *next_ext = 1;
1229
1230         if (add_binary_header_v1(cur))
1231                 return NULL;
1232
1233 #if defined(CONFIG_KWB_SECURE)
1234         if (secure_hdr && add_secure_header_v1(params, ptr, payloadsz,
1235                                                headersz, image, secure_hdr))
1236                 return NULL;
1237 #endif
1238
1239         /* Calculate and set the header checksum */
1240         main_hdr->checksum = image_checksum8(main_hdr, headersz);
1241
1242         *imagesz = headersz;
1243         return image;
1244 }
1245
1246 int recognize_keyword(char *keyword)
1247 {
1248         int kw_id;
1249
1250         for (kw_id = 1; kw_id < IMAGE_CFG_COUNT; ++kw_id)
1251                 if (!strcmp(keyword, id_strs[kw_id]))
1252                         return kw_id;
1253
1254         return 0;
1255 }
1256
1257 static int image_create_config_parse_oneline(char *line,
1258                                              struct image_cfg_element *el)
1259 {
1260         char *keyword, *saveptr, *value1, *value2;
1261         char delimiters[] = " \t";
1262         int keyword_id, ret, argi;
1263         char *unknown_msg = "Ignoring unknown line '%s'\n";
1264
1265         keyword = strtok_r(line, delimiters, &saveptr);
1266         keyword_id = recognize_keyword(keyword);
1267
1268         if (!keyword_id) {
1269                 fprintf(stderr, unknown_msg, line);
1270                 return 0;
1271         }
1272
1273         el->type = keyword_id;
1274
1275         value1 = strtok_r(NULL, delimiters, &saveptr);
1276
1277         if (!value1) {
1278                 fprintf(stderr, "Parameter missing in line '%s'\n", line);
1279                 return -1;
1280         }
1281
1282         switch (keyword_id) {
1283         case IMAGE_CFG_VERSION:
1284                 el->version = atoi(value1);
1285                 break;
1286         case IMAGE_CFG_BOOT_FROM:
1287                 ret = image_boot_mode_id(value1);
1288
1289                 if (ret < 0) {
1290                         fprintf(stderr, "Invalid boot media '%s'\n", value1);
1291                         return -1;
1292                 }
1293                 el->bootfrom = ret;
1294                 break;
1295         case IMAGE_CFG_NAND_BLKSZ:
1296                 el->nandblksz = strtoul(value1, NULL, 16);
1297                 break;
1298         case IMAGE_CFG_NAND_BADBLK_LOCATION:
1299                 el->nandbadblklocation = strtoul(value1, NULL, 16);
1300                 break;
1301         case IMAGE_CFG_NAND_ECC_MODE:
1302                 ret = image_nand_ecc_mode_id(value1);
1303
1304                 if (ret < 0) {
1305                         fprintf(stderr, "Invalid NAND ECC mode '%s'\n", value1);
1306                         return -1;
1307                 }
1308                 el->nandeccmode = ret;
1309                 break;
1310         case IMAGE_CFG_NAND_PAGESZ:
1311                 el->nandpagesz = strtoul(value1, NULL, 16);
1312                 break;
1313         case IMAGE_CFG_BINARY:
1314                 argi = 0;
1315
1316                 el->binary.file = strdup(value1);
1317                 while (1) {
1318                         char *value = strtok_r(NULL, delimiters, &saveptr);
1319
1320                         if (!value)
1321                                 break;
1322                         el->binary.args[argi] = strtoul(value, NULL, 16);
1323                         argi++;
1324                         if (argi >= BINARY_MAX_ARGS) {
1325                                 fprintf(stderr,
1326                                         "Too many arguments for BINARY\n");
1327                                 return -1;
1328                         }
1329                 }
1330                 el->binary.nargs = argi;
1331                 break;
1332         case IMAGE_CFG_DATA:
1333                 value2 = strtok_r(NULL, delimiters, &saveptr);
1334
1335                 if (!value1 || !value2) {
1336                         fprintf(stderr,
1337                                 "Invalid number of arguments for DATA\n");
1338                         return -1;
1339                 }
1340
1341                 el->regdata.raddr = strtoul(value1, NULL, 16);
1342                 el->regdata.rdata = strtoul(value2, NULL, 16);
1343                 break;
1344         case IMAGE_CFG_BAUDRATE:
1345                 el->baudrate = strtoul(value1, NULL, 10);
1346                 break;
1347         case IMAGE_CFG_DEBUG:
1348                 el->debug = strtoul(value1, NULL, 10);
1349                 break;
1350         case IMAGE_CFG_KAK:
1351                 el->key_name = strdup(value1);
1352                 break;
1353         case IMAGE_CFG_CSK:
1354                 el->key_name = strdup(value1);
1355                 break;
1356         case IMAGE_CFG_CSK_INDEX:
1357                 el->csk_idx = strtol(value1, NULL, 0);
1358                 break;
1359         case IMAGE_CFG_JTAG_DELAY:
1360                 el->jtag_delay = strtoul(value1, NULL, 0);
1361                 break;
1362         case IMAGE_CFG_BOX_ID:
1363                 el->boxid = strtoul(value1, NULL, 0);
1364                 break;
1365         case IMAGE_CFG_FLASH_ID:
1366                 el->flashid = strtoul(value1, NULL, 0);
1367                 break;
1368         case IMAGE_CFG_SEC_SPECIALIZED_IMG:
1369                 el->sec_specialized_img = true;
1370                 break;
1371         case IMAGE_CFG_SEC_COMMON_IMG:
1372                 el->sec_specialized_img = false;
1373                 break;
1374         case IMAGE_CFG_SEC_BOOT_DEV:
1375                 el->sec_boot_dev = strtoul(value1, NULL, 0);
1376                 break;
1377         case IMAGE_CFG_SEC_FUSE_DUMP:
1378                 el->name = strdup(value1);
1379                 break;
1380         default:
1381                 fprintf(stderr, unknown_msg, line);
1382         }
1383
1384         return 0;
1385 }
1386
1387 /*
1388  * Parse the configuration file 'fcfg' into the array of configuration
1389  * elements 'image_cfg', and return the number of configuration
1390  * elements in 'cfgn'.
1391  */
1392 static int image_create_config_parse(FILE *fcfg)
1393 {
1394         int ret;
1395         int cfgi = 0;
1396
1397         /* Parse the configuration file */
1398         while (!feof(fcfg)) {
1399                 char *line;
1400                 char buf[256];
1401
1402                 /* Read the current line */
1403                 memset(buf, 0, sizeof(buf));
1404                 line = fgets(buf, sizeof(buf), fcfg);
1405                 if (!line)
1406                         break;
1407
1408                 /* Ignore useless lines */
1409                 if (line[0] == '\n' || line[0] == '#')
1410                         continue;
1411
1412                 /* Strip final newline */
1413                 if (line[strlen(line) - 1] == '\n')
1414                         line[strlen(line) - 1] = 0;
1415
1416                 /* Parse the current line */
1417                 ret = image_create_config_parse_oneline(line,
1418                                                         &image_cfg[cfgi]);
1419                 if (ret)
1420                         return ret;
1421
1422                 cfgi++;
1423
1424                 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
1425                         fprintf(stderr,
1426                                 "Too many configuration elements in .cfg file\n");
1427                         return -1;
1428                 }
1429         }
1430
1431         cfgn = cfgi;
1432         return 0;
1433 }
1434
1435 static int image_get_version(void)
1436 {
1437         struct image_cfg_element *e;
1438
1439         e = image_find_option(IMAGE_CFG_VERSION);
1440         if (!e)
1441                 return -1;
1442
1443         return e->version;
1444 }
1445
1446 static int image_version_file(const char *input)
1447 {
1448         FILE *fcfg;
1449         int version;
1450         int ret;
1451
1452         fcfg = fopen(input, "r");
1453         if (!fcfg) {
1454                 fprintf(stderr, "Could not open input file %s\n", input);
1455                 return -1;
1456         }
1457
1458         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1459                            sizeof(struct image_cfg_element));
1460         if (!image_cfg) {
1461                 fprintf(stderr, "Cannot allocate memory\n");
1462                 fclose(fcfg);
1463                 return -1;
1464         }
1465
1466         memset(image_cfg, 0,
1467                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1468         rewind(fcfg);
1469
1470         ret = image_create_config_parse(fcfg);
1471         fclose(fcfg);
1472         if (ret) {
1473                 free(image_cfg);
1474                 return -1;
1475         }
1476
1477         version = image_get_version();
1478         /* Fallback to version 0 is no version is provided in the cfg file */
1479         if (version == -1)
1480                 version = 0;
1481
1482         free(image_cfg);
1483
1484         return version;
1485 }
1486
1487 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
1488                                 struct image_tool_params *params)
1489 {
1490         FILE *fcfg;
1491         void *image = NULL;
1492         int version;
1493         size_t headersz = 0;
1494         uint32_t checksum;
1495         int ret;
1496         int size;
1497
1498         fcfg = fopen(params->imagename, "r");
1499         if (!fcfg) {
1500                 fprintf(stderr, "Could not open input file %s\n",
1501                         params->imagename);
1502                 exit(EXIT_FAILURE);
1503         }
1504
1505         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1506                            sizeof(struct image_cfg_element));
1507         if (!image_cfg) {
1508                 fprintf(stderr, "Cannot allocate memory\n");
1509                 fclose(fcfg);
1510                 exit(EXIT_FAILURE);
1511         }
1512
1513         memset(image_cfg, 0,
1514                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1515         rewind(fcfg);
1516
1517         ret = image_create_config_parse(fcfg);
1518         fclose(fcfg);
1519         if (ret) {
1520                 free(image_cfg);
1521                 exit(EXIT_FAILURE);
1522         }
1523
1524         /* The MVEBU BootROM does not allow non word aligned payloads */
1525         sbuf->st_size = ALIGN_SUP(sbuf->st_size, 4);
1526
1527         version = image_get_version();
1528         switch (version) {
1529                 /*
1530                  * Fallback to version 0 if no version is provided in the
1531                  * cfg file
1532                  */
1533         case -1:
1534         case 0:
1535                 image = image_create_v0(&headersz, params, sbuf->st_size);
1536                 break;
1537
1538         case 1:
1539                 image = image_create_v1(&headersz, params, ptr, sbuf->st_size);
1540                 break;
1541
1542         default:
1543                 fprintf(stderr, "Unsupported version %d\n", version);
1544                 free(image_cfg);
1545                 exit(EXIT_FAILURE);
1546         }
1547
1548         if (!image) {
1549                 fprintf(stderr, "Could not create image\n");
1550                 free(image_cfg);
1551                 exit(EXIT_FAILURE);
1552         }
1553
1554         free(image_cfg);
1555
1556         /* Build and add image checksum header */
1557         checksum =
1558                 cpu_to_le32(image_checksum32((uint32_t *)ptr, sbuf->st_size));
1559         size = write(ifd, &checksum, sizeof(uint32_t));
1560         if (size != sizeof(uint32_t)) {
1561                 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
1562                         params->cmdname, size, params->imagefile);
1563                 exit(EXIT_FAILURE);
1564         }
1565
1566         sbuf->st_size += sizeof(uint32_t);
1567
1568         /* Finally copy the header into the image area */
1569         memcpy(ptr, image, headersz);
1570
1571         free(image);
1572 }
1573
1574 static void kwbimage_print_header(const void *ptr)
1575 {
1576         struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1577
1578         printf("Image Type:   MVEBU Boot from %s Image\n",
1579                image_boot_mode_name(mhdr->blockid));
1580         printf("Image version:%d\n", image_version((void *)ptr));
1581         printf("Data Size:    ");
1582         genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
1583         printf("Load Address: %08x\n", mhdr->destaddr);
1584         printf("Entry Point:  %08x\n", mhdr->execaddr);
1585 }
1586
1587 static int kwbimage_check_image_types(uint8_t type)
1588 {
1589         if (type == IH_TYPE_KWBIMAGE)
1590                 return EXIT_SUCCESS;
1591
1592         return EXIT_FAILURE;
1593 }
1594
1595 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
1596                                   struct image_tool_params *params)
1597 {
1598         struct main_hdr_v0 *main_hdr;
1599         uint8_t checksum;
1600
1601         main_hdr = (struct main_hdr_v0 *)ptr;
1602         checksum = image_checksum8(ptr,
1603                                    sizeof(struct main_hdr_v0)
1604                                    - sizeof(uint8_t));
1605         if (checksum != main_hdr->checksum)
1606                 return -FDT_ERR_BADSTRUCTURE;
1607
1608         /* Only version 0 extended header has checksum */
1609         if (image_version((void *)ptr) == 0) {
1610                 struct ext_hdr_v0 *ext_hdr;
1611
1612                 ext_hdr = (struct ext_hdr_v0 *)
1613                                 (ptr + sizeof(struct main_hdr_v0));
1614                 checksum = image_checksum8(ext_hdr,
1615                                            sizeof(struct ext_hdr_v0)
1616                                            - sizeof(uint8_t));
1617                 if (checksum != ext_hdr->checksum)
1618                         return -FDT_ERR_BADSTRUCTURE;
1619         }
1620
1621         return 0;
1622 }
1623
1624 static int kwbimage_generate(struct image_tool_params *params,
1625                              struct image_type_params *tparams)
1626 {
1627         int alloc_len;
1628         void *hdr;
1629         int version = 0;
1630
1631         version = image_version_file(params->imagename);
1632         if (version == 0) {
1633                 alloc_len = sizeof(struct main_hdr_v0) +
1634                         sizeof(struct ext_hdr_v0);
1635         } else {
1636                 alloc_len = image_headersz_v1(NULL);
1637         }
1638
1639         hdr = malloc(alloc_len);
1640         if (!hdr) {
1641                 fprintf(stderr, "%s: malloc return failure: %s\n",
1642                         params->cmdname, strerror(errno));
1643                 exit(EXIT_FAILURE);
1644         }
1645
1646         memset(hdr, 0, alloc_len);
1647         tparams->header_size = alloc_len;
1648         tparams->hdr = hdr;
1649
1650         /*
1651          * The resulting image needs to be 4-byte aligned. At least
1652          * the Marvell hdrparser tool complains if its unaligned.
1653          * By returning 1 here in this function, called via
1654          * tparams->vrec_header() in mkimage.c, mkimage will
1655          * automatically pad the the resulting image to a 4-byte
1656          * size if necessary.
1657          */
1658         return 1;
1659 }
1660
1661 /*
1662  * Report Error if xflag is set in addition to default
1663  */
1664 static int kwbimage_check_params(struct image_tool_params *params)
1665 {
1666         if (!strlen(params->imagename)) {
1667                 char *msg = "Configuration file for kwbimage creation omitted";
1668
1669                 fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg);
1670                 return CFG_INVALID;
1671         }
1672
1673         return (params->dflag && (params->fflag || params->lflag)) ||
1674                 (params->fflag && (params->dflag || params->lflag)) ||
1675                 (params->lflag && (params->dflag || params->fflag)) ||
1676                 (params->xflag) || !(strlen(params->imagename));
1677 }
1678
1679 /*
1680  * kwbimage type parameters definition
1681  */
1682 U_BOOT_IMAGE_TYPE(
1683         kwbimage,
1684         "Marvell MVEBU Boot Image support",
1685         0,
1686         NULL,
1687         kwbimage_check_params,
1688         kwbimage_verify_header,
1689         kwbimage_print_header,
1690         kwbimage_set_header,
1691         NULL,
1692         kwbimage_check_image_types,
1693         NULL,
1694         kwbimage_generate
1695 );