tools/firmware-utils/src/mkfwimage2.c

   1 /*
   2  * Copyright (C) 2007 Ubiquiti Networks, Inc.
   3  * Copyright (C) 2008 Lukas Kuna <ValXdater@seznam.cz>
   4  * Copyright (C) 2008 Gabor Juhos <juhosg@openwrt.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <zlib.h>
  28 #include <sys/mman.h>
  29 #include <netinet/in.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <limits.h>
  33 #include "fw.h"
  34
  35 #undef VERSION
  36 #define VERSION "1.2-OpenWrt.1"
  37
  38 #define MAX_SECTIONS            8
  39 #define DEFAULT_OUTPUT_FILE     "firmware-image.bin"
  40 #define DEFAULT_VERSION         "UNKNOWN"
  41 #define DEFAULT_FLASH_BASE      (0xbfc00000)
  42
  43 #define FIRMWARE_MAX_LENGTH     (0x390000)
  44
  45 typedef struct part_data {
  46         char            partition_name[64];
  47         int             partition_index;
  48         u_int32_t       partition_baseaddr;
  49         u_int32_t       partition_offset;
  50         u_int32_t       partition_memaddr;
  51         u_int32_t       partition_entryaddr;
  52         u_int32_t       partition_length;
  53
  54         char            filename[PATH_MAX];
  55         struct stat     stats;
  56 } part_data_t;
  57
  58 typedef struct image_info {
  59         char            version[256];
  60         char            outputfile[PATH_MAX];
  61         char            magic[MAGIC_LENGTH];
  62         u_int32_t       flash_baseaddr;
  63         u_int32_t       part_count;
  64         part_data_t     parts[MAX_SECTIONS];
  65 } image_info_t;
  66
  67 static image_info_t im;
  68 static int debug = 0;
  69 static int zero_part_baseaddr = 0;
  70
  71 static void write_header(void* mem, const char* version)
  72 {
  73         header_t* header = mem;
  74         memset(header, 0, sizeof(header_t));
  75
  76         memcpy(header->magic, im.magic, MAGIC_LENGTH);
  77         strncpy(header->version, version, sizeof(header->version));
  78         header->crc = htonl(crc32(0L, (unsigned char *)header,
  79                                 sizeof(header_t) - 2 * sizeof(u_int32_t)));
  80         header->pad = 0L;
  81 }
  82
  83 static void write_signature(void* mem, u_int32_t sig_offset)
  84 {
  85         /* write signature */
  86         signature_t* sign = (signature_t*)(mem + sig_offset);
  87         memset(sign, 0, sizeof(signature_t));
  88
  89         memcpy(sign->magic, MAGIC_END, MAGIC_LENGTH);
  90         sign->crc = htonl(crc32(0L,(unsigned char *)mem, sig_offset));
  91         sign->pad = 0L;
  92 }
  93
  94 static int write_part(void* mem, part_data_t* d)
  95 {
  96         char* addr;
  97         int fd;
  98         part_t* p = mem;
  99         part_crc_t* crc = mem + sizeof(part_t) + d->stats.st_size;
 100
 101         fd = open(d->filename, O_RDONLY);
 102         if (fd < 0) {
 103                 ERROR("Failed opening file '%s'\n", d->filename);
 104                 return -1;
 105         }
 106
 107         if ((addr=(char*)mmap(0, d->stats.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 108                 ERROR("Failed mmaping memory for file '%s'\n", d->filename);
 109                 close(fd);
 110                 return -2;
 111         }
 112
 113         memcpy(mem + sizeof(part_t), addr, d->stats.st_size);
 114         munmap(addr, d->stats.st_size);
 115
 116         memset(p->name, 0, sizeof(p->name));
 117         strncpy(p->magic, MAGIC_PART, MAGIC_LENGTH);
 118         strncpy(p->name, d->partition_name, sizeof(p->name));
 119         p->index = htonl(d->partition_index);
 120         p->data_size = htonl(d->stats.st_size);
 121         p->part_size = htonl(d->partition_length);
 122         p->baseaddr = htonl(d->partition_baseaddr);
 123         p->memaddr = htonl(d->partition_memaddr);
 124         p->entryaddr = htonl(d->partition_entryaddr);
 125
 126         crc->crc = htonl(crc32(0L, mem, d->stats.st_size + sizeof(part_t)));
 127         crc->pad = 0L;
 128
 129         return 0;
 130 }
 131
 132 static void usage(const char* progname)
 133 {
 134         INFO("Version %s\n"
 135              "Usage: %s [options]\n"
 136              "\t-v <version string>\t - firmware version information, default: %s\n"
 137              "\t-m <magic>\t\t - firmware magic, default: %s\n"
 138              "\t-f <flash base>\t\t - flash base address, default: 0x%08x\n"
 139              "\t-o <output file>\t - firmware output file, default: %s\n"
 140              "\t-p <name>:<offset>:<len>:<memaddr>:<entry>:<file>\n "
 141              "\t\t\t\t - create a partition from <file>\n"
 142              "\t-z\t\t\t - set partition offsets to zero\n"
 143              "\t-h\t\t\t - this help\n",
 144              VERSION, progname, DEFAULT_VERSION, MAGIC_HEADER,
 145              DEFAULT_FLASH_BASE, DEFAULT_OUTPUT_FILE);
 146 }
 147
 148 static void print_image_info(void)
 149 {
 150         int i;
 151
 152         INFO("Firmware version : '%s'\n"
 153              "Output file      : '%s'\n"
 154              "Part count       : %u\n",
 155              im.version, im.outputfile, im.part_count);
 156
 157         for (i = 0; i < im.part_count; ++i) {
 158                 const part_data_t* d = &im.parts[i];
 159                 INFO("  %10s: %08x %08x %08x %08x %8ld bytes (free: %8ld)\n",
 160                      d->partition_name,
 161                      d->partition_baseaddr,
 162                      d->partition_length,
 163                      d->partition_entryaddr,
 164                      d->partition_memaddr,
 165                      d->stats.st_size,
 166                      d->partition_length - d->stats.st_size);
 167         }
 168 }
 169
 170 static int filelength(const char* file)
 171 {
 172         FILE *p;
 173         int ret = -1;
 174
 175         if ( (p = fopen(file, "rb") ) == NULL) return (-1);
 176
 177         fseek(p, 0, SEEK_END);
 178         ret = ftell(p);
 179
 180         fclose (p);
 181
 182         return (ret);
 183 }
 184
 185 int str2u32(char *arg, u_int32_t *val)
 186 {
 187         char *err = NULL;
 188         uint32_t t;
 189
 190         errno = 0;
 191         t = strtoul(arg, &err, 0);
 192         if (errno || (err == arg) || ((err != NULL) && *err)) {
 193                 return -1;
 194         }
 195
 196         *val = t;
 197         return 0;
 198 }
 199
 200 static int image_layout_add_partition(const char *part_desc)
 201 {
 202         part_data_t *d;
 203         char memaddr[16];
 204         char entryaddr[16];
 205         char offset[16];
 206         char length[16];
 207         int t;
 208
 209         if (im.part_count >= MAX_SECTIONS) {
 210                 ERROR("Too many partitions specified\n");
 211                 return (-1);
 212         }
 213
 214         d = &im.parts[im.part_count];
 215         t = sscanf(part_desc, "%15[a-zA-Z]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%256s",
 216                         d->partition_name,
 217                         offset,
 218                         length,
 219                         memaddr,
 220                         entryaddr,
 221                         d->filename);
 222
 223         if (t != 6) {
 224                 ERROR("Bad partition parameter %d, '%s'\n", t, part_desc);
 225                 return (-1);
 226         }
 227
 228         if (strlen(d->partition_name) == 0) {
 229                 ERROR("No partition name specified in '%s'\n", part_desc);
 230                 return (-1);
 231         }
 232
 233         if (str2u32(offset, &d->partition_offset)) {
 234                 ERROR("Bad offset value '%s'\n", offset);
 235                 return (-1);
 236         }
 237
 238         if (str2u32(length, &d->partition_length)) {
 239                 ERROR("Bad length value '%s'\n", length);
 240                 return (-1);
 241         }
 242
 243         if (d->partition_length == 0) {
 244                 int flen;
 245                 flen = filelength(d->filename);
 246                 if (flen < 0) {
 247                         ERROR("Unable to determine size of '%s'\n",
 248                                         d->filename);
 249                         return (-1);
 250                 }
 251                 d->partition_length = flen;
 252         }
 253
 254         if (str2u32(memaddr, &d->partition_memaddr)) {
 255                 ERROR("Bad memaddr vaule '%s'\n", memaddr);
 256                 return (-1);
 257         }
 258
 259         if (str2u32(entryaddr, &d->partition_entryaddr)) {
 260                 ERROR("Bad entry address value '%s'\n", entryaddr);
 261                 return (-1);
 262         }
 263
 264         im.part_count++;
 265         d->partition_index = im.part_count;
 266
 267         return 0;
 268 }
 269
 270 static int image_layout_verify(void)
 271 {
 272         u_int32_t offset;
 273         int i;
 274
 275         if (im.part_count == 0) {
 276                 ERROR("No partitions specified\n");
 277                 return -1;
 278         }
 279
 280         offset = im.parts[0].partition_offset;
 281         for (i = 0; i < im.part_count; i++)
 282         {
 283                 part_data_t* d = &im.parts[i];
 284
 285                 if (stat(d->filename, &d->stats) < 0) {
 286                         ERROR("Couldn't stat file '%s' from part '%s'\n",
 287                                         d->filename, d->partition_name);
 288                         return -2;
 289                 }
 290
 291                 if (d->stats.st_size == 0) {
 292                         ERROR("File '%s' from part '%s' is empty!\n",
 293                                         d->filename, d->partition_name);
 294                         return -3;
 295                 }
 296
 297                 if (d->stats.st_size > d->partition_length) {
 298                         ERROR("File '%s' too big (%d) - max size: 0x%08X (exceeds %lu bytes)\n",
 299                                 d->filename, i, d->partition_length,
 300                                 d->stats.st_size - d->partition_length);
 301                         return -4;
 302                 }
 303
 304                 if (d->partition_offset < offset)
 305                         d->partition_offset = offset;
 306
 307                 if (zero_part_baseaddr) {
 308                         d->partition_baseaddr = 0;
 309                 } else {
 310                         d->partition_baseaddr =
 311                                 im.flash_baseaddr + d->partition_offset;
 312                 }
 313                 offset += d->partition_length;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int build_image(void)
 320 {
 321         char* mem;
 322         char* ptr;
 323         u_int32_t mem_size;
 324         FILE* f;
 325         int i;
 326
 327         /* build in-memory buffer */
 328         mem_size = sizeof(header_t) + sizeof(signature_t);
 329         for (i = 0; i < im.part_count; ++i) {
 330                 part_data_t* d = &im.parts[i];
 331                 mem_size += sizeof(part_t) + d->stats.st_size + sizeof(part_crc_t);
 332         }
 333
 334         mem = (char*)calloc(mem_size, 1);
 335         if (mem == NULL) {
 336                 ERROR("Cannot allocate memory chunk of size '%u'\n", mem_size);
 337                 return -1;
 338         }
 339
 340         /* write header */
 341         write_header(mem, im.version);
 342         ptr = mem + sizeof(header_t);
 343
 344         /* write all parts */
 345         for (i = 0; i < im.part_count; ++i) {
 346                 part_data_t* d = &im.parts[i];
 347                 int rc;
 348                 if ((rc = write_part(ptr, d)) != 0) {
 349                         ERROR("ERROR: failed writing part %u '%s'\n", i, d->partition_name);
 350                         return -1;
 351                 }
 352                 ptr += sizeof(part_t) + d->stats.st_size + sizeof(part_crc_t);
 353         }
 354
 355
 356         /* write signature */
 357         write_signature(mem, mem_size - sizeof(signature_t));
 358
 359         /* write in-memory buffer into file */
 360         if ((f = fopen(im.outputfile, "w")) == NULL) {
 361                 ERROR("Can not create output file: '%s'\n", im.outputfile);
 362                 return -10;
 363         }
 364
 365         if (fwrite(mem, mem_size, 1, f) != 1) {
 366                 ERROR("Could not write %d bytes into file: '%s'\n",
 367                                 mem_size, im.outputfile);
 368                 return -11;
 369         }
 370
 371         free(mem);
 372         fclose(f);
 373         return 0;
 374 }
 375
 376 int main(int argc, char* argv[])
 377 {
 378         int o, rc;
 379
 380         memset(&im, 0, sizeof(im));
 381
 382         strcpy(im.outputfile, DEFAULT_OUTPUT_FILE);
 383         strcpy(im.version, DEFAULT_VERSION);
 384         memcpy(im.magic, MAGIC_HEADER, MAGIC_LENGTH);
 385         im.flash_baseaddr = DEFAULT_FLASH_BASE;
 386
 387         while ((o = getopt(argc, argv, "f:hm:o:p:v:z")) != -1)
 388         {
 389                 switch (o) {
 390                 case 'f':
 391                         if (optarg)
 392                                 if (str2u32(optarg, &im.flash_baseaddr)) {
 393                                         ERROR("Invalid flash start address %s\n", optarg);
 394                                         return -1;
 395                                 }
 396                         break;
 397                 case 'h':
 398                         usage(argv[0]);
 399                         return -1;
 400                 case 'm':
 401                         if (optarg) {
 402                                 if (strlen(optarg) != MAGIC_LENGTH) {
 403                                         ERROR("Invalid magic %s\n", optarg);
 404                                         return -1;
 405                                 }
 406
 407                                 memcpy(im.magic, optarg, MAGIC_LENGTH);
 408                         }
 409                         break;
 410                 case 'o':
 411                         if (optarg)
 412                                 strncpy(im.outputfile, optarg, sizeof(im.outputfile));
 413                         break;
 414                 case 'p':
 415                         if (optarg) {
 416                                 if (image_layout_add_partition(optarg))
 417                                         return -1;
 418                         }
 419                         break;
 420                 case 'v':
 421                         if (optarg)
 422                                 strncpy(im.version, optarg, sizeof(im.version));
 423                         break;
 424                 case 'z':
 425                         zero_part_baseaddr = 1;
 426                         break;
 427                 }
 428         }
 429
 430         rc = image_layout_verify();
 431         if (rc) {
 432                 ERROR("Failed validating firmware layout - error code: %d\n",
 433                                 rc);
 434                 return -4;
 435         }
 436
 437         print_image_info();
 438
 439         rc = build_image();
 440         if (rc) {
 441                 ERROR("Failed building image file '%s' - error code: %d\n",
 442                                 im.outputfile, rc);
 443                 return -5;
 444         }
 445
 446         return 0;
 447 }