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