tools/firmware-utils/src/mkzynfw.c

   1 /*
   2  *  $Id$
   3  *
   4  *  Copyright (C) 2007-2008 OpenWrt.org
   5  *  Copyright (C) 2007-2008 Gabor Juhos <juhosg at openwrt.org>
   6  *
   7  *  This code was based on the information of the ZyXEL's firmware
   8  *  image format written by Kolja Waschk, can be found at:
   9  *  http://www.ixo.de/info/zyxel_uclinux
  10  *
  11  *  This program is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License version 2 as published
  13  *  by the Free Software Foundation.
  14  *
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdint.h>
  20 #include <string.h>
  21 #include <unistd.h>     /* for unlink() */
  22 #include <libgen.h>
  23 #include <getopt.h>     /* for getopt() */
  24 #include <stdarg.h>
  25 #include <errno.h>
  26 #include <sys/stat.h>
  27 #include <endian.h>     /* for __BYTE_ORDER */
  28 #if defined(__CYGWIN__)
  29 #  include <byteswap.h>
  30 #endif
  31
  32 #include "zynos.h"
  33
  34 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
  35 #  define HOST_TO_LE16(x)       (x)
  36 #  define HOST_TO_LE32(x)       (x)
  37 #  define LE16_TO_HOST(x)       (x)
  38 #  define LE32_TO_HOST(x)       (x)
  39 #  define HOST_TO_BE16(x)       bswap_16(x)
  40 #  define HOST_TO_BE32(x)       bswap_32(x)
  41 #  define BE16_TO_HOST(x)       bswap_16(x)
  42 #  define BE32_TO_HOST(x)       bswap_32(x)
  43 #else
  44 #  define HOST_TO_BE16(x)       (x)
  45 #  define HOST_TO_BE32(x)       (x)
  46 #  define BE16_TO_HOST(x)       (x)
  47 #  define BE32_TO_HOST(x)       (x)
  48 #  define HOST_TO_LE16(x)       bswap_16(x)
  49 #  define HOST_TO_LE32(x)       bswap_32(x)
  50 #  define LE16_TO_HOST(x)       bswap_16(x)
  51 #  define LE32_TO_HOST(x)       bswap_32(x)
  52 #endif
  53
  54 #define ALIGN(x,y)      (((x)+((y)-1)) & ~((y)-1))
  55
  56 #define MAX_NUM_BLOCKS  8
  57 #define MAX_ARG_COUNT   32
  58 #define MAX_ARG_LEN     1024
  59 #define FILE_BUF_LEN    (16*1024)
  60
  61
  62 struct csum_state{
  63         int             odd;
  64         uint32_t        sum;
  65         uint32_t        tmp;
  66 };
  67
  68 struct fw_block {
  69         uint32_t        align;          /* alignment of this block */
  70         char            *file_name;     /* name of the file */
  71         uint32_t        file_size;      /* length of the file */
  72         char            *mmap_name;     /* name in the MMAP table */
  73         int             type;           /* block type */
  74         uint32_t        padlen;
  75         uint8_t         padc;
  76 };
  77
  78 #define BLOCK_TYPE_BOOTEXT      0
  79 #define BLOCK_TYPE_RAW          1
  80
  81 struct fw_mmap {
  82         uint32_t        addr;
  83         uint32_t        size;
  84         uint32_t        user_addr;
  85         uint32_t        user_size;
  86 };
  87 #define MMAP_DATA_SIZE  1024
  88 #define MMAP_ALIGN      16
  89
  90 struct board_info {
  91         char *name;             /* model name */
  92         char *desc;             /* description */
  93         uint16_t vendor;        /* vendor id */
  94         uint16_t model;         /* model id */
  95         uint32_t flash_base;    /* flash base address */
  96         uint32_t flash_size;    /* board flash size */
  97         uint32_t code_start;    /* code start address */
  98         uint32_t romio_offs;    /* offset of the firmware within the flash */
  99         uint32_t bootext_size;  /* maximum size of bootext block */
 100 };
 101
 102 /*
 103  * Globals
 104  */
 105 char *progname;
 106 char *ofname = NULL;
 107 int verblevel = 0;
 108
 109 struct board_info *board = NULL;
 110
 111 struct fw_block blocks[MAX_NUM_BLOCKS];
 112 struct fw_block *bootext_block = NULL;
 113 int num_blocks = 0;
 114
 115 #define ADM5120_FLASH_BASE      0xBFC00000
 116 #define ADM5120_CODE_START      0x80008000
 117
 118 /* TODO: check values for AR7 */
 119 #define AR7_FLASH_BASE          0xB0000000
 120 #define AR7_CODE_START          0x94008000
 121
 122 #define ATHEROS_FLASH_BASE      0xBFC00000
 123 #define ATHEROS_CODE_START      0x80e00000
 124
 125 #define BOARD(n, d, v, m, fb, fs, cs, fo) {             \
 126         .name = (n), .desc=(d),                         \
 127         .vendor = (v), .model = (m),                    \
 128         .flash_base = (fb), .flash_size = (fs)<<20,     \
 129         .code_start = (cs), .romio_offs = (fo),         \
 130         .bootext_size = BOOTEXT_DEF_SIZE                \
 131         }
 132
 133 #define ADMBOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
 134         ADM5120_FLASH_BASE, fs, ADM5120_CODE_START, 0x8000)
 135
 136 #define ADMBOARD2(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
 137         ADM5120_FLASH_BASE, fs, ADM5120_CODE_START, 0x10000)
 138
 139 #define AR7BOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
 140         AR7_FLASH_BASE, fs, AR7_CODE_START, 0x8000)
 141
 142 #define ATHEROSBOARD1(n, d, m, fs) BOARD(n, d, ZYNOS_VENDOR_ID_ZYXEL, m, \
 143         ATHEROS_FLASH_BASE, fs, ATHEROS_CODE_START, 0x30000)
 144
 145 static struct board_info boards[] = {
 146         /*
 147          * Infineon/ADMtek ADM5120 based boards
 148          */
 149         ADMBOARD2("ES-2024A",   "ZyXEL ES-2024A", ZYNOS_MODEL_ES_2024A, 4),
 150         ADMBOARD2("ES-2024PWR", "ZyXEL ES-2024PWR", ZYNOS_MODEL_ES_2024PWR, 4),
 151         ADMBOARD2("ES-2108",    "ZyXEL ES-2108", ZYNOS_MODEL_ES_2108, 4),
 152         ADMBOARD2("ES-2108-F",  "ZyXEL ES-2108-F", ZYNOS_MODEL_ES_2108_F, 4),
 153         ADMBOARD2("ES-2108-G",  "ZyXEL ES-2108-G", ZYNOS_MODEL_ES_2108_G, 4),
 154         ADMBOARD2("ES-2108-LC", "ZyXEL ES-2108-LC", ZYNOS_MODEL_ES_2108_LC, 4),
 155         ADMBOARD2("ES-2108PWR", "ZyXEL ES-2108PWR", ZYNOS_MODEL_ES_2108PWR, 4),
 156         ADMBOARD1("HS-100",     "ZyXEL HomeSafe 100", ZYNOS_MODEL_HS_100, 2),
 157         ADMBOARD1("HS-100W",    "ZyXEL HomeSafe 100W", ZYNOS_MODEL_HS_100W, 2),
 158         ADMBOARD1("P-334",      "ZyXEL Prestige 334", ZYNOS_MODEL_P_334, 2),
 159         ADMBOARD1("P-334U",     "ZyXEL Prestige 334U", ZYNOS_MODEL_P_334U, 4),
 160         ADMBOARD1("P-334W",     "ZyXEL Prestige 334W", ZYNOS_MODEL_P_334W, 2),
 161         ADMBOARD1("P-334WH",    "ZyXEL Prestige 334WH", ZYNOS_MODEL_P_334WH, 4),
 162         ADMBOARD1("P-334WHD",   "ZyXEL Prestige 334WHD", ZYNOS_MODEL_P_334WHD, 4),
 163         ADMBOARD1("P-334WT",    "ZyXEL Prestige 334WT", ZYNOS_MODEL_P_334WT, 4),
 164         ADMBOARD1("P-335",      "ZyXEL Prestige 335", ZYNOS_MODEL_P_335, 4),
 165         ADMBOARD1("P-335Plus",  "ZyXEL Prestige 335Plus", ZYNOS_MODEL_P_335PLUS, 4),
 166         ADMBOARD1("P-335U",     "ZyXEL Prestige 335U", ZYNOS_MODEL_P_335U, 4),
 167         ADMBOARD1("P-335WT",    "ZyXEL Prestige 335WT", ZYNOS_MODEL_P_335WT, 4),
 168
 169         {
 170                 .name           = "P-2602HW-D1A",
 171                 .desc           = "ZyXEL P-2602HW-D1A",
 172                 .vendor         = ZYNOS_VENDOR_ID_ZYXEL,
 173                 .model          = ZYNOS_MODEL_P_2602HW_D1A,
 174                 .flash_base     = AR7_FLASH_BASE,
 175                 .flash_size     = 4*1024*1024,
 176                 .code_start     = 0x94008000,
 177                 .romio_offs     = 0x20000,
 178                 .bootext_size   = BOOTEXT_DEF_SIZE,
 179         },
 180
 181 #if 0
 182         /*
 183          * Texas Instruments AR7 based boards
 184          */
 185         AR7BOARD1("P-660H-61",  "ZyXEL P-660H-61", ZYNOS_MODEL_P_660H_61, 2),
 186         AR7BOARD1("P-660H-63",  "ZyXEL P-660H-63", ZYNOS_MODEL_P_660H_63, 2),
 187         AR7BOARD1("P-660H-D1",  "ZyXEL P-660H-D1", ZYNOS_MODEL_P_660H_D1, 2),
 188         AR7BOARD1("P-660H-D3",  "ZyXEL P-660H-D3", ZYNOS_MODEL_P_660H_D3, 2),
 189         AR7BOARD1("P-660HW-61", "ZyXEL P-660HW-61", ZYNOS_MODEL_P_660HW_61, 2),
 190         AR7BOARD1("P-660HW-63", "ZyXEL P-660HW-63", ZYNOS_MODEL_P_660HW_63, 2),
 191         AR7BOARD1("P-660HW-67", "ZyXEL P-660HW-67", ZYNOS_MODEL_P_660HW_67, 2),
 192         AR7BOARD1("P-660HW-D1", "ZyXEL P-660HW-D1", ZYNOS_MODEL_P_660HW_D1, 2),
 193         AR7BOARD1("P-660HW-D3", "ZyXEL P-660HW-D3", ZYNOS_MODEL_P_660HW_D3, 2),
 194         AR7BOARD1("P-660R-61",  "ZyXEL P-660R-61", ZYNOS_MODEL_P_660R_61, 2),
 195         AR7BOARD1("P-660R-61C", "ZyXEL P-660R-61C", ZYNOS_MODEL_P_660R_61C, 2),
 196         AR7BOARD1("P-660R-63",  "ZyXEL P-660R-63", ZYNOS_MODEL_P_660R_63, 2),
 197         AR7BOARD1("P-660R-63C", "ZyXEL P-660R-63C", ZYNOS_MODEL_P_660R_63C, 2),
 198         AR7BOARD1("P-660R-67",  "ZyXEL P-660R-67", ZYNOS_MODEL_P_660R_67, 2),
 199         AR7BOARD1("P-660R-D1",  "ZyXEL P-660R-D1", ZYNOS_MODEL_P_660R_D1, 2),
 200         AR7BOARD1("P-660R-D3",  "ZyXEL P-660R-D3", ZYNOS_MODEL_P_660R_D3, 2),
 201 #endif
 202         {
 203                 .name           = "O2SURF",
 204                 .desc           = "O2 DSL Surf & Phone",
 205                 .vendor         = ZYNOS_VENDOR_ID_O2,
 206                 .model          = ZYNOS_MODEL_O2SURF,
 207                 .flash_base     = AR7_FLASH_BASE,
 208                 .flash_size     = 8*1024*1024,
 209                 .code_start     = 0x94014000,
 210                 .romio_offs     = 0x40000,
 211                 .bootext_size   = BOOTEXT_DEF_SIZE,
 212         },
 213
 214         /*
 215 :x
 216          */
 217         ATHEROSBOARD1("NBG-318S", "ZyXEL NBG-318S", ZYNOS_MODEL_NBG_318S, 4),
 218
 219         {.name = NULL}
 220 };
 221
 222 /*
 223  * Message macros
 224  */
 225 #define ERR(fmt, ...) do { \
 226         fflush(0); \
 227         fprintf(stderr, "[%s] *** error: " fmt "\n", \
 228                         progname, ## __VA_ARGS__ ); \
 229 } while (0)
 230
 231 #define ERRS(fmt, ...) do { \
 232         int save = errno; \
 233         fflush(0); \
 234         fprintf(stderr, "[%s] *** error: " fmt ", %s\n", \
 235                         progname, ## __VA_ARGS__, strerror(save)); \
 236 } while (0)
 237
 238 #define WARN(fmt, ...) do { \
 239         fprintf(stderr, "[%s] *** warning: " fmt "\n", \
 240                         progname, ## __VA_ARGS__ ); \
 241 } while (0)
 242
 243 #define DBG(lev, fmt, ...) do { \
 244         if (verblevel < lev) \
 245                 break;\
 246         fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
 247 } while (0)
 248
 249 #define ERR_FATAL               -1
 250 #define ERR_INVALID_IMAGE       -2
 251
 252 /*
 253  * Helper routines
 254  */
 255 void
 256 usage(int status)
 257 {
 258         FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
 259         struct board_info *board;
 260
 261         fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
 262         fprintf(stream,
 263 "\n"
 264 "Options:\n"
 265 "  -B <board>      create image for the board specified with <board>.\n"
 266 "                  valid <board> values:\n"
 267         );
 268         for (board = boards; board->name != NULL; board++){
 269                 fprintf(stream,
 270 "                    %-12s= %s\n",
 271                  board->name, board->desc);
 272         };
 273         fprintf(stream,
 274 "  -b <file>[:<align>]\n"
 275 "                  add boot extension block to the image\n"
 276 "  -r <file>[:<align>]\n"
 277 "                  add raw block to the image\n"
 278 "  -o <file>       write output to the file <file>\n"
 279 "  -h              show this screen\n"
 280         );
 281
 282         exit(status);
 283 }
 284
 285
 286 /*
 287  * argument parsing
 288  */
 289 int
 290 str2u32(char *arg, uint32_t *val)
 291 {
 292         char *err = NULL;
 293         uint32_t t;
 294
 295         errno=0;
 296         t = strtoul(arg, &err, 0);
 297         if (errno || (err==arg) || ((err != NULL) && *err)) {
 298                 return -1;
 299         }
 300
 301         *val = t;
 302         return 0;
 303 }
 304
 305
 306 int
 307 str2u16(char *arg, uint16_t *val)
 308 {
 309         char *err = NULL;
 310         uint32_t t;
 311
 312         errno=0;
 313         t = strtoul(arg, &err, 0);
 314         if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x10000)) {
 315                 return -1;
 316         }
 317
 318         *val = t & 0xFFFF;
 319         return 0;
 320 }
 321
 322 int
 323 str2u8(char *arg, uint8_t *val)
 324 {
 325         char *err = NULL;
 326         uint32_t t;
 327
 328         errno=0;
 329         t = strtoul(arg, &err, 0);
 330         if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x100)) {
 331                 return -1;
 332         }
 333
 334         *val = t & 0xFF;
 335         return 0;
 336 }
 337
 338 int
 339 str2sig(char *arg, uint32_t *sig)
 340 {
 341         if (strlen(arg) != 4)
 342                 return -1;
 343
 344         *sig = arg[0] | (arg[1] << 8) | (arg[2] << 16) | (arg[3] << 24);
 345
 346         return 0;
 347 }
 348
 349
 350 int
 351 parse_arg(char *arg, char *buf, char *argv[])
 352 {
 353         int res = 0;
 354         size_t argl;
 355         char *tok;
 356         char **ap = &buf;
 357         int i;
 358
 359         memset(argv, 0, MAX_ARG_COUNT * sizeof(void *));
 360
 361         if ((arg == NULL)) {
 362                 /* no arguments */
 363                 return 0;
 364         }
 365
 366         argl = strlen(arg);
 367         if (argl == 0) {
 368                 /* no arguments */
 369                 return 0;
 370         }
 371
 372         if (argl >= MAX_ARG_LEN) {
 373                 /* argument is too long */
 374                 argl = MAX_ARG_LEN-1;
 375         }
 376
 377         memcpy(buf, arg, argl);
 378         buf[argl] = '\0';
 379
 380         for (i = 0; i < MAX_ARG_COUNT; i++) {
 381                 tok = strsep(ap, ":");
 382                 if (tok == NULL) {
 383                         break;
 384                 }
 385 #if 0
 386                 else if (tok[0] == '\0') {
 387                         break;
 388                 }
 389 #endif
 390                 argv[i] = tok;
 391                 res++;
 392         }
 393
 394         return res;
 395 }
 396
 397
 398 int
 399 required_arg(char c, char *arg)
 400 {
 401         if (arg == NULL || *arg != '-')
 402                 return 0;
 403
 404         ERR("option -%c requires an argument\n", c);
 405         return -1;
 406 }
 407
 408
 409 int
 410 is_empty_arg(char *arg)
 411 {
 412         int ret = 1;
 413         if (arg != NULL) {
 414                 if (*arg) ret = 0;
 415         };
 416         return ret;
 417 }
 418
 419
 420 void
 421 csum_init(struct csum_state *css)
 422 {
 423         css->odd = 0;
 424         css->sum = 0;
 425         css->tmp = 0;
 426 }
 427
 428
 429 void
 430 csum_update(uint8_t *p, uint32_t len, struct csum_state *css)
 431 {
 432         if (len == 0)
 433                 return;
 434
 435         if (css->odd) {
 436                 css->sum += (css->tmp << 8) + p[0];
 437                 if (css->sum > 0xFFFF) {
 438                         css->sum += 1;
 439                         css->sum &= 0xFFFF;
 440                 }
 441                 css->odd = 0;
 442                 len--;
 443                 p++;
 444         }
 445
 446         for ( ; len > 1; len -= 2, p +=2 ) {
 447                 css->sum  += (p[0] << 8) + p[1];
 448                 if (css->sum > 0xFFFF) {
 449                         css->sum += 1;
 450                         css->sum &= 0xFFFF;
 451                 }
 452         }
 453
 454         if (len == 1){
 455                 css->tmp = p[0];
 456                 css->odd = 1;
 457         }
 458 }
 459
 460
 461 uint16_t
 462 csum_get(struct csum_state *css)
 463 {
 464         char pad = 0;
 465
 466         csum_update(&pad, 1, css);
 467         return css->sum;
 468 }
 469
 470 uint16_t
 471 csum_buf(uint8_t *p, uint32_t len)
 472 {
 473         struct csum_state css;
 474
 475         csum_init(&css);
 476         csum_update(p, len, &css);
 477         return csum_get(&css);
 478
 479 }
 480
 481 /*
 482  * routines to write data to the output file
 483  */
 484 int
 485 write_out_data(FILE *outfile, uint8_t *data, size_t len,
 486                 struct csum_state *css)
 487 {
 488         errno = 0;
 489
 490         fwrite(data, len, 1, outfile);
 491         if (errno) {
 492                 ERR("unable to write output file");
 493                 return -1;
 494         }
 495
 496         if (css) {
 497                 csum_update(data, len, css);
 498         }
 499
 500         return 0;
 501 }
 502
 503
 504 int
 505 write_out_padding(FILE *outfile, size_t len, uint8_t padc,
 506                  struct csum_state *css)
 507 {
 508         uint8_t buf[512];
 509         size_t buflen = sizeof(buf);
 510
 511         memset(buf, padc, buflen);
 512         while (len > 0) {
 513                 if (len < buflen)
 514                         buflen = len;
 515
 516                 if (write_out_data(outfile, buf, buflen, css))
 517                         return -1;
 518
 519                 len -= buflen;
 520         }
 521
 522         return 0;
 523 }
 524
 525
 526 int
 527 write_out_data_align(FILE *outfile, uint8_t *data, size_t len, size_t align,
 528                 struct csum_state *css)
 529 {
 530         size_t padlen;
 531         int res;
 532
 533         res = write_out_data(outfile, data, len, css);
 534         if (res)
 535                 return res;
 536
 537         padlen = ALIGN(len,align) - len;
 538         res = write_out_padding(outfile, padlen, 0xFF, css);
 539
 540         return res;
 541 }
 542
 543
 544 int
 545 write_out_header(FILE *outfile, struct zyn_rombin_hdr *hdr)
 546 {
 547         struct zyn_rombin_hdr t;
 548
 549         errno = 0;
 550         if (fseek(outfile, 0, SEEK_SET) != 0) {
 551                 ERRS("fseek failed on output file");
 552                 return -1;
 553         }
 554
 555         /* setup temporary header fields */
 556         memset(&t, 0, sizeof(t));
 557         t.addr = HOST_TO_BE32(hdr->addr);
 558         memcpy(&t.sig, ROMBIN_SIGNATURE, ROMBIN_SIG_LEN);
 559         t.type = hdr->type;
 560         t.flags = hdr->flags;
 561         t.osize = HOST_TO_BE32(hdr->osize);
 562         t.csize = HOST_TO_BE32(hdr->csize);
 563         t.ocsum = HOST_TO_BE16(hdr->ocsum);
 564         t.ccsum = HOST_TO_BE16(hdr->ccsum);
 565         t.mmap_addr = HOST_TO_BE32(hdr->mmap_addr);
 566
 567         return write_out_data(outfile, (uint8_t *)&t, sizeof(t), NULL);
 568 }
 569
 570
 571 int
 572 write_out_mmap(FILE *outfile, struct fw_mmap *mmap, struct csum_state *css)
 573 {
 574         struct zyn_mmt_hdr *mh;
 575         uint8_t buf[MMAP_DATA_SIZE];
 576         uint32_t user_size;
 577         char *data;
 578         int res;
 579
 580         memset(buf, 0, sizeof(buf));
 581
 582         mh = (struct zyn_mmt_hdr *)buf;
 583
 584         /* TODO: needs to recreate the memory map too? */
 585         mh->count=0;
 586
 587         /* Build user data section */
 588         data = buf+sizeof(*mh);
 589         data += sprintf(data, "Vendor 1 %d", board->vendor);
 590         *data++ = '\0';
 591         data += sprintf(data, "Model 1 %d", BE16_TO_HOST(board->model));
 592         *data++ = '\0';
 593         /* TODO: make hardware version configurable? */
 594         data += sprintf(data, "HwVerRange 2 %d %d", 0, 0);
 595         *data++ = '\0';
 596
 597         user_size = (uint8_t *)data - buf;
 598         mh->user_start= HOST_TO_BE32(mmap->addr+sizeof(*mh));
 599         mh->user_end= HOST_TO_BE32(mmap->addr+user_size);
 600         mh->csum = HOST_TO_BE16(csum_buf(buf+sizeof(*mh), user_size));
 601
 602         res = write_out_data(outfile, buf, sizeof(buf), css);
 603
 604         return res;
 605 }
 606
 607
 608 int
 609 block_stat_file(struct fw_block *block)
 610 {
 611         struct stat st;
 612         int res;
 613
 614         if (block->file_name == NULL)
 615                 return 0;
 616
 617         res = stat(block->file_name, &st);
 618         if (res){
 619                 ERRS("stat failed on %s", block->file_name);
 620                 return res;
 621         }
 622
 623         block->file_size = st.st_size;
 624         return 0;
 625 }
 626
 627
 628 int
 629 write_out_file(FILE *outfile, char *name, size_t len, struct csum_state *css)
 630 {
 631         char buf[FILE_BUF_LEN];
 632         size_t buflen = sizeof(buf);
 633         FILE *f;
 634         int res;
 635
 636         DBG(2, "writing out file, name=%s, len=%d",
 637                 name, len);
 638
 639         errno = 0;
 640         f = fopen(name,"r");
 641         if (errno) {
 642                 ERRS("unable to open file: %s", name);
 643                 return -1;
 644         }
 645
 646         while (len > 0) {
 647                 if (len < buflen)
 648                         buflen = len;
 649
 650                 /* read data from source file */
 651                 errno = 0;
 652                 fread(buf, buflen, 1, f);
 653                 if (errno != 0) {
 654                         ERRS("unable to read from file: %s",name);
 655                         res = -1;
 656                         break;
 657                 }
 658
 659                 res = write_out_data(outfile, buf, buflen, css);
 660                 if (res)
 661                         break;
 662
 663                 len -= buflen;
 664         }
 665
 666         fclose(f);
 667         return res;
 668 }
 669
 670
 671 int
 672 write_out_block(FILE *outfile, struct fw_block *block, struct csum_state *css)
 673 {
 674         int res;
 675
 676         if (block == NULL)
 677                 return 0;
 678
 679         if (block->file_name == NULL)
 680                 return 0;
 681
 682         if (block->file_size == 0)
 683                 return 0;
 684
 685         res = write_out_file(outfile, block->file_name,
 686                         block->file_size, css);
 687         return res;
 688 }
 689
 690
 691 int
 692 write_out_image(FILE *outfile)
 693 {
 694         struct fw_block *block;
 695         struct fw_mmap mmap;
 696         struct zyn_rombin_hdr hdr;
 697         struct csum_state css;
 698         int i, res;
 699         uint32_t offset;
 700         uint32_t padlen;
 701
 702         /* setup header fields */
 703         memset(&hdr, 0, sizeof(hdr));
 704         hdr.addr = board->code_start;
 705         hdr.type = OBJECT_TYPE_BOOTEXT;
 706         hdr.flags = ROMBIN_FLAG_OCSUM;
 707
 708         offset = board->romio_offs;
 709
 710         res = write_out_header(outfile, &hdr);
 711         if (res)
 712                 return res;
 713
 714         offset += sizeof(hdr);
 715
 716         csum_init(&css);
 717         res = write_out_block(outfile, bootext_block, &css);
 718         if (res)
 719                 return res;
 720
 721         offset += bootext_block->file_size;
 722         if (offset > (board->romio_offs + board->bootext_size)) {
 723                 ERR("bootext file '%s' is too big", bootext_block->file_name);
 724                 return -1;
 725         }
 726
 727         padlen = ALIGN(offset, MMAP_ALIGN) - offset;
 728         res = write_out_padding(outfile, padlen, 0xFF, &css);
 729         if (res)
 730                 return res;
 731
 732         offset += padlen;
 733
 734         mmap.addr = board->flash_base + board->romio_offs + offset;
 735         hdr.mmap_addr = mmap.addr;
 736         res = write_out_mmap(outfile, &mmap, &css);
 737         if (res)
 738                 return res;
 739
 740         offset += MMAP_DATA_SIZE;
 741         hdr.osize = offset - sizeof(hdr) - board->romio_offs;
 742         hdr.ocsum = csum_get(&css);
 743
 744         if ((offset - board->romio_offs) < board->bootext_size) {
 745                 padlen = board->romio_offs + board->bootext_size - offset;
 746                 res = write_out_padding(outfile, padlen, 0xFF, NULL);
 747                 if (res)
 748                         return res;
 749                 offset += padlen;
 750
 751                 DBG(2, "bootext end at %08x", offset);
 752         }
 753
 754         for (i = 0; i < num_blocks; i++) {
 755                 block = &blocks[i];
 756
 757                 if (block->type == BLOCK_TYPE_BOOTEXT)
 758                         continue;
 759
 760                 padlen = ALIGN(offset, block->align) - offset;
 761                 res = write_out_padding(outfile, padlen, 0xFF, NULL);
 762                 if (res)
 763                         return res;
 764                 offset += padlen;
 765
 766                 res = write_out_block(outfile, block, NULL);
 767                 if (res)
 768                         return res;
 769                 offset += block->file_size;
 770         }
 771
 772         res = write_out_header(outfile, &hdr);
 773
 774         return res;
 775 }
 776
 777
 778 struct board_info *
 779 find_board(char *name)
 780 {
 781         struct board_info *ret;
 782         struct board_info *board;
 783
 784         ret = NULL;
 785         for (board = boards; board->name != NULL; board++){
 786                 if (strcasecmp(name, board->name) == 0) {
 787                         ret = board;
 788                         break;
 789                 }
 790         };
 791
 792         return ret;
 793 }
 794
 795
 796 int
 797 parse_opt_board(char ch, char *arg)
 798 {
 799
 800         DBG(1,"parsing board option: -%c %s", ch, arg);
 801
 802         if (board != NULL) {
 803                 ERR("only one board option allowed");
 804                 return -1;
 805         }
 806
 807         if (required_arg(ch, arg))
 808                 return -1;
 809
 810         board = find_board(arg);
 811         if (board == NULL){
 812                 ERR("invalid/unknown board specified: %s", arg);
 813                 return -1;
 814         }
 815
 816         return 0;
 817 }
 818
 819
 820 int
 821 parse_opt_ofname(char ch, char *arg)
 822 {
 823
 824         if (ofname != NULL) {
 825                 ERR("only one output file allowed");
 826                 return -1;
 827         }
 828
 829         if (required_arg(ch, arg))
 830                 return -1;
 831
 832         ofname = arg;
 833
 834         return 0;
 835 }
 836
 837
 838 int
 839 parse_opt_block(char ch, char *arg)
 840 {
 841         char buf[MAX_ARG_LEN];
 842         char *argv[MAX_ARG_COUNT];
 843         int argc;
 844         char *p;
 845         struct fw_block *block;
 846         int i;
 847
 848         if ( num_blocks >= MAX_NUM_BLOCKS ) {
 849                 ERR("too many blocks specified");
 850                 return -1;
 851         }
 852
 853         block = &blocks[num_blocks++];
 854
 855         /* setup default field values */
 856         block->padc = 0xFF;
 857
 858         switch(ch) {
 859         case 'b':
 860                 if (bootext_block) {
 861                         ERR("only one boot extension block allowed");
 862                         break;
 863                 }
 864                 block->type = BLOCK_TYPE_BOOTEXT;
 865                 bootext_block = block;
 866                 break;
 867         case 'r':
 868                 block->type = BLOCK_TYPE_RAW;
 869                 break;
 870         }
 871
 872         argc = parse_arg(arg, buf, argv);
 873
 874         i = 0;
 875         p = argv[i++];
 876         if (is_empty_arg(p)) {
 877                 ERR("no file specified in %s", arg);
 878                 return -1;
 879         } else {
 880                 block->file_name = strdup(p);
 881                 if (block->file_name == NULL) {
 882                         ERR("not enough memory");
 883                         return -1;
 884                 }
 885         }
 886
 887         if(block->type == BLOCK_TYPE_BOOTEXT)
 888                 return 0;
 889
 890         p = argv[i++];
 891         if (!is_empty_arg(p)) {
 892                 if (str2u32(p, &block->align) != 0) {
 893                         ERR("invalid block align in %s", arg);
 894                         return -1;
 895                 }
 896         }
 897
 898         return 0;
 899 }
 900
 901
 902 int
 903 calc_block_offsets(int type, uint32_t *offset)
 904 {
 905         struct fw_block *block;
 906         uint32_t next_offs;
 907         uint32_t avail;
 908         int i, res;
 909
 910         DBG(1,"calculating block offsets, starting with %lu",
 911                 *offset);
 912
 913         res = 0;
 914         for (i = 0; i < num_blocks; i++) {
 915                 block = &blocks[i];
 916
 917                 if (block->type != type)
 918                         continue;
 919
 920                 next_offs = ALIGN(*offset, block->align);
 921                 avail = board->flash_size - board->romio_offs - next_offs;
 922                 if (next_offs + block->file_size > avail) {
 923                         ERR("file %s is too big, offset = %u, size=%u,"
 924                                 " align = %u", block->file_name,
 925                                 (unsigned)next_offs,
 926                                 (unsigned)block->file_size,
 927                                 (unsigned)block->align);
 928                         res = -1;
 929                         break;
 930                 }
 931
 932                 block->padlen = next_offs - *offset;
 933                 *offset += block->file_size;
 934         }
 935
 936         return res;
 937 }
 938
 939 int
 940 process_blocks(void)
 941 {
 942         struct fw_block *block;
 943         uint32_t offset;
 944         int i;
 945         int res;
 946
 947         /* collecting file stats */
 948         for (i = 0; i < num_blocks; i++) {
 949                 block = &blocks[i];
 950                 res = block_stat_file(block);
 951                 if (res)
 952                         return res;
 953         }
 954
 955         offset = board->romio_offs + bootext_block->file_size;
 956         res = calc_block_offsets(BLOCK_TYPE_RAW, &offset);
 957
 958         return res;
 959 }
 960
 961
 962 int
 963 main(int argc, char *argv[])
 964 {
 965         int optinvalid = 0;   /* flag for invalid option */
 966         int c;
 967         int res = EXIT_FAILURE;
 968
 969         FILE *outfile;
 970
 971         progname=basename(argv[0]);
 972
 973         opterr = 0;  /* could not print standard getopt error messages */
 974         while ( 1 ) {
 975                 optinvalid = 0;
 976
 977                 c = getopt(argc, argv, "b:B:ho:r:v");
 978                 if (c == -1)
 979                         break;
 980
 981                 switch (c) {
 982                 case 'b':
 983                 case 'r':
 984                         optinvalid = parse_opt_block(c,optarg);
 985                         break;
 986                 case 'B':
 987                         optinvalid = parse_opt_board(c,optarg);
 988                         break;
 989                 case 'o':
 990                         optinvalid = parse_opt_ofname(c,optarg);
 991                         break;
 992                 case 'v':
 993                         verblevel++;
 994                         break;
 995                 case 'h':
 996                         usage(EXIT_SUCCESS);
 997                         break;
 998                 default:
 999                         optinvalid = 1;
1000                         break;
1001                 }
1002                 if (optinvalid != 0 ) {
1003                         ERR("invalid option: -%c", optopt);
1004                         goto out;
1005                 }
1006         }
1007
1008         if (board == NULL) {
1009                 ERR("no board specified");
1010                 goto out;
1011         }
1012
1013         if (ofname == NULL) {
1014                 ERR("no output file specified");
1015                 goto out;
1016         }
1017
1018         if (optind < argc) {
1019                 ERR("invalid option: %s", argv[optind]);
1020                 goto out;
1021         }
1022
1023         if (process_blocks() != 0) {
1024                 goto out;
1025         }
1026
1027         outfile = fopen(ofname, "w");
1028         if (outfile == NULL) {
1029                 ERRS("could not open \"%s\" for writing", ofname);
1030                 goto out;
1031         }
1032
1033         if (write_out_image(outfile) != 0)
1034                 goto out_flush;
1035
1036         DBG(1,"Image file %s completed.", ofname);
1037
1038         res = EXIT_SUCCESS;
1039
1040 out_flush:
1041         fflush(outfile);
1042         fclose(outfile);
1043         if (res != EXIT_SUCCESS) {
1044                 unlink(ofname);
1045         }
1046 out:
1047         return res;
1048 }