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 verbose_boot: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 /* FIXME -- add proper config option */ 1312 hdr->flags = ictx->verbose_boot ? SB_IMAGE_FLAG_VERBOSE : 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; 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 /* DCD */ 1432 if (!strcmp(tok, "DCD")) { 1433 ictx->in_section = 0; 1434 ictx->in_dcd = 1; 1435 sb_build_dcd(ictx, cmd); 1436 return 0; 1437 } 1438 1439 /* Section */ 1440 if (!strcmp(tok, "SECTION")) { 1441 ictx->in_section = 1; 1442 ictx->in_dcd = 0; 1443 sb_build_section(ictx, cmd); 1444 return 0; 1445 } 1446 1447 if (!ictx->in_section && !ictx->in_dcd) { 1448 fprintf(stderr, "#%i ERR: Data outside of a section!\n", 1449 cmd->lineno); 1450 return -EINVAL; 1451 } 1452 1453 if (ictx->in_section) { 1454 /* Section commands */ 1455 if (!strcmp(tok, "NOP")) { 1456 ret = sb_build_command_nop(ictx); 1457 } else if (!strcmp(tok, "TAG")) { 1458 ret = sb_build_command_tag(ictx, cmd); 1459 } else if (!strcmp(tok, "LOAD")) { 1460 ret = sb_build_command_load(ictx, cmd); 1461 } else if (!strcmp(tok, "FILL")) { 1462 ret = sb_build_command_fill(ictx, cmd); 1463 } else if (!strcmp(tok, "JUMP")) { 1464 ret = sb_build_command_jump(ictx, cmd); 1465 } else if (!strcmp(tok, "CALL")) { 1466 ret = sb_build_command_call(ictx, cmd); 1467 } else if (!strcmp(tok, "MODE")) { 1468 ret = sb_build_command_mode(ictx, cmd); 1469 } else { 1470 fprintf(stderr, 1471 "#%i ERR: Unsupported instruction '%s'!\n", 1472 cmd->lineno, tok); 1473 return -ENOTSUP; 1474 } 1475 } else if (ictx->in_dcd) { 1476 char *lptr; 1477 uint32_t ilen = '1'; 1478 1479 tok = strtok_r(tok, ".", &lptr); 1480 if (!tok || (strlen(tok) == 0) || (lptr && strlen(lptr) != 1)) { 1481 fprintf(stderr, "#%i ERR: Invalid line!\n", 1482 cmd->lineno); 1483 return -EINVAL; 1484 } 1485 1486 if (lptr && 1487 (lptr[0] != '1' && lptr[0] != '2' && lptr[0] != '4')) { 1488 fprintf(stderr, "#%i ERR: Invalid instruction width!\n", 1489 cmd->lineno); 1490 return -EINVAL; 1491 } 1492 1493 if (lptr) 1494 ilen = lptr[0] - '1'; 1495 1496 /* DCD commands */ 1497 if (!strcmp(tok, "WRITE")) { 1498 ret = sb_build_dcd_block(ictx, cmd, 1499 SB_DCD_WRITE | ilen); 1500 } else if (!strcmp(tok, "ANDC")) { 1501 ret = sb_build_dcd_block(ictx, cmd, 1502 SB_DCD_ANDC | ilen); 1503 } else if (!strcmp(tok, "ORR")) { 1504 ret = sb_build_dcd_block(ictx, cmd, 1505 SB_DCD_ORR | ilen); 1506 } else if (!strcmp(tok, "EQZ")) { 1507 ret = sb_build_dcd_block(ictx, cmd, 1508 SB_DCD_CHK_EQZ | ilen); 1509 } else if (!strcmp(tok, "EQ")) { 1510 ret = sb_build_dcd_block(ictx, cmd, 1511 SB_DCD_CHK_EQ | ilen); 1512 } else if (!strcmp(tok, "NEQ")) { 1513 ret = sb_build_dcd_block(ictx, cmd, 1514 SB_DCD_CHK_NEQ | ilen); 1515 } else if (!strcmp(tok, "NEZ")) { 1516 ret = sb_build_dcd_block(ictx, cmd, 1517 SB_DCD_CHK_NEZ | ilen); 1518 } else if (!strcmp(tok, "NOOP")) { 1519 ret = sb_build_dcd_block(ictx, cmd, SB_DCD_NOOP); 1520 } else { 1521 fprintf(stderr, 1522 "#%i ERR: Unsupported instruction '%s'!\n", 1523 cmd->lineno, tok); 1524 return -ENOTSUP; 1525 } 1526 } else { 1527 fprintf(stderr, "#%i ERR: Unsupported instruction '%s'!\n", 1528 cmd->lineno, tok); 1529 return -ENOTSUP; 1530 } 1531 1532 /* 1533 * Here we have at least one section with one command, otherwise we 1534 * would have failed already higher above. 1535 * 1536 * FIXME -- should the updating happen here ? 1537 */ 1538 if (ictx->in_section && !ret) { 1539 ictx->sect_tail->size += ictx->sect_tail->cmd_tail->size; 1540 ictx->sect_tail->payload.section_size = 1541 ictx->sect_tail->size / SB_BLOCK_SIZE; 1542 } 1543 1544 return ret; 1545 } 1546 1547 static int sb_load_cmdfile(struct sb_image_ctx *ictx) 1548 { 1549 struct sb_cmd_list cmd; 1550 int lineno = 1; 1551 FILE *fp; 1552 char *line = NULL; 1553 ssize_t rlen; 1554 size_t len; 1555 1556 fp = fopen(ictx->cfg_filename, "r"); 1557 if (!fp) 1558 goto err_file; 1559 1560 while ((rlen = getline(&line, &len, fp)) > 0) { 1561 memset(&cmd, 0, sizeof(cmd)); 1562 1563 /* Strip the trailing newline. */ 1564 line[rlen - 1] = '\0'; 1565 1566 cmd.cmd = line; 1567 cmd.len = rlen; 1568 cmd.lineno = lineno++; 1569 1570 sb_parse_line(ictx, &cmd); 1571 } 1572 1573 free(line); 1574 1575 fclose(fp); 1576 1577 return 0; 1578 1579 err_file: 1580 fclose(fp); 1581 fprintf(stderr, "ERR: Failed to load file \"%s\"\n", 1582 ictx->cfg_filename); 1583 return -EINVAL; 1584 } 1585 1586 static int sb_build_tree_from_cfg(struct sb_image_ctx *ictx) 1587 { 1588 int ret; 1589 1590 ret = sb_load_cmdfile(ictx); 1591 if (ret) 1592 return ret; 1593 1594 ret = sb_prefill_image_header(ictx); 1595 if (ret) 1596 return ret; 1597 1598 ret = sb_postfill_image_header(ictx); 1599 if (ret) 1600 return ret; 1601 1602 ret = sb_fixup_sections_and_tags(ictx); 1603 if (ret) 1604 return ret; 1605 1606 return 0; 1607 } 1608 1609 static int sb_verify_image_header(struct sb_image_ctx *ictx, 1610 FILE *fp, long fsize) 1611 { 1612 /* Verify static fields in the image header. */ 1613 struct sb_boot_image_header *hdr = &ictx->payload; 1614 const char *stat[2] = { "[PASS]", "[FAIL]" }; 1615 struct tm tm; 1616 int sz, ret = 0; 1617 unsigned char digest[20]; 1618 EVP_MD_CTX md_ctx; 1619 unsigned long size; 1620 1621 /* Start image-wide crypto. */ 1622 EVP_MD_CTX_init(&ictx->md_ctx); 1623 EVP_DigestInit(&ictx->md_ctx, EVP_sha1()); 1624 1625 soprintf(ictx, "---------- Verifying SB Image Header ----------\n"); 1626 1627 size = fread(&ictx->payload, 1, sizeof(ictx->payload), fp); 1628 if (size != sizeof(ictx->payload)) { 1629 fprintf(stderr, "ERR: SB image header too short!\n"); 1630 return -EINVAL; 1631 } 1632 1633 /* Compute header digest. */ 1634 EVP_MD_CTX_init(&md_ctx); 1635 EVP_DigestInit(&md_ctx, EVP_sha1()); 1636 EVP_DigestUpdate(&md_ctx, hdr->signature1, 1637 sizeof(struct sb_boot_image_header) - 1638 sizeof(hdr->digest)); 1639 EVP_DigestFinal(&md_ctx, digest, NULL); 1640 1641 sb_aes_init(ictx, NULL, 1); 1642 sb_encrypt_sb_header(ictx); 1643 1644 if (memcmp(digest, hdr->digest, 20)) 1645 ret = -EINVAL; 1646 soprintf(ictx, "%s Image header checksum: %s\n", stat[!!ret], 1647 ret ? "BAD" : "OK"); 1648 if (ret) 1649 return ret; 1650 1651 if (memcmp(hdr->signature1, "STMP", 4) || 1652 memcmp(hdr->signature2, "sgtl", 4)) 1653 ret = -EINVAL; 1654 soprintf(ictx, "%s Signatures: '%.4s' '%.4s'\n", 1655 stat[!!ret], hdr->signature1, hdr->signature2); 1656 if (ret) 1657 return ret; 1658 1659 if ((hdr->major_version != SB_VERSION_MAJOR) || 1660 ((hdr->minor_version != 1) && (hdr->minor_version != 2))) 1661 ret = -EINVAL; 1662 soprintf(ictx, "%s Image version: v%i.%i\n", stat[!!ret], 1663 hdr->major_version, hdr->minor_version); 1664 if (ret) 1665 return ret; 1666 1667 ret = sb_get_time(hdr->timestamp_us / 1000000, &tm); 1668 soprintf(ictx, 1669 "%s Creation time: %02i:%02i:%02i %02i/%02i/%04i\n", 1670 stat[!!ret], tm.tm_hour, tm.tm_min, tm.tm_sec, 1671 tm.tm_mday, tm.tm_mon, tm.tm_year + 2000); 1672 if (ret) 1673 return ret; 1674 1675 soprintf(ictx, "%s Product version: %x.%x.%x\n", stat[0], 1676 ntohs(hdr->product_version.major), 1677 ntohs(hdr->product_version.minor), 1678 ntohs(hdr->product_version.revision)); 1679 soprintf(ictx, "%s Component version: %x.%x.%x\n", stat[0], 1680 ntohs(hdr->component_version.major), 1681 ntohs(hdr->component_version.minor), 1682 ntohs(hdr->component_version.revision)); 1683 1684 if (hdr->flags & ~SB_IMAGE_FLAG_VERBOSE) 1685 ret = -EINVAL; 1686 soprintf(ictx, "%s Image flags: %s\n", stat[!!ret], 1687 hdr->flags & SB_IMAGE_FLAG_VERBOSE ? "Verbose_boot" : ""); 1688 if (ret) 1689 return ret; 1690 1691 if (hdr->drive_tag != 0) 1692 ret = -EINVAL; 1693 soprintf(ictx, "%s Drive tag: %i\n", stat[!!ret], 1694 hdr->drive_tag); 1695 if (ret) 1696 return ret; 1697 1698 sz = sizeof(struct sb_boot_image_header) / SB_BLOCK_SIZE; 1699 if (hdr->header_blocks != sz) 1700 ret = -EINVAL; 1701 soprintf(ictx, "%s Image header size (blocks): %i\n", stat[!!ret], 1702 hdr->header_blocks); 1703 if (ret) 1704 return ret; 1705 1706 sz = sizeof(struct sb_sections_header) / SB_BLOCK_SIZE; 1707 if (hdr->section_header_size != sz) 1708 ret = -EINVAL; 1709 soprintf(ictx, "%s Section header size (blocks): %i\n", stat[!!ret], 1710 hdr->section_header_size); 1711 if (ret) 1712 return ret; 1713 1714 soprintf(ictx, "%s Sections count: %i\n", stat[!!ret], 1715 hdr->section_count); 1716 soprintf(ictx, "%s First bootable section %i\n", stat[!!ret], 1717 hdr->first_boot_section_id); 1718 1719 if (hdr->image_blocks != fsize / SB_BLOCK_SIZE) 1720 ret = -EINVAL; 1721 soprintf(ictx, "%s Image size (blocks): %i\n", stat[!!ret], 1722 hdr->image_blocks); 1723 if (ret) 1724 return ret; 1725 1726 sz = hdr->header_blocks + hdr->section_header_size * hdr->section_count; 1727 if (hdr->key_dictionary_block != sz) 1728 ret = -EINVAL; 1729 soprintf(ictx, "%s Key dict offset (blocks): %i\n", stat[!!ret], 1730 hdr->key_dictionary_block); 1731 if (ret) 1732 return ret; 1733 1734 if (hdr->key_count != 1) 1735 ret = -EINVAL; 1736 soprintf(ictx, "%s Number of encryption keys: %i\n", stat[!!ret], 1737 hdr->key_count); 1738 if (ret) 1739 return ret; 1740 1741 sz = hdr->header_blocks + hdr->section_header_size * hdr->section_count; 1742 sz += hdr->key_count * 1743 sizeof(struct sb_key_dictionary_key) / SB_BLOCK_SIZE; 1744 if (hdr->first_boot_tag_block != (unsigned)sz) 1745 ret = -EINVAL; 1746 soprintf(ictx, "%s First TAG block (blocks): %i\n", stat[!!ret], 1747 hdr->first_boot_tag_block); 1748 if (ret) 1749 return ret; 1750 1751 return 0; 1752 } 1753 1754 static void sb_decrypt_tag(struct sb_image_ctx *ictx, 1755 struct sb_cmd_ctx *cctx) 1756 { 1757 EVP_MD_CTX *md_ctx = &ictx->md_ctx; 1758 struct sb_command *cmd = &cctx->payload; 1759 1760 sb_aes_crypt(ictx, (uint8_t *)&cctx->c_payload, 1761 (uint8_t *)&cctx->payload, sizeof(*cmd)); 1762 EVP_DigestUpdate(md_ctx, &cctx->c_payload, sizeof(*cmd)); 1763 } 1764 1765 static int sb_verify_command(struct sb_image_ctx *ictx, 1766 struct sb_cmd_ctx *cctx, FILE *fp, 1767 unsigned long *tsize) 1768 { 1769 struct sb_command *ccmd = &cctx->payload; 1770 unsigned long size, asize; 1771 char *csum, *flag = ""; 1772 int ret; 1773 unsigned int i; 1774 uint8_t csn, csc = ccmd->header.checksum; 1775 ccmd->header.checksum = 0x5a; 1776 csn = sb_command_checksum(ccmd); 1777 ccmd->header.checksum = csc; 1778 1779 if (csc == csn) 1780 ret = 0; 1781 else 1782 ret = -EINVAL; 1783 csum = ret ? "checksum BAD" : "checksum OK"; 1784 1785 switch (ccmd->header.tag) { 1786 case ROM_NOP_CMD: 1787 soprintf(ictx, " NOOP # %s\n", csum); 1788 return ret; 1789 case ROM_TAG_CMD: 1790 if (ccmd->header.flags & ROM_TAG_CMD_FLAG_ROM_LAST_TAG) 1791 flag = "LAST"; 1792 soprintf(ictx, " TAG %s # %s\n", flag, csum); 1793 sb_aes_reinit(ictx, 0); 1794 return ret; 1795 case ROM_LOAD_CMD: 1796 soprintf(ictx, " LOAD addr=0x%08x length=0x%08x # %s\n", 1797 ccmd->load.address, ccmd->load.count, csum); 1798 1799 cctx->length = ccmd->load.count; 1800 asize = roundup(cctx->length, SB_BLOCK_SIZE); 1801 cctx->data = malloc(asize); 1802 if (!cctx->data) 1803 return -ENOMEM; 1804 1805 size = fread(cctx->data, 1, asize, fp); 1806 if (size != asize) { 1807 fprintf(stderr, 1808 "ERR: SB LOAD command payload too short!\n"); 1809 return -EINVAL; 1810 } 1811 1812 *tsize += size; 1813 1814 EVP_DigestUpdate(&ictx->md_ctx, cctx->data, asize); 1815 sb_aes_crypt(ictx, cctx->data, cctx->data, asize); 1816 1817 if (ccmd->load.crc32 != pbl_crc32(0, 1818 (const char *)cctx->data, 1819 asize)) { 1820 fprintf(stderr, 1821 "ERR: SB LOAD command payload CRC32 invalid!\n"); 1822 return -EINVAL; 1823 } 1824 return 0; 1825 case ROM_FILL_CMD: 1826 soprintf(ictx, 1827 " FILL addr=0x%08x length=0x%08x pattern=0x%08x # %s\n", 1828 ccmd->fill.address, ccmd->fill.count, 1829 ccmd->fill.pattern, csum); 1830 return 0; 1831 case ROM_JUMP_CMD: 1832 if (ccmd->header.flags & ROM_JUMP_CMD_FLAG_HAB) 1833 flag = " HAB"; 1834 soprintf(ictx, 1835 " JUMP%s addr=0x%08x r0_arg=0x%08x # %s\n", 1836 flag, ccmd->fill.address, ccmd->jump.argument, csum); 1837 return 0; 1838 case ROM_CALL_CMD: 1839 if (ccmd->header.flags & ROM_CALL_CMD_FLAG_HAB) 1840 flag = " HAB"; 1841 soprintf(ictx, 1842 " CALL%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_MODE_CMD: 1846 for (i = 0; i < ARRAY_SIZE(modetable); i++) { 1847 if (ccmd->mode.mode == modetable[i].mode) { 1848 soprintf(ictx, " MODE %s # %s\n", 1849 modetable[i].name, csum); 1850 break; 1851 } 1852 } 1853 fprintf(stderr, " MODE !INVALID! # %s\n", csum); 1854 return 0; 1855 } 1856 1857 return ret; 1858 } 1859 1860 static int sb_verify_commands(struct sb_image_ctx *ictx, 1861 struct sb_section_ctx *sctx, FILE *fp) 1862 { 1863 unsigned long size, tsize = 0; 1864 struct sb_cmd_ctx *cctx; 1865 int ret; 1866 1867 sb_aes_reinit(ictx, 0); 1868 1869 while (tsize < sctx->size) { 1870 cctx = calloc(1, sizeof(*cctx)); 1871 if (!cctx) 1872 return -ENOMEM; 1873 if (!sctx->cmd_head) { 1874 sctx->cmd_head = cctx; 1875 sctx->cmd_tail = cctx; 1876 } else { 1877 sctx->cmd_tail->cmd = cctx; 1878 sctx->cmd_tail = cctx; 1879 } 1880 1881 size = fread(&cctx->c_payload, 1, sizeof(cctx->c_payload), fp); 1882 if (size != sizeof(cctx->c_payload)) { 1883 fprintf(stderr, "ERR: SB command header too short!\n"); 1884 return -EINVAL; 1885 } 1886 1887 tsize += size; 1888 1889 sb_decrypt_tag(ictx, cctx); 1890 1891 ret = sb_verify_command(ictx, cctx, fp, &tsize); 1892 if (ret) 1893 return -EINVAL; 1894 } 1895 1896 return 0; 1897 } 1898 1899 static int sb_verify_sections_cmds(struct sb_image_ctx *ictx, FILE *fp) 1900 { 1901 struct sb_boot_image_header *hdr = &ictx->payload; 1902 struct sb_sections_header *shdr; 1903 unsigned int i; 1904 int ret; 1905 struct sb_section_ctx *sctx; 1906 unsigned long size; 1907 char *bootable = ""; 1908 1909 soprintf(ictx, "----- Verifying SB Sections and Commands -----\n"); 1910 1911 for (i = 0; i < hdr->section_count; i++) { 1912 sctx = calloc(1, sizeof(*sctx)); 1913 if (!sctx) 1914 return -ENOMEM; 1915 if (!ictx->sect_head) { 1916 ictx->sect_head = sctx; 1917 ictx->sect_tail = sctx; 1918 } else { 1919 ictx->sect_tail->sect = sctx; 1920 ictx->sect_tail = sctx; 1921 } 1922 1923 size = fread(&sctx->payload, 1, sizeof(sctx->payload), fp); 1924 if (size != sizeof(sctx->payload)) { 1925 fprintf(stderr, "ERR: SB section header too short!\n"); 1926 return -EINVAL; 1927 } 1928 } 1929 1930 size = fread(&ictx->sb_dict_key, 1, sizeof(ictx->sb_dict_key), fp); 1931 if (size != sizeof(ictx->sb_dict_key)) { 1932 fprintf(stderr, "ERR: SB key dictionary too short!\n"); 1933 return -EINVAL; 1934 } 1935 1936 sb_encrypt_sb_sections_header(ictx); 1937 sb_aes_reinit(ictx, 0); 1938 sb_decrypt_key_dictionary_key(ictx); 1939 1940 sb_aes_reinit(ictx, 0); 1941 1942 sctx = ictx->sect_head; 1943 while (sctx) { 1944 shdr = &sctx->payload; 1945 1946 if (shdr->section_flags & SB_SECTION_FLAG_BOOTABLE) { 1947 sctx->boot = 1; 1948 bootable = " BOOTABLE"; 1949 } 1950 1951 sctx->size = (shdr->section_size * SB_BLOCK_SIZE) + 1952 sizeof(struct sb_command); 1953 soprintf(ictx, "SECTION 0x%x%s # size = %i bytes\n", 1954 shdr->section_number, bootable, sctx->size); 1955 1956 if (shdr->section_flags & ~SB_SECTION_FLAG_BOOTABLE) 1957 fprintf(stderr, " WARN: Unknown section flag(s) %08x\n", 1958 shdr->section_flags); 1959 1960 if ((shdr->section_flags & SB_SECTION_FLAG_BOOTABLE) && 1961 (hdr->first_boot_section_id != shdr->section_number)) { 1962 fprintf(stderr, 1963 " WARN: Bootable section does ID not match image header ID!\n"); 1964 } 1965 1966 ret = sb_verify_commands(ictx, sctx, fp); 1967 if (ret) 1968 return ret; 1969 1970 sctx = sctx->sect; 1971 } 1972 1973 /* 1974 * FIXME IDEA: 1975 * check if the first TAG command is at sctx->section_offset 1976 */ 1977 return 0; 1978 } 1979 1980 static int sb_verify_image_end(struct sb_image_ctx *ictx, 1981 FILE *fp, off_t filesz) 1982 { 1983 uint8_t digest[32]; 1984 unsigned long size; 1985 off_t pos; 1986 int ret; 1987 1988 soprintf(ictx, "------------- Verifying image end -------------\n"); 1989 1990 size = fread(digest, 1, sizeof(digest), fp); 1991 if (size != sizeof(digest)) { 1992 fprintf(stderr, "ERR: SB key dictionary too short!\n"); 1993 return -EINVAL; 1994 } 1995 1996 pos = ftell(fp); 1997 if (pos != filesz) { 1998 fprintf(stderr, "ERR: Trailing data past the image!\n"); 1999 return -EINVAL; 2000 } 2001 2002 /* Check the image digest. */ 2003 EVP_DigestFinal(&ictx->md_ctx, ictx->digest, NULL); 2004 2005 /* Decrypt the image digest from the input image. */ 2006 sb_aes_reinit(ictx, 0); 2007 sb_aes_crypt(ictx, digest, digest, sizeof(digest)); 2008 2009 /* Check all of 20 bytes of the SHA1 hash. */ 2010 ret = memcmp(digest, ictx->digest, 20) ? -EINVAL : 0; 2011 2012 if (ret) 2013 soprintf(ictx, "[FAIL] Full-image checksum: BAD\n"); 2014 else 2015 soprintf(ictx, "[PASS] Full-image checksum: OK\n"); 2016 2017 return ret; 2018 } 2019 2020 2021 static int sb_build_tree_from_img(struct sb_image_ctx *ictx) 2022 { 2023 long filesize; 2024 int ret; 2025 FILE *fp; 2026 2027 if (!ictx->input_filename) { 2028 fprintf(stderr, "ERR: Missing filename!\n"); 2029 return -EINVAL; 2030 } 2031 2032 fp = fopen(ictx->input_filename, "r"); 2033 if (!fp) 2034 goto err_open; 2035 2036 ret = fseek(fp, 0, SEEK_END); 2037 if (ret < 0) 2038 goto err_file; 2039 2040 filesize = ftell(fp); 2041 if (filesize < 0) 2042 goto err_file; 2043 2044 ret = fseek(fp, 0, SEEK_SET); 2045 if (ret < 0) 2046 goto err_file; 2047 2048 if (filesize < (signed)sizeof(ictx->payload)) { 2049 fprintf(stderr, "ERR: File too short!\n"); 2050 goto err_file; 2051 } 2052 2053 if (filesize & (SB_BLOCK_SIZE - 1)) { 2054 fprintf(stderr, "ERR: The file is not aligned!\n"); 2055 goto err_file; 2056 } 2057 2058 /* Load and verify image header */ 2059 ret = sb_verify_image_header(ictx, fp, filesize); 2060 if (ret) 2061 goto err_verify; 2062 2063 /* Load and verify sections and commands */ 2064 ret = sb_verify_sections_cmds(ictx, fp); 2065 if (ret) 2066 goto err_verify; 2067 2068 ret = sb_verify_image_end(ictx, fp, filesize); 2069 if (ret) 2070 goto err_verify; 2071 2072 ret = 0; 2073 2074 err_verify: 2075 soprintf(ictx, "-------------------- Result -------------------\n"); 2076 soprintf(ictx, "Verification %s\n", ret ? "FAILED" : "PASSED"); 2077 2078 /* Stop the encryption session. */ 2079 sb_aes_deinit(&ictx->cipher_ctx); 2080 2081 fclose(fp); 2082 return ret; 2083 2084 err_file: 2085 fclose(fp); 2086 err_open: 2087 fprintf(stderr, "ERR: Failed to load file \"%s\"\n", 2088 ictx->input_filename); 2089 return -EINVAL; 2090 } 2091 2092 static void sb_free_image(struct sb_image_ctx *ictx) 2093 { 2094 struct sb_section_ctx *sctx = ictx->sect_head, *s_head; 2095 struct sb_dcd_ctx *dctx = ictx->dcd_head, *d_head; 2096 struct sb_cmd_ctx *cctx, *c_head; 2097 2098 while (sctx) { 2099 s_head = sctx; 2100 c_head = sctx->cmd_head; 2101 2102 while (c_head) { 2103 cctx = c_head; 2104 c_head = c_head->cmd; 2105 if (cctx->data) 2106 free(cctx->data); 2107 free(cctx); 2108 } 2109 2110 sctx = sctx->sect; 2111 free(s_head); 2112 } 2113 2114 while (dctx) { 2115 d_head = dctx; 2116 dctx = dctx->dcd; 2117 free(d_head->payload); 2118 free(d_head); 2119 } 2120 } 2121 2122 /* 2123 * MXSSB-MKIMAGE glue code. 2124 */ 2125 static int mxsimage_check_image_types(uint8_t type) 2126 { 2127 if (type == IH_TYPE_MXSIMAGE) 2128 return EXIT_SUCCESS; 2129 else 2130 return EXIT_FAILURE; 2131 } 2132 2133 static void mxsimage_set_header(void *ptr, struct stat *sbuf, int ifd, 2134 struct image_tool_params *params) 2135 { 2136 } 2137 2138 int mxsimage_check_params(struct image_tool_params *params) 2139 { 2140 if (!params) 2141 return -1; 2142 if (!strlen(params->imagename)) { 2143 fprintf(stderr, 2144 "Error: %s - Configuration file not specified, it is needed for mxsimage generation\n", 2145 params->cmdname); 2146 return -1; 2147 } 2148 2149 /* 2150 * Check parameters: 2151 * XIP is not allowed and verify that incompatible 2152 * parameters are not sent at the same time 2153 * For example, if list is required a data image must not be provided 2154 */ 2155 return (params->dflag && (params->fflag || params->lflag)) || 2156 (params->fflag && (params->dflag || params->lflag)) || 2157 (params->lflag && (params->dflag || params->fflag)) || 2158 (params->xflag) || !(strlen(params->imagename)); 2159 } 2160 2161 static int mxsimage_verify_print_header(char *file, int silent) 2162 { 2163 int ret; 2164 struct sb_image_ctx ctx; 2165 2166 memset(&ctx, 0, sizeof(ctx)); 2167 2168 ctx.input_filename = file; 2169 ctx.silent_dump = silent; 2170 2171 ret = sb_build_tree_from_img(&ctx); 2172 sb_free_image(&ctx); 2173 2174 return ret; 2175 } 2176 2177 char *imagefile; 2178 static int mxsimage_verify_header(unsigned char *ptr, int image_size, 2179 struct image_tool_params *params) 2180 { 2181 struct sb_boot_image_header *hdr; 2182 2183 if (!ptr) 2184 return -EINVAL; 2185 2186 hdr = (struct sb_boot_image_header *)ptr; 2187 2188 /* 2189 * Check if the header contains the MXS image signatures, 2190 * if so, do a full-image verification. 2191 */ 2192 if (memcmp(hdr->signature1, "STMP", 4) || 2193 memcmp(hdr->signature2, "sgtl", 4)) 2194 return -EINVAL; 2195 2196 imagefile = params->imagefile; 2197 2198 return mxsimage_verify_print_header(params->imagefile, 1); 2199 } 2200 2201 static void mxsimage_print_header(const void *hdr) 2202 { 2203 if (imagefile) 2204 mxsimage_verify_print_header(imagefile, 0); 2205 } 2206 2207 static int sb_build_image(struct sb_image_ctx *ictx, 2208 struct image_type_params *tparams) 2209 { 2210 struct sb_boot_image_header *sb_header = &ictx->payload; 2211 struct sb_section_ctx *sctx; 2212 struct sb_cmd_ctx *cctx; 2213 struct sb_command *ccmd; 2214 struct sb_key_dictionary_key *sb_dict_key = &ictx->sb_dict_key; 2215 2216 uint8_t *image, *iptr; 2217 2218 /* Calculate image size. */ 2219 uint32_t size = sizeof(*sb_header) + 2220 ictx->sect_count * sizeof(struct sb_sections_header) + 2221 sizeof(*sb_dict_key) + sizeof(ictx->digest); 2222 2223 sctx = ictx->sect_head; 2224 while (sctx) { 2225 size += sctx->size; 2226 sctx = sctx->sect; 2227 }; 2228 2229 image = malloc(size); 2230 if (!image) 2231 return -ENOMEM; 2232 iptr = image; 2233 2234 memcpy(iptr, sb_header, sizeof(*sb_header)); 2235 iptr += sizeof(*sb_header); 2236 2237 sctx = ictx->sect_head; 2238 while (sctx) { 2239 memcpy(iptr, &sctx->payload, sizeof(struct sb_sections_header)); 2240 iptr += sizeof(struct sb_sections_header); 2241 sctx = sctx->sect; 2242 }; 2243 2244 memcpy(iptr, sb_dict_key, sizeof(*sb_dict_key)); 2245 iptr += sizeof(*sb_dict_key); 2246 2247 sctx = ictx->sect_head; 2248 while (sctx) { 2249 cctx = sctx->cmd_head; 2250 while (cctx) { 2251 ccmd = &cctx->payload; 2252 2253 memcpy(iptr, &cctx->c_payload, sizeof(cctx->payload)); 2254 iptr += sizeof(cctx->payload); 2255 2256 if (ccmd->header.tag == ROM_LOAD_CMD) { 2257 memcpy(iptr, cctx->data, cctx->length); 2258 iptr += cctx->length; 2259 } 2260 2261 cctx = cctx->cmd; 2262 } 2263 2264 sctx = sctx->sect; 2265 }; 2266 2267 memcpy(iptr, ictx->digest, sizeof(ictx->digest)); 2268 iptr += sizeof(ictx->digest); 2269 2270 /* Configure the mkimage */ 2271 tparams->hdr = image; 2272 tparams->header_size = size; 2273 2274 return 0; 2275 } 2276 2277 static int mxsimage_generate(struct image_tool_params *params, 2278 struct image_type_params *tparams) 2279 { 2280 int ret; 2281 struct sb_image_ctx ctx; 2282 2283 /* Do not copy the U-Boot image! */ 2284 params->skipcpy = 1; 2285 2286 memset(&ctx, 0, sizeof(ctx)); 2287 2288 ctx.cfg_filename = params->imagename; 2289 ctx.output_filename = params->imagefile; 2290 ctx.verbose_boot = 1; 2291 2292 ret = sb_build_tree_from_cfg(&ctx); 2293 if (ret) 2294 goto fail; 2295 2296 ret = sb_encrypt_image(&ctx); 2297 if (!ret) 2298 ret = sb_build_image(&ctx, tparams); 2299 2300 fail: 2301 sb_free_image(&ctx); 2302 2303 return ret; 2304 } 2305 2306 /* 2307 * mxsimage parameters 2308 */ 2309 static struct image_type_params mxsimage_params = { 2310 .name = "Freescale MXS Boot Image support", 2311 .header_size = 0, 2312 .hdr = NULL, 2313 .check_image_type = mxsimage_check_image_types, 2314 .verify_header = mxsimage_verify_header, 2315 .print_header = mxsimage_print_header, 2316 .set_header = mxsimage_set_header, 2317 .check_params = mxsimage_check_params, 2318 .vrec_header = mxsimage_generate, 2319 }; 2320 2321 void init_mxs_image_type(void) 2322 { 2323 register_image_type(&mxsimage_params); 2324 } 2325 2326 #else 2327 void init_mxs_image_type(void) 2328 { 2329 } 2330 #endif 2331