summaryrefslogtreecommitdiffstats
path: root/utils/AMS
diff options
context:
space:
mode:
authorDave Chapman <dave@dchapman.com>2008-10-02 12:37:47 +0000
committerDave Chapman <dave@dchapman.com>2008-10-02 12:37:47 +0000
commitc2933cd46e7a84df24acf488249f62f9ec090759 (patch)
tree34a0850ee83e61b890fcd74856f79ada9c2187b9 /utils/AMS
parentd1d8b4ca555b47f190a075efb83f66738477b485 (diff)
downloadrockbox-c2933cd46e7a84df24acf488249f62f9ec090759.tar.gz
rockbox-c2933cd46e7a84df24acf488249f62f9ec090759.tar.bz2
rockbox-c2933cd46e7a84df24acf488249f62f9ec090759.zip
Remove the dependency on sufficient free space in the padding at the end of the firmware block by storing the ucl unpack function in the main firmware block, immediately before the compressed firmware image. Also simplify the memcpy function in test.S. This has been tested successfully on a Clip.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18682 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'utils/AMS')
-rw-r--r--utils/AMS/hacking/mkamsboot.c88
-rw-r--r--utils/AMS/hacking/test.S21
2 files changed, 52 insertions, 57 deletions
diff --git a/utils/AMS/hacking/mkamsboot.c b/utils/AMS/hacking/mkamsboot.c
index 47738ebdde..52ead58b69 100644
--- a/utils/AMS/hacking/mkamsboot.c
+++ b/utils/AMS/hacking/mkamsboot.c
@@ -26,34 +26,41 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
Insert a Rockbox bootloader into an AMS original firmware file.
-We replace the main firmware block (bytes 0x400..padded_firmware_size+0x400)
-with the following:
-
-Bytes 0..(firmware_size-ucl_size) - Our bootloader code
-Bytes (firmware_size-ucl_size)..firmware_size - UCL compressed OF image
-Bytes firmware_size..padded_firmware_size - UCL decompress function
-
-mkamsboot writes the following values at offsets into our bootloader code:
-
-0x20 - Entry point (plus 1 - for thumb mode) of the ucl_unpack function
-0x24 - Location of the UCL compressed version of the original firmware block
-
-mkamsboot then corrects the length (to include the UCL decompress
-function) and checksum in the main firmware headers (both copies),
-creating a new legal firmware file which can be installed on the
-device.
+We replace the main firmware block (bytes 0x400..0x400+firmware_size)
+as follows:
+
+
+ --------------------- 0x0
+| |
+| Rockbox bootloader |
+| |
+|---------------------|
+| EMPTY SPACE |
+|---------------------|
+| ucl unpack function |
+|---------------------|
+| |
+| compressed OF image |
+| |
+| |
+ ---------------------
+
+This entire block fits into the space previously occupied by the main
+firmware block, and gives about 40KB of space to store the Rockbox
+bootloader. This could be increased if we also UCL compress the
+Rockbox bootloader.
+
+mkamsboot then corrects the checksums and writes a new legal firmware
+file which can be installed on the device.
Our bootloader first checks for the "dual-boot" keypress, and then either:
-a) Branches to the ucl_unpack function, which will then branch to 0x0 after
- decompressing the OF.
+a) Copies the ucl unpack function and compressed OF image to an unused
+ part of RAM and then branches to the ucl_unpack function, which
+ will then branch to 0x0 after decompressing the OF to that location.
b) Continues running with our test code
-This method uses no RAM outside the padded area of the original
-firmware block - the UCL compression can happen in-place when the
-compressed image is stored at the end of the destination buffer.
-
*/
@@ -142,6 +149,7 @@ int main(int argc, char* argv[])
uint32_t firmware_paddedsize;
uint32_t bootloader_size;
uint32_t ucl_size;
+ uint32_t ucl_paddedsize;
uint32_t uclunpack_size;
uint32_t sum,filesum;
uint32_t i;
@@ -204,6 +212,7 @@ int main(int argc, char* argv[])
return 1;
}
ucl_size = get_uint32be(&uclheader[22]) + 8;
+ ucl_paddedsize = (ucl_size + 3) & ~0x3;
if (ucl_size + 26 > (unsigned)filesize(fducl)) {
fprintf(stderr, "[ERR] Size mismatch in UCL file\n");
@@ -246,26 +255,15 @@ int main(int argc, char* argv[])
fprintf(stderr,"Original firmware size - %d bytes\n",firmware_size);
fprintf(stderr,"Padded firmware size - %d bytes\n",firmware_paddedsize);
fprintf(stderr,"Bootloader size - %d bytes\n",bootloader_size);
- fprintf(stderr,"UCL image size - %d bytes\n",ucl_size);
+ fprintf(stderr,"UCL image size - %d bytes (%d bytes padded)\n",ucl_size,ucl_paddedsize);
fprintf(stderr,"UCL unpack function size - %d bytes\n",uclunpack_size);
fprintf(stderr,"Original total size of firmware - %d bytes\n",(int)len);
/* Check we have room for our bootloader - in the future, we could UCL
pack this image as well if we need to. */
- if (bootloader_size > (firmware_size - ucl_size)) {
+ if (bootloader_size > (firmware_size - ucl_paddedsize - uclunpack_size)) {
fprintf(stderr,"[ERR] Bootloader too large (%d bytes, %d available)\n",
- bootloader_size, firmware_size - ucl_size);
- return 1;
- }
-
- /* Check we have enough room for the UCL unpack function. This
- needs to be outside the firmware block, so if we wanted to
- support every firmware version, we could store this function in
- the main firmware block, and then copy it to an unused part of
- RAM. */
- if (uclunpack_size > (firmware_paddedsize - firmware_size)) {
- fprintf(stderr,"[ERR] UCL unpack function too large (%d bytes, %d available)\n",
- uclunpack_size, firmware_paddedsize - firmware_size);
+ bootloader_size, firmware_size - ucl_paddedsize - uclunpack_size);
return 1;
}
@@ -283,7 +281,7 @@ int main(int argc, char* argv[])
/* Locate the compressed image of the original firmware block at the end
of the firmware block */
- n = read(fducl, buf + 0x400 + firmware_size - ucl_size, ucl_size);
+ n = read(fducl, buf + 0x400 + firmware_size - ucl_paddedsize, ucl_size);
if (n != ucl_size) {
fprintf(stderr,"[ERR] Could not load ucl file\n");
@@ -292,8 +290,8 @@ int main(int argc, char* argv[])
close(fducl);
- /* Locate our UCL unpack function in the padding after the firmware block */
- n = read(fduclunpack, buf + 0x400 + firmware_size, uclunpack_size);
+ /* Locate our UCL unpack function before copy of the compressed firmware */
+ n = read(fduclunpack, buf + 0x400 + firmware_size - ucl_paddedsize - uclunpack_size, uclunpack_size);
if (n != uclunpack_size) {
fprintf(stderr,"[ERR] Could not load uclunpack file\n");
@@ -301,20 +299,18 @@ int main(int argc, char* argv[])
}
close(fduclunpack);
- put_uint32le(&buf[0x420], firmware_size + 1); /* UCL unpack entry point */
- put_uint32le(&buf[0x424], firmware_size - ucl_size); /* Location of OF */
+ put_uint32le(&buf[0x420], 0x40000 - ucl_paddedsize - uclunpack_size + 1); /* UCL unpack entry point */
+ put_uint32le(&buf[0x424], 0x40000 - ucl_paddedsize); /* Location of OF */
put_uint32le(&buf[0x428], ucl_size); /* Size of UCL image */
+ put_uint32le(&buf[0x42c], firmware_size - uclunpack_size - ucl_paddedsize); /* Start of data to copy */
+ put_uint32le(&buf[0x430], uclunpack_size + ucl_paddedsize); /* Size of data to copy */
/* Update checksum */
- sum = calc_checksum(buf + 0x400,firmware_size + uclunpack_size);
+ sum = calc_checksum(buf + 0x400,firmware_size);
put_uint32le(&buf[0x04], sum);
put_uint32le(&buf[0x204], sum);
- /* Update firmware size */
- put_uint32le(&buf[0x0c], firmware_size + uclunpack_size);
- put_uint32le(&buf[0x20c], firmware_size + uclunpack_size);
-
/* Update the whole-file checksum */
filesum = 0;
for (i=0;i < (unsigned)len - 4; i+=4)
diff --git a/utils/AMS/hacking/test.S b/utils/AMS/hacking/test.S
index 79d23deb6a..a4757b44ce 100644
--- a/utils/AMS/hacking/test.S
+++ b/utils/AMS/hacking/test.S
@@ -16,10 +16,11 @@
.word 0
/* These values are filled in by mkamsboot - don't move them from offset 0x20 */
-ucl_unpack: .word 0 /* Entry point (plus 1 - for thumb) of ucl_unpack */
-ucl_start: .word 0 /* Start of the ucl-compressed OF image */
+ucl_unpack: .word 0 /* Entry point (plus 1 - for thumb) of ucl_unpack after copy*/
+ucl_start: .word 0 /* Start of the ucl-compressed OF image after copy */
ucl_size: .word 0 /* Length in bytes of the compressed OF image */
-
+copy_start: .word 0 /* Start of the copy of the ucl_unpack function */
+copy_size: .word 0 /* uclunpack_size + ucl_paddedsize */
start:
/* A delay loop - just to prove we're running */
@@ -29,25 +30,23 @@ loop: subs r1, r1, #1
/* First copy the compressed firmware to unused RAM */
- ldr r0, ucl_start /* Source */
- ldr r1, ucl_size /* Source length */
+ ldr r0, copy_start /* Source */
+ ldr r1, copy_size /* Source length */
mov r2, #0x40000 /* Destination end */
sub r2, r2, r1
memcpy:
- ldrb r3, [r0]
- strb r3, [r2]
- adds r0, r0, #1
- adds r2, r2, #1
+ ldrb r3, [r0], #1
+ strb r3, [r2], #1
cmp r2, #0x40000 /* Stop when we reached dest_end */
bne memcpy
- sub r0, r2, r1 /* Point to the compressed firmware */
-
/* Call the ucl decompress function, which will branch to 0x0 */
/* on completion */
+ ldr r0, ucl_start /* Address of compressed image */
+ ldr r1, ucl_size /* Compressed size */
mov r2, #0 /* Destination */
ldr r3, ucl_unpack