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 }