[tools] firmware_utils/mkmylofw: add support of named partitions
[openwrt/svn-archive/archive.git] / tools / firmware-utils / src / mkmylofw.c
1 /*
2 * Copyright (C) 2006-2008 Gabor Juhos <juhosg@openwrt.org>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 *
19 */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdint.h>
24 #include <string.h>
25 #include <unistd.h> /* for unlink() */
26 #include <libgen.h>
27 #include <getopt.h> /* for getopt() */
28 #include <stdarg.h>
29 #include <errno.h>
30 #include <sys/stat.h>
31 #include <endian.h> /* for __BYTE_ORDER */
32
33 #if defined(__CYGWIN__)
34 # include <byteswap.h>
35 #endif
36
37 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
38 # define HOST_TO_LE16(x) (x)
39 # define HOST_TO_LE32(x) (x)
40 #else
41 # define HOST_TO_LE16(x) bswap_16(x)
42 # define HOST_TO_LE32(x) bswap_32(x)
43 #endif
44
45 #include "myloader.h"
46
47 #define MAX_FW_BLOCKS 32
48 #define MAX_ARG_COUNT 32
49 #define MAX_ARG_LEN 1024
50 #define FILE_BUF_LEN (16*1024)
51 #define PART_NAME_LEN 32
52
53 struct fw_block {
54 uint32_t addr;
55 uint32_t blocklen; /* length of the block */
56 uint32_t flags;
57
58 char *name; /* name of the file */
59 uint32_t size; /* length of the file */
60 uint32_t crc; /* crc value of the file */
61 };
62
63 struct fw_part {
64 struct mylo_partition mylo;
65 char name[PART_NAME_LEN];
66 };
67
68 #define BLOCK_FLAG_HAVEHDR 0x0001
69
70 struct cpx_board {
71 char *model; /* model number*/
72 char *name; /* model name*/
73 char *desc; /* description */
74 uint16_t vid; /* vendor id */
75 uint16_t did; /* device id */
76 uint16_t svid; /* sub vendor id */
77 uint16_t sdid; /* sub device id */
78 uint32_t flash_size; /* size of flash */
79 uint32_t part_offset; /* offset of the partition_table */
80 uint32_t part_size; /* size of the partition_table */
81 };
82
83 #define BOARD(_vid, _did, _svid, _sdid, _flash, _mod, _name, _desc, _po, _ps) { \
84 .model = _mod, .name = _name, .desc = _desc, \
85 .vid = _vid, .did = _did, .svid = _svid, .sdid = _sdid, \
86 .flash_size = (_flash << 20), \
87 .part_offset = _po, .part_size = _ps }
88
89 #define CPX_BOARD(_did, _flash, _mod, _name, _desc, _po, _ps) \
90 BOARD(VENID_COMPEX, _did, VENID_COMPEX, _did, _flash, _mod, _name, _desc, _po, _ps)
91
92 #define CPX_BOARD_ADM(_did, _flash, _mod, _name, _desc) \
93 CPX_BOARD(_did, _flash, _mod, _name, _desc, 0x10000, 0x10000)
94
95 #define CPX_BOARD_AR71XX(_did, _flash, _mod, _name, _desc) \
96 CPX_BOARD(_did, _flash, _mod, _name, _desc, 0x20000, 0x8000)
97
98 #define CPX_BOARD_AR23XX(_did, _flash, _mod, _name, _desc) \
99 CPX_BOARD(_did, _flash, _mod, _name, _desc, 0x10000, 0x10000)
100
101 #define ALIGN(x,y) ((x)+((y)-1)) & ~((y)-1)
102
103 char *progname;
104 char *ofname = NULL;
105
106 uint32_t flash_size = 0;
107 int fw_num_partitions = 0;
108 int fw_num_blocks = 0;
109 int verblevel = 0;
110
111 struct mylo_fw_header fw_header;
112 struct fw_part fw_parts[MYLO_MAX_PARTITIONS];
113 struct fw_block fw_blocks[MAX_FW_BLOCKS];
114 struct cpx_board *board;
115
116 struct cpx_board boards[] = {
117 CPX_BOARD_ADM(DEVID_COMPEX_NP18A, 4,
118 "NP18A", "Compex NetPassage 18A",
119 "Dualband Wireless A+G Internet Gateway"),
120 CPX_BOARD_ADM(DEVID_COMPEX_NP26G8M, 2,
121 "NP26G8M", "Compex NetPassage 26G (8M)",
122 "Wireless-G Broadband Multimedia Gateway"),
123 CPX_BOARD_ADM(DEVID_COMPEX_NP26G16M, 4,
124 "NP26G16M", "Compex NetPassage 26G (16M)",
125 "Wireless-G Broadband Multimedia Gateway"),
126 CPX_BOARD_ADM(DEVID_COMPEX_NP27G, 4,
127 "NP27G", "Compex NetPassage 27G",
128 "Wireless-G 54Mbps eXtended Range Router"),
129 CPX_BOARD_ADM(DEVID_COMPEX_NP28G, 4,
130 "NP28G", "Compex NetPassage 28G",
131 "Wireless 108Mbps Super-G XR Multimedia Router with 4 USB Ports"),
132 CPX_BOARD_ADM(DEVID_COMPEX_NP28GHS, 4,
133 "NP28GHS", "Compex NetPassage 28G (HotSpot)",
134 "HotSpot Solution"),
135 CPX_BOARD_ADM(DEVID_COMPEX_WP18, 4,
136 "WP18", "Compex NetPassage WP18",
137 "Wireless-G 54Mbps A+G Dualband Access Point"),
138 CPX_BOARD_ADM(DEVID_COMPEX_WP54G, 4,
139 "WP54G", "Compex WP54G",
140 "Wireless-G 54Mbps XR Access Point"),
141 CPX_BOARD_ADM(DEVID_COMPEX_WP54Gv1C, 2,
142 "WP54Gv1C", "Compex WP54G rev.1C",
143 "Wireless-G 54Mbps XR Access Point"),
144 CPX_BOARD_ADM(DEVID_COMPEX_WP54AG, 4,
145 "WP54AG", "Compex WP54AG",
146 "Wireless-AG 54Mbps XR Access Point"),
147 CPX_BOARD_ADM(DEVID_COMPEX_WPP54G, 4,
148 "WPP54G", "Compex WPP54G",
149 "Outdoor Access Point"),
150 CPX_BOARD_ADM(DEVID_COMPEX_WPP54AG, 4,
151 "WPP54AG", "Compex WPP54AG",
152 "Outdoor Access Point"),
153
154 CPX_BOARD_AR71XX(DEVID_COMPEX_WP543, 2,
155 "WP543", "Compex WP543",
156 "BareBoard"),
157
158 CPX_BOARD_AR23XX(DEVID_COMPEX_NP25G, 4,
159 "NP25G", "Compex NetPassage 25G",
160 "Wireless 54Mbps XR Router"),
161 CPX_BOARD_AR23XX(DEVID_COMPEX_WPE53G, 4,
162 "WPE53G", "Compex NetPassage 25G",
163 "Wireless 54Mbps XR Access Point"),
164 {.model = NULL}
165 };
166
167 void
168 errmsgv(int syserr, const char *fmt, va_list arg_ptr)
169 {
170 int save = errno;
171
172 fflush(0);
173 fprintf(stderr, "[%s] Error: ", progname);
174 vfprintf(stderr, fmt, arg_ptr);
175 if (syserr != 0) {
176 fprintf(stderr, ": %s", strerror(save));
177 }
178 fprintf(stderr, "\n");
179 }
180
181 void
182 errmsg(int syserr, const char *fmt, ...)
183 {
184 va_list arg_ptr;
185 va_start(arg_ptr, fmt);
186 errmsgv(syserr, fmt, arg_ptr);
187 va_end(arg_ptr);
188 }
189
190 void
191 dbgmsg(int level, const char *fmt, ...)
192 {
193 va_list arg_ptr;
194 if (verblevel >= level) {
195 fflush(0);
196 va_start(arg_ptr, fmt);
197 vfprintf(stderr, fmt, arg_ptr);
198 fprintf(stderr, "\n");
199 va_end(arg_ptr);
200 }
201 }
202
203
204 void
205 usage(int status)
206 {
207 FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
208 struct cpx_board *board;
209
210 fprintf(stream, "Usage: %s [OPTION...] <file>\n", progname);
211 fprintf(stream,
212 "\n"
213 " <file> write output to the <file>\n"
214 "\n"
215 "Options:\n"
216 " -B <board> create firmware for the board specified with <board>.\n"
217 " This option set vendor id, device id, subvendor id,\n"
218 " subdevice id, and flash size options to the right value.\n"
219 " valid <board> values:\n");
220 for (board = boards; board->model != NULL; board++){
221 fprintf(stream,
222 " %-12s: %s\n",
223 board->model, board->name);
224 };
225 fprintf(stream,
226 " -i <vid>:<did>[:<svid>[:<sdid>]]\n"
227 " create firmware for board with vendor id <vid>, device\n"
228 " id <did>, subvendor id <svid> and subdevice id <sdid>.\n"
229 " -r <rev> set board revision to <rev>.\n"
230 " -s <size> set flash size to <size>\n"
231 " -b <addr>:<len>[:[<flags>]:<file>]\n"
232 " define block at <addr> with length of <len>.\n"
233 " valid <flag> values:\n"
234 " h : add crc header before the file data.\n"
235 " -p <addr>:<len>[:<flags>[:<param>[:<name>[:<file>]]]]\n"
236 " add partition at <addr>, with size of <len> to the\n"
237 " partition table, set partition name to <name>, partition \n"
238 " flags to <flags> and partition parameter to <param>.\n"
239 " If the <file> is specified content of the file will be \n"
240 " added to the firmware image.\n"
241 " valid <flag> values:\n"
242 " a: this is the active partition. The bootloader loads\n"
243 " the firmware from this partition.\n"
244 " h: the partition data have a header.\n"
245 " l: the partition data uses LZMA compression.\n"
246 " p: the bootloader loads data from this partition to\n"
247 " the RAM before decompress it.\n"
248 " -h show this screen\n"
249 );
250
251 exit(status);
252 }
253
254 /*
255 * Code to compute the CRC-32 table. Borrowed from
256 * gzip-1.0.3/makecrc.c.
257 */
258
259 static uint32_t crc_32_tab[256];
260
261 void
262 init_crc_table(void)
263 {
264 /* Not copyrighted 1990 Mark Adler */
265
266 uint32_t c; /* crc shift register */
267 uint32_t e; /* polynomial exclusive-or pattern */
268 int i; /* counter for all possible eight bit values */
269 int k; /* byte being shifted into crc apparatus */
270
271 /* terms of polynomial defining this crc (except x^32): */
272 static const int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
273
274 /* Make exclusive-or pattern from polynomial */
275 e = 0;
276 for (i = 0; i < sizeof(p)/sizeof(int); i++)
277 e |= 1L << (31 - p[i]);
278
279 crc_32_tab[0] = 0;
280
281 for (i = 1; i < 256; i++) {
282 c = 0;
283 for (k = i | 256; k != 1; k >>= 1) {
284 c = c & 1 ? (c >> 1) ^ e : c >> 1;
285 if (k & 1)
286 c ^= e;
287 }
288 crc_32_tab[i] = c;
289 }
290 }
291
292
293 void
294 update_crc(uint8_t *p, uint32_t len, uint32_t *crc)
295 {
296 uint32_t t;
297
298 t = *crc ^ 0xFFFFFFFFUL;
299 while (len--) {
300 t = crc_32_tab[(t ^ *p++) & 0xff] ^ (t >> 8);
301 }
302 *crc = t ^ 0xFFFFFFFFUL;
303 }
304
305
306 uint32_t
307 get_crc(uint8_t *p, uint32_t len)
308 {
309 uint32_t crc;
310
311 crc = 0;
312 update_crc(p ,len , &crc);
313 return crc;
314 }
315
316
317 int
318 str2u32(char *arg, uint32_t *val)
319 {
320 char *err = NULL;
321 uint32_t t;
322
323 errno=0;
324 t = strtoul(arg, &err, 0);
325 if (errno || (err==arg) || ((err != NULL) && *err)) {
326 return -1;
327 }
328
329 *val = t;
330 return 0;
331 }
332
333
334 int
335 str2u16(char *arg, uint16_t *val)
336 {
337 char *err = NULL;
338 uint32_t t;
339
340 errno=0;
341 t = strtoul(arg, &err, 0);
342 if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x10000)) {
343 return -1;
344 }
345
346 *val = t & 0xFFFF;
347 return 0;
348 }
349
350
351 struct cpx_board *
352 find_board(char *model){
353 struct cpx_board *board;
354 struct cpx_board *tmp;
355
356 board = NULL;
357 for (tmp = boards; tmp->model != NULL; tmp++){
358 if (strcasecmp(model, tmp->model) == 0) {
359 board = tmp;
360 break;
361 }
362 };
363
364 return board;
365 }
366
367
368 int
369 get_file_crc(struct fw_block *ff)
370 {
371 FILE *f;
372 uint8_t buf[FILE_BUF_LEN];
373 uint32_t readlen = sizeof(buf);
374 int res = -1;
375 size_t len;
376
377 if ((ff->flags & BLOCK_FLAG_HAVEHDR) == 0) {
378 res = 0;
379 goto out;
380 }
381
382 errno = 0;
383 f = fopen(ff->name,"r");
384 if (errno) {
385 errmsg(1,"unable to open file %s", ff->name);
386 goto out;
387 }
388
389 ff->crc = 0;
390 len = ff->size;
391 while (len > 0) {
392 if (len < readlen)
393 readlen = len;
394
395 errno = 0;
396 fread(buf, readlen, 1, f);
397 if (errno) {
398 errmsg(1,"unable to read from file %s", ff->name);
399 goto out_close;
400 }
401
402 update_crc(buf, readlen, &ff->crc);
403 len -= readlen;
404 }
405
406 res = 0;
407
408 out_close:
409 fclose(f);
410 out:
411 return res;
412 }
413
414
415 int
416 process_files(void)
417 {
418 struct fw_block *b;
419 struct stat st;
420 int i;
421
422 for (i = 0; i < fw_num_blocks; i++) {
423 b = &fw_blocks[i];
424 if ((b->addr + b->blocklen) > flash_size) {
425 errmsg(0, "block at 0x%08X is too big", b->addr);
426 return -1;
427 }
428 if (b->name == NULL)
429 continue;
430
431 if (stat(b->name, &st) < 0) {
432 errmsg(0, "stat failed on %s",b->name);
433 return -1;
434 }
435 if (b->blocklen == 0) {
436 b->blocklen = flash_size - b->addr;
437 }
438 if (st.st_size > b->blocklen) {
439 errmsg(0,"file %s is too big",b->name);
440 return -1;
441 }
442
443 b->size = st.st_size;
444 }
445
446 return 0;
447 }
448
449
450 int
451 process_partitions(void)
452 {
453 struct mylo_partition *part;
454 int i;
455
456 for (i = 0; i < fw_num_partitions; i++) {
457 part = &fw_parts[i].mylo;
458
459 if (part->addr > flash_size) {
460 errmsg(0, "invalid partition at 0x%08X", part->addr);
461 return -1;
462 }
463
464 if ((part->addr + part->size) > flash_size) {
465 errmsg(0, "partition at 0x%08X is too big", part->addr);
466 return -1;
467 }
468 }
469
470 return 0;
471 }
472
473
474 /*
475 * routines to write data to the output file
476 */
477 int
478 write_out_data(FILE *outfile, uint8_t *data, size_t len, uint32_t *crc)
479 {
480 errno = 0;
481
482 fwrite(data, len, 1, outfile);
483 if (errno) {
484 errmsg(1,"unable to write output file");
485 return -1;
486 }
487
488 if (crc) {
489 update_crc(data, len, crc);
490 }
491
492 return 0;
493 }
494
495
496 int
497 write_out_desc(FILE *outfile, struct mylo_fw_blockdesc *desc, uint32_t *crc)
498 {
499 return write_out_data(outfile, (uint8_t *)desc,
500 sizeof(*desc), crc);
501 }
502
503
504 int
505 write_out_padding(FILE *outfile, size_t len, uint8_t padc, uint32_t *crc)
506 {
507 uint8_t buff[512];
508 size_t buflen = sizeof(buff);
509
510 memset(buff, padc, buflen);
511
512 while (len > 0) {
513 if (len < buflen)
514 buflen = len;
515
516 if (write_out_data(outfile, buff, buflen, crc))
517 return -1;
518
519 len -= buflen;
520 }
521
522 return 0;
523 }
524
525
526 int
527 write_out_file(FILE *outfile, struct fw_block *block, uint32_t *crc)
528 {
529 char buff[FILE_BUF_LEN];
530 size_t buflen = sizeof(buff);
531 FILE *f;
532 size_t len;
533
534 errno = 0;
535
536 if (block->name == NULL) {
537 return 0;
538 }
539
540 if ((block->flags & BLOCK_FLAG_HAVEHDR) != 0) {
541 struct mylo_partition_header ph;
542
543 if (get_file_crc(block) != 0)
544 return -1;
545
546 ph.crc = HOST_TO_LE32(block->crc);
547 ph.len = HOST_TO_LE32(block->size);
548
549 if (write_out_data(outfile, (uint8_t *)&ph, sizeof(ph), crc) != 0)
550 return -1;
551 }
552
553 f = fopen(block->name,"r");
554 if (errno) {
555 errmsg(1,"unable to open file: %s", block->name);
556 return -1;
557 }
558
559 len = block->size;
560 while (len > 0) {
561 if (len < buflen)
562 buflen = len;
563
564 /* read data from source file */
565 errno = 0;
566 fread(buff, buflen, 1, f);
567 if (errno != 0) {
568 errmsg(1,"unable to read from file: %s",block->name);
569 return -1;
570 }
571
572 if (write_out_data(outfile, buff, buflen, crc) != 0)
573 return -1;
574
575 len -= buflen;
576 }
577
578 fclose(f);
579
580 /* align next block on a 4 byte boundary */
581 len = ALIGN(len,4) - block->size;
582 if (write_out_padding(outfile, len, 0xFF, crc))
583 return -1;
584
585 dbgmsg(1,"file %s written out", block->name);
586 return 0;
587 }
588
589
590 int
591 write_out_header(FILE *outfile, uint32_t *crc)
592 {
593 struct mylo_fw_header hdr;
594
595 memset(&hdr, 0, sizeof(hdr));
596
597 hdr.magic = HOST_TO_LE32(MYLO_MAGIC_FIRMWARE);
598 hdr.crc = HOST_TO_LE32(fw_header.crc);
599 hdr.vid = HOST_TO_LE16(fw_header.vid);
600 hdr.did = HOST_TO_LE16(fw_header.did);
601 hdr.svid = HOST_TO_LE16(fw_header.svid);
602 hdr.sdid = HOST_TO_LE16(fw_header.sdid);
603 hdr.rev = HOST_TO_LE32(fw_header.rev);
604 hdr.fwhi = HOST_TO_LE32(fw_header.fwhi);
605 hdr.fwlo = HOST_TO_LE32(fw_header.fwlo);
606 hdr.flags = HOST_TO_LE32(fw_header.flags);
607
608 if (fseek(outfile, 0, SEEK_SET) != 0) {
609 errmsg(1,"fseek failed on output file");
610 return -1;
611 }
612
613 return write_out_data(outfile, (uint8_t *)&hdr, sizeof(hdr), crc);
614 }
615
616
617 int
618 write_out_partitions(FILE *outfile, uint32_t *crc)
619 {
620 struct mylo_partition_table p;
621 char part_names[MYLO_MAX_PARTITIONS][PART_NAME_LEN];
622 int ret;
623 int i;
624
625 if (fw_num_partitions == 0)
626 return 0;
627
628 memset(&p, 0, sizeof(p));
629 memset(part_names, 0, sizeof(part_names));
630
631 p.magic = HOST_TO_LE32(MYLO_MAGIC_PARTITIONS);
632 for (i = 0; i < fw_num_partitions; i++) {
633 struct mylo_partition *mp;
634 struct fw_part *fp;
635
636 mp = &p.partitions[i];
637 fp = &fw_parts[i];
638 mp->flags = HOST_TO_LE16(fp->mylo.flags);
639 mp->type = HOST_TO_LE16(PARTITION_TYPE_USED);
640 mp->addr = HOST_TO_LE32(fp->mylo.addr);
641 mp->size = HOST_TO_LE32(fp->mylo.size);
642 mp->param = HOST_TO_LE32(fp->mylo.param);
643
644 memcpy(part_names[i], fp->name, PART_NAME_LEN);
645 }
646
647 ret = write_out_data(outfile, (uint8_t *)&p, sizeof(p), crc);
648 if (ret)
649 return ret;
650
651 ret = write_out_data(outfile, (uint8_t *)part_names, sizeof(part_names),
652 crc);
653 return ret;
654 }
655
656
657 int
658 write_out_blocks(FILE *outfile, uint32_t *crc)
659 {
660 struct mylo_fw_blockdesc desc;
661 struct fw_block *b;
662 uint32_t dlen;
663 int i;
664
665 /*
666 * if at least one partition specified, write out block descriptor
667 * for the partition table
668 */
669 if (fw_num_partitions > 0) {
670 desc.type = HOST_TO_LE32(FW_DESC_TYPE_USED);
671 desc.addr = HOST_TO_LE32(board->part_offset);
672 desc.dlen = HOST_TO_LE32(sizeof(struct mylo_partition_table) +
673 (MYLO_MAX_PARTITIONS * PART_NAME_LEN));
674 desc.blen = HOST_TO_LE32(board->part_size);
675
676 if (write_out_desc(outfile, &desc, crc) != 0)
677 return -1;
678 }
679
680 /*
681 * write out block descriptors for each files
682 */
683 for (i = 0; i < fw_num_blocks; i++) {
684 b = &fw_blocks[i];
685
686 /* detect block size */
687 dlen = b->size;
688 if ((b->flags & BLOCK_FLAG_HAVEHDR) != 0) {
689 dlen += sizeof(struct mylo_partition_header);
690 }
691
692 /* round up to 4 bytes */
693 dlen = ALIGN(dlen, 4);
694
695 /* setup the descriptor */
696 desc.type = HOST_TO_LE32(FW_DESC_TYPE_USED);
697 desc.addr = HOST_TO_LE32(b->addr);
698 desc.dlen = HOST_TO_LE32(dlen);
699 desc.blen = HOST_TO_LE32(b->blocklen);
700
701 if (write_out_desc(outfile, &desc, crc) != 0)
702 return -1;
703 }
704
705 /*
706 * write out the null block descriptor
707 */
708 memset(&desc, 0, sizeof(desc));
709 if (write_out_desc(outfile, &desc, crc) != 0)
710 return -1;
711
712 if (write_out_partitions(outfile, crc) != 0)
713 return -1;
714
715 /*
716 * write out data for each blocks
717 */
718 for (i = 0; i < fw_num_blocks; i++) {
719 b = &fw_blocks[i];
720 if (write_out_file(outfile, b, crc) != 0)
721 return -1;
722 }
723
724 return 0;
725 }
726
727
728 /*
729 * argument parsing
730 */
731 int
732 parse_arg(char *arg, char *buf, char *argv[])
733 {
734 int res = 0;
735 size_t argl;
736 char *tok;
737 char **ap = &buf;
738 int i;
739
740 if ((arg == NULL)) {
741 /* invalid argument string */
742 return -1;
743 }
744
745 argl = strlen(arg);
746 if (argl == 0) {
747 /* no arguments */
748 return res;
749 }
750
751 if (argl >= MAX_ARG_LEN) {
752 /* argument is too long */
753 argl = MAX_ARG_LEN-1;
754 }
755
756 memset(argv, 0, MAX_ARG_COUNT * sizeof(void *));
757 memcpy(buf, arg, argl);
758 buf[argl] = '\0';
759
760 for (i = 0; i < MAX_ARG_COUNT; i++) {
761 tok = strsep(ap, ":");
762 if (tok == NULL) {
763 break;
764 }
765 #if 0
766 else if (tok[0] == '\0') {
767 break;
768 }
769 #endif
770 argv[i] = tok;
771 res++;
772 }
773
774 return res;
775 }
776
777
778 int
779 required_arg(char c, char *arg)
780 {
781 if ((optarg != NULL) && (*arg == '-')){
782 errmsg(0,"option %c requires an argument\n", c);
783 return -1;
784 }
785
786 return 0;
787 }
788
789
790 int
791 is_empty_arg(char *arg)
792 {
793 int ret = 1;
794 if (arg != NULL) {
795 if (*arg) ret = 0;
796 };
797 return ret;
798 }
799
800
801 int
802 parse_opt_flags(char ch, char *arg)
803 {
804 if (required_arg(ch, arg)) {
805 goto err_out;
806 }
807
808 if (str2u32(arg, &fw_header.flags) != 0) {
809 errmsg(0,"invalid firmware flags: %s", arg);
810 goto err_out;
811 }
812
813 dbgmsg(1, "firmware flags set to %X bytes", fw_header.flags);
814
815 return 0;
816
817 err_out:
818 return -1;
819 }
820
821
822 int
823 parse_opt_size(char ch, char *arg)
824 {
825 if (required_arg(ch, arg)) {
826 goto err_out;
827 }
828
829 if (str2u32(arg, &flash_size) != 0) {
830 errmsg(0,"invalid flash size: %s", arg);
831 goto err_out;
832 }
833
834 dbgmsg(1, "flash size set to %d bytes", flash_size);
835
836 return 0;
837
838 err_out:
839 return -1;
840 }
841
842
843 int
844 parse_opt_id(char ch, char *arg)
845 {
846 char buf[MAX_ARG_LEN];
847 char *argv[MAX_ARG_COUNT];
848 int argc;
849 char *p;
850
851 if (required_arg(ch, arg)) {
852 goto err_out;
853 }
854
855 argc = parse_arg(arg, buf, argv);
856
857 /* processing vendor ID*/
858 p = argv[0];
859 if (is_empty_arg(p)) {
860 errmsg(0,"vendor id is missing from -%c %s",ch, arg);
861 goto err_out;
862 } else if (str2u16(p, &fw_header.vid) != 0) {
863 errmsg(0,"invalid vendor id: %s", p);
864 goto err_out;
865 }
866
867 dbgmsg(1, "vendor id is set to 0x%04X", fw_header.vid);
868
869 /* processing device ID*/
870 p = argv[1];
871 if (is_empty_arg(p)) {
872 errmsg(0,"device id is missing from -%c %s",ch, arg);
873 goto err_out;
874 } else if (str2u16(p, &fw_header.did) != 0) {
875 errmsg(0,"invalid device id: %s", p);
876 goto err_out;
877 }
878
879 dbgmsg(1, "device id is set to 0x%04X", fw_header.did);
880
881 /* processing sub vendor ID*/
882 p = argv[2];
883 if (is_empty_arg(p)) {
884 fw_header.svid = fw_header.vid;
885 } else if (str2u16(p, &fw_header.svid) != 0) {
886 errmsg(0,"invalid sub vendor id: %s", p);
887 goto err_out;
888 }
889
890 dbgmsg(1, "sub vendor id is set to 0x%04X", fw_header.svid);
891
892 /* processing device ID*/
893 p = argv[3];
894 if (is_empty_arg(p)) {
895 fw_header.sdid = fw_header.did;
896 } else if (str2u16(p, &fw_header.sdid) != 0) {
897 errmsg(0,"invalid sub device id: %s", p);
898 goto err_out;
899 }
900
901 dbgmsg(1, "sub device id is set to 0x%04X", fw_header.sdid);
902
903 /* processing revision */
904 p = argv[4];
905 if (is_empty_arg(p)) {
906 fw_header.rev = 0;
907 } else if (str2u32(arg, &fw_header.rev) != 0) {
908 errmsg(0,"invalid revision number: %s", p);
909 goto err_out;
910 }
911
912 dbgmsg(1, "board revision is set to 0x%08X", fw_header.rev);
913
914 return 0;
915
916 err_out:
917 return -1;
918 }
919
920
921 int
922 parse_opt_block(char ch, char *arg)
923 {
924 char buf[MAX_ARG_LEN];
925 char *argv[MAX_ARG_COUNT];
926 int argc;
927 struct fw_block *b;
928 char *p;
929
930 if (required_arg(ch, arg)) {
931 goto err_out;
932 }
933
934 if (fw_num_blocks >= MAX_FW_BLOCKS) {
935 errmsg(0,"too many blocks specified");
936 goto err_out;
937 }
938
939 argc = parse_arg(arg, buf, argv);
940 dbgmsg(1,"processing block option %s, count %d", arg, argc);
941
942 b = &fw_blocks[fw_num_blocks++];
943
944 /* processing block address */
945 p = argv[0];
946 if (is_empty_arg(p)) {
947 errmsg(0,"no block address specified in %s", arg);
948 goto err_out;
949 } else if (str2u32(p, &b->addr) != 0) {
950 errmsg(0,"invalid block address: %s", p);
951 goto err_out;
952 }
953
954 /* processing block length */
955 p = argv[1];
956 if (is_empty_arg(p)) {
957 errmsg(0,"no block length specified in %s", arg);
958 goto err_out;
959 } else if (str2u32(p, &b->blocklen) != 0) {
960 errmsg(0,"invalid block length: %s", p);
961 goto err_out;
962 }
963
964 if (argc < 3) {
965 dbgmsg(1,"empty block %s", arg);
966 goto success;
967 }
968
969 /* processing flags */
970 p = argv[2];
971 if (is_empty_arg(p) == 0) {
972 for ( ; *p != '\0'; p++) {
973 switch (*p) {
974 case 'h':
975 b->flags |= BLOCK_FLAG_HAVEHDR;
976 break;
977 default:
978 errmsg(0, "invalid block flag \"%c\"", *p);
979 goto err_out;
980 }
981 }
982 }
983
984 /* processing file name */
985 p = argv[3];
986 if (is_empty_arg(p)) {
987 errmsg(0,"file name missing in %s", arg);
988 goto err_out;
989 }
990
991 b->name = strdup(p);
992 if (b->name == NULL) {
993 errmsg(0,"not enough memory");
994 goto err_out;
995 }
996
997 success:
998
999 return 0;
1000
1001 err_out:
1002 return -1;
1003 }
1004
1005
1006 int
1007 parse_opt_partition(char ch, char *arg)
1008 {
1009 char buf[MAX_ARG_LEN];
1010 char *argv[MAX_ARG_COUNT];
1011 int argc;
1012 char *p;
1013 struct mylo_partition *part;
1014 struct fw_part *fp;
1015
1016 if (required_arg(ch, arg)) {
1017 goto err_out;
1018 }
1019
1020 if (fw_num_partitions >= MYLO_MAX_PARTITIONS) {
1021 errmsg(0, "too many partitions specified");
1022 goto err_out;
1023 }
1024
1025 fp = &fw_parts[fw_num_partitions++];
1026 part = &fp->mylo;
1027
1028 argc = parse_arg(arg, buf, argv);
1029
1030 /* processing partition address */
1031 p = argv[0];
1032 if (is_empty_arg(p)) {
1033 errmsg(0,"partition address missing in -%c %s",ch, arg);
1034 goto err_out;
1035 } else if (str2u32(p, &part->addr) != 0) {
1036 errmsg(0,"invalid partition address: %s", p);
1037 goto err_out;
1038 }
1039
1040 /* processing partition size */
1041 p = argv[1];
1042 if (is_empty_arg(p)) {
1043 errmsg(0,"partition size missing in -%c %s",ch, arg);
1044 goto err_out;
1045 } else if (str2u32(p, &part->size) != 0) {
1046 errmsg(0,"invalid partition size: %s", p);
1047 goto err_out;
1048 }
1049
1050 /* processing partition flags */
1051 p = argv[2];
1052 if (is_empty_arg(p) == 0) {
1053 for ( ; *p != '\0'; p++) {
1054 switch (*p) {
1055 case 'a':
1056 part->flags |= PARTITION_FLAG_ACTIVE;
1057 break;
1058 case 'p':
1059 part->flags |= PARTITION_FLAG_PRELOAD;
1060 break;
1061 case 'l':
1062 part->flags |= PARTITION_FLAG_LZMA;
1063 break;
1064 case 'h':
1065 part->flags |= PARTITION_FLAG_HAVEHDR;
1066 break;
1067 default:
1068 errmsg(0, "invalid partition flag \"%c\"", *p);
1069 goto err_out;
1070 }
1071 }
1072 }
1073
1074 /* processing partition parameter */
1075 p = argv[3];
1076 if (is_empty_arg(p)) {
1077 /* set default partition parameter */
1078 part->param = 0;
1079 } else if (str2u32(p, &part->param) != 0) {
1080 errmsg(0,"invalid partition parameter: %s", p);
1081 goto err_out;
1082 }
1083
1084 p = argv[4];
1085 if (is_empty_arg(p)) {
1086 /* set default partition parameter */
1087 fp->name[0] = '\0';
1088 } else {
1089 strncpy(fp->name, p, PART_NAME_LEN);
1090 }
1091
1092 #if 1
1093 if (part->size == 0) {
1094 part->size = flash_size - part->addr;
1095 }
1096
1097 /* processing file parameter */
1098 p = argv[5];
1099 if (is_empty_arg(p) == 0) {
1100 struct fw_block *b;
1101
1102 if (fw_num_blocks == MAX_FW_BLOCKS) {
1103 errmsg(0,"too many blocks specified", p);
1104 goto err_out;
1105 }
1106 b = &fw_blocks[fw_num_blocks++];
1107 b->name = strdup(p);
1108 b->addr = part->addr;
1109 b->blocklen = part->size;
1110 if (part->flags & PARTITION_FLAG_HAVEHDR) {
1111 b->flags |= BLOCK_FLAG_HAVEHDR;
1112 }
1113 }
1114 #endif
1115
1116 return 0;
1117
1118 err_out:
1119 return -1;
1120 }
1121
1122
1123 int
1124 parse_opt_board(char ch, char *arg)
1125 {
1126 if (required_arg(ch, arg)) {
1127 goto err_out;
1128 }
1129
1130 board = find_board(arg);
1131 if (board == NULL){
1132 errmsg(0,"invalid/unknown board specified: %s", arg);
1133 goto err_out;
1134 }
1135
1136 fw_header.vid = board->vid;
1137 fw_header.did = board->did;
1138 fw_header.svid = board->svid;
1139 fw_header.sdid = board->sdid;
1140
1141 flash_size = board->flash_size;
1142
1143 return 0;
1144
1145 err_out:
1146 return -1;
1147 }
1148
1149
1150 int
1151 parse_opt_rev(char ch, char *arg)
1152 {
1153 if (required_arg(ch, arg)) {
1154 return -1;
1155 }
1156
1157 if (str2u32(arg, &fw_header.rev) != 0) {
1158 errmsg(0,"invalid revision number: %s", arg);
1159 return -1;
1160 }
1161
1162 return 0;
1163 }
1164
1165
1166 /*
1167 * main
1168 */
1169 int
1170 main(int argc, char *argv[])
1171 {
1172 int optinvalid = 0; /* flag for invalid option */
1173 int c;
1174 int res = EXIT_FAILURE;
1175
1176 FILE *outfile;
1177 uint32_t crc;
1178
1179 progname=basename(argv[0]);
1180
1181 memset(&fw_header, 0, sizeof(fw_header));
1182
1183 /* init header defaults */
1184 fw_header.vid = VENID_COMPEX;
1185 fw_header.did = DEVID_COMPEX_WP54G;
1186 fw_header.svid = VENID_COMPEX;
1187 fw_header.sdid = DEVID_COMPEX_WP54G;
1188 fw_header.fwhi = 0x20000;
1189 fw_header.fwlo = 0x20000;
1190 fw_header.flags = 0;
1191
1192 opterr = 0; /* could not print standard getopt error messages */
1193 while ((c = getopt(argc, argv, "b:B:f:hi:p:r:s:v")) != -1) {
1194 optinvalid = 0;
1195 switch (c) {
1196 case 'b':
1197 optinvalid = parse_opt_block(c,optarg);
1198 break;
1199 case 'B':
1200 optinvalid = parse_opt_board(c,optarg);
1201 break;
1202 case 'f':
1203 optinvalid = parse_opt_flags(c,optarg);
1204 break;
1205 case 'h':
1206 usage(EXIT_SUCCESS);
1207 break;
1208 case 'i':
1209 optinvalid = parse_opt_id(c,optarg);
1210 break;
1211 case 'p':
1212 optinvalid = parse_opt_partition(c,optarg);
1213 break;
1214 case 'r':
1215 optinvalid = parse_opt_rev(c,optarg);
1216 break;
1217 case 's':
1218 optinvalid = parse_opt_size(c,optarg);
1219 break;
1220 case 'v':
1221 verblevel++;
1222 break;
1223 default:
1224 optinvalid = 1;
1225 break;
1226 }
1227 if (optinvalid != 0 ){
1228 errmsg(0, "invalid option: -%c", optopt);
1229 goto out;
1230 }
1231 }
1232
1233 if (optind == argc) {
1234 errmsg(0, "no output file specified");
1235 goto out;
1236 }
1237
1238 ofname = argv[optind++];
1239
1240 if (optind < argc) {
1241 errmsg(0, "invalid option: %s", argv[optind]);
1242 goto out;
1243 }
1244
1245 if (!board) {
1246 errmsg(0, "no board specified");
1247 goto out;
1248 }
1249
1250 if (flash_size == 0) {
1251 errmsg(0, "no flash size specified");
1252 goto out;
1253 }
1254
1255 if (process_files() != 0) {
1256 goto out;
1257 }
1258
1259 if (process_partitions() != 0) {
1260 goto out;
1261 }
1262
1263 outfile = fopen(ofname, "w");
1264 if (outfile == NULL) {
1265 errmsg(1, "could not open \"%s\" for writing", ofname);
1266 goto out;
1267 }
1268
1269 crc = 0;
1270 init_crc_table();
1271
1272 if (write_out_header(outfile, &crc) != 0)
1273 goto out_flush;
1274
1275 if (write_out_blocks(outfile, &crc) != 0)
1276 goto out_flush;
1277
1278 fw_header.crc = crc;
1279 if (write_out_header(outfile, NULL) != 0)
1280 goto out_flush;
1281
1282 dbgmsg(1,"Firmware file %s completed.", ofname);
1283
1284 res = EXIT_SUCCESS;
1285
1286 out_flush:
1287 fflush(outfile);
1288 fclose(outfile);
1289 if (res != EXIT_SUCCESS) {
1290 unlink(ofname);
1291 }
1292 out:
1293 return res;
1294 }