rbutil/mkamsboot/mkamsboot.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * mkamsboot.c - a tool for merging bootloader code into an Sansa V2
  11  *               (AMS) firmware file
  12  *
  13  * Copyright (C) 2008 Dave Chapman
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21  * KIND, either express or implied.
  22  *
  23  ****************************************************************************/
  24
  25 /*
  26
  27 Insert a Rockbox bootloader into a Sansa AMS original firmware file.
  28
  29 Layout of a Sansa AMS original firmware file:
  30
  31  ----------------------  0x0
  32 |        HEADER        |
  33 |----------------------| 0x400
  34 |    FIRMWARE BLOCK    | (contains the OF version on some fuzev2 firmwares
  35 |----------------------| 0x600
  36 |    FIRMWARE BLOCK    |
  37 |----------------------| 0x400 + firmware block size
  38 |    LIBRARIES/DATA    |
  39  ----------------------  END
  40
  41 We replace the main firmware block while preserving the potential OF version
  42 (bytes 0x600..0x400+firmware_size) as follows:
  43
  44
  45  ----------------------  0x0
  46 |                      |
  47 |    Dual-boot code    |
  48 |                      |
  49 |----------------------|
  50 |     EMPTY SPACE      |
  51 |----------------------|
  52 |                      |
  53 | compressed RB image  |
  54 |                      |
  55 |----------------------|
  56 |                      |
  57 | compressed OF image  |
  58 |                      |
  59 |----------------------|
  60 | UCL unpack function  |
  61  ----------------------
  62
  63 This entire block fits into the space previously occupied by the main
  64 firmware block - the space saved by compressing the OF image is used
  65 to store the compressed version of the Rockbox bootloader.
  66
  67 On version 1 firmwares, the OF image is typically about 120KB, which allows
  68 us to store a Rockbox bootloader with an uncompressed size of about 60KB-70KB.
  69 Version 2 firmwares are bigger and are stored in SDRAM (instead of IRAM).
  70 In both cases, the RAM we are using is mapped at offset 0x0.
  71
  72 mkamsboot then corrects the checksums and writes a new legal firmware
  73 file which can be installed on the device.
  74
  75 When the Sansa device boots, this firmware block is loaded to RAM at
  76 address 0x0 and executed.
  77
  78 Firstly, the dual-boot code will copy the UCL unpack function to the
  79 end of RAM.
  80
  81 Then, depending on the detection of the dual-boot keypress, either the
  82 OF image or the Rockbox image is copied to the end of RAM (just before
  83 the ucl unpack function) and uncompressed to the start of RAM.
  84
  85 Finally, the ucl unpack function branches to address 0x0, passing
  86 execution to the uncompressed firmware.
  87
  88
  89 */
  90
  91 #include <stdio.h>
  92 #include <stdlib.h>
  93 #include <stdint.h>
  94 #include <sys/types.h>
  95 #include <sys/stat.h>
  96 #include <fcntl.h>
  97 #include <unistd.h>
  98 #include <string.h>
  99
 100 #include <ucl/ucl.h>
 101
 102 #include "mkamsboot.h"
 103
 104 #include "md5.h"
 105
 106 /* Header for ARM code binaries */
 107 #include "dualboot.h"
 108
 109 /* Win32 compatibility */
 110 #ifndef O_BINARY
 111 #define O_BINARY 0
 112 #endif
 113
 114 /* fw_revision: version 2 is used in Clipv2, Clip+ and Fuzev2 firmwares */
 115 /* hw_revision: 4 for m200, 2 for e200/c200, 1 or 2 for fuze/clip, 1 for clip+ */
 116 const struct ams_models ams_identity[] = {
 117     [MODEL_C200V2]  = { 2, 1, "c200",  dualboot_c200v2,   sizeof(dualboot_c200v2),   "c2v2", 44 },
 118     [MODEL_CLIPPLUS]= { 1, 2, "Clip+", dualboot_clipplus, sizeof(dualboot_clipplus), "cli+", 66 },
 119     [MODEL_CLIPV2]  = { 2, 2, "Clip",  dualboot_clipv2,   sizeof(dualboot_clipv2),   "clv2", 60 },
 120     [MODEL_CLIP]    = { 1, 1, "Clip",  dualboot_clip,     sizeof(dualboot_clip),     "clip", 40 },
 121     [MODEL_E200V2]  = { 2, 1, "e200",  dualboot_e200v2,   sizeof(dualboot_e200v2),   "e2v2", 41 },
 122     [MODEL_FUZEV2]  = { 2, 2, "Fuze",  dualboot_fuzev2,   sizeof(dualboot_fuzev2),   "fuz2", 68 },
 123     [MODEL_FUZE]    = { 1, 1, "Fuze",  dualboot_fuze,     sizeof(dualboot_fuze),     "fuze", 43 },
 124     [MODEL_M200V4]  = { 4, 1, "m200",  dualboot_m200v4,   sizeof(dualboot_m200v4),   "m2v4", 42 },
 125 };
 126
 127
 128 /* Checksums of unmodified original firmwares - for safety, and device
 129    detection */
 130 static struct md5sums sansasums[] = {
 131     /* NOTE: Different regional versions of the firmware normally only
 132              differ in the filename - the md5sums are identical */
 133
 134     /*   model       version    md5                        */
 135     { MODEL_E200V2, "3.01.11", "e622ca8cb6df423f54b8b39628a1f0a3" },
 136     { MODEL_E200V2, "3.01.14", "2c1d0383fc3584b2cc83ba8cc2243af6" },
 137     { MODEL_E200V2, "3.01.16", "12563ad71b25a1034cf2092d1e0218c4" },
 138
 139     { MODEL_FUZE,   "1.01.11", "cac8ffa03c599330ac02c4d41de66166" },
 140     { MODEL_FUZE,   "1.01.15", "df0e2c1612727f722c19a3c764cff7f2" },
 141     { MODEL_FUZE,   "1.01.22", "5aff5486fe8dd64239cc71eac470af98" },
 142     { MODEL_FUZE,   "1.02.26", "7c632c479461c48c8833baed74eb5e4f" },
 143     { MODEL_FUZE,   "1.02.28", "5b34260f6470e75f702a9c6825471752" },
 144     { MODEL_FUZE,   "1.02.31", "66d01b37462a5ef7ccc6ad37188b4235" },
 145
 146     { MODEL_C200V2, "3.02.05", "b6378ebd720b0ade3fad4dc7ab61c1a5" },
 147
 148     { MODEL_M200V4, "4.00.45", "82e3194310d1514e3bbcd06e84c4add3" },
 149     { MODEL_M200V4, "4.01.08-A", "fc9dd6116001b3e6a150b898f1b091f0" },
 150     { MODEL_M200V4, "4.01.08-E", "d3fb7d8ec8624ee65bc99f8dab0e2369" },
 151
 152     { MODEL_CLIP,   "1.01.17", "12caad785d506219d73f538772afd99e" },
 153     { MODEL_CLIP,   "1.01.18", "d720b266bd5afa38a198986ef0508a45" },
 154     { MODEL_CLIP,   "1.01.20", "236d8f75189f468462c03f6d292cf2ac" },
 155     { MODEL_CLIP,   "1.01.29", "c12711342169c66e209540cd1f27cd26" },
 156     { MODEL_CLIP,   "1.01.30", "f2974d47c536549c9d8259170f1dbe4d" },
 157     { MODEL_CLIP,   "1.01.32", "d835d12342500732ffb9c4ee54abec15" },
 158     { MODEL_CLIP,   "1.01.35", "b4d0edb3b8f2a4e8eee0a344f7f8e480" },
 159
 160     { MODEL_CLIPV2, "2.01.16", "c57fb3fcbe07c2c9b360f060938f80cb" },
 161     { MODEL_CLIPV2, "2.01.32", "0ad3723e52022509089d938d0fbbf8c5" },
 162     { MODEL_CLIPV2, "2.01.35", "a3cbbd22b9508d7f8a9a1a39acc342c2" },
 163
 164     { MODEL_CLIPPLUS, "01.02.09", "656d38114774c2001dc18e6726df3c5d" },
 165     { MODEL_CLIPPLUS, "01.02.13", "5f89872b79ef440b0e5ee3a7a44328b2" },
 166     { MODEL_CLIPPLUS, "01.02.15", "680a4f521e790ad25b93b1b16f3a207d" },
 167
 168     { MODEL_FUZEV2, "2.01.17", "8b85fb05bf645d08a4c8c3e344ec9ebe" },
 169     { MODEL_FUZEV2, "2.02.26", "d4f6f85c3e4a8ea8f2e5acc421641801" },
 170     { MODEL_FUZEV2, "2.03.31", "74fb197ccd51707388f3b233402186a6" },
 171     { MODEL_FUZEV2, "2.03.33", "1599cc73d02ea7fe53fe2d4379c24b66" },
 172 };
 173
 174 #define NUM_MD5S (sizeof(sansasums)/sizeof(sansasums[0]))
 175
 176 static unsigned int model_memory_size(int model)
 177 {
 178     /* The OF boots with IRAM (320kB) mapped at 0x0 */
 179
 180     if(model == MODEL_CLIPV2)
 181     {
 182         /* The decompressed Clipv2 OF is around 380kB.
 183          * Let's use the full IRAM (1MB on AMSv2)
 184          */
 185         return 1 << 20;
 186     }
 187     else
 188     {
 189         /* The IRAM is 320kB on AMSv1, and 320 will be enough on Fuzev1/Clip+ */
 190         return 320 << 10;
 191     }
 192 }
 193
 194 int firmware_revision(int model)
 195 {
 196     return ams_identity[model].fw_revision;
 197 }
 198
 199 static off_t filesize(int fd)
 200 {
 201     struct stat buf;
 202
 203     if (fstat(fd, &buf) < 0) {
 204         perror("[ERR]  Checking filesize of input file");
 205         return -1;
 206     } else {
 207         return(buf.st_size);
 208     }
 209 }
 210
 211 static uint32_t get_uint32le(unsigned char* p)
 212 {
 213     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 214 }
 215
 216 static uint32_t get_uint32be(unsigned char* p)
 217 {
 218     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 219 }
 220
 221 static void put_uint32le(unsigned char* p, uint32_t x)
 222 {
 223     p[0] = x & 0xff;
 224     p[1] = (x >> 8) & 0xff;
 225     p[2] = (x >> 16) & 0xff;
 226     p[3] = (x >> 24) & 0xff;
 227 }
 228
 229 void calc_MD5(unsigned char* buf, int len, char *md5str)
 230 {
 231     int i;
 232     md5_context ctx;
 233     unsigned char md5sum[16];
 234
 235     md5_starts(&ctx);
 236     md5_update(&ctx, buf, len);
 237     md5_finish(&ctx, md5sum);
 238
 239     for (i = 0; i < 16; ++i)
 240         sprintf(md5str + 2*i, "%02x", md5sum[i]);
 241 }
 242
 243 /* Calculate a simple checksum used in Sansa Original Firmwares */
 244 static uint32_t calc_checksum(unsigned char* buf, uint32_t n)
 245 {
 246     uint32_t sum = 0;
 247     uint32_t i;
 248
 249     for (i=0;i<n;i+=4)
 250         sum += get_uint32le(buf + i);
 251
 252     return sum;
 253 }
 254
 255 /* Compress using nrv2e algorithm : Thumb decompressor fits in 168 bytes ! */
 256 static unsigned char* uclpack(unsigned char* inbuf, int insize, int* outsize)
 257 {
 258     int maxsize;
 259     unsigned char* outbuf;
 260     int r;
 261
 262     /* The following formula comes from the UCL documentation */
 263     maxsize = insize + (insize / 8) + 256;
 264
 265     /* Allocate some memory for the output buffer */
 266     outbuf = malloc(maxsize);
 267
 268     if (outbuf == NULL)
 269         return NULL;
 270
 271     r = ucl_nrv2e_99_compress(
 272             (const ucl_bytep) inbuf,
 273             (ucl_uint) insize,
 274             (ucl_bytep) outbuf,
 275             (ucl_uintp) outsize,
 276             0, 10, NULL, NULL);
 277
 278     if (r != UCL_E_OK || *outsize > maxsize) {
 279         /* this should NEVER happen, and implies memory corruption */
 280         fprintf(stderr, "internal error - compression failed: %d\n", r);
 281         free(outbuf);
 282         return NULL;
 283     }
 284
 285     return outbuf;
 286 }
 287
 288 #define ERROR(format, ...) \
 289     do { \
 290         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 291         goto error; \
 292     } while(0)
 293
 294 /* Loads a Sansa AMS Original Firmware file into memory */
 295 unsigned char* load_of_file(
 296         char* filename, int model, off_t* bufsize, struct md5sums *sum,
 297         int* firmware_size, unsigned char** of_packed,
 298         int* of_packedsize, char* errstr, int errstrsize)
 299 {
 300     int fd;
 301     unsigned char* buf =NULL;
 302     off_t n;
 303     unsigned int i=0;
 304     uint32_t checksum;
 305     unsigned int last_word;
 306
 307     fd = open(filename, O_RDONLY|O_BINARY);
 308     if (fd < 0)
 309         ERROR("[ERR]  Could not open %s for reading\n", filename);
 310
 311     *bufsize = filesize(fd);
 312
 313     buf = malloc(*bufsize);
 314     if (buf == NULL)
 315         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 316
 317     n = read(fd, buf, *bufsize);
 318
 319     if (n != *bufsize)
 320         ERROR("[ERR]  Could not read file %s\n", filename);
 321
 322     /* check the file */
 323
 324     /* Calculate MD5 checksum of OF */
 325     calc_MD5(buf, *bufsize, sum->md5);
 326
 327     while ((i < NUM_MD5S) && (strcmp(sansasums[i].md5, sum->md5) != 0))
 328         i++;
 329
 330     if (i < NUM_MD5S) {
 331         *sum = sansasums[i];
 332         if(sum->model != model) {
 333             ERROR("[ERR]  OF File provided is %sv%d version %s, not for %sv%d\n",
 334                 ams_identity[sum->model].model_name, ams_identity[sum->model].hw_revision,
 335                 sum->version, ams_identity[model].model_name, ams_identity[model].hw_revision
 336             );
 337         }
 338     } else {
 339         /* OF unknown, give a list of tested versions for the requested model */
 340
 341         char tested_versions[100];
 342         tested_versions[0] = '\0';
 343
 344         for (i = 0; i < NUM_MD5S ; i++)
 345             if (sansasums[i].model == model) {
 346                 if (tested_versions[0] != '\0') {
 347                     strncat(tested_versions, ", ",
 348                         sizeof(tested_versions) - strlen(tested_versions) - 1);
 349                 }
 350                 strncat(tested_versions, sansasums[i].version,
 351                     sizeof(tested_versions) - strlen(tested_versions) - 1);
 352             }
 353
 354         ERROR("[ERR]  Original firmware unknown, please try an other version." \
 355               " Tested %sv%d versions are : %s\n",
 356               ams_identity[model].model_name, ams_identity[model].hw_revision, tested_versions);
 357     }
 358
 359     /* TODO: Do some more sanity checks on the OF image. Some images (like
 360        m200v4) dont have a checksum at the end, only padding (0xdeadbeef). */
 361     last_word = *bufsize - 4;
 362     checksum = get_uint32le(buf + last_word);
 363     if (checksum != 0xefbeadde && checksum != calc_checksum(buf, last_word))
 364         ERROR("%s", "[ERR]  Whole file checksum failed\n");
 365
 366     if (ams_identity[sum->model].bootloader == NULL)
 367         ERROR("[ERR]  Unsupported model - \"%s\"\n", ams_identity[sum->model].model_name);
 368
 369     /* Get the firmware size */
 370     if (ams_identity[sum->model].fw_revision == 1)
 371         *firmware_size = get_uint32le(&buf[0x0c]);
 372     else if (ams_identity[sum->model].fw_revision == 2)
 373         *firmware_size = get_uint32le(&buf[0x10]);
 374
 375     /* Compress the original firmware image */
 376     *of_packed = uclpack(buf + 0x400, *firmware_size, of_packedsize);
 377     if (*of_packed == NULL)
 378         ERROR("[ERR]  Could not compress %s\n", filename);
 379
 380     return buf;
 381
 382 error:
 383     free(buf);
 384     return NULL;
 385 }
 386
 387 /* Loads a rockbox bootloader file into memory */
 388 unsigned char* load_rockbox_file(
 389             char* filename, int *model, int* bufsize, int* rb_packedsize,
 390             char* errstr, int errstrsize)
 391 {
 392     int fd;
 393     unsigned char* buf = NULL;
 394     unsigned char* packed = NULL;
 395     unsigned char header[8];
 396     uint32_t sum;
 397     off_t n;
 398     int i;
 399
 400     fd = open(filename, O_RDONLY|O_BINARY);
 401     if (fd < 0)
 402         ERROR("[ERR]  Could not open %s for reading\n", filename);
 403
 404     /* Read Rockbox header */
 405     n = read(fd, header, sizeof(header));
 406     if (n != sizeof(header))
 407         ERROR("[ERR]  Could not read file %s\n", filename);
 408
 409     for(*model = 0; *model < NUM_MODELS; (*model)++)
 410         if (memcmp(ams_identity[*model].rb_model_name, header + 4, 4) == 0)
 411             break;
 412
 413     if(*model == NUM_MODELS)
 414         ERROR("[ERR]  Model name \"%4.4s\" unknown. Is this really a rockbox bootloader?\n", header + 4);
 415
 416     *bufsize = filesize(fd) - sizeof(header);
 417
 418     buf = malloc(*bufsize);
 419     if (buf == NULL)
 420         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 421
 422     n = read(fd, buf, *bufsize);
 423
 424     if (n != *bufsize)
 425         ERROR("[ERR]  Could not read file %s\n", filename);
 426
 427     /* Check checksum */
 428     sum = ams_identity[*model].rb_model_num;
 429     for (i = 0; i < *bufsize; i++) {
 430          /* add 8 unsigned bits but keep a 32 bit sum */
 431          sum += buf[i];
 432     }
 433
 434     if (sum != get_uint32be(header))
 435         ERROR("[ERR]  Checksum mismatch in %s\n", filename);
 436
 437     packed = uclpack(buf, *bufsize, rb_packedsize);
 438     if(packed == NULL)
 439         ERROR("[ERR]  Could not compress %s\n", filename);
 440
 441     free(buf);
 442     return packed;
 443
 444 error:
 445     free(buf);
 446     return NULL;
 447 }
 448
 449 #undef ERROR
 450
 451 /* Patches a Sansa AMS Original Firmware file */
 452 void patch_firmware(
 453         int model, int fw_revision, int firmware_size, unsigned char* buf,
 454         int len, unsigned char* of_packed, int of_packedsize,
 455         unsigned char* rb_packed, int rb_packedsize)
 456 {
 457     unsigned char *p;
 458     uint32_t sum, filesum;
 459     uint32_t ucl_dest;
 460     unsigned int i;
 461
 462     /* Zero the original firmware area - not needed, but helps debugging */
 463     memset(buf + 0x600, 0, firmware_size);
 464
 465     /* Insert dual-boot bootloader at offset 0x200, we preserve the OF
 466      * version string located between 0x0 and 0x200 */
 467     memcpy(buf + 0x600, ams_identity[model].bootloader, ams_identity[model].bootloader_size);
 468
 469     /* Insert vectors, they won't overwrite the OF version string */
 470
 471     /* Reset vector: branch 0x200 bytes away, to our dualboot code */
 472     static const uint8_t b_0x200[4] = { 0x7e, 0x00, 0x00, 0xea }; // b 0x200
 473     memcpy(buf + 0x400, b_0x200, sizeof(b_0x200));
 474
 475     /* Other vectors: infinite loops */
 476     static const uint8_t b_1b[4]    = { 0xfe, 0xff, 0xff, 0xea }; // 1: b 1b
 477     for (i=1; i < 8; i++)
 478         memcpy(buf + 0x400 + 4*i, b_1b, sizeof(b_1b));
 479
 480     /* We are filling the firmware buffer backwards from the end */
 481     p = buf + 0x400 + firmware_size;
 482
 483     /* 1 - UCL unpack function */
 484     p -= sizeof(nrv2e_d8);
 485     memcpy(p, nrv2e_d8, sizeof(nrv2e_d8));
 486
 487     /* 2 - Compressed copy of original firmware */
 488     p -= of_packedsize;
 489     memcpy(p, of_packed, of_packedsize);
 490
 491     /* 3 - Compressed copy of Rockbox bootloader */
 492     p -= rb_packedsize;
 493     memcpy(p, rb_packed, rb_packedsize);
 494
 495     /* Write the locations of the various images to the variables at the
 496        start of the dualboot image - we save the location of the last byte
 497        in each image, along with the size in bytes */
 498
 499     /* UCL unpack function */
 500     put_uint32le(&buf[0x604], firmware_size - 1);
 501     put_uint32le(&buf[0x608], sizeof(nrv2e_d8));
 502
 503     /* Compressed original firmware image */
 504     put_uint32le(&buf[0x60c], firmware_size - sizeof(nrv2e_d8) - 1);
 505     put_uint32le(&buf[0x610], of_packedsize);
 506
 507     /* Compressed Rockbox image */
 508     put_uint32le(&buf[0x614], firmware_size - sizeof(nrv2e_d8) - of_packedsize
 509             - 1);
 510     put_uint32le(&buf[0x618], rb_packedsize);
 511
 512     ucl_dest = model_memory_size(model) - 1; /* last byte of memory */
 513     put_uint32le(&buf[0x61c], ucl_dest);
 514
 515     /* Update the firmware block checksum */
 516     sum = calc_checksum(buf + 0x400, firmware_size);
 517
 518     if (fw_revision == 1) {
 519         put_uint32le(&buf[0x04], sum);
 520         put_uint32le(&buf[0x204], sum);
 521     } else if (fw_revision == 2) {
 522         put_uint32le(&buf[0x08], sum);
 523         put_uint32le(&buf[0x208], sum);
 524
 525         /* Update the header checksums */
 526         put_uint32le(&buf[0x1fc], calc_checksum(buf, 0x1fc));
 527         put_uint32le(&buf[0x3fc], calc_checksum(buf + 0x200, 0x1fc));
 528     }
 529
 530     /* Update the whole-file checksum */
 531     filesum = 0;
 532     for (i=0;i < (unsigned)len - 4; i+=4)
 533         filesum += get_uint32le(&buf[i]);
 534
 535     put_uint32le(buf + len - 4, filesum);
 536 }
 537
 538 /* returns != 0 if the firmware can be safely patched */
 539 int check_sizes(int model, int rb_packed_size, int rb_unpacked_size,
 540         int of_packed_size, int of_unpacked_size, int *total_size,
 541         char *errstr, int errstrsize)
 542 {
 543     /* XXX: we keep the first 0x200 bytes block unmodified, we just replace
 544      * the ARM vectors */
 545     unsigned int packed_size = ams_identity[model].bootloader_size + sizeof(nrv2e_d8) +
 546             of_packed_size + rb_packed_size + 0x200;
 547
 548     /* how much memory is available */
 549     unsigned int memory_size = model_memory_size(model);
 550
 551     /* the memory used when unpacking the OF */
 552     unsigned int ram_of = sizeof(nrv2e_d8) + of_packed_size + of_unpacked_size;
 553
 554     /* the memory used when unpacking the bootloader */
 555     unsigned int ram_rb = sizeof(nrv2e_d8) + rb_packed_size + rb_unpacked_size;
 556
 557     *total_size = packed_size;
 558
 559 #define ERROR(format, ...) \
 560     do { \
 561         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 562         return 0; \
 563     } while(0)
 564
 565     /* will packed data fit in the OF file ? */
 566     if(packed_size > of_unpacked_size)
 567         ERROR(
 568             "[ERR]  Packed data (%d bytes) doesn't fit in the firmware "
 569             "(%d bytes)\n", packed_size, of_unpacked_size
 570             );
 571
 572     else if(ram_rb > memory_size)
 573         ERROR("[ERR]  Rockbox can't be unpacked at runtime, needs %d bytes "
 574             "of memory and only %d available\n", ram_rb, memory_size
 575             );
 576
 577     else if(ram_of > memory_size)
 578         ERROR("[ERR]  OF can't be unpacked at runtime, needs %d bytes "
 579             "of memory and only %d available\n", ram_of, memory_size
 580             );
 581
 582     return 1;
 583
 584 #undef ERROR
 585 }