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