1 /* 2 * Freescale i.MX23/i.MX28 SB image generator 3 * 4 * Copyright (C) 2012-2013 Marek Vasut <marex@denx.de> 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #ifdef CONFIG_MXS 10 11 #include <errno.h> 12 #include <fcntl.h> 13 #include <stdio.h> 14 #include <string.h> 15 #include <unistd.h> 16 #include <limits.h> 17 18 #include <openssl/evp.h> 19 20 #include "imagetool.h" 21 #include "mxsimage.h" 22 #include "pbl_crc32.h" 23 #include <image.h> 24 25 26 /* 27 * DCD block 28 * |-Write to address command block 29 * | 0xf00 == 0xf33d 30 * | 0xba2 == 0xb33f 31 * |-ORR address with mask command block 32 * | 0xf00 |= 0x1337 33 * |-Write to address command block 34 * | 0xba2 == 0xd00d 35 * : 36 */ 37 #define SB_HAB_DCD_WRITE 0xccUL 38 #define SB_HAB_DCD_CHECK 0xcfUL 39 #define SB_HAB_DCD_NOOP 0xc0UL 40 #define SB_HAB_DCD_MASK_BIT (1 << 3) 41 #define SB_HAB_DCD_SET_BIT (1 << 4) 42 43 /* Addr.n = Value.n */ 44 #define SB_DCD_WRITE \ 45 (SB_HAB_DCD_WRITE << 24) 46 /* Addr.n &= ~Value.n */ 47 #define SB_DCD_ANDC \ 48 ((SB_HAB_DCD_WRITE << 24) | SB_HAB_DCD_SET_BIT) 49 /* Addr.n |= Value.n */ 50 #define SB_DCD_ORR \ 51 ((SB_HAB_DCD_WRITE << 24) | SB_HAB_DCD_SET_BIT | SB_HAB_DCD_MASK_BIT) 52 /* (Addr.n & Value.n) == 0 */ 53 #define SB_DCD_CHK_EQZ \ 54 (SB_HAB_DCD_CHECK << 24) 55 /* (Addr.n & Value.n) == Value.n */ 56 #define SB_DCD_CHK_EQ \ 57 ((SB_HAB_DCD_CHECK << 24) | SB_HAB_DCD_SET_BIT) 58 /* (Addr.n & Value.n) != Value.n */ 59 #define SB_DCD_CHK_NEQ \ 60 ((SB_HAB_DCD_CHECK << 24) | SB_HAB_DCD_MASK_BIT) 61 /* (Addr.n & Value.n) != 0 */ 62 #define SB_DCD_CHK_NEZ \ 63 ((SB_HAB_DCD_CHECK << 24) | SB_HAB_DCD_SET_BIT | SB_HAB_DCD_MASK_BIT) 64 /* NOP */ 65 #define SB_DCD_NOOP \ 66 (SB_HAB_DCD_NOOP << 24) 67 68 struct sb_dcd_ctx { 69 struct sb_dcd_ctx *dcd; 70 71 uint32_t id; 72 73 /* The DCD block. */ 74 uint32_t *payload; 75 /* Size of the whole DCD block. */ 76 uint32_t size; 77 78 /* Pointer to previous DCD command block. */ 79 uint32_t *prev_dcd_head; 80 }; 81 82 /* 83 * IMAGE 84 * |-SECTION 85 * | |-CMD 86 * | |-CMD 87 * | `-CMD 88 * |-SECTION 89 * | |-CMD 90 * : : 91 */ 92 struct sb_cmd_list { 93 char *cmd; 94 size_t len; 95 unsigned int lineno; 96 }; 97 98 struct sb_cmd_ctx { 99 uint32_t size; 100 101 struct sb_cmd_ctx *cmd; 102 103 uint8_t *data; 104 uint32_t length; 105 106 struct sb_command payload; 107 struct sb_command c_payload; 108 }; 109 110 struct sb_section_ctx { 111 uint32_t size; 112 113 /* Section flags */ 114 unsigned int boot:1; 115 116 struct sb_section_ctx *sect; 117 118 struct sb_cmd_ctx *cmd_head; 119 struct sb_cmd_ctx *cmd_tail; 120 121 struct sb_sections_header payload; 122 }; 123 124 struct sb_image_ctx { 125 unsigned int in_section:1; 126 unsigned int in_dcd:1; 127 /* Image configuration */ 128 unsigned int display_progress:1; 129 unsigned int silent_dump:1; 130 char *input_filename; 131 char *output_filename; 132 char *cfg_filename; 133 uint8_t image_key[16]; 134 135 /* Number of section in the image */ 136 unsigned int sect_count; 137 /* Bootable section */ 138 unsigned int sect_boot; 139 unsigned int sect_boot_found:1; 140 141 struct sb_section_ctx *sect_head; 142 struct sb_section_ctx *sect_tail; 143 144 struct sb_dcd_ctx *dcd_head; 145 struct sb_dcd_ctx *dcd_tail; 146 147 EVP_CIPHER_CTX cipher_ctx; 148 EVP_MD_CTX md_ctx; 149 uint8_t digest[32]; 150 struct sb_key_dictionary_key sb_dict_key; 151 152 struct sb_boot_image_header payload; 153 }; 154 155 /* 156 * Instruction semantics: 157 * NOOP 158 * TAG [LAST] 159 * LOAD address file 160 * LOAD IVT address IVT_entry_point 161 * FILL address pattern length 162 * JUMP [HAB] address [r0_arg] 163 * CALL [HAB] address [r0_arg] 164 * MODE mode 165 * For i.MX23, mode = USB/I2C/SPI1_FLASH/SPI2_FLASH/NAND_BCH 166 * JTAG/SPI3_EEPROM/SD_SSP0/SD_SSP1 167 * For i.MX28, mode = USB/I2C/SPI2_FLASH/SPI3_FLASH/NAND_BCH 168 * JTAG/SPI2_EEPROM/SD_SSP0/SD_SSP1 169 */ 170 171 /* 172 * AES libcrypto 173 */ 174 static int sb_aes_init(struct sb_image_ctx *ictx, uint8_t *iv, int enc) 175 { 176 EVP_CIPHER_CTX *ctx = &ictx->cipher_ctx; 177 int ret; 178 179 /* If there is no init vector, init vector is all zeroes. */ 180 if (!iv) 181 iv = ictx->image_key; 182 183 EVP_CIPHER_CTX_init(ctx); 184 ret = EVP_CipherInit(ctx, EVP_aes_128_cbc(), ictx->image_key, iv, enc); 185 if (ret == 1) 186 EVP_CIPHER_CTX_set_padding(ctx, 0); 187 return ret; 188 } 189 190 static int sb_aes_crypt(struct sb_image_ctx *ictx, uint8_t *in_data, 191 uint8_t *out_data, int in_len) 192 { 193 EVP_CIPHER_CTX *ctx = &ictx->cipher_ctx; 194 int ret, outlen; 195 uint8_t *outbuf; 196 197 outbuf = malloc(in_len); 198 if (!outbuf) 199 return -ENOMEM; 200 memset(outbuf, 0, sizeof(in_len)); 201 202 ret = EVP_CipherUpdate(ctx, outbuf, &outlen, in_data, in_len); 203 if (!ret) { 204 ret = -EINVAL; 205 goto err; 206 } 207 208 if (out_data) 209 memcpy(out_data, outbuf, outlen); 210 211 err: 212 free(outbuf); 213 return ret; 214 } 215 216 static int sb_aes_deinit(EVP_CIPHER_CTX *ctx) 217 { 218 return EVP_CIPHER_CTX_cleanup(ctx); 219 } 220 221 static int sb_aes_reinit(struct sb_image_ctx *ictx, int enc) 222 { 223 int ret; 224 EVP_CIPHER_CTX *ctx = &ictx->cipher_ctx; 225 struct sb_boot_image_header *sb_header = &ictx->payload; 226 uint8_t *iv = sb_header->iv; 227 228 ret = sb_aes_deinit(ctx); 229 if (!ret) 230 return ret; 231 return sb_aes_init(ictx, iv, enc); 232 } 233 234 /* 235 * Debug 236 */ 237 static void soprintf(struct sb_image_ctx *ictx, const char *fmt, ...) 238 { 239 va_list ap; 240 241 if (ictx->silent_dump) 242 return; 243 244 va_start(ap, fmt); 245 vfprintf(stdout, fmt, ap); 246 va_end(ap); 247 } 248 249 /* 250 * Code 251 */ 252 static time_t sb_get_timestamp(void) 253 { 254 struct tm time_2000 = { 255 .tm_yday = 1, /* Jan. 1st */ 256 .tm_year = 100, /* 2000 */ 257 }; 258 time_t seconds_to_2000 = mktime(&time_2000); 259 time_t seconds_to_now = time(NULL); 260 261 return seconds_to_now - seconds_to_2000; 262 } 263 264 static int sb_get_time(time_t time, struct tm *tm) 265 { 266 struct tm time_2000 = { 267 .tm_yday = 1, /* Jan. 1st */ 268 .tm_year = 0, /* 1900 */ 269 }; 270 const time_t seconds_to_2000 = mktime(&time_2000); 271 const time_t seconds_to_now = seconds_to_2000 + time; 272 struct tm *ret; 273 ret = gmtime_r(&seconds_to_now, tm); 274 return ret ? 0 : -EINVAL; 275 } 276 277 static void sb_encrypt_sb_header(struct sb_image_ctx *ictx) 278 { 279 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 280 struct sb_boot_image_header *sb_header = &ictx->payload; 281 uint8_t *sb_header_ptr = (uint8_t *)sb_header; 282 283 /* Encrypt the header, compute the digest. */ 284 sb_aes_crypt(ictx, sb_header_ptr, NULL, sizeof(*sb_header)); 285 EVP_DigestUpdate(md_ctx, sb_header_ptr, sizeof(*sb_header)); 286 } 287 288 static void sb_encrypt_sb_sections_header(struct sb_image_ctx *ictx) 289 { 290 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 291 struct sb_section_ctx *sctx = ictx->sect_head; 292 struct sb_sections_header *shdr; 293 uint8_t *sb_sections_header_ptr; 294 const int size = sizeof(*shdr); 295 296 while (sctx) { 297 shdr = &sctx->payload; 298 sb_sections_header_ptr = (uint8_t *)shdr; 299 300 sb_aes_crypt(ictx, sb_sections_header_ptr, 301 ictx->sb_dict_key.cbc_mac, size); 302 EVP_DigestUpdate(md_ctx, sb_sections_header_ptr, size); 303 304 sctx = sctx->sect; 305 }; 306 } 307 308 static void sb_encrypt_key_dictionary_key(struct sb_image_ctx *ictx) 309 { 310 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 311 312 sb_aes_crypt(ictx, ictx->image_key, ictx->sb_dict_key.key, 313 sizeof(ictx->sb_dict_key.key)); 314 EVP_DigestUpdate(md_ctx, &ictx->sb_dict_key, sizeof(ictx->sb_dict_key)); 315 } 316 317 static void sb_decrypt_key_dictionary_key(struct sb_image_ctx *ictx) 318 { 319 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 320 321 EVP_DigestUpdate(md_ctx, &ictx->sb_dict_key, sizeof(ictx->sb_dict_key)); 322 sb_aes_crypt(ictx, ictx->sb_dict_key.key, ictx->image_key, 323 sizeof(ictx->sb_dict_key.key)); 324 } 325 326 static void sb_encrypt_tag(struct sb_image_ctx *ictx, 327 struct sb_cmd_ctx *cctx) 328 { 329 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 330 struct sb_command *cmd = &cctx->payload; 331 332 sb_aes_crypt(ictx, (uint8_t *)cmd, 333 (uint8_t *)&cctx->c_payload, sizeof(*cmd)); 334 EVP_DigestUpdate(md_ctx, &cctx->c_payload, sizeof(*cmd)); 335 } 336 337 static int sb_encrypt_image(struct sb_image_ctx *ictx) 338 { 339 /* Start image-wide crypto. */ 340 EVP_MD_CTX_init(&ictx->md_ctx); 341 EVP_DigestInit(&ictx->md_ctx, EVP_sha1()); 342 343 /* 344 * SB image header. 345 */ 346 sb_aes_init(ictx, NULL, 1); 347 sb_encrypt_sb_header(ictx); 348 349 /* 350 * SB sections header. 351 */ 352 sb_encrypt_sb_sections_header(ictx); 353 354 /* 355 * Key dictionary. 356 */ 357 sb_aes_reinit(ictx, 1); 358 sb_encrypt_key_dictionary_key(ictx); 359 360 /* 361 * Section tags. 362 */ 363 struct sb_cmd_ctx *cctx; 364 struct sb_command *ccmd; 365 struct sb_section_ctx *sctx = ictx->sect_head; 366 367 while (sctx) { 368 cctx = sctx->cmd_head; 369 370 sb_aes_reinit(ictx, 1); 371 372 while (cctx) { 373 ccmd = &cctx->payload; 374 375 sb_encrypt_tag(ictx, cctx); 376 377 if (ccmd->header.tag == ROM_TAG_CMD) { 378 sb_aes_reinit(ictx, 1); 379 } else if (ccmd->header.tag == ROM_LOAD_CMD) { 380 sb_aes_crypt(ictx, cctx->data, cctx->data, 381 cctx->length); 382 EVP_DigestUpdate(&ictx->md_ctx, cctx->data, 383 cctx->length); 384 } 385 386 cctx = cctx->cmd; 387 } 388 389 sctx = sctx->sect; 390 }; 391 392 /* 393 * Dump the SHA1 of the whole image. 394 */ 395 sb_aes_reinit(ictx, 1); 396 397 EVP_DigestFinal(&ictx->md_ctx, ictx->digest, NULL); 398 sb_aes_crypt(ictx, ictx->digest, ictx->digest, sizeof(ictx->digest)); 399 400 /* Stop the encryption session. */ 401 sb_aes_deinit(&ictx->cipher_ctx); 402 403 return 0; 404 } 405 406 static int sb_load_file(struct sb_cmd_ctx *cctx, char *filename) 407 { 408 long real_size, roundup_size; 409 uint8_t *data; 410 long ret; 411 unsigned long size; 412 FILE *fp; 413 414 if (!filename) { 415 fprintf(stderr, "ERR: Missing filename!\n"); 416 return -EINVAL; 417 } 418 419 fp = fopen(filename, "r"); 420 if (!fp) 421 goto err_open; 422 423 ret = fseek(fp, 0, SEEK_END); 424 if (ret < 0) 425 goto err_file; 426 427 real_size = ftell(fp); 428 if (real_size < 0) 429 goto err_file; 430 431 ret = fseek(fp, 0, SEEK_SET); 432 if (ret < 0) 433 goto err_file; 434 435 roundup_size = roundup(real_size, SB_BLOCK_SIZE); 436 data = calloc(1, roundup_size); 437 if (!data) 438 goto err_file; 439 440 size = fread(data, 1, real_size, fp); 441 if (size != (unsigned long)real_size) 442 goto err_alloc; 443 444 cctx->data = data; 445 cctx->length = roundup_size; 446 447 fclose(fp); 448 return 0; 449 450 err_alloc: 451 free(data); 452 err_file: 453 fclose(fp); 454 err_open: 455 fprintf(stderr, "ERR: Failed to load file \"%s\"\n", filename); 456 return -EINVAL; 457 } 458 459 static uint8_t sb_command_checksum(struct sb_command *inst) 460 { 461 uint8_t *inst_ptr = (uint8_t *)inst; 462 uint8_t csum = 0; 463 unsigned int i; 464 465 for (i = 0; i < sizeof(struct sb_command); i++) 466 csum += inst_ptr[i]; 467 468 return csum; 469 } 470 471 static int sb_token_to_long(char *tok, uint32_t *rid) 472 { 473 char *endptr; 474 unsigned long id; 475 476 if (tok[0] != '0' || tok[1] != 'x') { 477 fprintf(stderr, "ERR: Invalid hexadecimal number!\n"); 478 return -EINVAL; 479 } 480 481 tok += 2; 482 483 errno = 0; 484 id = strtoul(tok, &endptr, 16); 485 if ((errno == ERANGE && id == ULONG_MAX) || (errno != 0 && id == 0)) { 486 fprintf(stderr, "ERR: Value can't be decoded!\n"); 487 return -EINVAL; 488 } 489 490 /* Check for 32-bit overflow. */ 491 if (id > 0xffffffff) { 492 fprintf(stderr, "ERR: Value too big!\n"); 493 return -EINVAL; 494 } 495 496 if (endptr == tok) { 497 fprintf(stderr, "ERR: Deformed value!\n"); 498 return -EINVAL; 499 } 500 501 *rid = (uint32_t)id; 502 return 0; 503 } 504 505 static int sb_grow_dcd(struct sb_dcd_ctx *dctx, unsigned int inc_size) 506 { 507 uint32_t *tmp; 508 509 if (!inc_size) 510 return 0; 511 512 dctx->size += inc_size; 513 tmp = realloc(dctx->payload, dctx->size); 514 if (!tmp) 515 return -ENOMEM; 516 517 dctx->payload = tmp; 518 519 /* Assemble and update the HAB DCD header. */ 520 dctx->payload[0] = htonl((SB_HAB_DCD_TAG << 24) | 521 (dctx->size << 8) | 522 SB_HAB_VERSION); 523 524 return 0; 525 } 526 527 static int sb_build_dcd(struct sb_image_ctx *ictx, struct sb_cmd_list *cmd) 528 { 529 struct sb_dcd_ctx *dctx; 530 531 char *tok; 532 uint32_t id; 533 int ret; 534 535 dctx = calloc(1, sizeof(*dctx)); 536 if (!dctx) 537 return -ENOMEM; 538 539 ret = sb_grow_dcd(dctx, 4); 540 if (ret) 541 goto err_dcd; 542 543 /* Read DCD block number. */ 544 tok = strtok(cmd->cmd, " "); 545 if (!tok) { 546 fprintf(stderr, "#%i ERR: DCD block without number!\n", 547 cmd->lineno); 548 ret = -EINVAL; 549 goto err_dcd; 550 } 551 552 /* Parse the DCD block number. */ 553 ret = sb_token_to_long(tok, &id); 554 if (ret) { 555 fprintf(stderr, "#%i ERR: Malformed DCD block number!\n", 556 cmd->lineno); 557 goto err_dcd; 558 } 559 560 dctx->id = id; 561 562 /* 563 * The DCD block is now constructed. Append it to the list. 564 * WARNING: The DCD size is still not computed and will be 565 * updated while parsing it's commands. 566 */ 567 if (!ictx->dcd_head) { 568 ictx->dcd_head = dctx; 569 ictx->dcd_tail = dctx; 570 } else { 571 ictx->dcd_tail->dcd = dctx; 572 ictx->dcd_tail = dctx; 573 } 574 575 return 0; 576 577 err_dcd: 578 free(dctx->payload); 579 free(dctx); 580 return ret; 581 } 582 583 static int sb_build_dcd_block(struct sb_image_ctx *ictx, 584 struct sb_cmd_list *cmd, 585 uint32_t type) 586 { 587 char *tok; 588 uint32_t address, value, length; 589 int ret; 590 591 struct sb_dcd_ctx *dctx = ictx->dcd_tail; 592 uint32_t *dcd; 593 594 if (dctx->prev_dcd_head && (type != SB_DCD_NOOP) && 595 ((dctx->prev_dcd_head[0] & 0xff0000ff) == type)) { 596 /* Same instruction as before, just append it. */ 597 ret = sb_grow_dcd(dctx, 8); 598 if (ret) 599 return ret; 600 } else if (type == SB_DCD_NOOP) { 601 ret = sb_grow_dcd(dctx, 4); 602 if (ret) 603 return ret; 604 605 /* Update DCD command block pointer. */ 606 dctx->prev_dcd_head = dctx->payload + 607 dctx->size / sizeof(*dctx->payload) - 1; 608 609 /* NOOP has only 4 bytes and no payload. */ 610 goto noop; 611 } else { 612 /* 613 * Either a different instruction block started now 614 * or this is the first instruction block. 615 */ 616 ret = sb_grow_dcd(dctx, 12); 617 if (ret) 618 return ret; 619 620 /* Update DCD command block pointer. */ 621 dctx->prev_dcd_head = dctx->payload + 622 dctx->size / sizeof(*dctx->payload) - 3; 623 } 624 625 dcd = dctx->payload + dctx->size / sizeof(*dctx->payload) - 2; 626 627 /* 628 * Prepare the command. 629 */ 630 tok = strtok(cmd->cmd, " "); 631 if (!tok) { 632 fprintf(stderr, "#%i ERR: Missing DCD address!\n", 633 cmd->lineno); 634 ret = -EINVAL; 635 goto err; 636 } 637 638 /* Read DCD destination address. */ 639 ret = sb_token_to_long(tok, &address); 640 if (ret) { 641 fprintf(stderr, "#%i ERR: Incorrect DCD address!\n", 642 cmd->lineno); 643 goto err; 644 } 645 646 tok = strtok(NULL, " "); 647 if (!tok) { 648 fprintf(stderr, "#%i ERR: Missing DCD value!\n", 649 cmd->lineno); 650 ret = -EINVAL; 651 goto err; 652 } 653 654 /* Read DCD operation value. */ 655 ret = sb_token_to_long(tok, &value); 656 if (ret) { 657 fprintf(stderr, "#%i ERR: Incorrect DCD value!\n", 658 cmd->lineno); 659 goto err; 660 } 661 662 /* Fill in the new DCD entry. */ 663 dcd[0] = htonl(address); 664 dcd[1] = htonl(value); 665 666 noop: 667 /* Update the DCD command block. */ 668 length = dctx->size - 669 ((dctx->prev_dcd_head - dctx->payload) * 670 sizeof(*dctx->payload)); 671 dctx->prev_dcd_head[0] = htonl(type | (length << 8)); 672 673 err: 674 return ret; 675 } 676 677 static int sb_build_section(struct sb_image_ctx *ictx, struct sb_cmd_list *cmd) 678 { 679 struct sb_section_ctx *sctx; 680 struct sb_sections_header *shdr; 681 char *tok; 682 uint32_t bootable = 0; 683 uint32_t id; 684 int ret; 685 686 sctx = calloc(1, sizeof(*sctx)); 687 if (!sctx) 688 return -ENOMEM; 689 690 /* Read section number. */ 691 tok = strtok(cmd->cmd, " "); 692 if (!tok) { 693 fprintf(stderr, "#%i ERR: Section without number!\n", 694 cmd->lineno); 695 ret = -EINVAL; 696 goto err_sect; 697 } 698 699 /* Parse the section number. */ 700 ret = sb_token_to_long(tok, &id); 701 if (ret) { 702 fprintf(stderr, "#%i ERR: Malformed section number!\n", 703 cmd->lineno); 704 goto err_sect; 705 } 706 707 /* Read section's BOOTABLE flag. */ 708 tok = strtok(NULL, " "); 709 if (tok && (strlen(tok) == 8) && !strncmp(tok, "BOOTABLE", 8)) 710 bootable = SB_SECTION_FLAG_BOOTABLE; 711 712 sctx->boot = bootable; 713 714 shdr = &sctx->payload; 715 shdr->section_number = id; 716 shdr->section_flags = bootable; 717 718 /* 719 * The section is now constructed. Append it to the list. 720 * WARNING: The section size is still not computed and will 721 * be updated while parsing it's commands. 722 */ 723 ictx->sect_count++; 724 725 /* Mark that this section is bootable one. */ 726 if (bootable) { 727 if (ictx->sect_boot_found) { 728 fprintf(stderr, 729 "#%i WARN: Multiple bootable section!\n", 730 cmd->lineno); 731 } else { 732 ictx->sect_boot = id; 733 ictx->sect_boot_found = 1; 734 } 735 } 736 737 if (!ictx->sect_head) { 738 ictx->sect_head = sctx; 739 ictx->sect_tail = sctx; 740 } else { 741 ictx->sect_tail->sect = sctx; 742 ictx->sect_tail = sctx; 743 } 744 745 return 0; 746 747 err_sect: 748 free(sctx); 749 return ret; 750 } 751 752 static int sb_build_command_nop(struct sb_image_ctx *ictx) 753 { 754 struct sb_section_ctx *sctx = ictx->sect_tail; 755 struct sb_cmd_ctx *cctx; 756 struct sb_command *ccmd; 757 758 cctx = calloc(1, sizeof(*cctx)); 759 if (!cctx) 760 return -ENOMEM; 761 762 ccmd = &cctx->payload; 763 764 /* 765 * Construct the command. 766 */ 767 ccmd->header.checksum = 0x5a; 768 ccmd->header.tag = ROM_NOP_CMD; 769 770 cctx->size = sizeof(*ccmd); 771 772 /* 773 * Append the command to the last section. 774 */ 775 if (!sctx->cmd_head) { 776 sctx->cmd_head = cctx; 777 sctx->cmd_tail = cctx; 778 } else { 779 sctx->cmd_tail->cmd = cctx; 780 sctx->cmd_tail = cctx; 781 } 782 783 return 0; 784 } 785 786 static int sb_build_command_tag(struct sb_image_ctx *ictx, 787 struct sb_cmd_list *cmd) 788 { 789 struct sb_section_ctx *sctx = ictx->sect_tail; 790 struct sb_cmd_ctx *cctx; 791 struct sb_command *ccmd; 792 char *tok; 793 794 cctx = calloc(1, sizeof(*cctx)); 795 if (!cctx) 796 return -ENOMEM; 797 798 ccmd = &cctx->payload; 799 800 /* 801 * Prepare the command. 802 */ 803 /* Check for the LAST keyword. */ 804 tok = strtok(cmd->cmd, " "); 805 if (tok && !strcmp(tok, "LAST")) 806 ccmd->header.flags = ROM_TAG_CMD_FLAG_ROM_LAST_TAG; 807 808 /* 809 * Construct the command. 810 */ 811 ccmd->header.checksum = 0x5a; 812 ccmd->header.tag = ROM_TAG_CMD; 813 814 cctx->size = sizeof(*ccmd); 815 816 /* 817 * Append the command to the last section. 818 */ 819 if (!sctx->cmd_head) { 820 sctx->cmd_head = cctx; 821 sctx->cmd_tail = cctx; 822 } else { 823 sctx->cmd_tail->cmd = cctx; 824 sctx->cmd_tail = cctx; 825 } 826 827 return 0; 828 } 829 830 static int sb_build_command_load(struct sb_image_ctx *ictx, 831 struct sb_cmd_list *cmd) 832 { 833 struct sb_section_ctx *sctx = ictx->sect_tail; 834 struct sb_cmd_ctx *cctx; 835 struct sb_command *ccmd; 836 char *tok; 837 int ret, is_ivt = 0, is_dcd = 0; 838 uint32_t dest, dcd = 0; 839 840 cctx = calloc(1, sizeof(*cctx)); 841 if (!cctx) 842 return -ENOMEM; 843 844 ccmd = &cctx->payload; 845 846 /* 847 * Prepare the command. 848 */ 849 tok = strtok(cmd->cmd, " "); 850 if (!tok) { 851 fprintf(stderr, "#%i ERR: Missing LOAD address or 'IVT'!\n", 852 cmd->lineno); 853 ret = -EINVAL; 854 goto err; 855 } 856 857 /* Check for "IVT" flag. */ 858 if (!strcmp(tok, "IVT")) 859 is_ivt = 1; 860 if (!strcmp(tok, "DCD")) 861 is_dcd = 1; 862 if (is_ivt || is_dcd) { 863 tok = strtok(NULL, " "); 864 if (!tok) { 865 fprintf(stderr, "#%i ERR: Missing LOAD address!\n", 866 cmd->lineno); 867 ret = -EINVAL; 868 goto err; 869 } 870 } 871 872 /* Read load destination address. */ 873 ret = sb_token_to_long(tok, &dest); 874 if (ret) { 875 fprintf(stderr, "#%i ERR: Incorrect LOAD address!\n", 876 cmd->lineno); 877 goto err; 878 } 879 880 /* Read filename or IVT entrypoint or DCD block ID. */ 881 tok = strtok(NULL, " "); 882 if (!tok) { 883 fprintf(stderr, 884 "#%i ERR: Missing LOAD filename or IVT ep or DCD block ID!\n", 885 cmd->lineno); 886 ret = -EINVAL; 887 goto err; 888 } 889 890 if (is_ivt) { 891 /* Handle IVT. */ 892 struct sb_ivt_header *ivt; 893 uint32_t ivtep; 894 ret = sb_token_to_long(tok, &ivtep); 895 896 if (ret) { 897 fprintf(stderr, 898 "#%i ERR: Incorrect IVT entry point!\n", 899 cmd->lineno); 900 goto err; 901 } 902 903 ivt = calloc(1, sizeof(*ivt)); 904 if (!ivt) { 905 ret = -ENOMEM; 906 goto err; 907 } 908 909 ivt->header = sb_hab_ivt_header(); 910 ivt->entry = ivtep; 911 ivt->self = dest; 912 913 cctx->data = (uint8_t *)ivt; 914 cctx->length = sizeof(*ivt); 915 } else if (is_dcd) { 916 struct sb_dcd_ctx *dctx = ictx->dcd_head; 917 uint32_t dcdid; 918 uint8_t *payload; 919 uint32_t asize; 920 ret = sb_token_to_long(tok, &dcdid); 921 922 if (ret) { 923 fprintf(stderr, 924 "#%i ERR: Incorrect DCD block ID!\n", 925 cmd->lineno); 926 goto err; 927 } 928 929 while (dctx) { 930 if (dctx->id == dcdid) 931 break; 932 dctx = dctx->dcd; 933 } 934 935 if (!dctx) { 936 fprintf(stderr, "#%i ERR: DCD block %08x not found!\n", 937 cmd->lineno, dcdid); 938 goto err; 939 } 940 941 asize = roundup(dctx->size, SB_BLOCK_SIZE); 942 payload = calloc(1, asize); 943 if (!payload) { 944 ret = -ENOMEM; 945 goto err; 946 } 947 948 memcpy(payload, dctx->payload, dctx->size); 949 950 cctx->data = payload; 951 cctx->length = asize; 952 953 /* Set the Load DCD flag. */ 954 dcd = ROM_LOAD_CMD_FLAG_DCD_LOAD; 955 } else { 956 /* Regular LOAD of a file. */ 957 ret = sb_load_file(cctx, tok); 958 if (ret) { 959 fprintf(stderr, "#%i ERR: Cannot load '%s'!\n", 960 cmd->lineno, tok); 961 goto err; 962 } 963 } 964 965 if (cctx->length & (SB_BLOCK_SIZE - 1)) { 966 fprintf(stderr, "#%i ERR: Unaligned payload!\n", 967 cmd->lineno); 968 } 969 970 /* 971 * Construct the command. 972 */ 973 ccmd->header.checksum = 0x5a; 974 ccmd->header.tag = ROM_LOAD_CMD; 975 ccmd->header.flags = dcd; 976 977 ccmd->load.address = dest; 978 ccmd->load.count = cctx->length; 979 ccmd->load.crc32 = pbl_crc32(0, 980 (const char *)cctx->data, 981 cctx->length); 982 983 cctx->size = sizeof(*ccmd) + cctx->length; 984 985 /* 986 * Append the command to the last section. 987 */ 988 if (!sctx->cmd_head) { 989 sctx->cmd_head = cctx; 990 sctx->cmd_tail = cctx; 991 } else { 992 sctx->cmd_tail->cmd = cctx; 993 sctx->cmd_tail = cctx; 994 } 995 996 return 0; 997 998 err: 999 free(cctx); 1000 return ret; 1001 } 1002 1003 static int sb_build_command_fill(struct sb_image_ctx *ictx, 1004 struct sb_cmd_list *cmd) 1005 { 1006 struct sb_section_ctx *sctx = ictx->sect_tail; 1007 struct sb_cmd_ctx *cctx; 1008 struct sb_command *ccmd; 1009 char *tok; 1010 uint32_t address, pattern, length; 1011 int ret; 1012 1013 cctx = calloc(1, sizeof(*cctx)); 1014 if (!cctx) 1015 return -ENOMEM; 1016 1017 ccmd = &cctx->payload; 1018 1019 /* 1020 * Prepare the command. 1021 */ 1022 tok = strtok(cmd->cmd, " "); 1023 if (!tok) { 1024 fprintf(stderr, "#%i ERR: Missing FILL address!\n", 1025 cmd->lineno); 1026 ret = -EINVAL; 1027 goto err; 1028 } 1029 1030 /* Read fill destination address. */ 1031 ret = sb_token_to_long(tok, &address); 1032 if (ret) { 1033 fprintf(stderr, "#%i ERR: Incorrect FILL address!\n", 1034 cmd->lineno); 1035 goto err; 1036 } 1037 1038 tok = strtok(NULL, " "); 1039 if (!tok) { 1040 fprintf(stderr, "#%i ERR: Missing FILL pattern!\n", 1041 cmd->lineno); 1042 ret = -EINVAL; 1043 goto err; 1044 } 1045 1046 /* Read fill pattern address. */ 1047 ret = sb_token_to_long(tok, &pattern); 1048 if (ret) { 1049 fprintf(stderr, "#%i ERR: Incorrect FILL pattern!\n", 1050 cmd->lineno); 1051 goto err; 1052 } 1053 1054 tok = strtok(NULL, " "); 1055 if (!tok) { 1056 fprintf(stderr, "#%i ERR: Missing FILL length!\n", 1057 cmd->lineno); 1058 ret = -EINVAL; 1059 goto err; 1060 } 1061 1062 /* Read fill pattern address. */ 1063 ret = sb_token_to_long(tok, &length); 1064 if (ret) { 1065 fprintf(stderr, "#%i ERR: Incorrect FILL length!\n", 1066 cmd->lineno); 1067 goto err; 1068 } 1069 1070 /* 1071 * Construct the command. 1072 */ 1073 ccmd->header.checksum = 0x5a; 1074 ccmd->header.tag = ROM_FILL_CMD; 1075 1076 ccmd->fill.address = address; 1077 ccmd->fill.count = length; 1078 ccmd->fill.pattern = pattern; 1079 1080 cctx->size = sizeof(*ccmd); 1081 1082 /* 1083 * Append the command to the last section. 1084 */ 1085 if (!sctx->cmd_head) { 1086 sctx->cmd_head = cctx; 1087 sctx->cmd_tail = cctx; 1088 } else { 1089 sctx->cmd_tail->cmd = cctx; 1090 sctx->cmd_tail = cctx; 1091 } 1092 1093 return 0; 1094 1095 err: 1096 free(cctx); 1097 return ret; 1098 } 1099 1100 static int sb_build_command_jump_call(struct sb_image_ctx *ictx, 1101 struct sb_cmd_list *cmd, 1102 unsigned int is_call) 1103 { 1104 struct sb_section_ctx *sctx = ictx->sect_tail; 1105 struct sb_cmd_ctx *cctx; 1106 struct sb_command *ccmd; 1107 char *tok; 1108 uint32_t dest, arg = 0x0; 1109 uint32_t hab = 0; 1110 int ret; 1111 const char *cmdname = is_call ? "CALL" : "JUMP"; 1112 1113 cctx = calloc(1, sizeof(*cctx)); 1114 if (!cctx) 1115 return -ENOMEM; 1116 1117 ccmd = &cctx->payload; 1118 1119 /* 1120 * Prepare the command. 1121 */ 1122 tok = strtok(cmd->cmd, " "); 1123 if (!tok) { 1124 fprintf(stderr, 1125 "#%i ERR: Missing %s address or 'HAB'!\n", 1126 cmd->lineno, cmdname); 1127 ret = -EINVAL; 1128 goto err; 1129 } 1130 1131 /* Check for "HAB" flag. */ 1132 if (!strcmp(tok, "HAB")) { 1133 hab = is_call ? ROM_CALL_CMD_FLAG_HAB : ROM_JUMP_CMD_FLAG_HAB; 1134 tok = strtok(NULL, " "); 1135 if (!tok) { 1136 fprintf(stderr, "#%i ERR: Missing %s address!\n", 1137 cmd->lineno, cmdname); 1138 ret = -EINVAL; 1139 goto err; 1140 } 1141 } 1142 /* Read load destination address. */ 1143 ret = sb_token_to_long(tok, &dest); 1144 if (ret) { 1145 fprintf(stderr, "#%i ERR: Incorrect %s address!\n", 1146 cmd->lineno, cmdname); 1147 goto err; 1148 } 1149 1150 tok = strtok(NULL, " "); 1151 if (tok) { 1152 ret = sb_token_to_long(tok, &arg); 1153 if (ret) { 1154 fprintf(stderr, 1155 "#%i ERR: Incorrect %s argument!\n", 1156 cmd->lineno, cmdname); 1157 goto err; 1158 } 1159 } 1160 1161 /* 1162 * Construct the command. 1163 */ 1164 ccmd->header.checksum = 0x5a; 1165 ccmd->header.tag = is_call ? ROM_CALL_CMD : ROM_JUMP_CMD; 1166 ccmd->header.flags = hab; 1167 1168 ccmd->call.address = dest; 1169 ccmd->call.argument = arg; 1170 1171 cctx->size = sizeof(*ccmd); 1172 1173 /* 1174 * Append the command to the last section. 1175 */ 1176 if (!sctx->cmd_head) { 1177 sctx->cmd_head = cctx; 1178 sctx->cmd_tail = cctx; 1179 } else { 1180 sctx->cmd_tail->cmd = cctx; 1181 sctx->cmd_tail = cctx; 1182 } 1183 1184 return 0; 1185 1186 err: 1187 free(cctx); 1188 return ret; 1189 } 1190 1191 static int sb_build_command_jump(struct sb_image_ctx *ictx, 1192 struct sb_cmd_list *cmd) 1193 { 1194 return sb_build_command_jump_call(ictx, cmd, 0); 1195 } 1196 1197 static int sb_build_command_call(struct sb_image_ctx *ictx, 1198 struct sb_cmd_list *cmd) 1199 { 1200 return sb_build_command_jump_call(ictx, cmd, 1); 1201 } 1202 1203 static int sb_build_command_mode(struct sb_image_ctx *ictx, 1204 struct sb_cmd_list *cmd) 1205 { 1206 struct sb_section_ctx *sctx = ictx->sect_tail; 1207 struct sb_cmd_ctx *cctx; 1208 struct sb_command *ccmd; 1209 char *tok; 1210 int ret; 1211 unsigned int i; 1212 uint32_t mode = 0xffffffff; 1213 1214 cctx = calloc(1, sizeof(*cctx)); 1215 if (!cctx) 1216 return -ENOMEM; 1217 1218 ccmd = &cctx->payload; 1219 1220 /* 1221 * Prepare the command. 1222 */ 1223 tok = strtok(cmd->cmd, " "); 1224 if (!tok) { 1225 fprintf(stderr, "#%i ERR: Missing MODE boot mode argument!\n", 1226 cmd->lineno); 1227 ret = -EINVAL; 1228 goto err; 1229 } 1230 1231 for (i = 0; i < ARRAY_SIZE(modetable); i++) { 1232 if (!strcmp(tok, modetable[i].name)) { 1233 mode = modetable[i].mode; 1234 break; 1235 } 1236 1237 if (!modetable[i].altname) 1238 continue; 1239 1240 if (!strcmp(tok, modetable[i].altname)) { 1241 mode = modetable[i].mode; 1242 break; 1243 } 1244 } 1245 1246 if (mode == 0xffffffff) { 1247 fprintf(stderr, "#%i ERR: Invalid MODE boot mode argument!\n", 1248 cmd->lineno); 1249 ret = -EINVAL; 1250 goto err; 1251 } 1252 1253 /* 1254 * Construct the command. 1255 */ 1256 ccmd->header.checksum = 0x5a; 1257 ccmd->header.tag = ROM_MODE_CMD; 1258 1259 ccmd->mode.mode = mode; 1260 1261 cctx->size = sizeof(*ccmd); 1262 1263 /* 1264 * Append the command to the last section. 1265 */ 1266 if (!sctx->cmd_head) { 1267 sctx->cmd_head = cctx; 1268 sctx->cmd_tail = cctx; 1269 } else { 1270 sctx->cmd_tail->cmd = cctx; 1271 sctx->cmd_tail = cctx; 1272 } 1273 1274 return 0; 1275 1276 err: 1277 free(cctx); 1278 return ret; 1279 } 1280 1281 static int sb_prefill_image_header(struct sb_image_ctx *ictx) 1282 { 1283 struct sb_boot_image_header *hdr = &ictx->payload; 1284 1285 /* Fill signatures */ 1286 memcpy(hdr->signature1, "STMP", 4); 1287 memcpy(hdr->signature2, "sgtl", 4); 1288 1289 /* SB Image version 1.1 */ 1290 hdr->major_version = SB_VERSION_MAJOR; 1291 hdr->minor_version = SB_VERSION_MINOR; 1292 1293 /* Boot image major version */ 1294 hdr->product_version.major = htons(0x999); 1295 hdr->product_version.minor = htons(0x999); 1296 hdr->product_version.revision = htons(0x999); 1297 /* Boot image major version */ 1298 hdr->component_version.major = htons(0x999); 1299 hdr->component_version.minor = htons(0x999); 1300 hdr->component_version.revision = htons(0x999); 1301 1302 /* Drive tag must be 0x0 for i.MX23 */ 1303 hdr->drive_tag = 0; 1304 1305 hdr->header_blocks = 1306 sizeof(struct sb_boot_image_header) / SB_BLOCK_SIZE; 1307 hdr->section_header_size = 1308 sizeof(struct sb_sections_header) / SB_BLOCK_SIZE; 1309 hdr->timestamp_us = sb_get_timestamp() * 1000000; 1310 1311 hdr->flags = ictx->display_progress ? 1312 SB_IMAGE_FLAG_DISPLAY_PROGRESS : 0; 1313 1314 /* FIXME -- We support only default key */ 1315 hdr->key_count = 1; 1316 1317 return 0; 1318 } 1319 1320 static int sb_postfill_image_header(struct sb_image_ctx *ictx) 1321 { 1322 struct sb_boot_image_header *hdr = &ictx->payload; 1323 struct sb_section_ctx *sctx = ictx->sect_head; 1324 uint32_t kd_size, sections_blocks; 1325 EVP_MD_CTX md_ctx; 1326 1327 /* The main SB header size in blocks. */ 1328 hdr->image_blocks = hdr->header_blocks; 1329 1330 /* Size of the key dictionary, which has single zero entry. */ 1331 kd_size = hdr->key_count * sizeof(struct sb_key_dictionary_key); 1332 hdr->image_blocks += kd_size / SB_BLOCK_SIZE; 1333 1334 /* Now count the payloads. */ 1335 hdr->section_count = ictx->sect_count; 1336 while (sctx) { 1337 hdr->image_blocks += sctx->size / SB_BLOCK_SIZE; 1338 sctx = sctx->sect; 1339 } 1340 1341 if (!ictx->sect_boot_found) { 1342 fprintf(stderr, "ERR: No bootable section selected!\n"); 1343 return -EINVAL; 1344 } 1345 hdr->first_boot_section_id = ictx->sect_boot; 1346 1347 /* The n * SB section size in blocks. */ 1348 sections_blocks = hdr->section_count * hdr->section_header_size; 1349 hdr->image_blocks += sections_blocks; 1350 1351 /* Key dictionary offset. */ 1352 hdr->key_dictionary_block = hdr->header_blocks + sections_blocks; 1353 1354 /* Digest of the whole image. */ 1355 hdr->image_blocks += 2; 1356 1357 /* Pointer past the dictionary. */ 1358 hdr->first_boot_tag_block = 1359 hdr->key_dictionary_block + kd_size / SB_BLOCK_SIZE; 1360 1361 /* Compute header digest. */ 1362 EVP_MD_CTX_init(&md_ctx); 1363 1364 EVP_DigestInit(&md_ctx, EVP_sha1()); 1365 EVP_DigestUpdate(&md_ctx, hdr->signature1, 1366 sizeof(struct sb_boot_image_header) - 1367 sizeof(hdr->digest)); 1368 EVP_DigestFinal(&md_ctx, hdr->digest, NULL); 1369 1370 return 0; 1371 } 1372 1373 static int sb_fixup_sections_and_tags(struct sb_image_ctx *ictx) 1374 { 1375 /* Fixup the placement of sections. */ 1376 struct sb_boot_image_header *ihdr = &ictx->payload; 1377 struct sb_section_ctx *sctx = ictx->sect_head; 1378 struct sb_sections_header *shdr; 1379 struct sb_cmd_ctx *cctx; 1380 struct sb_command *ccmd; 1381 uint32_t offset = ihdr->first_boot_tag_block; 1382 1383 while (sctx) { 1384 shdr = &sctx->payload; 1385 1386 /* Fill in the section TAG offset. */ 1387 shdr->section_offset = offset + 1; 1388 offset += shdr->section_size; 1389 1390 /* Section length is measured from the TAG block. */ 1391 shdr->section_size--; 1392 1393 /* Fixup the TAG command. */ 1394 cctx = sctx->cmd_head; 1395 while (cctx) { 1396 ccmd = &cctx->payload; 1397 if (ccmd->header.tag == ROM_TAG_CMD) { 1398 ccmd->tag.section_number = shdr->section_number; 1399 ccmd->tag.section_length = shdr->section_size; 1400 ccmd->tag.section_flags = shdr->section_flags; 1401 } 1402 1403 /* Update the command checksum. */ 1404 ccmd->header.checksum = sb_command_checksum(ccmd); 1405 1406 cctx = cctx->cmd; 1407 } 1408 1409 sctx = sctx->sect; 1410 } 1411 1412 return 0; 1413 } 1414 1415 static int sb_parse_line(struct sb_image_ctx *ictx, struct sb_cmd_list *cmd) 1416 { 1417 char *tok; 1418 char *line = cmd->cmd; 1419 char *rptr = NULL; 1420 int ret; 1421 1422 /* Analyze the identifier on this line first. */ 1423 tok = strtok_r(line, " ", &rptr); 1424 if (!tok || (strlen(tok) == 0)) { 1425 fprintf(stderr, "#%i ERR: Invalid line!\n", cmd->lineno); 1426 return -EINVAL; 1427 } 1428 1429 cmd->cmd = rptr; 1430 1431 /* set DISPLAY_PROGRESS flag */ 1432 if (!strcmp(tok, "DISPLAYPROGRESS")) { 1433 ictx->display_progress = 1; 1434 return 0; 1435 } 1436 1437 /* DCD */ 1438 if (!strcmp(tok, "DCD")) { 1439 ictx->in_section = 0; 1440 ictx->in_dcd = 1; 1441 sb_build_dcd(ictx, cmd); 1442 return 0; 1443 } 1444 1445 /* Section */ 1446 if (!strcmp(tok, "SECTION")) { 1447 ictx->in_section = 1; 1448 ictx->in_dcd = 0; 1449 sb_build_section(ictx, cmd); 1450 return 0; 1451 } 1452 1453 if (!ictx->in_section && !ictx->in_dcd) { 1454 fprintf(stderr, "#%i ERR: Data outside of a section!\n", 1455 cmd->lineno); 1456 return -EINVAL; 1457 } 1458 1459 if (ictx->in_section) { 1460 /* Section commands */ 1461 if (!strcmp(tok, "NOP")) { 1462 ret = sb_build_command_nop(ictx); 1463 } else if (!strcmp(tok, "TAG")) { 1464 ret = sb_build_command_tag(ictx, cmd); 1465 } else if (!strcmp(tok, "LOAD")) { 1466 ret = sb_build_command_load(ictx, cmd); 1467 } else if (!strcmp(tok, "FILL")) { 1468 ret = sb_build_command_fill(ictx, cmd); 1469 } else if (!strcmp(tok, "JUMP")) { 1470 ret = sb_build_command_jump(ictx, cmd); 1471 } else if (!strcmp(tok, "CALL")) { 1472 ret = sb_build_command_call(ictx, cmd); 1473 } else if (!strcmp(tok, "MODE")) { 1474 ret = sb_build_command_mode(ictx, cmd); 1475 } else { 1476 fprintf(stderr, 1477 "#%i ERR: Unsupported instruction '%s'!\n", 1478 cmd->lineno, tok); 1479 return -ENOTSUP; 1480 } 1481 } else if (ictx->in_dcd) { 1482 char *lptr; 1483 uint32_t ilen = '1'; 1484 1485 tok = strtok_r(tok, ".", &lptr); 1486 if (!tok || (strlen(tok) == 0) || (lptr && strlen(lptr) != 1)) { 1487 fprintf(stderr, "#%i ERR: Invalid line!\n", 1488 cmd->lineno); 1489 return -EINVAL; 1490 } 1491 1492 if (lptr && 1493 (lptr[0] != '1' && lptr[0] != '2' && lptr[0] != '4')) { 1494 fprintf(stderr, "#%i ERR: Invalid instruction width!\n", 1495 cmd->lineno); 1496 return -EINVAL; 1497 } 1498 1499 if (lptr) 1500 ilen = lptr[0] - '1'; 1501 1502 /* DCD commands */ 1503 if (!strcmp(tok, "WRITE")) { 1504 ret = sb_build_dcd_block(ictx, cmd, 1505 SB_DCD_WRITE | ilen); 1506 } else if (!strcmp(tok, "ANDC")) { 1507 ret = sb_build_dcd_block(ictx, cmd, 1508 SB_DCD_ANDC | ilen); 1509 } else if (!strcmp(tok, "ORR")) { 1510 ret = sb_build_dcd_block(ictx, cmd, 1511 SB_DCD_ORR | ilen); 1512 } else if (!strcmp(tok, "EQZ")) { 1513 ret = sb_build_dcd_block(ictx, cmd, 1514 SB_DCD_CHK_EQZ | ilen); 1515 } else if (!strcmp(tok, "EQ")) { 1516 ret = sb_build_dcd_block(ictx, cmd, 1517 SB_DCD_CHK_EQ | ilen); 1518 } else if (!strcmp(tok, "NEQ")) { 1519 ret = sb_build_dcd_block(ictx, cmd, 1520 SB_DCD_CHK_NEQ | ilen); 1521 } else if (!strcmp(tok, "NEZ")) { 1522 ret = sb_build_dcd_block(ictx, cmd, 1523 SB_DCD_CHK_NEZ | ilen); 1524 } else if (!strcmp(tok, "NOOP")) { 1525 ret = sb_build_dcd_block(ictx, cmd, SB_DCD_NOOP); 1526 } else { 1527 fprintf(stderr, 1528 "#%i ERR: Unsupported instruction '%s'!\n", 1529 cmd->lineno, tok); 1530 return -ENOTSUP; 1531 } 1532 } else { 1533 fprintf(stderr, "#%i ERR: Unsupported instruction '%s'!\n", 1534 cmd->lineno, tok); 1535 return -ENOTSUP; 1536 } 1537 1538 /* 1539 * Here we have at least one section with one command, otherwise we 1540 * would have failed already higher above. 1541 * 1542 * FIXME -- should the updating happen here ? 1543 */ 1544 if (ictx->in_section && !ret) { 1545 ictx->sect_tail->size += ictx->sect_tail->cmd_tail->size; 1546 ictx->sect_tail->payload.section_size = 1547 ictx->sect_tail->size / SB_BLOCK_SIZE; 1548 } 1549 1550 return ret; 1551 } 1552 1553 static int sb_load_cmdfile(struct sb_image_ctx *ictx) 1554 { 1555 struct sb_cmd_list cmd; 1556 int lineno = 1; 1557 FILE *fp; 1558 char *line = NULL; 1559 ssize_t rlen; 1560 size_t len; 1561 1562 fp = fopen(ictx->cfg_filename, "r"); 1563 if (!fp) 1564 goto err_file; 1565 1566 while ((rlen = getline(&line, &len, fp)) > 0) { 1567 memset(&cmd, 0, sizeof(cmd)); 1568 1569 /* Strip the trailing newline. */ 1570 line[rlen - 1] = '\0'; 1571 1572 cmd.cmd = line; 1573 cmd.len = rlen; 1574 cmd.lineno = lineno++; 1575 1576 sb_parse_line(ictx, &cmd); 1577 } 1578 1579 free(line); 1580 1581 fclose(fp); 1582 1583 return 0; 1584 1585 err_file: 1586 fclose(fp); 1587 fprintf(stderr, "ERR: Failed to load file \"%s\"\n", 1588 ictx->cfg_filename); 1589 return -EINVAL; 1590 } 1591 1592 static int sb_build_tree_from_cfg(struct sb_image_ctx *ictx) 1593 { 1594 int ret; 1595 1596 ret = sb_load_cmdfile(ictx); 1597 if (ret) 1598 return ret; 1599 1600 ret = sb_prefill_image_header(ictx); 1601 if (ret) 1602 return ret; 1603 1604 ret = sb_postfill_image_header(ictx); 1605 if (ret) 1606 return ret; 1607 1608 ret = sb_fixup_sections_and_tags(ictx); 1609 if (ret) 1610 return ret; 1611 1612 return 0; 1613 } 1614 1615 static int sb_verify_image_header(struct sb_image_ctx *ictx, 1616 FILE *fp, long fsize) 1617 { 1618 /* Verify static fields in the image header. */ 1619 struct sb_boot_image_header *hdr = &ictx->payload; 1620 const char *stat[2] = { "[PASS]", "[FAIL]" }; 1621 struct tm tm; 1622 int sz, ret = 0; 1623 unsigned char digest[20]; 1624 EVP_MD_CTX md_ctx; 1625 unsigned long size; 1626 1627 /* Start image-wide crypto. */ 1628 EVP_MD_CTX_init(&ictx->md_ctx); 1629 EVP_DigestInit(&ictx->md_ctx, EVP_sha1()); 1630 1631 soprintf(ictx, "---------- Verifying SB Image Header ----------\n"); 1632 1633 size = fread(&ictx->payload, 1, sizeof(ictx->payload), fp); 1634 if (size != sizeof(ictx->payload)) { 1635 fprintf(stderr, "ERR: SB image header too short!\n"); 1636 return -EINVAL; 1637 } 1638 1639 /* Compute header digest. */ 1640 EVP_MD_CTX_init(&md_ctx); 1641 EVP_DigestInit(&md_ctx, EVP_sha1()); 1642 EVP_DigestUpdate(&md_ctx, hdr->signature1, 1643 sizeof(struct sb_boot_image_header) - 1644 sizeof(hdr->digest)); 1645 EVP_DigestFinal(&md_ctx, digest, NULL); 1646 1647 sb_aes_init(ictx, NULL, 1); 1648 sb_encrypt_sb_header(ictx); 1649 1650 if (memcmp(digest, hdr->digest, 20)) 1651 ret = -EINVAL; 1652 soprintf(ictx, "%s Image header checksum: %s\n", stat[!!ret], 1653 ret ? "BAD" : "OK"); 1654 if (ret) 1655 return ret; 1656 1657 if (memcmp(hdr->signature1, "STMP", 4) || 1658 memcmp(hdr->signature2, "sgtl", 4)) 1659 ret = -EINVAL; 1660 soprintf(ictx, "%s Signatures: '%.4s' '%.4s'\n", 1661 stat[!!ret], hdr->signature1, hdr->signature2); 1662 if (ret) 1663 return ret; 1664 1665 if ((hdr->major_version != SB_VERSION_MAJOR) || 1666 ((hdr->minor_version != 1) && (hdr->minor_version != 2))) 1667 ret = -EINVAL; 1668 soprintf(ictx, "%s Image version: v%i.%i\n", stat[!!ret], 1669 hdr->major_version, hdr->minor_version); 1670 if (ret) 1671 return ret; 1672 1673 ret = sb_get_time(hdr->timestamp_us / 1000000, &tm); 1674 soprintf(ictx, 1675 "%s Creation time: %02i:%02i:%02i %02i/%02i/%04i\n", 1676 stat[!!ret], tm.tm_hour, tm.tm_min, tm.tm_sec, 1677 tm.tm_mday, tm.tm_mon, tm.tm_year + 2000); 1678 if (ret) 1679 return ret; 1680 1681 soprintf(ictx, "%s Product version: %x.%x.%x\n", stat[0], 1682 ntohs(hdr->product_version.major), 1683 ntohs(hdr->product_version.minor), 1684 ntohs(hdr->product_version.revision)); 1685 soprintf(ictx, "%s Component version: %x.%x.%x\n", stat[0], 1686 ntohs(hdr->component_version.major), 1687 ntohs(hdr->component_version.minor), 1688 ntohs(hdr->component_version.revision)); 1689 1690 if (hdr->flags & ~SB_IMAGE_FLAGS_MASK) 1691 ret = -EINVAL; 1692 soprintf(ictx, "%s Image flags: %s\n", stat[!!ret], 1693 hdr->flags & SB_IMAGE_FLAG_DISPLAY_PROGRESS ? 1694 "Display_progress" : ""); 1695 if (ret) 1696 return ret; 1697 1698 if (hdr->drive_tag != 0) 1699 ret = -EINVAL; 1700 soprintf(ictx, "%s Drive tag: %i\n", stat[!!ret], 1701 hdr->drive_tag); 1702 if (ret) 1703 return ret; 1704 1705 sz = sizeof(struct sb_boot_image_header) / SB_BLOCK_SIZE; 1706 if (hdr->header_blocks != sz) 1707 ret = -EINVAL; 1708 soprintf(ictx, "%s Image header size (blocks): %i\n", stat[!!ret], 1709 hdr->header_blocks); 1710 if (ret) 1711 return ret; 1712 1713 sz = sizeof(struct sb_sections_header) / SB_BLOCK_SIZE; 1714 if (hdr->section_header_size != sz) 1715 ret = -EINVAL; 1716 soprintf(ictx, "%s Section header size (blocks): %i\n", stat[!!ret], 1717 hdr->section_header_size); 1718 if (ret) 1719 return ret; 1720 1721 soprintf(ictx, "%s Sections count: %i\n", stat[!!ret], 1722 hdr->section_count); 1723 soprintf(ictx, "%s First bootable section %i\n", stat[!!ret], 1724 hdr->first_boot_section_id); 1725 1726 if (hdr->image_blocks != fsize / SB_BLOCK_SIZE) 1727 ret = -EINVAL; 1728 soprintf(ictx, "%s Image size (blocks): %i\n", stat[!!ret], 1729 hdr->image_blocks); 1730 if (ret) 1731 return ret; 1732 1733 sz = hdr->header_blocks + hdr->section_header_size * hdr->section_count; 1734 if (hdr->key_dictionary_block != sz) 1735 ret = -EINVAL; 1736 soprintf(ictx, "%s Key dict offset (blocks): %i\n", stat[!!ret], 1737 hdr->key_dictionary_block); 1738 if (ret) 1739 return ret; 1740 1741 if (hdr->key_count != 1) 1742 ret = -EINVAL; 1743 soprintf(ictx, "%s Number of encryption keys: %i\n", stat[!!ret], 1744 hdr->key_count); 1745 if (ret) 1746 return ret; 1747 1748 sz = hdr->header_blocks + hdr->section_header_size * hdr->section_count; 1749 sz += hdr->key_count * 1750 sizeof(struct sb_key_dictionary_key) / SB_BLOCK_SIZE; 1751 if (hdr->first_boot_tag_block != (unsigned)sz) 1752 ret = -EINVAL; 1753 soprintf(ictx, "%s First TAG block (blocks): %i\n", stat[!!ret], 1754 hdr->first_boot_tag_block); 1755 if (ret) 1756 return ret; 1757 1758 return 0; 1759 } 1760 1761 static void sb_decrypt_tag(struct sb_image_ctx *ictx, 1762 struct sb_cmd_ctx *cctx) 1763 { 1764 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 1765 struct sb_command *cmd = &cctx->payload; 1766 1767 sb_aes_crypt(ictx, (uint8_t *)&cctx->c_payload, 1768 (uint8_t *)&cctx->payload, sizeof(*cmd)); 1769 EVP_DigestUpdate(md_ctx, &cctx->c_payload, sizeof(*cmd)); 1770 } 1771 1772 static int sb_verify_command(struct sb_image_ctx *ictx, 1773 struct sb_cmd_ctx *cctx, FILE *fp, 1774 unsigned long *tsize) 1775 { 1776 struct sb_command *ccmd = &cctx->payload; 1777 unsigned long size, asize; 1778 char *csum, *flag = ""; 1779 int ret; 1780 unsigned int i; 1781 uint8_t csn, csc = ccmd->header.checksum; 1782 ccmd->header.checksum = 0x5a; 1783 csn = sb_command_checksum(ccmd); 1784 ccmd->header.checksum = csc; 1785 1786 if (csc == csn) 1787 ret = 0; 1788 else 1789 ret = -EINVAL; 1790 csum = ret ? "checksum BAD" : "checksum OK"; 1791 1792 switch (ccmd->header.tag) { 1793 case ROM_NOP_CMD: 1794 soprintf(ictx, " NOOP # %s\n", csum); 1795 return ret; 1796 case ROM_TAG_CMD: 1797 if (ccmd->header.flags & ROM_TAG_CMD_FLAG_ROM_LAST_TAG) 1798 flag = "LAST"; 1799 soprintf(ictx, " TAG %s # %s\n", flag, csum); 1800 sb_aes_reinit(ictx, 0); 1801 return ret; 1802 case ROM_LOAD_CMD: 1803 soprintf(ictx, " LOAD addr=0x%08x length=0x%08x # %s\n", 1804 ccmd->load.address, ccmd->load.count, csum); 1805 1806 cctx->length = ccmd->load.count; 1807 asize = roundup(cctx->length, SB_BLOCK_SIZE); 1808 cctx->data = malloc(asize); 1809 if (!cctx->data) 1810 return -ENOMEM; 1811 1812 size = fread(cctx->data, 1, asize, fp); 1813 if (size != asize) { 1814 fprintf(stderr, 1815 "ERR: SB LOAD command payload too short!\n"); 1816 return -EINVAL; 1817 } 1818 1819 *tsize += size; 1820 1821 EVP_DigestUpdate(&ictx->md_ctx, cctx->data, asize); 1822 sb_aes_crypt(ictx, cctx->data, cctx->data, asize); 1823 1824 if (ccmd->load.crc32 != pbl_crc32(0, 1825 (const char *)cctx->data, 1826 asize)) { 1827 fprintf(stderr, 1828 "ERR: SB LOAD command payload CRC32 invalid!\n"); 1829 return -EINVAL; 1830 } 1831 return 0; 1832 case ROM_FILL_CMD: 1833 soprintf(ictx, 1834 " FILL addr=0x%08x length=0x%08x pattern=0x%08x # %s\n", 1835 ccmd->fill.address, ccmd->fill.count, 1836 ccmd->fill.pattern, csum); 1837 return 0; 1838 case ROM_JUMP_CMD: 1839 if (ccmd->header.flags & ROM_JUMP_CMD_FLAG_HAB) 1840 flag = " HAB"; 1841 soprintf(ictx, 1842 " JUMP%s addr=0x%08x r0_arg=0x%08x # %s\n", 1843 flag, ccmd->fill.address, ccmd->jump.argument, csum); 1844 return 0; 1845 case ROM_CALL_CMD: 1846 if (ccmd->header.flags & ROM_CALL_CMD_FLAG_HAB) 1847 flag = " HAB"; 1848 soprintf(ictx, 1849 " CALL%s addr=0x%08x r0_arg=0x%08x # %s\n", 1850 flag, ccmd->fill.address, ccmd->jump.argument, csum); 1851 return 0; 1852 case ROM_MODE_CMD: 1853 for (i = 0; i < ARRAY_SIZE(modetable); i++) { 1854 if (ccmd->mode.mode == modetable[i].mode) { 1855 soprintf(ictx, " MODE %s # %s\n", 1856 modetable[i].name, csum); 1857 break; 1858 } 1859 } 1860 fprintf(stderr, " MODE !INVALID! # %s\n", csum); 1861 return 0; 1862 } 1863 1864 return ret; 1865 } 1866 1867 static int sb_verify_commands(struct sb_image_ctx *ictx, 1868 struct sb_section_ctx *sctx, FILE *fp) 1869 { 1870 unsigned long size, tsize = 0; 1871 struct sb_cmd_ctx *cctx; 1872 int ret; 1873 1874 sb_aes_reinit(ictx, 0); 1875 1876 while (tsize < sctx->size) { 1877 cctx = calloc(1, sizeof(*cctx)); 1878 if (!cctx) 1879 return -ENOMEM; 1880 if (!sctx->cmd_head) { 1881 sctx->cmd_head = cctx; 1882 sctx->cmd_tail = cctx; 1883 } else { 1884 sctx->cmd_tail->cmd = cctx; 1885 sctx->cmd_tail = cctx; 1886 } 1887 1888 size = fread(&cctx->c_payload, 1, sizeof(cctx->c_payload), fp); 1889 if (size != sizeof(cctx->c_payload)) { 1890 fprintf(stderr, "ERR: SB command header too short!\n"); 1891 return -EINVAL; 1892 } 1893 1894 tsize += size; 1895 1896 sb_decrypt_tag(ictx, cctx); 1897 1898 ret = sb_verify_command(ictx, cctx, fp, &tsize); 1899 if (ret) 1900 return -EINVAL; 1901 } 1902 1903 return 0; 1904 } 1905 1906 static int sb_verify_sections_cmds(struct sb_image_ctx *ictx, FILE *fp) 1907 { 1908 struct sb_boot_image_header *hdr = &ictx->payload; 1909 struct sb_sections_header *shdr; 1910 unsigned int i; 1911 int ret; 1912 struct sb_section_ctx *sctx; 1913 unsigned long size; 1914 char *bootable = ""; 1915 1916 soprintf(ictx, "----- Verifying SB Sections and Commands -----\n"); 1917 1918 for (i = 0; i < hdr->section_count; i++) { 1919 sctx = calloc(1, sizeof(*sctx)); 1920 if (!sctx) 1921 return -ENOMEM; 1922 if (!ictx->sect_head) { 1923 ictx->sect_head = sctx; 1924 ictx->sect_tail = sctx; 1925 } else { 1926 ictx->sect_tail->sect = sctx; 1927 ictx->sect_tail = sctx; 1928 } 1929 1930 size = fread(&sctx->payload, 1, sizeof(sctx->payload), fp); 1931 if (size != sizeof(sctx->payload)) { 1932 fprintf(stderr, "ERR: SB section header too short!\n"); 1933 return -EINVAL; 1934 } 1935 } 1936 1937 size = fread(&ictx->sb_dict_key, 1, sizeof(ictx->sb_dict_key), fp); 1938 if (size != sizeof(ictx->sb_dict_key)) { 1939 fprintf(stderr, "ERR: SB key dictionary too short!\n"); 1940 return -EINVAL; 1941 } 1942 1943 sb_encrypt_sb_sections_header(ictx); 1944 sb_aes_reinit(ictx, 0); 1945 sb_decrypt_key_dictionary_key(ictx); 1946 1947 sb_aes_reinit(ictx, 0); 1948 1949 sctx = ictx->sect_head; 1950 while (sctx) { 1951 shdr = &sctx->payload; 1952 1953 if (shdr->section_flags & SB_SECTION_FLAG_BOOTABLE) { 1954 sctx->boot = 1; 1955 bootable = " BOOTABLE"; 1956 } 1957 1958 sctx->size = (shdr->section_size * SB_BLOCK_SIZE) + 1959 sizeof(struct sb_command); 1960 soprintf(ictx, "SECTION 0x%x%s # size = %i bytes\n", 1961 shdr->section_number, bootable, sctx->size); 1962 1963 if (shdr->section_flags & ~SB_SECTION_FLAG_BOOTABLE) 1964 fprintf(stderr, " WARN: Unknown section flag(s) %08x\n", 1965 shdr->section_flags); 1966 1967 if ((shdr->section_flags & SB_SECTION_FLAG_BOOTABLE) && 1968 (hdr->first_boot_section_id != shdr->section_number)) { 1969 fprintf(stderr, 1970 " WARN: Bootable section does ID not match image header ID!\n"); 1971 } 1972 1973 ret = sb_verify_commands(ictx, sctx, fp); 1974 if (ret) 1975 return ret; 1976 1977 sctx = sctx->sect; 1978 } 1979 1980 /* 1981 * FIXME IDEA: 1982 * check if the first TAG command is at sctx->section_offset 1983 */ 1984 return 0; 1985 } 1986 1987 static int sb_verify_image_end(struct sb_image_ctx *ictx, 1988 FILE *fp, off_t filesz) 1989 { 1990 uint8_t digest[32]; 1991 unsigned long size; 1992 off_t pos; 1993 int ret; 1994 1995 soprintf(ictx, "------------- Verifying image end -------------\n"); 1996 1997 size = fread(digest, 1, sizeof(digest), fp); 1998 if (size != sizeof(digest)) { 1999 fprintf(stderr, "ERR: SB key dictionary too short!\n"); 2000 return -EINVAL; 2001 } 2002 2003 pos = ftell(fp); 2004 if (pos != filesz) { 2005 fprintf(stderr, "ERR: Trailing data past the image!\n"); 2006 return -EINVAL; 2007 } 2008 2009 /* Check the image digest. */ 2010 EVP_DigestFinal(&ictx->md_ctx, ictx->digest, NULL); 2011 2012 /* Decrypt the image digest from the input image. */ 2013 sb_aes_reinit(ictx, 0); 2014 sb_aes_crypt(ictx, digest, digest, sizeof(digest)); 2015 2016 /* Check all of 20 bytes of the SHA1 hash. */ 2017 ret = memcmp(digest, ictx->digest, 20) ? -EINVAL : 0; 2018 2019 if (ret) 2020 soprintf(ictx, "[FAIL] Full-image checksum: BAD\n"); 2021 else 2022 soprintf(ictx, "[PASS] Full-image checksum: OK\n"); 2023 2024 return ret; 2025 } 2026 2027 2028 static int sb_build_tree_from_img(struct sb_image_ctx *ictx) 2029 { 2030 long filesize; 2031 int ret; 2032 FILE *fp; 2033 2034 if (!ictx->input_filename) { 2035 fprintf(stderr, "ERR: Missing filename!\n"); 2036 return -EINVAL; 2037 } 2038 2039 fp = fopen(ictx->input_filename, "r"); 2040 if (!fp) 2041 goto err_open; 2042 2043 ret = fseek(fp, 0, SEEK_END); 2044 if (ret < 0) 2045 goto err_file; 2046 2047 filesize = ftell(fp); 2048 if (filesize < 0) 2049 goto err_file; 2050 2051 ret = fseek(fp, 0, SEEK_SET); 2052 if (ret < 0) 2053 goto err_file; 2054 2055 if (filesize < (signed)sizeof(ictx->payload)) { 2056 fprintf(stderr, "ERR: File too short!\n"); 2057 goto err_file; 2058 } 2059 2060 if (filesize & (SB_BLOCK_SIZE - 1)) { 2061 fprintf(stderr, "ERR: The file is not aligned!\n"); 2062 goto err_file; 2063 } 2064 2065 /* Load and verify image header */ 2066 ret = sb_verify_image_header(ictx, fp, filesize); 2067 if (ret) 2068 goto err_verify; 2069 2070 /* Load and verify sections and commands */ 2071 ret = sb_verify_sections_cmds(ictx, fp); 2072 if (ret) 2073 goto err_verify; 2074 2075 ret = sb_verify_image_end(ictx, fp, filesize); 2076 if (ret) 2077 goto err_verify; 2078 2079 ret = 0; 2080 2081 err_verify: 2082 soprintf(ictx, "-------------------- Result -------------------\n"); 2083 soprintf(ictx, "Verification %s\n", ret ? "FAILED" : "PASSED"); 2084 2085 /* Stop the encryption session. */ 2086 sb_aes_deinit(&ictx->cipher_ctx); 2087 2088 fclose(fp); 2089 return ret; 2090 2091 err_file: 2092 fclose(fp); 2093 err_open: 2094 fprintf(stderr, "ERR: Failed to load file \"%s\"\n", 2095 ictx->input_filename); 2096 return -EINVAL; 2097 } 2098 2099 static void sb_free_image(struct sb_image_ctx *ictx) 2100 { 2101 struct sb_section_ctx *sctx = ictx->sect_head, *s_head; 2102 struct sb_dcd_ctx *dctx = ictx->dcd_head, *d_head; 2103 struct sb_cmd_ctx *cctx, *c_head; 2104 2105 while (sctx) { 2106 s_head = sctx; 2107 c_head = sctx->cmd_head; 2108 2109 while (c_head) { 2110 cctx = c_head; 2111 c_head = c_head->cmd; 2112 if (cctx->data) 2113 free(cctx->data); 2114 free(cctx); 2115 } 2116 2117 sctx = sctx->sect; 2118 free(s_head); 2119 } 2120 2121 while (dctx) { 2122 d_head = dctx; 2123 dctx = dctx->dcd; 2124 free(d_head->payload); 2125 free(d_head); 2126 } 2127 } 2128 2129 /* 2130 * MXSSB-MKIMAGE glue code. 2131 */ 2132 static int mxsimage_check_image_types(uint8_t type) 2133 { 2134 if (type == IH_TYPE_MXSIMAGE) 2135 return EXIT_SUCCESS; 2136 else 2137 return EXIT_FAILURE; 2138 } 2139 2140 static void mxsimage_set_header(void *ptr, struct stat *sbuf, int ifd, 2141 struct image_tool_params *params) 2142 { 2143 } 2144 2145 int mxsimage_check_params(struct image_tool_params *params) 2146 { 2147 if (!params) 2148 return -1; 2149 if (!strlen(params->imagename)) { 2150 fprintf(stderr, 2151 "Error: %s - Configuration file not specified, it is needed for mxsimage generation\n", 2152 params->cmdname); 2153 return -1; 2154 } 2155 2156 /* 2157 * Check parameters: 2158 * XIP is not allowed and verify that incompatible 2159 * parameters are not sent at the same time 2160 * For example, if list is required a data image must not be provided 2161 */ 2162 return (params->dflag && (params->fflag || params->lflag)) || 2163 (params->fflag && (params->dflag || params->lflag)) || 2164 (params->lflag && (params->dflag || params->fflag)) || 2165 (params->xflag) || !(strlen(params->imagename)); 2166 } 2167 2168 static int mxsimage_verify_print_header(char *file, int silent) 2169 { 2170 int ret; 2171 struct sb_image_ctx ctx; 2172 2173 memset(&ctx, 0, sizeof(ctx)); 2174 2175 ctx.input_filename = file; 2176 ctx.silent_dump = silent; 2177 2178 ret = sb_build_tree_from_img(&ctx); 2179 sb_free_image(&ctx); 2180 2181 return ret; 2182 } 2183 2184 char *imagefile; 2185 static int mxsimage_verify_header(unsigned char *ptr, int image_size, 2186 struct image_tool_params *params) 2187 { 2188 struct sb_boot_image_header *hdr; 2189 2190 if (!ptr) 2191 return -EINVAL; 2192 2193 hdr = (struct sb_boot_image_header *)ptr; 2194 2195 /* 2196 * Check if the header contains the MXS image signatures, 2197 * if so, do a full-image verification. 2198 */ 2199 if (memcmp(hdr->signature1, "STMP", 4) || 2200 memcmp(hdr->signature2, "sgtl", 4)) 2201 return -EINVAL; 2202 2203 imagefile = params->imagefile; 2204 2205 return mxsimage_verify_print_header(params->imagefile, 1); 2206 } 2207 2208 static void mxsimage_print_header(const void *hdr) 2209 { 2210 if (imagefile) 2211 mxsimage_verify_print_header(imagefile, 0); 2212 } 2213 2214 static int sb_build_image(struct sb_image_ctx *ictx, 2215 struct image_type_params *tparams) 2216 { 2217 struct sb_boot_image_header *sb_header = &ictx->payload; 2218 struct sb_section_ctx *sctx; 2219 struct sb_cmd_ctx *cctx; 2220 struct sb_command *ccmd; 2221 struct sb_key_dictionary_key *sb_dict_key = &ictx->sb_dict_key; 2222 2223 uint8_t *image, *iptr; 2224 2225 /* Calculate image size. */ 2226 uint32_t size = sizeof(*sb_header) + 2227 ictx->sect_count * sizeof(struct sb_sections_header) + 2228 sizeof(*sb_dict_key) + sizeof(ictx->digest); 2229 2230 sctx = ictx->sect_head; 2231 while (sctx) { 2232 size += sctx->size; 2233 sctx = sctx->sect; 2234 }; 2235 2236 image = malloc(size); 2237 if (!image) 2238 return -ENOMEM; 2239 iptr = image; 2240 2241 memcpy(iptr, sb_header, sizeof(*sb_header)); 2242 iptr += sizeof(*sb_header); 2243 2244 sctx = ictx->sect_head; 2245 while (sctx) { 2246 memcpy(iptr, &sctx->payload, sizeof(struct sb_sections_header)); 2247 iptr += sizeof(struct sb_sections_header); 2248 sctx = sctx->sect; 2249 }; 2250 2251 memcpy(iptr, sb_dict_key, sizeof(*sb_dict_key)); 2252 iptr += sizeof(*sb_dict_key); 2253 2254 sctx = ictx->sect_head; 2255 while (sctx) { 2256 cctx = sctx->cmd_head; 2257 while (cctx) { 2258 ccmd = &cctx->payload; 2259 2260 memcpy(iptr, &cctx->c_payload, sizeof(cctx->payload)); 2261 iptr += sizeof(cctx->payload); 2262 2263 if (ccmd->header.tag == ROM_LOAD_CMD) { 2264 memcpy(iptr, cctx->data, cctx->length); 2265 iptr += cctx->length; 2266 } 2267 2268 cctx = cctx->cmd; 2269 } 2270 2271 sctx = sctx->sect; 2272 }; 2273 2274 memcpy(iptr, ictx->digest, sizeof(ictx->digest)); 2275 iptr += sizeof(ictx->digest); 2276 2277 /* Configure the mkimage */ 2278 tparams->hdr = image; 2279 tparams->header_size = size; 2280 2281 return 0; 2282 } 2283 2284 static int mxsimage_generate(struct image_tool_params *params, 2285 struct image_type_params *tparams) 2286 { 2287 int ret; 2288 struct sb_image_ctx ctx; 2289 2290 /* Do not copy the U-Boot image! */ 2291 params->skipcpy = 1; 2292 2293 memset(&ctx, 0, sizeof(ctx)); 2294 2295 ctx.cfg_filename = params->imagename; 2296 ctx.output_filename = params->imagefile; 2297 2298 ret = sb_build_tree_from_cfg(&ctx); 2299 if (ret) 2300 goto fail; 2301 2302 ret = sb_encrypt_image(&ctx); 2303 if (!ret) 2304 ret = sb_build_image(&ctx, tparams); 2305 2306 fail: 2307 sb_free_image(&ctx); 2308 2309 return ret; 2310 } 2311 2312 /* 2313 * mxsimage parameters 2314 */ 2315 U_BOOT_IMAGE_TYPE( 2316 mxsimage, 2317 "Freescale MXS Boot Image support", 2318 0, 2319 NULL, 2320 mxsimage_check_params, 2321 mxsimage_verify_header, 2322 mxsimage_print_header, 2323 mxsimage_set_header, 2324 NULL, 2325 mxsimage_check_image_types, 2326 NULL, 2327 mxsimage_generate 2328 ); 2329 #endif 2330