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    |
  35 |----------------------| 0x400 + firmware block size
  36 |    LIBRARIES/DATA    |
  37  ----------------------  END
  38
  39 We replace the main firmware block (bytes 0x400..0x400+firmware_size)
  40 as follows:
  41
  42
  43  ----------------------  0x0
  44 |                      |
  45 |    Dual-boot code    |
  46 |                      |
  47 |----------------------|
  48 |     EMPTY SPACE      |
  49 |----------------------|
  50 |                      |
  51 | compressed RB image  |
  52 |                      |
  53 |----------------------|
  54 |                      |
  55 | compressed OF image  |
  56 |                      |
  57 |----------------------|
  58 | UCL unpack function  |
  59  ----------------------
  60
  61 This entire block fits into the space previously occupied by the main
  62 firmware block - the space saved by compressing the OF image is used
  63 to store the compressed version of the Rockbox bootloader.
  64
  65 On version 1 firmwares, the OF image is typically about 120KB, which allows
  66 us to store a Rockbox bootloader with an uncompressed size of about 60KB-70KB.
  67 Version 2 firmwares are bigger and are stored in SDRAM (instead of IRAM).
  68 In both cases, the RAM we are using is mapped at offset 0x0.
  69
  70 mkamsboot then corrects the checksums and writes a new legal firmware
  71 file which can be installed on the device.
  72
  73 When the Sansa device boots, this firmware block is loaded to RAM at
  74 address 0x0 and executed.
  75
  76 Firstly, the dual-boot code will copy the UCL unpack function to the
  77 end of RAM.
  78
  79 Then, depending on the detection of the dual-boot keypress, either the
  80 OF image or the Rockbox image is copied to the end of RAM (just before
  81 the ucl unpack function) and uncompressed to the start of RAM.
  82
  83 Finally, the ucl unpack function branches to address 0x0, passing
  84 execution to the uncompressed firmware.
  85
  86
  87 */
  88
  89 #include <stdio.h>
  90 #include <stdlib.h>
  91 #include <stdint.h>
  92 #include <sys/types.h>
  93 #include <sys/stat.h>
  94 #include <fcntl.h>
  95 #include <unistd.h>
  96 #include <string.h>
  97
  98 #include <ucl/ucl.h>
  99
 100 #include "mkamsboot.h"
 101
 102 #include "md5.h"
 103
 104 /* Header for ARM code binaries */
 105 #include "dualboot.h"
 106
 107 /* Win32 compatibility */
 108 #ifndef O_BINARY
 109 #define O_BINARY 0
 110 #endif
 111
 112 /* 4 for m200, 2 for e200/c200, 1 or 2 for fuze/clip, 1 for clip+ */
 113 const unsigned short hw_revisions[] = {
 114     [MODEL_FUZE]    = 1,
 115     [MODEL_CLIP]    = 1,
 116     [MODEL_CLIPV2]  = 2,
 117     [MODEL_E200V2]  = 2,
 118     [MODEL_M200V4]  = 4,
 119     [MODEL_C200V2]  = 2,
 120     [MODEL_CLIPPLUS]= 1,
 121     [MODEL_FUZEV2]  = 2,
 122 };
 123
 124 /* version 2 is used in Clipv2, Clip+ and Fuzev2 firmwares */
 125 const unsigned short fw_revisions[] = {
 126     [MODEL_FUZE]    = 1,
 127     [MODEL_CLIP]    = 1,
 128     [MODEL_CLIPV2]  = 2,
 129     [MODEL_E200V2]  = 1,
 130     [MODEL_M200V4]  = 1,
 131     [MODEL_C200V2]  = 1,
 132     [MODEL_CLIPPLUS]= 2,
 133     [MODEL_FUZEV2]  = 2,
 134 };
 135
 136 /* Descriptive name of these models */
 137 const char* model_names[] = {
 138     [MODEL_FUZE]    = "Fuze",
 139     [MODEL_CLIP]    = "Clip",
 140     [MODEL_CLIPV2]  = "Clip",
 141     [MODEL_CLIPPLUS]= "Clip+",
 142     [MODEL_E200V2]  = "e200",
 143     [MODEL_M200V4]  = "m200",
 144     [MODEL_C200V2]  = "c200",
 145     [MODEL_FUZEV2]  = "Fuze",
 146 };
 147
 148 /* Dualboot functions for these models */
 149 static const unsigned char* bootloaders[] = {
 150     [MODEL_FUZE]    = dualboot_fuze,
 151     [MODEL_CLIP]    = dualboot_clip,
 152     [MODEL_CLIPV2]  = dualboot_clipv2,
 153     [MODEL_E200V2]  = dualboot_e200v2,
 154     [MODEL_M200V4]  = dualboot_m200v4,
 155     [MODEL_C200V2]  = dualboot_c200v2,
 156     [MODEL_CLIPPLUS]= dualboot_clipplus,
 157     [MODEL_FUZEV2]  = dualboot_fuzev2,
 158 };
 159
 160 /* Size of dualboot functions for these models */
 161 const int bootloader_sizes[] = {
 162     [MODEL_FUZE]    = sizeof(dualboot_fuze),
 163     [MODEL_CLIP]    = sizeof(dualboot_clip),
 164     [MODEL_CLIPV2]  = sizeof(dualboot_clipv2),
 165     [MODEL_E200V2]  = sizeof(dualboot_e200v2),
 166     [MODEL_M200V4]  = sizeof(dualboot_m200v4),
 167     [MODEL_C200V2]  = sizeof(dualboot_c200v2),
 168     [MODEL_CLIPPLUS]= sizeof(dualboot_clipplus),
 169     [MODEL_FUZEV2]  = sizeof(dualboot_fuzev2),
 170 };
 171
 172 /* Model names used in the Rockbox header in ".sansa" files - these match the
 173    -add parameter to the "scramble" tool */
 174 static const char* rb_model_names[] = {
 175     [MODEL_FUZE]    = "fuze",
 176     [MODEL_CLIP]    = "clip",
 177     [MODEL_CLIPV2]  = "clv2",
 178     [MODEL_E200V2]  = "e2v2",
 179     [MODEL_M200V4]  = "m2v4",
 180     [MODEL_C200V2]  = "c2v2",
 181     [MODEL_CLIPPLUS]= "cli+",
 182     [MODEL_FUZEV2]  = "fuz2",
 183 };
 184
 185 /* Model numbers used to initialise the checksum in the Rockbox header in
 186    ".sansa" files - these are the same as MODEL_NUMBER in config-target.h */
 187 static const int rb_model_num[] = {
 188     [MODEL_FUZE]    = 43,
 189     [MODEL_CLIP]    = 40,
 190     [MODEL_CLIPV2]  = 60,
 191     [MODEL_E200V2]  = 41,
 192     [MODEL_M200V4]  = 42,
 193     [MODEL_C200V2]  = 44,
 194     [MODEL_CLIPPLUS]= 66,
 195     [MODEL_FUZEV2]  = 68,
 196 };
 197
 198 /* Checksums of unmodified original firmwares - for safety, and device
 199    detection */
 200 static struct md5sums sansasums[] = {
 201     /* NOTE: Different regional versions of the firmware normally only
 202              differ in the filename - the md5sums are identical */
 203
 204     /*   model       version    md5                        */
 205     { MODEL_E200V2, "3.01.11", "e622ca8cb6df423f54b8b39628a1f0a3" },
 206     { MODEL_E200V2, "3.01.14", "2c1d0383fc3584b2cc83ba8cc2243af6" },
 207     { MODEL_E200V2, "3.01.16", "12563ad71b25a1034cf2092d1e0218c4" },
 208
 209     { MODEL_FUZE,   "1.01.11", "cac8ffa03c599330ac02c4d41de66166" },
 210     { MODEL_FUZE,   "1.01.15", "df0e2c1612727f722c19a3c764cff7f2" },
 211     { MODEL_FUZE,   "1.01.22", "5aff5486fe8dd64239cc71eac470af98" },
 212     { MODEL_FUZE,   "1.02.26", "7c632c479461c48c8833baed74eb5e4f" },
 213     { MODEL_FUZE,   "1.02.28", "5b34260f6470e75f702a9c6825471752" },
 214     { MODEL_FUZE,   "1.02.31", "66d01b37462a5ef7ccc6ad37188b4235" },
 215
 216     { MODEL_C200V2, "3.02.05", "b6378ebd720b0ade3fad4dc7ab61c1a5" },
 217
 218     { MODEL_M200V4, "4.00.45", "82e3194310d1514e3bbcd06e84c4add3" },
 219     { MODEL_M200V4, "4.01.08-A", "fc9dd6116001b3e6a150b898f1b091f0" },
 220     { MODEL_M200V4, "4.01.08-E", "d3fb7d8ec8624ee65bc99f8dab0e2369" },
 221
 222     { MODEL_CLIP,   "1.01.17", "12caad785d506219d73f538772afd99e" },
 223     { MODEL_CLIP,   "1.01.18", "d720b266bd5afa38a198986ef0508a45" },
 224     { MODEL_CLIP,   "1.01.20", "236d8f75189f468462c03f6d292cf2ac" },
 225     { MODEL_CLIP,   "1.01.29", "c12711342169c66e209540cd1f27cd26" },
 226     { MODEL_CLIP,   "1.01.30", "f2974d47c536549c9d8259170f1dbe4d" },
 227     { MODEL_CLIP,   "1.01.32", "d835d12342500732ffb9c4ee54abec15" },
 228
 229     { MODEL_CLIPV2, "2.01.16", "c57fb3fcbe07c2c9b360f060938f80cb" },
 230     { MODEL_CLIPV2, "2.01.32", "0ad3723e52022509089d938d0fbbf8c5" },
 231
 232     { MODEL_CLIPPLUS, "01.02.09", "656d38114774c2001dc18e6726df3c5d" },
 233
 234     { MODEL_FUZEV2, "2.01.17", "8b85fb05bf645d08a4c8c3e344ec9ebe" },
 235     { MODEL_FUZEV2, "2.02.26", "d4f6f85c3e4a8ea8f2e5acc421641801" },
 236 };
 237
 238 #define NUM_MD5S (sizeof(sansasums)/sizeof(sansasums[0]))
 239
 240 static unsigned int model_memory_size(int model)
 241 {
 242     if(model == MODEL_CLIPV2)
 243     {
 244         /* The decompressed Clipv2 OF is around 380kB.
 245          * Since it doesn't fit in the 0x50000 bytes IRAM, the OF starts
 246          * with DRAM mapped at 0x0
 247          *
 248          * We could use all the available memory (supposedly 8MB)
 249          * but 1MB ought to be enough for our use
 250          */
 251         return 1 << 20;
 252     }
 253     else
 254     {   /* The OF boots with IRAM (320kB) mapped at 0x0 */
 255         return 320 << 10;
 256     }
 257 }
 258
 259 int firmware_revision(int model)
 260 {
 261     return fw_revisions[model];
 262 }
 263
 264 static off_t filesize(int fd)
 265 {
 266     struct stat buf;
 267
 268     if (fstat(fd, &buf) < 0) {
 269         perror("[ERR]  Checking filesize of input file");
 270         return -1;
 271     } else {
 272         return(buf.st_size);
 273     }
 274 }
 275
 276 static uint32_t get_uint32le(unsigned char* p)
 277 {
 278     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 279 }
 280
 281 static uint32_t get_uint32be(unsigned char* p)
 282 {
 283     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 284 }
 285
 286 static void put_uint32le(unsigned char* p, uint32_t x)
 287 {
 288     p[0] = x & 0xff;
 289     p[1] = (x >> 8) & 0xff;
 290     p[2] = (x >> 16) & 0xff;
 291     p[3] = (x >> 24) & 0xff;
 292 }
 293
 294 void calc_MD5(unsigned char* buf, int len, char *md5str)
 295 {
 296     int i;
 297     md5_context ctx;
 298     unsigned char md5sum[16];
 299
 300     md5_starts(&ctx);
 301     md5_update(&ctx, buf, len);
 302     md5_finish(&ctx, md5sum);
 303
 304     for (i = 0; i < 16; ++i)
 305         sprintf(md5str + 2*i, "%02x", md5sum[i]);
 306 }
 307
 308 /* Calculate a simple checksum used in Sansa Original Firmwares */
 309 static uint32_t calc_checksum(unsigned char* buf, uint32_t n)
 310 {
 311     uint32_t sum = 0;
 312     uint32_t i;
 313
 314     for (i=0;i<n;i+=4)
 315         sum += get_uint32le(buf + i);
 316
 317     return sum;
 318 }
 319
 320 static int get_model(int model_id)
 321 {
 322     switch(model_id) {
 323         case 0x1e:
 324             return MODEL_FUZE;
 325         case 0x22:
 326             return MODEL_CLIP;
 327         case 0x23:
 328             return MODEL_C200V2;
 329         case 0x24:
 330             return MODEL_E200V2;
 331         case 0x25:
 332             return MODEL_M200V4;
 333         case 0x27:
 334             return MODEL_CLIPV2;
 335         case 0x28:
 336             return MODEL_CLIPPLUS;
 337         case 0x70:
 338             return MODEL_FUZEV2;
 339     }
 340
 341     return MODEL_UNKNOWN;
 342 }
 343
 344 /* Compress using nrv2e algorithm : Thumb decompressor fits in 168 bytes ! */
 345 static unsigned char* uclpack(unsigned char* inbuf, int insize, int* outsize)
 346 {
 347     int maxsize;
 348     unsigned char* outbuf;
 349     int r;
 350
 351     /* The following formula comes from the UCL documentation */
 352     maxsize = insize + (insize / 8) + 256;
 353
 354     /* Allocate some memory for the output buffer */
 355     outbuf = malloc(maxsize);
 356
 357     if (outbuf == NULL)
 358         return NULL;
 359
 360     r = ucl_nrv2e_99_compress(
 361             (const ucl_bytep) inbuf,
 362             (ucl_uint) insize,
 363             (ucl_bytep) outbuf,
 364             (ucl_uintp) outsize,
 365             0, 10, NULL, NULL);
 366
 367     if (r != UCL_E_OK || *outsize > maxsize) {
 368         /* this should NEVER happen, and implies memory corruption */
 369         fprintf(stderr, "internal error - compression failed: %d\n", r);
 370         free(outbuf);
 371         return NULL;
 372     }
 373
 374     return outbuf;
 375 }
 376
 377 #define ERROR(format, ...) \
 378     do { \
 379         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 380         goto error; \
 381     } while(0)
 382
 383 /* Loads a Sansa AMS Original Firmware file into memory */
 384 unsigned char* load_of_file(
 385         char* filename, off_t* bufsize, struct md5sums *sum,
 386         int* firmware_size, unsigned char** of_packed,
 387         int* of_packedsize, char* errstr, int errstrsize)
 388 {
 389     int fd;
 390     unsigned char* buf =NULL;
 391     off_t n;
 392     unsigned int i=0;
 393     uint32_t checksum;
 394     int model_id;
 395     unsigned int last_word;
 396
 397     fd = open(filename, O_RDONLY|O_BINARY);
 398     if (fd < 0)
 399         ERROR("[ERR]  Could not open %s for reading\n", filename);
 400
 401     *bufsize = filesize(fd);
 402
 403     buf = malloc(*bufsize);
 404     if (buf == NULL)
 405         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 406
 407     n = read(fd, buf, *bufsize);
 408
 409     if (n != *bufsize)
 410         ERROR("[ERR]  Could not read file %s\n", filename);
 411
 412     /* check the file */
 413
 414     /* Calculate MD5 checksum of OF */
 415     calc_MD5(buf, *bufsize, sum->md5);
 416
 417     while ((i < NUM_MD5S) && (strcmp(sansasums[i].md5, sum->md5) != 0))
 418         i++;
 419
 420     if (i < NUM_MD5S) {
 421         *sum = sansasums[i];
 422     } else {
 423         int fw_version = (get_uint32le(&buf[0x204]) == 0x0000f000) ? 2 : 1;
 424         model_id = buf[(fw_version == 2) ? 0x219 : 0x215];
 425         sum->model = get_model(model_id);
 426
 427         if (sum->model == MODEL_UNKNOWN)
 428             ERROR("[ERR]  Unknown firmware model (v%d) - model id 0x%02x\n",
 429                   fw_version, model_id);
 430
 431 #if 1   /* comment to test new OFs */
 432         char tested_versions[100];
 433         tested_versions[0] = '\0';
 434
 435         for (i = 0; i < NUM_MD5S ; i++)
 436             if (sansasums[i].model == sum->model) {
 437                 if (tested_versions[0] != '\0') {
 438                     strncat(tested_versions, ", ",
 439                         sizeof(tested_versions) - strlen(tested_versions) - 1);
 440                 }
 441                 strncat(tested_versions, sansasums[i].version,
 442                     sizeof(tested_versions) - strlen(tested_versions) - 1);
 443             }
 444
 445         ERROR("[ERR]  Original firmware unknown, please try an other version." \
 446               " Tested %s versions are : %s\n",
 447               model_names[sum->model], tested_versions);
 448 #endif
 449     }
 450
 451     /* TODO: Do some more sanity checks on the OF image. Some images (like
 452        m200v4) dont have a checksum at the end, only padding (0xdeadbeef). */
 453     last_word = *bufsize - 4;
 454     checksum = get_uint32le(buf + last_word);
 455     if (checksum != 0xefbeadde && checksum != calc_checksum(buf, last_word))
 456         ERROR("%s", "[ERR]  Whole file checksum failed\n");
 457
 458     if (bootloaders[sum->model] == NULL)
 459         ERROR("[ERR]  Unsupported model - \"%s\"\n", model_names[sum->model]);
 460
 461     /* Get the firmware size */
 462     if (fw_revisions[sum->model] == 1)
 463         *firmware_size = get_uint32le(&buf[0x0c]);
 464     else if (fw_revisions[sum->model] == 2)
 465         *firmware_size = get_uint32le(&buf[0x10]);
 466
 467     /* Compress the original firmware image */
 468     *of_packed = uclpack(buf + 0x400, *firmware_size, of_packedsize);
 469     if (*of_packed == NULL)
 470         ERROR("[ERR]  Could not compress %s\n", filename);
 471
 472     return buf;
 473
 474 error:
 475     free(buf);
 476     return NULL;
 477 }
 478
 479 /* Loads a rockbox bootloader file into memory */
 480 unsigned char* load_rockbox_file(
 481             char* filename, int model, int* bufsize, int* rb_packedsize,
 482             char* errstr, int errstrsize)
 483 {
 484     int fd;
 485     unsigned char* buf = NULL;
 486     unsigned char* packed = NULL;
 487     unsigned char header[8];
 488     uint32_t sum;
 489     off_t n;
 490     int i;
 491
 492     fd = open(filename, O_RDONLY|O_BINARY);
 493     if (fd < 0)
 494         ERROR("[ERR]  Could not open %s for reading\n", filename);
 495
 496     /* Read Rockbox header */
 497     n = read(fd, header, sizeof(header));
 498     if (n != sizeof(header))
 499         ERROR("[ERR]  Could not read file %s\n", filename);
 500
 501     /* Check for correct model string */
 502     if (memcmp(rb_model_names[model], header + 4, 4)!=0)
 503         ERROR("[ERR]  Expected model name \"%s\" in %s, not \"%4.4s\"\n",
 504                        rb_model_names[model], filename, (char*)header+4);
 505
 506     *bufsize = filesize(fd) - sizeof(header);
 507
 508     buf = malloc(*bufsize);
 509     if (buf == NULL)
 510         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 511
 512     n = read(fd, buf, *bufsize);
 513
 514     if (n != *bufsize)
 515         ERROR("[ERR]  Could not read file %s\n", filename);
 516
 517     /* Check checksum */
 518     sum = rb_model_num[model];
 519     for (i = 0; i < *bufsize; i++) {
 520          /* add 8 unsigned bits but keep a 32 bit sum */
 521          sum += buf[i];
 522     }
 523
 524     if (sum != get_uint32be(header))
 525         ERROR("[ERR]  Checksum mismatch in %s\n", filename);
 526
 527     packed = uclpack(buf, *bufsize, rb_packedsize);
 528     if(packed == NULL)
 529         ERROR("[ERR]  Could not compress %s\n", filename);
 530
 531     free(buf);
 532     return packed;
 533
 534 error:
 535     free(buf);
 536     return NULL;
 537 }
 538
 539 #undef ERROR
 540
 541 /* Patches a Sansa AMS Original Firmware file */
 542 void patch_firmware(
 543         int model, int fw_revision, int firmware_size, unsigned char* buf,
 544         int len, unsigned char* of_packed, int of_packedsize,
 545         unsigned char* rb_packed, int rb_packedsize)
 546 {
 547     unsigned char *p;
 548     uint32_t sum, filesum;
 549     uint32_t ucl_dest;
 550     unsigned int i;
 551
 552     /* Zero the original firmware area - not needed, but helps debugging */
 553     memset(buf + 0x400, 0, firmware_size);
 554
 555     /* Insert dual-boot bootloader at offset 0 */
 556     memcpy(buf + 0x400, bootloaders[model], bootloader_sizes[model]);
 557
 558     /* We are filling the firmware buffer backwards from the end */
 559     p = buf + 0x400 + firmware_size;
 560
 561     /* 1 - UCL unpack function */
 562     p -= sizeof(nrv2e_d8);
 563     memcpy(p, nrv2e_d8, sizeof(nrv2e_d8));
 564
 565     /* 2 - Compressed copy of original firmware */
 566     p -= of_packedsize;
 567     memcpy(p, of_packed, of_packedsize);
 568
 569     /* 3 - Compressed copy of Rockbox bootloader */
 570     p -= rb_packedsize;
 571     memcpy(p, rb_packed, rb_packedsize);
 572
 573     /* Write the locations of the various images to the variables at the
 574        start of the dualboot image - we save the location of the last byte
 575        in each image, along with the size in bytes */
 576
 577     /* UCL unpack function */
 578     put_uint32le(&buf[0x420], firmware_size - 1);
 579     put_uint32le(&buf[0x424], sizeof(nrv2e_d8));
 580
 581     /* Compressed original firmware image */
 582     put_uint32le(&buf[0x428], firmware_size - sizeof(nrv2e_d8) - 1);
 583     put_uint32le(&buf[0x42c], of_packedsize);
 584
 585     /* Compressed Rockbox image */
 586     put_uint32le(&buf[0x430], firmware_size - sizeof(nrv2e_d8) - of_packedsize
 587             - 1);
 588     put_uint32le(&buf[0x434], rb_packedsize);
 589
 590     ucl_dest = model_memory_size(model) - 1; /* last byte of memory */
 591     put_uint32le(&buf[0x438], ucl_dest);
 592
 593     /* Update the firmware block checksum */
 594     sum = calc_checksum(buf + 0x400, firmware_size);
 595
 596     if (fw_revision == 1) {
 597         put_uint32le(&buf[0x04], sum);
 598         put_uint32le(&buf[0x204], sum);
 599     } else if (fw_revision == 2) {
 600         put_uint32le(&buf[0x08], sum);
 601         put_uint32le(&buf[0x208], sum);
 602
 603         /* Update the header checksums */
 604         put_uint32le(&buf[0x1fc], calc_checksum(buf, 0x1fc));
 605         put_uint32le(&buf[0x3fc], calc_checksum(buf + 0x200, 0x1fc));
 606     }
 607
 608     /* Update the whole-file checksum */
 609     filesum = 0;
 610     for (i=0;i < (unsigned)len - 4; i+=4)
 611         filesum += get_uint32le(&buf[i]);
 612
 613     put_uint32le(buf + len - 4, filesum);
 614 }
 615
 616 /* returns != 0 if the firmware can be safely patched */
 617 int check_sizes(int model, int rb_packed_size, int rb_unpacked_size,
 618         int of_packed_size, int of_unpacked_size, int *total_size,
 619         char *errstr, int errstrsize)
 620 {
 621     unsigned int packed_size = bootloader_sizes[model] + sizeof(nrv2e_d8) +
 622             of_packed_size + rb_packed_size;
 623
 624     /* how much memory is available */
 625     unsigned int memory_size = model_memory_size(model);
 626
 627     /* the memory used when unpacking the OF */
 628     unsigned int ram_of = sizeof(nrv2e_d8) + of_packed_size + of_unpacked_size;
 629
 630     /* the memory used when unpacking the bootloader */
 631     unsigned int ram_rb = sizeof(nrv2e_d8) + rb_packed_size + rb_unpacked_size;
 632
 633     *total_size = packed_size;
 634
 635 #define ERROR(format, ...) \
 636     do { \
 637         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 638         return 0; \
 639     } while(0)
 640
 641     /* will packed data fit in the OF file ? */
 642     if(packed_size > of_unpacked_size)
 643         ERROR(
 644             "[ERR]  Packed data (%d bytes) doesn't fit in the firmware "
 645             "(%d bytes)\n", packed_size, of_unpacked_size
 646             );
 647
 648     else if(ram_rb > memory_size)
 649         ERROR("[ERR]  Rockbox can't be unpacked at runtime, needs %d bytes "
 650             "of memory and only %d available\n", ram_rb, memory_size
 651             );
 652
 653     else if(ram_of > memory_size)
 654         ERROR("[ERR]  OF can't be unpacked at runtime, needs %d bytes "
 655             "of memory and only %d available\n", ram_of, memory_size
 656             );
 657
 658     return 1;
 659
 660 #undef ERROR
 661 }