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     [MODEL_CLIPZIP] = { 1, 2, "ClipZip", dualboot_clipzip, sizeof(dualboot_clipzip), "clzp", 79 },
 126 };
 127
 128
 129 /* Checksums of unmodified original firmwares - for safety, and device
 130    detection */
 131 static struct md5sums sansasums[] = {
 132     /* NOTE: Different regional versions of the firmware normally only
 133              differ in the filename - the md5sums are identical */
 134
 135     /*   model       version    md5                        */
 136     { MODEL_E200V2, "3.01.11", "e622ca8cb6df423f54b8b39628a1f0a3" },
 137     { MODEL_E200V2, "3.01.14", "2c1d0383fc3584b2cc83ba8cc2243af6" },
 138     { MODEL_E200V2, "3.01.16", "12563ad71b25a1034cf2092d1e0218c4" },
 139
 140     { MODEL_FUZE,   "1.01.11", "cac8ffa03c599330ac02c4d41de66166" },
 141     { MODEL_FUZE,   "1.01.15", "df0e2c1612727f722c19a3c764cff7f2" },
 142     { MODEL_FUZE,   "1.01.22", "5aff5486fe8dd64239cc71eac470af98" },
 143     { MODEL_FUZE,   "1.02.26", "7c632c479461c48c8833baed74eb5e4f" },
 144     { MODEL_FUZE,   "1.02.28", "5b34260f6470e75f702a9c6825471752" },
 145     { MODEL_FUZE,   "1.02.31", "66d01b37462a5ef7ccc6ad37188b4235" },
 146
 147     { MODEL_C200V2, "3.02.05", "b6378ebd720b0ade3fad4dc7ab61c1a5" },
 148
 149     { MODEL_M200V4, "4.00.45", "82e3194310d1514e3bbcd06e84c4add3" },
 150     { MODEL_M200V4, "4.01.08-A", "fc9dd6116001b3e6a150b898f1b091f0" },
 151     { MODEL_M200V4, "4.01.08-E", "d3fb7d8ec8624ee65bc99f8dab0e2369" },
 152
 153     { MODEL_CLIP,   "1.01.17", "12caad785d506219d73f538772afd99e" },
 154     { MODEL_CLIP,   "1.01.18", "d720b266bd5afa38a198986ef0508a45" },
 155     { MODEL_CLIP,   "1.01.20", "236d8f75189f468462c03f6d292cf2ac" },
 156     { MODEL_CLIP,   "1.01.29", "c12711342169c66e209540cd1f27cd26" },
 157     { MODEL_CLIP,   "1.01.30", "f2974d47c536549c9d8259170f1dbe4d" },
 158     { MODEL_CLIP,   "1.01.32", "d835d12342500732ffb9c4ee54abec15" },
 159     { MODEL_CLIP,   "1.01.35", "b4d0edb3b8f2a4e8eee0a344f7f8e480" },
 160
 161     { MODEL_CLIPV2, "2.01.16", "c57fb3fcbe07c2c9b360f060938f80cb" },
 162     { MODEL_CLIPV2, "2.01.32", "0ad3723e52022509089d938d0fbbf8c5" },
 163     { MODEL_CLIPV2, "2.01.35", "a3cbbd22b9508d7f8a9a1a39acc342c2" },
 164
 165     { MODEL_CLIPPLUS, "01.02.09", "656d38114774c2001dc18e6726df3c5d" },
 166     { MODEL_CLIPPLUS, "01.02.13", "5f89872b79ef440b0e5ee3a7a44328b2" },
 167     { MODEL_CLIPPLUS, "01.02.15", "680a4f521e790ad25b93b1b16f3a207d" },
 168     { MODEL_CLIPPLUS, "01.02.16", "055a53de1dfb09f6cb71c504ad48bd13" },
 169     { MODEL_CLIPPLUS, "01.02.18", "80b547244438b113e2a55ff0305f12c0" },
 170
 171     { MODEL_FUZEV2, "2.01.17", "8b85fb05bf645d08a4c8c3e344ec9ebe" },
 172     { MODEL_FUZEV2, "2.02.26", "d4f6f85c3e4a8ea8f2e5acc421641801" },
 173     { MODEL_FUZEV2, "2.03.31", "74fb197ccd51707388f3b233402186a6" },
 174     { MODEL_FUZEV2, "2.03.33", "1599cc73d02ea7fe53fe2d4379c24b66" },
 175
 176     { MODEL_CLIPZIP, "1.01.12", "45adea0873326b5af34f096e5c402f78" },
 177     { MODEL_CLIPZIP, "1.01.15", "f62af954334cd9ba1a87a7fa58ec6074" },
 178     { MODEL_CLIPZIP, "1.01.17", "27bcb343d6950f35dc261629e22ba60c" },
 179     { MODEL_CLIPZIP, "1.01.18", "ef16aa9e02b49885ebede5aa149502e8" },
 180     { MODEL_CLIPZIP, "1.01.20", "d88c8977cc6a952d3f51ece105869d97" },
 181 };
 182
 183 #define NUM_MD5S (sizeof(sansasums)/sizeof(sansasums[0]))
 184
 185 static unsigned int model_memory_size(int model)
 186 {
 187     /* The OF boots with IRAM (320kB) mapped at 0x0 */
 188
 189     if(model == MODEL_CLIPV2)
 190     {
 191         /* The decompressed Clipv2 OF is around 380kB.
 192          * Let's use the full IRAM (1MB on AMSv2)
 193          */
 194         return 1 << 20;
 195     }
 196     else
 197     {
 198         /* The IRAM is 320kB on AMSv1, and 320 will be enough on Fuzev1/Clip+ */
 199         return 320 << 10;
 200     }
 201 }
 202
 203 int firmware_revision(int model)
 204 {
 205     return ams_identity[model].fw_revision;
 206 }
 207
 208 static off_t filesize(int fd)
 209 {
 210     struct stat buf;
 211
 212     if (fstat(fd, &buf) < 0) {
 213         perror("[ERR]  Checking filesize of input file");
 214         return -1;
 215     } else {
 216         return(buf.st_size);
 217     }
 218 }
 219
 220 static uint32_t get_uint32le(unsigned char* p)
 221 {
 222     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 223 }
 224
 225 static uint32_t get_uint32be(unsigned char* p)
 226 {
 227     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 228 }
 229
 230 static void put_uint32le(unsigned char* p, uint32_t x)
 231 {
 232     p[0] = x & 0xff;
 233     p[1] = (x >> 8) & 0xff;
 234     p[2] = (x >> 16) & 0xff;
 235     p[3] = (x >> 24) & 0xff;
 236 }
 237
 238 void calc_MD5(unsigned char* buf, int len, char *md5str)
 239 {
 240     int i;
 241     md5_context ctx;
 242     unsigned char md5sum[16];
 243
 244     md5_starts(&ctx);
 245     md5_update(&ctx, buf, len);
 246     md5_finish(&ctx, md5sum);
 247
 248     for (i = 0; i < 16; ++i)
 249         sprintf(md5str + 2*i, "%02x", md5sum[i]);
 250 }
 251
 252 /* Calculate a simple checksum used in Sansa Original Firmwares */
 253 static uint32_t calc_checksum(unsigned char* buf, uint32_t n)
 254 {
 255     uint32_t sum = 0;
 256     uint32_t i;
 257
 258     for (i=0;i<n;i+=4)
 259         sum += get_uint32le(buf + i);
 260
 261     return sum;
 262 }
 263
 264 /* Compress using nrv2e algorithm : Thumb decompressor fits in 168 bytes ! */
 265 static unsigned char* uclpack(unsigned char* inbuf, int insize, int* outsize)
 266 {
 267     int maxsize;
 268     unsigned char* outbuf;
 269     int r;
 270
 271     /* The following formula comes from the UCL documentation */
 272     maxsize = insize + (insize / 8) + 256;
 273
 274     /* Allocate some memory for the output buffer */
 275     outbuf = malloc(maxsize);
 276
 277     if (outbuf == NULL)
 278         return NULL;
 279
 280     r = ucl_nrv2e_99_compress(
 281             (const ucl_bytep) inbuf,
 282             (ucl_uint) insize,
 283             (ucl_bytep) outbuf,
 284             (ucl_uintp) outsize,
 285             0, 10, NULL, NULL);
 286
 287     if (r != UCL_E_OK || *outsize > maxsize) {
 288         /* this should NEVER happen, and implies memory corruption */
 289         fprintf(stderr, "internal error - compression failed: %d\n", r);
 290         free(outbuf);
 291         return NULL;
 292     }
 293
 294     return outbuf;
 295 }
 296
 297 #define ERROR(format, ...) \
 298     do { \
 299         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 300         goto error; \
 301     } while(0)
 302
 303 /* Loads a Sansa AMS Original Firmware file into memory */
 304 unsigned char* load_of_file(
 305         char* filename, int model, off_t* bufsize, struct md5sums *sum,
 306         int* firmware_size, unsigned char** of_packed,
 307         int* of_packedsize, char* errstr, int errstrsize)
 308 {
 309     int fd;
 310     unsigned char* buf =NULL;
 311     off_t n;
 312     unsigned int i=0;
 313     uint32_t checksum;
 314     unsigned int last_word;
 315
 316     fd = open(filename, O_RDONLY|O_BINARY);
 317     if (fd < 0)
 318         ERROR("[ERR]  Could not open %s for reading\n", filename);
 319
 320     *bufsize = filesize(fd);
 321
 322     buf = malloc(*bufsize);
 323     if (buf == NULL)
 324         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 325
 326     n = read(fd, buf, *bufsize);
 327
 328     if (n != *bufsize)
 329         ERROR("[ERR]  Could not read file %s\n", filename);
 330
 331     /* check the file */
 332
 333     /* Calculate MD5 checksum of OF */
 334     calc_MD5(buf, *bufsize, sum->md5);
 335
 336     while ((i < NUM_MD5S) && (strcmp(sansasums[i].md5, sum->md5) != 0))
 337         i++;
 338
 339     if (i < NUM_MD5S) {
 340         *sum = sansasums[i];
 341         if(sum->model != model) {
 342             ERROR("[ERR]  OF File provided is %sv%d version %s, not for %sv%d\n",
 343                 ams_identity[sum->model].model_name, ams_identity[sum->model].hw_revision,
 344                 sum->version, ams_identity[model].model_name, ams_identity[model].hw_revision
 345             );
 346         }
 347     } else {
 348         /* OF unknown, give a list of tested versions for the requested model */
 349
 350         char tested_versions[100];
 351         tested_versions[0] = '\0';
 352
 353         for (i = 0; i < NUM_MD5S ; i++)
 354             if (sansasums[i].model == model) {
 355                 if (tested_versions[0] != '\0') {
 356                     strncat(tested_versions, ", ",
 357                         sizeof(tested_versions) - strlen(tested_versions) - 1);
 358                 }
 359                 strncat(tested_versions, sansasums[i].version,
 360                     sizeof(tested_versions) - strlen(tested_versions) - 1);
 361             }
 362
 363         ERROR("[ERR]  Original firmware unknown, please try another version."
 364               " Tested %sv%d versions are: %s\n",
 365               ams_identity[model].model_name, ams_identity[model].hw_revision, tested_versions);
 366     }
 367
 368     /* TODO: Do some more sanity checks on the OF image. Some images (like
 369        m200v4) dont have a checksum at the end, only padding (0xdeadbeef). */
 370     last_word = *bufsize - 4;
 371     checksum = get_uint32le(buf + last_word);
 372     if (checksum != 0xefbeadde && checksum != calc_checksum(buf, last_word))
 373         ERROR("%s", "[ERR]  Whole file checksum failed\n");
 374
 375     if (ams_identity[sum->model].bootloader == NULL)
 376         ERROR("[ERR]  Unsupported model - \"%s\"\n", ams_identity[sum->model].model_name);
 377
 378     /* Get the firmware size */
 379     if (ams_identity[sum->model].fw_revision == 1)
 380         *firmware_size = get_uint32le(&buf[0x0c]);
 381     else if (ams_identity[sum->model].fw_revision == 2)
 382         *firmware_size = get_uint32le(&buf[0x10]);
 383
 384     /* Compress the original firmware image */
 385     *of_packed = uclpack(buf + 0x400, *firmware_size, of_packedsize);
 386     if (*of_packed == NULL)
 387         ERROR("[ERR]  Could not compress %s\n", filename);
 388
 389     return buf;
 390
 391 error:
 392     free(buf);
 393     return NULL;
 394 }
 395
 396 /* Loads a rockbox bootloader file into memory */
 397 unsigned char* load_rockbox_file(
 398             char* filename, int *model, int* bufsize, int* rb_packedsize,
 399             char* errstr, int errstrsize)
 400 {
 401     int fd;
 402     unsigned char* buf = NULL;
 403     unsigned char* packed = NULL;
 404     unsigned char header[8];
 405     uint32_t sum;
 406     off_t n;
 407     int i;
 408
 409     fd = open(filename, O_RDONLY|O_BINARY);
 410     if (fd < 0)
 411         ERROR("[ERR]  Could not open %s for reading\n", filename);
 412
 413     /* Read Rockbox header */
 414     n = read(fd, header, sizeof(header));
 415     if (n != sizeof(header))
 416         ERROR("[ERR]  Could not read file %s\n", filename);
 417
 418     for(*model = 0; *model < NUM_MODELS; (*model)++)
 419         if (memcmp(ams_identity[*model].rb_model_name, header + 4, 4) == 0)
 420             break;
 421
 422     if(*model == NUM_MODELS)
 423         ERROR("[ERR]  Model name \"%4.4s\" unknown. Is this really a rockbox bootloader?\n", header + 4);
 424
 425     *bufsize = filesize(fd) - sizeof(header);
 426
 427     buf = malloc(*bufsize);
 428     if (buf == NULL)
 429         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 430
 431     n = read(fd, buf, *bufsize);
 432
 433     if (n != *bufsize)
 434         ERROR("[ERR]  Could not read file %s\n", filename);
 435
 436     /* Check checksum */
 437     sum = ams_identity[*model].rb_model_num;
 438     for (i = 0; i < *bufsize; i++) {
 439          /* add 8 unsigned bits but keep a 32 bit sum */
 440          sum += buf[i];
 441     }
 442
 443     if (sum != get_uint32be(header))
 444         ERROR("[ERR]  Checksum mismatch in %s\n", filename);
 445
 446     packed = uclpack(buf, *bufsize, rb_packedsize);
 447     if(packed == NULL)
 448         ERROR("[ERR]  Could not compress %s\n", filename);
 449
 450     free(buf);
 451     return packed;
 452
 453 error:
 454     free(buf);
 455     return NULL;
 456 }
 457
 458 #undef ERROR
 459
 460 /* Patches a Sansa AMS Original Firmware file */
 461 void patch_firmware(
 462         int model, int fw_revision, int firmware_size, unsigned char* buf,
 463         int len, unsigned char* of_packed, int of_packedsize,
 464         unsigned char* rb_packed, int rb_packedsize)
 465 {
 466     unsigned char *p;
 467     uint32_t sum, filesum;
 468     uint32_t ucl_dest;
 469     unsigned int i;
 470
 471     /* Zero the original firmware area - not needed, but helps debugging */
 472     memset(buf + 0x600, 0, firmware_size);
 473
 474     /* Insert dual-boot bootloader at offset 0x200, we preserve the OF
 475      * version string located between 0x0 and 0x200 */
 476     memcpy(buf + 0x600, ams_identity[model].bootloader, ams_identity[model].bootloader_size);
 477
 478     /* Insert vectors, they won't overwrite the OF version string */
 479     static const uint32_t goto_start    = 0xe3a0fc02; // mov pc, #0x200
 480     static const uint32_t infinite_loop = 0xeafffffe; // 1: b 1b
 481     /* ALL vectors: infinite loop */
 482     for (i=0; i < 8; i++)
 483         put_uint32le(buf + 0x400 + 4*i, infinite_loop);
 484     /* Now change only the interesting vectors */
 485     /* Reset/SWI vectors: branch to our dualboot code at 0x200 */
 486     put_uint32le(buf + 0x400 + 4*0, goto_start); // Reset
 487     put_uint32le(buf + 0x400 + 4*2, goto_start); // SWI
 488
 489     /* We are filling the firmware buffer backwards from the end */
 490     p = buf + 0x400 + firmware_size;
 491
 492     /* 1 - UCL unpack function */
 493     p -= sizeof(nrv2e_d8);
 494     memcpy(p, nrv2e_d8, sizeof(nrv2e_d8));
 495
 496     /* 2 - Compressed copy of original firmware */
 497     p -= of_packedsize;
 498     memcpy(p, of_packed, of_packedsize);
 499
 500     /* 3 - Compressed copy of Rockbox bootloader */
 501     p -= rb_packedsize;
 502     memcpy(p, rb_packed, rb_packedsize);
 503
 504     /* Write the locations of the various images to the variables at the
 505        start of the dualboot image - we save the location of the last byte
 506        in each image, along with the size in bytes */
 507
 508     /* UCL unpack function */
 509     put_uint32le(&buf[0x604], firmware_size - 1);
 510     put_uint32le(&buf[0x608], sizeof(nrv2e_d8));
 511
 512     /* Compressed original firmware image */
 513     put_uint32le(&buf[0x60c], firmware_size - sizeof(nrv2e_d8) - 1);
 514     put_uint32le(&buf[0x610], of_packedsize);
 515
 516     /* Compressed Rockbox image */
 517     put_uint32le(&buf[0x614], firmware_size - sizeof(nrv2e_d8) - of_packedsize
 518             - 1);
 519     put_uint32le(&buf[0x618], rb_packedsize);
 520
 521     ucl_dest = model_memory_size(model) - 1; /* last byte of memory */
 522     put_uint32le(&buf[0x61c], ucl_dest);
 523
 524     /* Update the firmware block checksum */
 525     sum = calc_checksum(buf + 0x400, firmware_size);
 526
 527     if (fw_revision == 1) {
 528         put_uint32le(&buf[0x04], sum);
 529         put_uint32le(&buf[0x204], sum);
 530     } else if (fw_revision == 2) {
 531         put_uint32le(&buf[0x08], sum);
 532         put_uint32le(&buf[0x208], sum);
 533
 534         /* Update the header checksums */
 535         put_uint32le(&buf[0x1fc], calc_checksum(buf, 0x1fc));
 536         put_uint32le(&buf[0x3fc], calc_checksum(buf + 0x200, 0x1fc));
 537     }
 538
 539     /* Update the whole-file checksum */
 540     filesum = 0;
 541     for (i=0;i < (unsigned)len - 4; i+=4)
 542         filesum += get_uint32le(&buf[i]);
 543
 544     put_uint32le(buf + len - 4, filesum);
 545 }
 546
 547 /* returns != 0 if the firmware can be safely patched */
 548 int check_sizes(int model, int rb_packed_size, int rb_unpacked_size,
 549         int of_packed_size, int of_unpacked_size, int *total_size,
 550         char *errstr, int errstrsize)
 551 {
 552     /* XXX: we keep the first 0x200 bytes block unmodified, we just replace
 553      * the ARM vectors */
 554     unsigned int packed_size = ams_identity[model].bootloader_size + sizeof(nrv2e_d8) +
 555             of_packed_size + rb_packed_size + 0x200;
 556
 557     /* how much memory is available */
 558     unsigned int memory_size = model_memory_size(model);
 559
 560     /* the memory used when unpacking the OF */
 561     unsigned int ram_of = sizeof(nrv2e_d8) + of_packed_size + of_unpacked_size;
 562
 563     /* the memory used when unpacking the bootloader */
 564     unsigned int ram_rb = sizeof(nrv2e_d8) + rb_packed_size + rb_unpacked_size;
 565
 566     *total_size = packed_size;
 567
 568 #define ERROR(format, ...) \
 569     do { \
 570         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 571         return 0; \
 572     } while(0)
 573
 574     /* will packed data fit in the OF file ? */
 575     if(packed_size > of_unpacked_size)
 576         ERROR(
 577             "[ERR]  Packed data (%d bytes) doesn't fit in the firmware "
 578             "(%d bytes)\n", packed_size, of_unpacked_size
 579             );
 580
 581     else if(ram_rb > memory_size)
 582         ERROR("[ERR]  Rockbox can't be unpacked at runtime, needs %d bytes "
 583             "of memory and only %d available\n", ram_rb, memory_size
 584             );
 585
 586     else if(ram_of > memory_size)
 587         ERROR("[ERR]  OF can't be unpacked at runtime, needs %d bytes "
 588             "of memory and only %d available\n", ram_of, memory_size
 589             );
 590
 591     return 1;
 592
 593 #undef ERROR
 594 }