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