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     { MODEL_CLIP,   "1.01.35", "b4d0edb3b8f2a4e8eee0a344f7f8e480" },
 229
 230     { MODEL_CLIPV2, "2.01.16", "c57fb3fcbe07c2c9b360f060938f80cb" },
 231     { MODEL_CLIPV2, "2.01.32", "0ad3723e52022509089d938d0fbbf8c5" },
 232     { MODEL_CLIPV2, "2.01.35", "a3cbbd22b9508d7f8a9a1a39acc342c2" },
 233
 234     { MODEL_CLIPPLUS, "01.02.09", "656d38114774c2001dc18e6726df3c5d" },
 235
 236     { MODEL_FUZEV2, "2.01.17", "8b85fb05bf645d08a4c8c3e344ec9ebe" },
 237     { MODEL_FUZEV2, "2.02.26", "d4f6f85c3e4a8ea8f2e5acc421641801" },
 238     { MODEL_FUZEV2, "2.03.31", "74fb197ccd51707388f3b233402186a6" },
 239 };
 240
 241 #define NUM_MD5S (sizeof(sansasums)/sizeof(sansasums[0]))
 242
 243 static unsigned int model_memory_size(int model)
 244 {
 245     if(model == MODEL_CLIPV2)
 246     {
 247         /* The decompressed Clipv2 OF is around 380kB.
 248          * Since it doesn't fit in the 0x50000 bytes IRAM, the OF starts
 249          * with DRAM mapped at 0x0
 250          *
 251          * We could use all the available memory (supposedly 8MB)
 252          * but 1MB ought to be enough for our use
 253          */
 254         return 1 << 20;
 255     }
 256     else
 257     {   /* The OF boots with IRAM (320kB) mapped at 0x0 */
 258         return 320 << 10;
 259     }
 260 }
 261
 262 int firmware_revision(int model)
 263 {
 264     return fw_revisions[model];
 265 }
 266
 267 static off_t filesize(int fd)
 268 {
 269     struct stat buf;
 270
 271     if (fstat(fd, &buf) < 0) {
 272         perror("[ERR]  Checking filesize of input file");
 273         return -1;
 274     } else {
 275         return(buf.st_size);
 276     }
 277 }
 278
 279 static uint32_t get_uint32le(unsigned char* p)
 280 {
 281     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 282 }
 283
 284 static uint32_t get_uint32be(unsigned char* p)
 285 {
 286     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 287 }
 288
 289 static void put_uint32le(unsigned char* p, uint32_t x)
 290 {
 291     p[0] = x & 0xff;
 292     p[1] = (x >> 8) & 0xff;
 293     p[2] = (x >> 16) & 0xff;
 294     p[3] = (x >> 24) & 0xff;
 295 }
 296
 297 void calc_MD5(unsigned char* buf, int len, char *md5str)
 298 {
 299     int i;
 300     md5_context ctx;
 301     unsigned char md5sum[16];
 302
 303     md5_starts(&ctx);
 304     md5_update(&ctx, buf, len);
 305     md5_finish(&ctx, md5sum);
 306
 307     for (i = 0; i < 16; ++i)
 308         sprintf(md5str + 2*i, "%02x", md5sum[i]);
 309 }
 310
 311 /* Calculate a simple checksum used in Sansa Original Firmwares */
 312 static uint32_t calc_checksum(unsigned char* buf, uint32_t n)
 313 {
 314     uint32_t sum = 0;
 315     uint32_t i;
 316
 317     for (i=0;i<n;i+=4)
 318         sum += get_uint32le(buf + i);
 319
 320     return sum;
 321 }
 322
 323 static int get_model(int model_id)
 324 {
 325     switch(model_id) {
 326         case 0x1e:
 327             return MODEL_FUZE;
 328         case 0x22:
 329             return MODEL_CLIP;
 330         case 0x23:
 331             return MODEL_C200V2;
 332         case 0x24:
 333             return MODEL_E200V2;
 334         case 0x25:
 335             return MODEL_M200V4;
 336         case 0x27:
 337             return MODEL_CLIPV2;
 338         case 0x28:
 339             return MODEL_CLIPPLUS;
 340         case 0x70:
 341             return MODEL_FUZEV2;
 342     }
 343
 344     return MODEL_UNKNOWN;
 345 }
 346
 347 /* Compress using nrv2e algorithm : Thumb decompressor fits in 168 bytes ! */
 348 static unsigned char* uclpack(unsigned char* inbuf, int insize, int* outsize)
 349 {
 350     int maxsize;
 351     unsigned char* outbuf;
 352     int r;
 353
 354     /* The following formula comes from the UCL documentation */
 355     maxsize = insize + (insize / 8) + 256;
 356
 357     /* Allocate some memory for the output buffer */
 358     outbuf = malloc(maxsize);
 359
 360     if (outbuf == NULL)
 361         return NULL;
 362
 363     r = ucl_nrv2e_99_compress(
 364             (const ucl_bytep) inbuf,
 365             (ucl_uint) insize,
 366             (ucl_bytep) outbuf,
 367             (ucl_uintp) outsize,
 368             0, 10, NULL, NULL);
 369
 370     if (r != UCL_E_OK || *outsize > maxsize) {
 371         /* this should NEVER happen, and implies memory corruption */
 372         fprintf(stderr, "internal error - compression failed: %d\n", r);
 373         free(outbuf);
 374         return NULL;
 375     }
 376
 377     return outbuf;
 378 }
 379
 380 #define ERROR(format, ...) \
 381     do { \
 382         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 383         goto error; \
 384     } while(0)
 385
 386 /* Loads a Sansa AMS Original Firmware file into memory */
 387 unsigned char* load_of_file(
 388         char* filename, off_t* bufsize, struct md5sums *sum,
 389         int* firmware_size, unsigned char** of_packed,
 390         int* of_packedsize, char* errstr, int errstrsize)
 391 {
 392     int fd;
 393     unsigned char* buf =NULL;
 394     off_t n;
 395     unsigned int i=0;
 396     uint32_t checksum;
 397     int model_id;
 398     unsigned int last_word;
 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     *bufsize = filesize(fd);
 405
 406     buf = malloc(*bufsize);
 407     if (buf == NULL)
 408         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 409
 410     n = read(fd, buf, *bufsize);
 411
 412     if (n != *bufsize)
 413         ERROR("[ERR]  Could not read file %s\n", filename);
 414
 415     /* check the file */
 416
 417     /* Calculate MD5 checksum of OF */
 418     calc_MD5(buf, *bufsize, sum->md5);
 419
 420     while ((i < NUM_MD5S) && (strcmp(sansasums[i].md5, sum->md5) != 0))
 421         i++;
 422
 423     if (i < NUM_MD5S) {
 424         *sum = sansasums[i];
 425     } else {
 426         int fw_version = (get_uint32le(&buf[0x204]) == 0x0000f000) ? 2 : 1;
 427         model_id = buf[(fw_version == 2) ? 0x219 : 0x215];
 428         sum->model = get_model(model_id);
 429
 430         if (sum->model == MODEL_UNKNOWN)
 431             ERROR("[ERR]  Unknown firmware model (v%d) - model id 0x%02x\n",
 432                   fw_version, model_id);
 433
 434 #if 1   /* comment to test new OFs */
 435         char tested_versions[100];
 436         tested_versions[0] = '\0';
 437
 438         for (i = 0; i < NUM_MD5S ; i++)
 439             if (sansasums[i].model == sum->model) {
 440                 if (tested_versions[0] != '\0') {
 441                     strncat(tested_versions, ", ",
 442                         sizeof(tested_versions) - strlen(tested_versions) - 1);
 443                 }
 444                 strncat(tested_versions, sansasums[i].version,
 445                     sizeof(tested_versions) - strlen(tested_versions) - 1);
 446             }
 447
 448         ERROR("[ERR]  Original firmware unknown, please try an other version." \
 449               " Tested %s versions are : %s\n",
 450               model_names[sum->model], tested_versions);
 451 #endif
 452     }
 453
 454     /* TODO: Do some more sanity checks on the OF image. Some images (like
 455        m200v4) dont have a checksum at the end, only padding (0xdeadbeef). */
 456     last_word = *bufsize - 4;
 457     checksum = get_uint32le(buf + last_word);
 458     if (checksum != 0xefbeadde && checksum != calc_checksum(buf, last_word))
 459         ERROR("%s", "[ERR]  Whole file checksum failed\n");
 460
 461     if (bootloaders[sum->model] == NULL)
 462         ERROR("[ERR]  Unsupported model - \"%s\"\n", model_names[sum->model]);
 463
 464     /* Get the firmware size */
 465     if (fw_revisions[sum->model] == 1)
 466         *firmware_size = get_uint32le(&buf[0x0c]);
 467     else if (fw_revisions[sum->model] == 2)
 468         *firmware_size = get_uint32le(&buf[0x10]);
 469
 470     /* Compress the original firmware image */
 471     *of_packed = uclpack(buf + 0x400, *firmware_size, of_packedsize);
 472     if (*of_packed == NULL)
 473         ERROR("[ERR]  Could not compress %s\n", filename);
 474
 475     return buf;
 476
 477 error:
 478     free(buf);
 479     return NULL;
 480 }
 481
 482 /* Loads a rockbox bootloader file into memory */
 483 unsigned char* load_rockbox_file(
 484             char* filename, int model, int* bufsize, int* rb_packedsize,
 485             char* errstr, int errstrsize)
 486 {
 487     int fd;
 488     unsigned char* buf = NULL;
 489     unsigned char* packed = NULL;
 490     unsigned char header[8];
 491     uint32_t sum;
 492     off_t n;
 493     int i;
 494
 495     fd = open(filename, O_RDONLY|O_BINARY);
 496     if (fd < 0)
 497         ERROR("[ERR]  Could not open %s for reading\n", filename);
 498
 499     /* Read Rockbox header */
 500     n = read(fd, header, sizeof(header));
 501     if (n != sizeof(header))
 502         ERROR("[ERR]  Could not read file %s\n", filename);
 503
 504     /* Check for correct model string */
 505     if (memcmp(rb_model_names[model], header + 4, 4)!=0)
 506         ERROR("[ERR]  Expected model name \"%s\" in %s, not \"%4.4s\"\n",
 507                        rb_model_names[model], filename, (char*)header+4);
 508
 509     *bufsize = filesize(fd) - sizeof(header);
 510
 511     buf = malloc(*bufsize);
 512     if (buf == NULL)
 513         ERROR("[ERR]  Could not allocate memory for %s\n", filename);
 514
 515     n = read(fd, buf, *bufsize);
 516
 517     if (n != *bufsize)
 518         ERROR("[ERR]  Could not read file %s\n", filename);
 519
 520     /* Check checksum */
 521     sum = rb_model_num[model];
 522     for (i = 0; i < *bufsize; i++) {
 523          /* add 8 unsigned bits but keep a 32 bit sum */
 524          sum += buf[i];
 525     }
 526
 527     if (sum != get_uint32be(header))
 528         ERROR("[ERR]  Checksum mismatch in %s\n", filename);
 529
 530     packed = uclpack(buf, *bufsize, rb_packedsize);
 531     if(packed == NULL)
 532         ERROR("[ERR]  Could not compress %s\n", filename);
 533
 534     free(buf);
 535     return packed;
 536
 537 error:
 538     free(buf);
 539     return NULL;
 540 }
 541
 542 #undef ERROR
 543
 544 /* Patches a Sansa AMS Original Firmware file */
 545 void patch_firmware(
 546         int model, int fw_revision, int firmware_size, unsigned char* buf,
 547         int len, unsigned char* of_packed, int of_packedsize,
 548         unsigned char* rb_packed, int rb_packedsize)
 549 {
 550     unsigned char *p;
 551     uint32_t sum, filesum;
 552     uint32_t ucl_dest;
 553     unsigned int i;
 554
 555     /* Zero the original firmware area - not needed, but helps debugging */
 556     memset(buf + 0x400, 0, firmware_size);
 557
 558     /* Insert dual-boot bootloader at offset 0 */
 559     memcpy(buf + 0x400, bootloaders[model], bootloader_sizes[model]);
 560
 561     /* We are filling the firmware buffer backwards from the end */
 562     p = buf + 0x400 + firmware_size;
 563
 564     /* 1 - UCL unpack function */
 565     p -= sizeof(nrv2e_d8);
 566     memcpy(p, nrv2e_d8, sizeof(nrv2e_d8));
 567
 568     /* 2 - Compressed copy of original firmware */
 569     p -= of_packedsize;
 570     memcpy(p, of_packed, of_packedsize);
 571
 572     /* 3 - Compressed copy of Rockbox bootloader */
 573     p -= rb_packedsize;
 574     memcpy(p, rb_packed, rb_packedsize);
 575
 576     /* Write the locations of the various images to the variables at the
 577        start of the dualboot image - we save the location of the last byte
 578        in each image, along with the size in bytes */
 579
 580     /* UCL unpack function */
 581     put_uint32le(&buf[0x420], firmware_size - 1);
 582     put_uint32le(&buf[0x424], sizeof(nrv2e_d8));
 583
 584     /* Compressed original firmware image */
 585     put_uint32le(&buf[0x428], firmware_size - sizeof(nrv2e_d8) - 1);
 586     put_uint32le(&buf[0x42c], of_packedsize);
 587
 588     /* Compressed Rockbox image */
 589     put_uint32le(&buf[0x430], firmware_size - sizeof(nrv2e_d8) - of_packedsize
 590             - 1);
 591     put_uint32le(&buf[0x434], rb_packedsize);
 592
 593     ucl_dest = model_memory_size(model) - 1; /* last byte of memory */
 594     put_uint32le(&buf[0x438], ucl_dest);
 595
 596     /* Update the firmware block checksum */
 597     sum = calc_checksum(buf + 0x400, firmware_size);
 598
 599     if (fw_revision == 1) {
 600         put_uint32le(&buf[0x04], sum);
 601         put_uint32le(&buf[0x204], sum);
 602     } else if (fw_revision == 2) {
 603         put_uint32le(&buf[0x08], sum);
 604         put_uint32le(&buf[0x208], sum);
 605
 606         /* Update the header checksums */
 607         put_uint32le(&buf[0x1fc], calc_checksum(buf, 0x1fc));
 608         put_uint32le(&buf[0x3fc], calc_checksum(buf + 0x200, 0x1fc));
 609     }
 610
 611     /* Update the whole-file checksum */
 612     filesum = 0;
 613     for (i=0;i < (unsigned)len - 4; i+=4)
 614         filesum += get_uint32le(&buf[i]);
 615
 616     put_uint32le(buf + len - 4, filesum);
 617 }
 618
 619 /* returns != 0 if the firmware can be safely patched */
 620 int check_sizes(int model, int rb_packed_size, int rb_unpacked_size,
 621         int of_packed_size, int of_unpacked_size, int *total_size,
 622         char *errstr, int errstrsize)
 623 {
 624     unsigned int packed_size = bootloader_sizes[model] + sizeof(nrv2e_d8) +
 625             of_packed_size + rb_packed_size;
 626
 627     /* how much memory is available */
 628     unsigned int memory_size = model_memory_size(model);
 629
 630     /* the memory used when unpacking the OF */
 631     unsigned int ram_of = sizeof(nrv2e_d8) + of_packed_size + of_unpacked_size;
 632
 633     /* the memory used when unpacking the bootloader */
 634     unsigned int ram_rb = sizeof(nrv2e_d8) + rb_packed_size + rb_unpacked_size;
 635
 636     *total_size = packed_size;
 637
 638 #define ERROR(format, ...) \
 639     do { \
 640         snprintf(errstr, errstrsize, format, __VA_ARGS__); \
 641         return 0; \
 642     } while(0)
 643
 644     /* will packed data fit in the OF file ? */
 645     if(packed_size > of_unpacked_size)
 646         ERROR(
 647             "[ERR]  Packed data (%d bytes) doesn't fit in the firmware "
 648             "(%d bytes)\n", packed_size, of_unpacked_size
 649             );
 650
 651     else if(ram_rb > memory_size)
 652         ERROR("[ERR]  Rockbox can't be unpacked at runtime, needs %d bytes "
 653             "of memory and only %d available\n", ram_rb, memory_size
 654             );
 655
 656     else if(ram_of > memory_size)
 657         ERROR("[ERR]  OF can't be unpacked at runtime, needs %d bytes "
 658             "of memory and only %d available\n", ram_of, memory_size
 659             );
 660
 661     return 1;
 662
 663 #undef ERROR
 664 }