tools/firmware-utils/src/mkporayfw.c

   1 /*
   2  * Builder/viewer/extractor utility for Poray firmware image files
   3  *
   4  * Copyright (C) 2013 Michel Stempin <michel.stempin@wanadoo.fr>
   5  * Copyright (C) 2013 Felix Kaechele <felix@fetzig.org>
   6  * Copyright (C) 2013 <admin@openschemes.com>
   7  *
   8  * This tool is based on:
   9  *   TP-Link firmware upgrade tool.
  10  *   Copyright (C) 2009 Gabor Juhos <juhosg@openwrt.org>
  11  *
  12  * Itself based on:
  13  *   TP-Link WR941 V2 firmware checksum fixing tool.
  14  *   Copyright (C) 2008,2009 Wang Jian <lark@linux.net.cn>
  15  *
  16  * This program is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License version 2 as published
  18  * by the Free Software Foundation.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdint.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <libgen.h>
  28 #include <getopt.h>
  29 #include <stdarg.h>
  30 #include <errno.h>
  31 #include <sys/stat.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in.h>
  34
  35 #if (__BYTE_ORDER == __BIG_ENDIAN)
  36 #  define HOST_TO_BE32(x)       (x)
  37 #  define BE32_TO_HOST(x)       (x)
  38 #  define HOST_TO_LE32(x)       bswap_32(x)
  39 #  define LE32_TO_HOST(x)       bswap_32(x)
  40 #else
  41 #  define HOST_TO_BE32(x)       bswap_32(x)
  42 #  define BE32_TO_HOST(x)       bswap_32(x)
  43 #  define HOST_TO_LE32(x)       (x)
  44 #  define LE32_TO_HOST(x)       (x)
  45 #endif
  46
  47 /* Fixed header flags */
  48 #define HEADER_FLAGS            0x020e0000
  49
  50 /* Recognized Hardware ID magic */
  51 #define HWID_HAME_MPR_A1_L8     0x32473352
  52 #define HWID_PORAY_R50B         0x31353033
  53 #define HWID_PORAY_R50D         0x33353033
  54 #define HWID_PORAY_R50E         0x34353033
  55 #define HWID_PORAY_M3           0x31353335
  56 #define HWID_PORAY_M4           0x32353335
  57 #define HWID_PORAY_Q3           0x33353335
  58 #define HWID_PORAY_X5_X6        0x35353335
  59 #define HWID_PORAY_X8           0x36353335
  60 #define HWID_PORAY_X1           0x38353335
  61 #define HWID_NEXX_WT15XXX       0x30353332
  62 #define HWID_NEXX_WT3020A       0x30323033
  63
  64 /* Recognized XOR obfuscation keys */
  65 #define KEY_HAME                0
  66 #define KEY_PORAY_1             1
  67 #define KEY_PORAY_2             2
  68 #define KEY_PORAY_3             3
  69 #define KEY_PORAY_4             4
  70 #define KEY_NEXX_1              5
  71 #define KEY_NEXX_2              6
  72
  73 /* XOR key length */
  74 #define KEY_LEN                 15
  75
  76 struct file_info {
  77         char            *file_name;     /* Name of the file */
  78         uint32_t        file_size;      /* Length of the file */
  79 };
  80
  81 struct fw_header {
  82         uint32_t        hw_id;          /* Hardware id */
  83         uint32_t        firmware_len;   /* Firmware data length */
  84         uint32_t        flags;          /* Header flags */
  85         uint8_t         pad[16];
  86 } __attribute__ ((packed));
  87
  88 struct flash_layout {
  89         char            *id;
  90         uint32_t        fw_max_len;
  91 };
  92
  93 struct board_info {
  94         char            *id;
  95         uint32_t        hw_id;
  96         char            *layout_id;
  97         uint32_t        key;
  98 };
  99
 100 /*
 101  * Globals
 102  */
 103 static char *ofname;
 104 static char *progname;
 105
 106 static char *board_id;
 107 static struct board_info *board;
 108 static char *layout_id;
 109 static struct flash_layout *layout;
 110 static char *opt_hw_id;
 111 static uint32_t hw_id;
 112 static struct file_info firmware_info;
 113 static uint32_t firmware_len = 0;
 114
 115 static int inspect = 0;
 116 static int extract = 0;
 117
 118 static uint8_t key[][KEY_LEN] = {
 119   {0xC8, 0x3C, 0x3A, 0x93, 0xA2, 0x95, 0xC3, 0x63, 0x48, 0x45, 0x58, 0x09, 0x12, 0x03, 0x08},
 120   {0x89, 0x6B, 0x5A, 0x93, 0x92, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0xE6, 0xC7},
 121   {0xC9, 0x1C, 0x3A, 0x93, 0x92, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0xE6, 0xC7},
 122   {0x19, 0x1B, 0x3A, 0x93, 0x92, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0xE6, 0xC7},
 123   {0x79, 0x7B, 0x7A, 0x93, 0x92, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0xE6, 0xC7},
 124   {0x19, 0x1C, 0x4A, 0x93, 0x96, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0x16, 0xC6},
 125   {0x39, 0x1C, 0x4A, 0x93, 0x96, 0x95, 0xC3, 0x63, 0xD0, 0xA3, 0x9C, 0x92, 0x2E, 0x16, 0xC6},
 126 };
 127
 128 static struct flash_layout layouts[] = {
 129         {
 130                 .id             = "4M",
 131                 .fw_max_len     = 0x3c0000,
 132         }, {
 133                 .id             = "8M",
 134                 .fw_max_len     = 0x7c0000,
 135         }, {
 136                 /* terminating entry */
 137         }
 138 };
 139
 140 static struct board_info boards[] = {
 141         {
 142                 .id             = "MPR-A1",
 143                 .hw_id          = HWID_HAME_MPR_A1_L8,
 144                 .layout_id      = "4M",
 145                 .key            = KEY_HAME,
 146         }, {
 147                 .id             = "MPR-L8",
 148                 .hw_id          = HWID_HAME_MPR_A1_L8,
 149                 .layout_id      = "4M",
 150                 .key            = KEY_HAME,
 151         }, {
 152                 .id             = "R50B",
 153                 .hw_id          = HWID_PORAY_R50B,
 154                 .layout_id      = "4M",
 155                 .key            = KEY_PORAY_2,
 156         }, {
 157                 .id             = "R50D",
 158                 .hw_id          = HWID_PORAY_R50D,
 159                 .layout_id      = "4M",
 160                 .key            = KEY_PORAY_3,
 161         }, {
 162                 .id             = "R50E",
 163                 .hw_id          = HWID_PORAY_R50E,
 164                 .layout_id      = "4M",
 165                 .key            = KEY_PORAY_4,
 166         }, {
 167                 .id             = "M3",
 168                 .hw_id          = HWID_PORAY_M3,
 169                 .layout_id      = "4M",
 170                 .key            = KEY_PORAY_1,
 171         }, {
 172                 .id             = "M4",
 173                 .hw_id          = HWID_PORAY_M4,
 174                 .layout_id      = "4M",
 175                 .key            = KEY_PORAY_1,
 176         }, {
 177                 .id             = "Q3",
 178                 .hw_id          = HWID_PORAY_Q3,
 179                 .layout_id      = "4M",
 180                 .key            = KEY_PORAY_1,
 181         }, {
 182                 .id             = "X5 or X6",
 183                 .hw_id          = HWID_PORAY_X5_X6,
 184                 .layout_id      = "8M",
 185                 .key            = KEY_PORAY_1,
 186         }, {
 187                 .id             = "X5",
 188                 .hw_id          = HWID_PORAY_X5_X6,
 189                 .layout_id      = "8M",
 190                 .key            = KEY_PORAY_1,
 191         }, {
 192                 .id             = "X6",
 193                 .hw_id          = HWID_PORAY_X5_X6,
 194                 .layout_id      = "8M",
 195                 .key            = KEY_PORAY_1,
 196         }, {
 197                 .id             = "X8",
 198                 .hw_id          = HWID_PORAY_X8,
 199                 .layout_id      = "8M",
 200                 .key            = KEY_PORAY_1,
 201         }, {
 202                 .id             = "X1",
 203                 .hw_id          = HWID_PORAY_X1,
 204                 .layout_id      = "8M",
 205                 .key            = KEY_PORAY_1,
 206         }, {
 207                 .id             = "WT15XXX",
 208                 .hw_id          = HWID_NEXX_WT15XXX,
 209                 .layout_id      = "4M",
 210                 .key            = KEY_NEXX_1,
 211         }, {
 212                 .id             = "WT3020A",
 213                 .hw_id          = HWID_NEXX_WT3020A,
 214                 .layout_id      = "4M",
 215                 .key            = KEY_NEXX_2,
 216         }, {
 217                 /* terminating entry */
 218         }
 219 };
 220
 221 /*
 222  * Message macros
 223  */
 224 #define ERR(fmt, ...) do { \
 225         fflush(0); \
 226         fprintf(stderr, "[%s] *** error: " fmt "\n", \
 227                         progname, ## __VA_ARGS__ ); \
 228 } while (0)
 229
 230 #define ERRS(fmt, ...) do { \
 231         int save = errno; \
 232         fflush(0); \
 233         fprintf(stderr, "[%s] *** error: " fmt ":%s\n", \
 234                         progname, ## __VA_ARGS__, strerror(save)); \
 235 } while (0)
 236
 237 #define DBG(fmt, ...) do { \
 238         fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
 239 } while (0)
 240
 241 /*
 242  * Find a board by its name
 243  */
 244 static struct board_info *find_board(char *id)
 245 {
 246         struct board_info *ret;
 247         struct board_info *board;
 248
 249         ret = NULL;
 250         for (board = boards; board->id != NULL; board++){
 251                 if (strcasecmp(id, board->id) == 0) {
 252                         ret = board;
 253                         break;
 254                 }
 255         };
 256
 257         return ret;
 258 }
 259
 260 /*
 261  * Find a board by its hardware ID
 262  */
 263 static struct board_info *find_board_by_hwid(uint32_t hw_id)
 264 {
 265         struct board_info *board;
 266
 267         for (board = boards; board->id != NULL; board++) {
 268                 if (hw_id == board->hw_id)
 269                         return board;
 270         };
 271
 272         return NULL;
 273 }
 274
 275 /*
 276  * Find a Flash memory layout by its name
 277  */
 278 static struct flash_layout *find_layout(char *id)
 279 {
 280         struct flash_layout *ret;
 281         struct flash_layout *l;
 282
 283         ret = NULL;
 284         for (l = layouts; l->id != NULL; l++){
 285                 if (strcasecmp(id, l->id) == 0) {
 286                         ret = l;
 287                         break;
 288                 }
 289         };
 290
 291         return ret;
 292 }
 293
 294 /*
 295  * Display usage
 296  */
 297 static void usage(int status)
 298 {
 299         FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
 300
 301         fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
 302         fprintf(stream,
 303 "\n"
 304 "Options:\n"
 305 "  -B <board>      create image for the board specified with <board>\n"
 306 "  -H <hwid>       use hardware id specified with <hwid>\n"
 307 "  -F <id>         use flash layout specified with <id>\n"
 308 "  -f <file>       read firmware image from the file <file>\n"
 309 "  -o <file>       write output to the file <file>\n"
 310 "  -i              inspect given firmware file (requires -f)\n"
 311 "  -x              extract combined kernel and rootfs while inspecting (implies -i)\n"
 312 "  -h              show this screen\n"
 313         );
 314
 315         exit(status);
 316 }
 317
 318 /*
 319  * Get file statistics
 320  */
 321 static int get_file_stat(struct file_info *fdata)
 322 {
 323         struct stat st;
 324         int res;
 325
 326         if (fdata->file_name == NULL) {
 327                 return 0;
 328         }
 329         res = stat(fdata->file_name, &st);
 330         if (res){
 331                 ERRS("stat failed on %s", fdata->file_name);
 332                 return res;
 333         }
 334
 335         fdata->file_size = st.st_size;
 336         return 0;
 337 }
 338
 339 /*
 340  * Read file into buffer
 341  */
 342 static int read_to_buf(struct file_info *fdata, uint8_t *buf)
 343 {
 344         FILE *f;
 345         int ret = EXIT_FAILURE;
 346
 347         f = fopen(fdata->file_name, "rb");
 348         if (f == NULL) {
 349                 ERRS("could not open \"%s\" for reading", fdata->file_name);
 350                 goto out;
 351         }
 352
 353         errno = 0;
 354         fread(buf, fdata->file_size, 1, f);
 355         if (errno != 0) {
 356                 ERRS("unable to read from file \"%s\"", fdata->file_name);
 357                 goto out_close;
 358         }
 359
 360         ret = EXIT_SUCCESS;
 361
 362  out_close:
 363         fclose(f);
 364  out:
 365         return ret;
 366 }
 367
 368 /*
 369  * Check command line options
 370  */
 371 static int check_options(void)
 372 {
 373         int ret;
 374
 375         if (firmware_info.file_name == NULL) {
 376                 ERR("no firmware image specified");
 377                 return -1;
 378         }
 379
 380         ret = get_file_stat(&firmware_info);
 381         if (ret)
 382                 return ret;
 383
 384         if (inspect)
 385                 return 0;
 386
 387         if (board_id == NULL && opt_hw_id == NULL) {
 388                 ERR("either board or hardware id must be specified");
 389                 return -1;
 390         }
 391
 392         if (board_id) {
 393                 board = find_board(board_id);
 394                 if (board == NULL) {
 395                         ERR("unknown/unsupported board id \"%s\"", board_id);
 396                         return -1;
 397                 }
 398                 if (layout_id == NULL) {
 399                         layout_id = board->layout_id;
 400                 }
 401                 hw_id = board->hw_id;
 402         } else {
 403                 hw_id = strtoul(opt_hw_id, NULL, 0);
 404                 board = find_board_by_hwid(hw_id);
 405                 if (layout_id == NULL) {
 406                         layout_id = board->layout_id;
 407                 }
 408         }
 409
 410         layout = find_layout(layout_id);
 411         if (layout == NULL) {
 412                 ERR("unknown flash layout \"%s\"", layout_id);
 413                 return -1;
 414         }
 415
 416         firmware_len = firmware_info.file_size;
 417
 418         if (firmware_info.file_size >
 419                 layout->fw_max_len - sizeof (struct fw_header)) {
 420                 ERR("firmware image is too big");
 421                 return -1;
 422         }
 423
 424         if (ofname == NULL) {
 425                 ERR("no output file specified");
 426                 return -1;
 427         }
 428         return 0;
 429 }
 430
 431 /*
 432  * Fill in firmware header
 433  */
 434 static void fill_header(uint8_t *buf)
 435 {
 436         struct fw_header *hdr = (struct fw_header *) buf;
 437
 438         memset(hdr, 0, sizeof (struct fw_header));
 439         hdr->hw_id = HOST_TO_LE32(hw_id);
 440         hdr->firmware_len = HOST_TO_LE32(firmware_len);
 441         hdr->flags = HOST_TO_LE32(HEADER_FLAGS);
 442 }
 443
 444 /*
 445  * Compute firmware checksum
 446  */
 447 static uint16_t checksum_fw(uint8_t *data, int len)
 448 {
 449         int i;
 450         int32_t checksum = 0;
 451
 452         for (i = 0; i < len - 1; i += 2) {
 453                 checksum += (data[i + 1] << 8) | data[i];
 454         }
 455         if (i < len) {
 456                 checksum += data[i];
 457         }
 458         checksum = checksum + (checksum >> 16) + 0xffff;
 459         checksum = ~(checksum + (checksum >> 16)) & 0xffff;
 460         return (uint16_t) checksum;
 461 }
 462
 463 /*
 464  * (De)obfuscate firmware using an XOR operation with a fixed length key
 465  */
 466 static void xor_fw(uint8_t *data, int len)
 467 {
 468         int i;
 469
 470         for (i = 0; i <= len; i++) {
 471                 data[i] ^= key[board->key][i % KEY_LEN];
 472         }
 473 }
 474
 475 /*
 476  * Write firmware to file
 477  */
 478 static int write_fw(uint8_t *data, int len)
 479 {
 480         FILE *f;
 481         int ret = EXIT_FAILURE;
 482
 483         f = fopen(ofname, "wb");
 484         if (f == NULL) {
 485                 ERRS("could not open \"%s\" for writing", ofname);
 486                 goto out;
 487         }
 488
 489         errno = 0;
 490         fwrite(data, len, 1, f);
 491         if (errno) {
 492                 ERRS("unable to write output file");
 493                 goto out_flush;
 494         }
 495
 496         DBG("firmware file \"%s\" completed", ofname);
 497
 498         ret = EXIT_SUCCESS;
 499
 500  out_flush:
 501         fflush(f);
 502         fclose(f);
 503         if (ret != EXIT_SUCCESS) {
 504                 unlink(ofname);
 505         }
 506  out:
 507         return ret;
 508 }
 509
 510 /*
 511  * Build firmware file
 512  */
 513 static int build_fw(void)
 514 {
 515         int buflen;
 516         uint8_t *buf, *p;
 517         int ret = EXIT_FAILURE;
 518         int writelen = 0;
 519         uint16_t checksum;
 520
 521         buflen = layout->fw_max_len;
 522
 523         buf = (uint8_t *) malloc(buflen);
 524         if (!buf) {
 525                 ERR("no memory for buffer\n");
 526                 goto out;
 527         }
 528
 529         memset(buf, 0xff, buflen);
 530         p = buf + sizeof (struct fw_header);
 531         ret = read_to_buf(&firmware_info, p);
 532         if (ret) {
 533                 goto out_free_buf;
 534         }
 535         writelen = sizeof (struct fw_header) + firmware_len + 2;
 536
 537         /* Fill in header */
 538         fill_header(buf);
 539
 540         /* Compute firmware checksum */
 541         checksum = checksum_fw(buf + sizeof (struct fw_header), firmware_len);
 542
 543         /* Cannot use network order function because checksum is not word-aligned */
 544         buf[writelen - 1] = checksum >> 8;
 545         buf[writelen - 2] = checksum & 0xff;
 546
 547         /* XOR obfuscate firmware */
 548         xor_fw(buf + sizeof (struct fw_header), firmware_len + 2);
 549
 550         /* Write firmware file */
 551         ret = write_fw(buf, writelen);
 552         if (ret) {
 553                 goto out_free_buf;
 554         }
 555         ret = EXIT_SUCCESS;
 556
 557  out_free_buf:
 558         free(buf);
 559  out:
 560         return ret;
 561 }
 562
 563 /* Helper functions to inspect_fw() representing different output formats */
 564 static inline void inspect_fw_pstr(char *label, char *str)
 565 {
 566         printf("%-23s: %s\n", label, str);
 567 }
 568
 569 static inline void inspect_fw_phex(char *label, uint32_t val)
 570 {
 571         printf("%-23s: 0x%08x\n", label, val);
 572 }
 573
 574 static inline void inspect_fw_phexpost(char *label,
 575                                        uint32_t val, char *post)
 576 {
 577         printf("%-23s: 0x%08x (%s)\n", label, val, post);
 578 }
 579
 580 static inline void inspect_fw_phexdef(char *label,
 581                                       uint32_t val, uint32_t defval)
 582 {
 583         printf("%-23s: 0x%08x                  ", label, val);
 584
 585         if (val == defval) {
 586                 printf("(== OpenWrt default)\n");
 587         } else {
 588                 printf("(OpenWrt default: 0x%08x)\n", defval);
 589         }
 590 }
 591
 592 static inline void inspect_fw_phexexp(char *label,
 593                                       uint32_t val, uint32_t expval)
 594 {
 595         printf("%-23s: 0x%08x ", label, val);
 596
 597         if (val == expval) {
 598                 printf("(ok)\n");
 599         } else {
 600                 printf("(expected: 0x%08x)\n", expval);
 601         }
 602 }
 603
 604 static inline void inspect_fw_phexdec(char *label, uint32_t val)
 605 {
 606         printf("%-23s: 0x%08x / %8u bytes\n", label, val, val);
 607 }
 608
 609 static inline void inspect_fw_pchecksum(char *label,
 610                                         uint16_t val, uint16_t expval)
 611 {
 612         printf("%-23s: 0x%04x     ", label, val);
 613         if (val == expval) {
 614                 printf("(ok)\n");
 615         } else {
 616                 printf("(expected: 0x%04x)\n", expval);
 617         }
 618 }
 619
 620 static int inspect_fw(void)
 621 {
 622         uint8_t *buf;
 623         struct fw_header *hdr;
 624         int ret = EXIT_FAILURE;
 625         uint16_t computed_checksum, file_checksum;
 626
 627         buf = (uint8_t *) malloc(firmware_info.file_size);
 628         if (!buf) {
 629                 ERR("no memory for buffer!\n");
 630                 goto out;
 631         }
 632
 633         ret = read_to_buf(&firmware_info, buf);
 634         if (ret) {
 635                 goto out_free_buf;
 636         }
 637         hdr = (struct fw_header *)buf;
 638
 639         inspect_fw_pstr("File name", firmware_info.file_name);
 640         inspect_fw_phexdec("File size", firmware_info.file_size);
 641
 642         printf("\n");
 643
 644         inspect_fw_phexdec("Header size", sizeof (struct fw_header));
 645         board = find_board_by_hwid(LE32_TO_HOST(hdr->hw_id));
 646         if (board) {
 647                 layout = find_layout(board->layout_id);
 648                 inspect_fw_phexpost("Hardware ID",
 649                                     LE32_TO_HOST( hdr->hw_id), board->id);
 650         } else {
 651                 inspect_fw_phexpost("Hardware ID",
 652                                     LE32_TO_HOST(hdr->hw_id), "unknown");
 653         }
 654         inspect_fw_phexdec("Firmware data length",
 655                            LE32_TO_HOST(hdr->firmware_len));
 656
 657         inspect_fw_phexexp("Flags",
 658                            LE32_TO_HOST(hdr->flags), HEADER_FLAGS);
 659         printf("\n");
 660
 661         /* XOR unobfuscate firmware */
 662         xor_fw(buf + sizeof (struct fw_header), LE32_TO_HOST(hdr->firmware_len) + 2);
 663
 664         /* Compute firmware checksum */
 665         computed_checksum = checksum_fw(buf + sizeof (struct fw_header), LE32_TO_HOST(hdr->firmware_len));
 666
 667         /* Cannot use network order function because checksum is not word-aligned */
 668         file_checksum = (buf[firmware_info.file_size - 1] << 8) | buf[firmware_info.file_size - 2];
 669         inspect_fw_pchecksum("Firmware checksum", computed_checksum, file_checksum);
 670
 671         /* Verify checksum */
 672         if (computed_checksum != file_checksum) {
 673                 ret = -1;
 674                 ERR("checksums do not match");
 675                 goto out_free_buf;
 676         }
 677
 678         printf("\n");
 679
 680         if (extract) {
 681                 FILE *fp;
 682                 char *filename;
 683
 684                 if (ofname == NULL) {
 685                         filename = malloc(strlen(firmware_info.file_name) + 10);
 686                         sprintf(filename, "%s-firmware", firmware_info.file_name);
 687                 } else {
 688                         filename = ofname;
 689                 }
 690                 printf("Extracting firmware to \"%s\"...\n", filename);
 691                 fp = fopen(filename, "wb");
 692                 if (fp) {
 693                   if (!fwrite(buf + sizeof (struct fw_header),
 694                                     LE32_TO_HOST(hdr->firmware_len), 1, fp)) {
 695                                 ERRS("error in fwrite(): %s", strerror(errno));
 696                         }
 697                         fclose(fp);
 698                 } else {
 699                         ERRS("error in fopen(): %s", strerror(errno));
 700                 }
 701                 if (ofname == NULL) {
 702                         free(filename);
 703                 }
 704                 printf("\n");
 705         }
 706
 707  out_free_buf:
 708         free(buf);
 709  out:
 710         return ret;
 711 }
 712
 713 /*
 714  * Main entry point
 715  */
 716 int main(int argc, char *argv[])
 717 {
 718         int ret = EXIT_FAILURE;
 719
 720         progname = basename(argv[0]);
 721
 722         int c;
 723
 724         while ((c = getopt(argc, argv, "B:H:F:f:o:ixh")) != -1) {
 725                 switch (c) {
 726                 case 'B':
 727                         board_id = optarg;
 728                         break;
 729                 case 'H':
 730                         opt_hw_id = optarg;
 731                         break;
 732                 case 'F':
 733                         layout_id = optarg;
 734                         break;
 735                 case 'f':
 736                         firmware_info.file_name = optarg;
 737                         break;
 738                 case 'o':
 739                         ofname = optarg;
 740                         break;
 741                 case 'i':
 742                         inspect = 1;
 743                         break;
 744                 case 'x':
 745                         inspect = 1;
 746                         extract = 1;
 747                         break;
 748                 case 'h':
 749                         usage(EXIT_SUCCESS);
 750                         break;
 751                 default:
 752                         usage(EXIT_FAILURE);
 753                         break;
 754                 }
 755         }
 756
 757         ret = check_options();
 758         if (ret) {
 759                 goto out;
 760         }
 761         if (!inspect) {
 762                 ret = build_fw();
 763         } else {
 764                 ret = inspect_fw();
 765         }
 766
 767  out:
 768         return ret;
 769 }