1 // SPDX-License-Identifier: GPL-2.0-only
4 * Copyright (C) 2007-2008 OpenWrt.org
5 * Copyright (C) 2007-2008 Gabor Juhos <juhosg at openwrt.org>
12 #include <unistd.h> /* for unlink() */
14 #include <getopt.h> /* for getopt() */
18 #include <endian.h> /* for __BYTE_ORDER */
19 #if defined(__CYGWIN__)
20 # include <byteswap.h>
26 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
27 # define HOST_TO_LE16(x) (x)
28 # define HOST_TO_LE32(x) (x)
29 # define LE16_TO_HOST(x) (x)
30 # define LE32_TO_HOST(x) (x)
31 # define HOST_TO_BE16(x) bswap_16(x)
32 # define HOST_TO_BE32(x) bswap_32(x)
33 # define BE16_TO_HOST(x) bswap_16(x)
34 # define BE32_TO_HOST(x) bswap_32(x)
36 # define HOST_TO_BE16(x) (x)
37 # define HOST_TO_BE32(x) (x)
38 # define BE16_TO_HOST(x) (x)
39 # define BE32_TO_HOST(x) (x)
40 # define HOST_TO_LE16(x) bswap_16(x)
41 # define HOST_TO_LE32(x) bswap_32(x)
42 # define LE16_TO_HOST(x) bswap_16(x)
43 # define LE32_TO_HOST(x) bswap_32(x)
46 #define ALIGN(x,y) (((x)+((y)-1)) & ~((y)-1))
48 #define MAX_NUM_BLOCKS 8
49 #define MAX_ARG_COUNT 32
50 #define MAX_ARG_LEN 1024
51 #define FILE_BUF_LEN (16*1024)
61 uint32_t align
; /* alignment of this block */
62 char *file_name
; /* name of the file */
63 uint32_t file_size
; /* length of the file */
64 char *mmap_name
; /* name in the MMAP table */
65 int type
; /* block type */
70 #define BLOCK_TYPE_BOOTEXT 0
71 #define BLOCK_TYPE_RAW 1
79 #define MMAP_DATA_SIZE 1024
83 char *name
; /* model name */
84 char *desc
; /* description */
85 uint16_t vendor
; /* vendor id */
86 uint16_t model
; /* model id */
87 uint32_t flash_base
; /* flash base address */
88 uint32_t flash_size
; /* board flash size */
89 uint32_t code_start
; /* code start address */
90 uint32_t romio_offs
; /* offset of the firmware within the flash */
91 uint32_t bootext_size
; /* maximum size of bootext block */
101 struct board_info
*board
= NULL
;
103 struct fw_block blocks
[MAX_NUM_BLOCKS
];
104 struct fw_block
*bootext_block
= NULL
;
107 #define ADM5120_FLASH_BASE 0xBFC00000
108 #define ADM5120_CODE_START 0x80008000
110 /* TODO: check values for AR7 */
111 #define AR7_FLASH_BASE 0xB0000000
112 #define AR7_CODE_START 0x94008000
114 #define ATHEROS_FLASH_BASE 0xBFC00000
115 #define ATHEROS_CODE_START 0x80e00000
117 #define AR71XX_FLASH_BASE 0xBFC00000
118 #define AR71XX_CODE_START 0x81E00000
120 #define BOARD(n, d, v, m, fb, fs, cs, fo) { \
121 .name = (n), .desc=(d), \
122 .vendor = (v), .model = (m), \
123 .flash_base = (fb), .flash_size = (fs)<<20, \
124 .code_start = (cs), .romio_offs = (fo), \
125 .bootext_size = BOOTEXT_DEF_SIZE \
128 #define ADMBOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
129 ADM5120_FLASH_BASE, fs, ADM5120_CODE_START, 0x8000)
131 #define ADMBOARD2(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
132 ADM5120_FLASH_BASE, fs, ADM5120_CODE_START, 0x10000)
134 #define AR7BOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
135 AR7_FLASH_BASE, fs, AR7_CODE_START, 0x8000)
137 #define ATHEROSBOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
138 ATHEROS_FLASH_BASE, fs, ATHEROS_CODE_START, 0x30000)
140 #define AR71XXBOARD1(n, d, m, fs) { \
141 .name = (n), .desc=(d), \
142 .vendor = (ZYNOS_VENDOR_ID_ZYXEL), .model = (m), \
143 .flash_base = (AR71XX_FLASH_BASE), .flash_size = (fs)<<20, \
144 .code_start = (AR71XX_CODE_START), .romio_offs = (0x40000), \
145 .bootext_size = 0x30000 \
149 static struct board_info boards
[] = {
151 * Infineon/ADMtek ADM5120 based boards
153 ADMBOARD2("ES-2024A", "ZyXEL ES-2024A", ZYNOS_MODEL_ES_2024A
, 4),
154 ADMBOARD2("ES-2024PWR", "ZyXEL ES-2024PWR", ZYNOS_MODEL_ES_2024PWR
, 4),
155 ADMBOARD2("ES-2108", "ZyXEL ES-2108", ZYNOS_MODEL_ES_2108
, 4),
156 ADMBOARD2("ES-2108-F", "ZyXEL ES-2108-F", ZYNOS_MODEL_ES_2108_F
, 4),
157 ADMBOARD2("ES-2108-G", "ZyXEL ES-2108-G", ZYNOS_MODEL_ES_2108_G
, 4),
158 ADMBOARD2("ES-2108-LC", "ZyXEL ES-2108-LC", ZYNOS_MODEL_ES_2108_LC
, 4),
159 ADMBOARD2("ES-2108PWR", "ZyXEL ES-2108PWR", ZYNOS_MODEL_ES_2108PWR
, 4),
160 ADMBOARD1("HS-100", "ZyXEL HomeSafe 100", ZYNOS_MODEL_HS_100
, 2),
161 ADMBOARD1("HS-100W", "ZyXEL HomeSafe 100W", ZYNOS_MODEL_HS_100W
, 2),
162 ADMBOARD1("P-334", "ZyXEL Prestige 334", ZYNOS_MODEL_P_334
, 2),
163 ADMBOARD1("P-334U", "ZyXEL Prestige 334U", ZYNOS_MODEL_P_334U
, 4),
164 ADMBOARD1("P-334W", "ZyXEL Prestige 334W", ZYNOS_MODEL_P_334W
, 2),
165 ADMBOARD1("P-334WH", "ZyXEL Prestige 334WH", ZYNOS_MODEL_P_334WH
, 4),
166 ADMBOARD1("P-334WHD", "ZyXEL Prestige 334WHD", ZYNOS_MODEL_P_334WHD
, 4),
167 ADMBOARD1("P-334WT", "ZyXEL Prestige 334WT", ZYNOS_MODEL_P_334WT
, 4),
168 ADMBOARD1("P-335", "ZyXEL Prestige 335", ZYNOS_MODEL_P_335
, 4),
169 ADMBOARD1("P-335Plus", "ZyXEL Prestige 335Plus", ZYNOS_MODEL_P_335PLUS
, 4),
170 ADMBOARD1("P-335U", "ZyXEL Prestige 335U", ZYNOS_MODEL_P_335U
, 4),
171 ADMBOARD1("P-335WT", "ZyXEL Prestige 335WT", ZYNOS_MODEL_P_335WT
, 4),
174 .name
= "P-2602HW-D1A",
175 .desc
= "ZyXEL P-2602HW-D1A",
176 .vendor
= ZYNOS_VENDOR_ID_ZYXEL
,
177 .model
= ZYNOS_MODEL_P_2602HW_D1A
,
178 .flash_base
= AR7_FLASH_BASE
,
179 .flash_size
= 4*1024*1024,
180 .code_start
= 0x94008000,
181 .romio_offs
= 0x20000,
182 .bootext_size
= BOOTEXT_DEF_SIZE
,
187 * Texas Instruments AR7 based boards
189 AR7BOARD1("P-660H-61", "ZyXEL P-660H-61", ZYNOS_MODEL_P_660H_61
, 2),
190 AR7BOARD1("P-660H-63", "ZyXEL P-660H-63", ZYNOS_MODEL_P_660H_63
, 2),
191 AR7BOARD1("P-660H-D1", "ZyXEL P-660H-D1", ZYNOS_MODEL_P_660H_D1
, 2),
192 AR7BOARD1("P-660H-D3", "ZyXEL P-660H-D3", ZYNOS_MODEL_P_660H_D3
, 2),
193 AR7BOARD1("P-660HW-61", "ZyXEL P-660HW-61", ZYNOS_MODEL_P_660HW_61
, 2),
194 AR7BOARD1("P-660HW-63", "ZyXEL P-660HW-63", ZYNOS_MODEL_P_660HW_63
, 2),
195 AR7BOARD1("P-660HW-67", "ZyXEL P-660HW-67", ZYNOS_MODEL_P_660HW_67
, 2),
196 AR7BOARD1("P-660HW-D1", "ZyXEL P-660HW-D1", ZYNOS_MODEL_P_660HW_D1
, 2),
197 AR7BOARD1("P-660HW-D3", "ZyXEL P-660HW-D3", ZYNOS_MODEL_P_660HW_D3
, 2),
198 AR7BOARD1("P-660R-61", "ZyXEL P-660R-61", ZYNOS_MODEL_P_660R_61
, 2),
199 AR7BOARD1("P-660R-61C", "ZyXEL P-660R-61C", ZYNOS_MODEL_P_660R_61C
, 2),
200 AR7BOARD1("P-660R-63", "ZyXEL P-660R-63", ZYNOS_MODEL_P_660R_63
, 2),
201 AR7BOARD1("P-660R-63C", "ZyXEL P-660R-63C", ZYNOS_MODEL_P_660R_63C
, 2),
202 AR7BOARD1("P-660R-67", "ZyXEL P-660R-67", ZYNOS_MODEL_P_660R_67
, 2),
203 AR7BOARD1("P-660R-D1", "ZyXEL P-660R-D1", ZYNOS_MODEL_P_660R_D1
, 2),
204 AR7BOARD1("P-660R-D3", "ZyXEL P-660R-D3", ZYNOS_MODEL_P_660R_D3
, 2),
208 .desc
= "O2 DSL Surf & Phone",
209 .vendor
= ZYNOS_VENDOR_ID_O2
,
210 .model
= ZYNOS_MODEL_O2SURF
,
211 .flash_base
= AR7_FLASH_BASE
,
212 .flash_size
= 8*1024*1024,
213 .code_start
= 0x94014000,
214 .romio_offs
= 0x40000,
215 .bootext_size
= BOOTEXT_DEF_SIZE
,
221 ATHEROSBOARD1("NBG-318S", "ZyXEL NBG-318S", ZYNOS_MODEL_NBG_318S
, 4),
224 * Atheros ar71xx based boards
226 AR71XXBOARD1("NBG-460N", "ZyXEL NBG-460N", ZYNOS_MODEL_NBG_460N
, 4),
234 #define ERR(fmt, ...) do { \
236 fprintf(stderr, "[%s] *** error: " fmt "\n", \
237 progname, ## __VA_ARGS__ ); \
240 #define ERRS(fmt, ...) do { \
243 fprintf(stderr, "[%s] *** error: " fmt ", %s\n", \
244 progname, ## __VA_ARGS__, strerror(save)); \
247 #define WARN(fmt, ...) do { \
248 fprintf(stderr, "[%s] *** warning: " fmt "\n", \
249 progname, ## __VA_ARGS__ ); \
252 #define DBG(lev, fmt, ...) do { \
253 if (verblevel < lev) \
255 fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
259 #define ERR_INVALID_IMAGE -2
267 FILE *stream
= (status
!= EXIT_SUCCESS
) ? stderr
: stdout
;
268 struct board_info
*board
;
270 fprintf(stream
, "Usage: %s [OPTIONS...]\n", progname
);
274 " -B <board> create image for the board specified with <board>.\n"
275 " valid <board> values:\n"
277 for (board
= boards
; board
->name
!= NULL
; board
++){
280 board
->name
, board
->desc
);
283 " -b <file>[:<align>]\n"
284 " add boot extension block to the image\n"
285 " -r <file>[:<align>]\n"
286 " add raw block to the image\n"
287 " -o <file> write output to the file <file>\n"
288 " -h show this screen\n"
299 str2u32(char *arg
, uint32_t *val
)
305 t
= strtoul(arg
, &err
, 0);
306 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
)) {
316 str2u16(char *arg
, uint16_t *val
)
322 t
= strtoul(arg
, &err
, 0);
323 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
) || (t
>= 0x10000)) {
332 str2u8(char *arg
, uint8_t *val
)
338 t
= strtoul(arg
, &err
, 0);
339 if (errno
|| (err
==arg
) || ((err
!= NULL
) && *err
) || (t
>= 0x100)) {
348 str2sig(char *arg
, uint32_t *sig
)
350 if (strlen(arg
) != 4)
353 *sig
= arg
[0] | (arg
[1] << 8) | (arg
[2] << 16) | (arg
[3] << 24);
360 parse_arg(char *arg
, char *buf
, char *argv
[])
368 memset(argv
, 0, MAX_ARG_COUNT
* sizeof(void *));
381 if (argl
>= MAX_ARG_LEN
) {
382 /* argument is too long */
383 argl
= MAX_ARG_LEN
-1;
386 memcpy(buf
, arg
, argl
);
389 for (i
= 0; i
< MAX_ARG_COUNT
; i
++) {
390 tok
= strsep(ap
, ":");
395 else if (tok
[0] == '\0') {
408 required_arg(char c
, char *arg
)
410 if (arg
== NULL
|| *arg
!= '-')
413 ERR("option -%c requires an argument\n", c
);
419 is_empty_arg(char *arg
)
430 csum_init(struct csum_state
*css
)
439 csum_update(void *data
, uint32_t len
, struct csum_state
*css
)
447 css
->sum
+= (css
->tmp
<< 8) + p
[0];
448 if (css
->sum
> 0xFFFF) {
457 for ( ; len
> 1; len
-= 2, p
+=2 ) {
458 css
->sum
+= (p
[0] << 8) + p
[1];
459 if (css
->sum
> 0xFFFF) {
473 csum_get(struct csum_state
*css
)
477 csum_update(&pad
, 1, css
);
482 csum_buf(uint8_t *p
, uint32_t len
)
484 struct csum_state css
;
487 csum_update(p
, len
, &css
);
488 return csum_get(&css
);
493 * routines to write data to the output file
496 write_out_data(FILE *outfile
, void *data
, size_t len
,
497 struct csum_state
*css
)
503 fwrite(ptr
, len
, 1, outfile
);
505 ERR("unable to write output file");
510 csum_update(ptr
, len
, css
);
518 write_out_padding(FILE *outfile
, size_t len
, uint8_t padc
,
519 struct csum_state
*css
)
522 size_t buflen
= sizeof(buf
);
524 memset(buf
, padc
, buflen
);
529 if (write_out_data(outfile
, buf
, buflen
, css
))
540 write_out_data_align(FILE *outfile
, void *data
, size_t len
, size_t align
,
541 struct csum_state
*css
)
546 res
= write_out_data(outfile
, data
, len
, css
);
550 padlen
= ALIGN(len
,align
) - len
;
551 res
= write_out_padding(outfile
, padlen
, 0xFF, css
);
558 write_out_header(FILE *outfile
, struct zyn_rombin_hdr
*hdr
)
560 struct zyn_rombin_hdr t
;
563 if (fseek(outfile
, 0, SEEK_SET
) != 0) {
564 ERRS("fseek failed on output file");
568 /* setup temporary header fields */
569 memset(&t
, 0, sizeof(t
));
570 t
.addr
= HOST_TO_BE32(hdr
->addr
);
571 memcpy(&t
.sig
, ROMBIN_SIGNATURE
, ROMBIN_SIG_LEN
);
573 t
.flags
= hdr
->flags
;
574 t
.osize
= HOST_TO_BE32(hdr
->osize
);
575 t
.csize
= HOST_TO_BE32(hdr
->csize
);
576 t
.ocsum
= HOST_TO_BE16(hdr
->ocsum
);
577 t
.ccsum
= HOST_TO_BE16(hdr
->ccsum
);
578 t
.mmap_addr
= HOST_TO_BE32(hdr
->mmap_addr
);
580 DBG(2, "hdr.addr = 0x%08x", hdr
->addr
);
581 DBG(2, "hdr.type = 0x%02x", hdr
->type
);
582 DBG(2, "hdr.osize = 0x%08x", hdr
->osize
);
583 DBG(2, "hdr.csize = 0x%08x", hdr
->csize
);
584 DBG(2, "hdr.flags = 0x%02x", hdr
->flags
);
585 DBG(2, "hdr.ocsum = 0x%04x", hdr
->ocsum
);
586 DBG(2, "hdr.ccsum = 0x%04x", hdr
->ccsum
);
587 DBG(2, "hdr.mmap_addr = 0x%08x", hdr
->mmap_addr
);
589 return write_out_data(outfile
, (uint8_t *)&t
, sizeof(t
), NULL
);
594 write_out_mmap(FILE *outfile
, struct fw_mmap
*mmap
, struct csum_state
*css
)
596 struct zyn_mmt_hdr
*mh
;
597 uint8_t buf
[MMAP_DATA_SIZE
];
602 memset(buf
, 0, sizeof(buf
));
604 mh
= (struct zyn_mmt_hdr
*)buf
;
606 /* TODO: needs to recreate the memory map too? */
609 /* Build user data section */
610 data
= (char *)buf
+ sizeof(*mh
);
611 data
+= sprintf(data
, "Vendor 1 %d", board
->vendor
);
613 data
+= sprintf(data
, "Model 1 %d", BE16_TO_HOST(board
->model
));
615 /* TODO: make hardware version configurable? */
616 data
+= sprintf(data
, "HwVerRange 2 %d %d", 0, 0);
619 user_size
= (uint8_t *)data
- buf
;
620 mh
->user_start
= HOST_TO_BE32(mmap
->addr
+sizeof(*mh
));
621 mh
->user_end
= HOST_TO_BE32(mmap
->addr
+user_size
);
622 mh
->csum
= HOST_TO_BE16(csum_buf(buf
+sizeof(*mh
), user_size
));
624 res
= write_out_data(outfile
, buf
, sizeof(buf
), css
);
631 block_stat_file(struct fw_block
*block
)
636 if (block
->file_name
== NULL
)
639 res
= stat(block
->file_name
, &st
);
641 ERRS("stat failed on %s", block
->file_name
);
645 block
->file_size
= st
.st_size
;
651 read_magic(uint16_t *magic
)
657 f
= fopen(bootext_block
->file_name
,"r");
659 ERRS("unable to open file: %s", bootext_block
->file_name
);
664 fread(magic
, 2, 1, f
);
666 ERRS("unable to read from file: %s", bootext_block
->file_name
);
680 write_out_file(FILE *outfile
, char *name
, size_t len
, struct csum_state
*css
)
682 char buf
[FILE_BUF_LEN
];
683 size_t buflen
= sizeof(buf
);
687 DBG(2, "writing out file, name=%s, len=%zu",
693 ERRS("unable to open file: %s", name
);
701 /* read data from source file */
703 fread(buf
, buflen
, 1, f
);
705 ERRS("unable to read from file: %s",name
);
710 res
= write_out_data(outfile
, buf
, buflen
, css
);
723 write_out_block(FILE *outfile
, struct fw_block
*block
, struct csum_state
*css
)
730 if (block
->file_name
== NULL
)
733 if (block
->file_size
== 0)
736 res
= write_out_file(outfile
, block
->file_name
,
737 block
->file_size
, css
);
743 write_out_image(FILE *outfile
)
745 struct fw_block
*block
;
747 struct zyn_rombin_hdr hdr
;
748 struct csum_state css
;
755 /* setup header fields */
756 memset(&hdr
, 0, sizeof(hdr
));
757 hdr
.addr
= board
->code_start
;
758 hdr
.type
= OBJECT_TYPE_BOOTEXT
;
759 hdr
.flags
= ROMBIN_FLAG_OCSUM
;
761 offset
= board
->romio_offs
;
763 res
= write_out_header(outfile
, &hdr
);
767 offset
+= sizeof(hdr
);
770 res
= write_out_block(outfile
, bootext_block
, &css
);
774 offset
+= bootext_block
->file_size
;
775 if (offset
> (board
->romio_offs
+ board
->bootext_size
)) {
776 ERR("bootext file '%s' is too big", bootext_block
->file_name
);
780 padlen
= ALIGN(offset
, MMAP_ALIGN
) - offset
;
781 res
= write_out_padding(outfile
, padlen
, 0xFF, &css
);
787 mmap
.addr
= board
->flash_base
+ offset
;
788 res
= write_out_mmap(outfile
, &mmap
, &css
);
792 offset
+= MMAP_DATA_SIZE
;
794 if ((offset
- board
->romio_offs
) < board
->bootext_size
) {
795 padlen
= board
->romio_offs
+ board
->bootext_size
- offset
;
796 res
= write_out_padding(outfile
, padlen
, 0xFF, &css
);
801 DBG(2, "bootext end at %08x", offset
);
804 for (i
= 0; i
< num_blocks
; i
++) {
807 if (block
->type
== BLOCK_TYPE_BOOTEXT
)
810 padlen
= ALIGN(offset
, block
->align
) - offset
;
811 res
= write_out_padding(outfile
, padlen
, 0xFF, &css
);
816 res
= write_out_block(outfile
, block
, &css
);
819 offset
+= block
->file_size
;
822 padlen
= ALIGN(offset
, 4) - offset
;
823 res
= write_out_padding(outfile
, padlen
, 0xFF, &css
);
828 csum
= csum_get(&css
);
829 hdr
.mmap_addr
= mmap
.addr
;
832 res
= read_magic(&hdr
.ocsum
);
835 hdr
.ocsum
= BE16_TO_HOST(hdr
.ocsum
);
837 if (csum
<= hdr
.ocsum
)
838 t
= hdr
.ocsum
- csum
;
840 t
= hdr
.ocsum
- csum
- 1;
842 DBG(2, "ocsum=%04x, csum=%04x, fix=%04x", hdr
.ocsum
, csum
, t
);
845 res
= write_out_data(outfile
, (uint8_t *)&t
, 2, NULL
);
850 res
= write_out_header(outfile
, &hdr
);
857 find_board(char *name
)
859 struct board_info
*ret
;
860 struct board_info
*board
;
863 for (board
= boards
; board
->name
!= NULL
; board
++){
864 if (strcasecmp(name
, board
->name
) == 0) {
875 parse_opt_board(char ch
, char *arg
)
878 DBG(1,"parsing board option: -%c %s", ch
, arg
);
881 ERR("only one board option allowed");
885 if (required_arg(ch
, arg
))
888 board
= find_board(arg
);
890 ERR("invalid/unknown board specified: %s", arg
);
899 parse_opt_ofname(char ch
, char *arg
)
902 if (ofname
!= NULL
) {
903 ERR("only one output file allowed");
907 if (required_arg(ch
, arg
))
917 parse_opt_block(char ch
, char *arg
)
919 char buf
[MAX_ARG_LEN
];
920 char *argv
[MAX_ARG_COUNT
];
922 struct fw_block
*block
;
925 if ( num_blocks
>= MAX_NUM_BLOCKS
) {
926 ERR("too many blocks specified");
930 block
= &blocks
[num_blocks
++];
932 /* setup default field values */
938 ERR("only one boot extension block allowed");
941 block
->type
= BLOCK_TYPE_BOOTEXT
;
942 bootext_block
= block
;
945 block
->type
= BLOCK_TYPE_RAW
;
949 parse_arg(arg
, buf
, argv
);
953 if (is_empty_arg(p
)) {
954 ERR("no file specified in %s", arg
);
957 block
->file_name
= strdup(p
);
958 if (block
->file_name
== NULL
) {
959 ERR("not enough memory");
964 if (block
->type
== BLOCK_TYPE_BOOTEXT
)
968 if (!is_empty_arg(p
)) {
969 if (str2u32(p
, &block
->align
) != 0) {
970 ERR("invalid block align in %s", arg
);
980 calc_block_offsets(int type
, uint32_t *offset
)
982 struct fw_block
*block
;
987 DBG(1,"calculating block offsets, starting with %" PRIu32
,
991 for (i
= 0; i
< num_blocks
; i
++) {
994 if (block
->type
!= type
)
997 next_offs
= ALIGN(*offset
, block
->align
);
998 avail
= board
->flash_size
- next_offs
;
999 if (block
->file_size
> avail
) {
1000 ERR("file %s is too big, offset = %u, size=%u,"
1001 " avail = %u, align = %u", block
->file_name
,
1002 (unsigned)next_offs
,
1003 (unsigned)block
->file_size
,
1005 (unsigned)block
->align
);
1010 block
->padlen
= next_offs
- *offset
;
1011 *offset
+= block
->file_size
;
1018 process_blocks(void)
1020 struct fw_block
*block
;
1025 /* collecting file stats */
1026 for (i
= 0; i
< num_blocks
; i
++) {
1028 res
= block_stat_file(block
);
1033 offset
= board
->romio_offs
+ bootext_block
->file_size
;
1034 res
= calc_block_offsets(BLOCK_TYPE_RAW
, &offset
);
1041 main(int argc
, char *argv
[])
1043 int optinvalid
= 0; /* flag for invalid option */
1045 int res
= EXIT_FAILURE
;
1049 progname
=basename(argv
[0]);
1051 opterr
= 0; /* could not print standard getopt error messages */
1055 c
= getopt(argc
, argv
, "b:B:ho:r:v");
1062 optinvalid
= parse_opt_block(c
,optarg
);
1065 optinvalid
= parse_opt_board(c
,optarg
);
1068 optinvalid
= parse_opt_ofname(c
,optarg
);
1074 usage(EXIT_SUCCESS
);
1080 if (optinvalid
!= 0 ) {
1081 ERR("invalid option: -%c", optopt
);
1086 if (board
== NULL
) {
1087 ERR("no board specified");
1091 if (ofname
== NULL
) {
1092 ERR("no output file specified");
1096 if (optind
< argc
) {
1097 ERR("invalid option: %s", argv
[optind
]);
1101 if (process_blocks() != 0) {
1105 outfile
= fopen(ofname
, "w");
1106 if (outfile
== NULL
) {
1107 ERRS("could not open \"%s\" for writing", ofname
);
1111 if (write_out_image(outfile
) != 0)
1114 DBG(1,"Image file %s completed.", ofname
);
1121 if (res
!= EXIT_SUCCESS
) {