1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2006 by Barry Wardell
12 * Based on Rockbox iriver bootloader by Linus Nielsen Feltzing
13 * and the ipodlinux bootloader by Daniel Palffy and Bernard Leach
15 * All files in this archive are subject to the GNU General Public License.
16 * See the file COPYING in the source tree root for full license agreement.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ****************************************************************************/
34 #include "crc32-mi4.h"
37 #if defined(SANSA_E200)
39 #include "backlight-target.h"
41 #if defined(SANSA_E200) || defined(SANSA_C200)
47 /* Button definitions */
48 #if CONFIG_KEYPAD == IRIVER_H10_PAD
49 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
51 #elif CONFIG_KEYPAD == SANSA_E200_PAD
52 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
54 #elif CONFIG_KEYPAD == SANSA_C200_PAD
55 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
57 #elif CONFIG_KEYPAD == MROBE100_PAD
58 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
62 /* Maximum allowed firmware image size. 10MB is more than enough */
63 #define MAX_LOADSIZE (10*1024*1024)
65 /* A buffer to load the original firmware or Rockbox into */
66 unsigned char *loadbuffer
= (unsigned char *)DRAM_START
;
68 /* Bootloader version */
69 char version
[] = APPSVERSION
;
71 /* Locations and sizes in hidden partition on Sansa */
72 #if defined(SANSA_E200) || defined(SANSA_C200)
73 #define PPMI_SECTOR_OFFSET 1024
74 #define PPMI_SECTORS 1
75 #define MI4_HEADER_SECTORS 1
76 #define NUM_PARTITIONS 2
79 #define NUM_PARTITIONS 1
83 #define MI4_HEADER_SIZE 0x200
85 /* mi4 header structure */
87 unsigned char magic
[4];
96 unsigned char type
[4];
97 unsigned char model
[4];
100 /* PPMI header structure */
101 struct ppmi_header_t
{
102 unsigned char magic
[4];
107 inline unsigned int le2int(unsigned char* buf
)
109 int32_t res
= (buf
[3] << 24) | (buf
[2] << 16) | (buf
[1] << 8) | buf
[0];
114 inline void int2le(unsigned int val
, unsigned char* addr
)
116 addr
[0] = val
& 0xFF;
117 addr
[1] = (val
>> 8) & 0xff;
118 addr
[2] = (val
>> 16) & 0xff;
119 addr
[3] = (val
>> 24) & 0xff;
127 #define NUM_KEYS (sizeof(tea_keytable)/sizeof(tea_keytable[0]))
128 struct tea_key tea_keytable
[] = {
129 { "default" , { 0x20d36cc0, 0x10e8c07d, 0xc0e7dcaa, 0x107eb080 } },
130 { "sansa", { 0xe494e96e, 0x3ee32966, 0x6f48512b, 0xa93fbb42 } },
131 { "sansa_gh", { 0xd7b10538, 0xc662945b, 0x1b3fce68, 0xf389c0e6 } },
132 { "sansa_103", { 0x1d29ddc0, 0x2579c2cd, 0xce339e1a, 0x75465dfe } },
133 { "rhapsody", { 0x7aa9c8dc, 0xbed0a82a, 0x16204cc7, 0x5904ef38 } },
134 { "p610", { 0x950e83dc, 0xec4907f9, 0x023734b9, 0x10cfb7c7 } },
135 { "p640", { 0x220c5f23, 0xd04df68e, 0x431b5e25, 0x4dcc1fa1 } },
136 { "virgin", { 0xe83c29a1, 0x04862973, 0xa9b3f0d4, 0x38be2a9c } },
137 { "20gc_eng", { 0x0240772c, 0x6f3329b5, 0x3ec9a6c5, 0xb0c9e493 } },
138 { "20gc_fre", { 0xbede8817, 0xb23bfe4f, 0x80aa682d, 0xd13f598c } },
139 { "elio_p722", { 0x6af3b9f8, 0x777483f5, 0xae8181cc, 0xfa6d8a84 } },
140 { "c200", { 0xbf2d06fa, 0xf0e23d59, 0x29738132, 0xe2d04ca7 } },
141 { "c200_103", { 0x2a7968de, 0x15127979, 0x142e60a7, 0xe49c1893 } },
142 { "c200_106", { 0xa913d139, 0xf842f398, 0x3e03f1a6, 0x060ee012 } },
147 tea_decrypt() from http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
149 "Following is an adaptation of the reference encryption and decryption
150 routines in C, released into the public domain by David Wheeler and
155 /* NOTE: The mi4 version of TEA uses a different initial value to sum compared
156 to the reference implementation and the main loop is 8 iterations, not
160 static void tea_decrypt(uint32_t* v0
, uint32_t* v1
, uint32_t* k
) {
161 uint32_t sum
=0xF1BBCDC8, i
; /* set up */
162 uint32_t delta
=0x9E3779B9; /* a key schedule constant */
163 uint32_t k0
=k
[0], k1
=k
[1], k2
=k
[2], k3
=k
[3]; /* cache key */
164 for(i
=0; i
<8; i
++) { /* basic cycle start */
165 *v1
-= ((*v0
<<4) + k2
) ^ (*v0
+ sum
) ^ ((*v0
>>5) + k3
);
166 *v0
-= ((*v1
<<4) + k0
) ^ (*v1
+ sum
) ^ ((*v1
>>5) + k1
);
167 sum
-= delta
; /* end cycle */
171 /* mi4 files are encrypted in 64-bit blocks (two little-endian 32-bit
172 integers) and the key is incremented after each block
175 static void tea_decrypt_buf(unsigned char* src
, unsigned char* dest
, size_t n
, uint32_t * key
)
180 for (i
= 0; i
< (n
/ 8); i
++) {
184 tea_decrypt(&v0
, &v1
, key
);
192 /* Now increment the key */
206 static inline bool tea_test_key(unsigned char magic_enc
[8], uint32_t * key
, int unaligned
)
208 unsigned char magic_dec
[8];
209 tea_decrypt_buf(magic_enc
, magic_dec
, 8, key
);
211 return (le2int(&magic_dec
[4*unaligned
]) == 0xaa55aa55);
214 static int tea_find_key(struct mi4header_t
*mi4header
, int fd
)
220 unsigned char magic_enc
[8];
222 unsigned int magic_location
= mi4header
->length
-4;
225 if ( (magic_location
% 8) != 0 )
231 /* Load encrypted magic 0xaa55aa55 to check key */
232 lseek(fd
, MI4_HEADER_SIZE
+ magic_location
, SEEK_SET
);
233 rc
= read(fd
, magic_enc
, 8);
235 return EREAD_IMAGE_FAILED
;
237 printf("Searching for key:");
239 for (i
=0; i
< NUM_KEYS
&& (key_found
<0) ; i
++) {
240 key
[0] = tea_keytable
[i
].key
[0];
241 key
[1] = tea_keytable
[i
].key
[1];
242 key
[2] = tea_keytable
[i
].key
[2];
243 key
[3] = tea_keytable
[i
].key
[3];
245 /* Now increment the key */
246 for(j
=0; j
<((magic_location
-mi4header
->plaintext
)/8); j
++){
259 if (tea_test_key(magic_enc
,key
,unaligned
))
262 printf("%s...found", tea_keytable
[i
].name
);
264 /* printf("%s...failed", tea_keytable[i].name); */
272 /* Load mi4 format firmware image */
273 int load_mi4(unsigned char* buf
, char* firmware
, unsigned int buffer_size
)
276 struct mi4header_t mi4header
;
279 char filename
[MAX_PATH
];
281 snprintf(filename
,sizeof(filename
),"/.rockbox/%s",firmware
);
282 fd
= open(filename
, O_RDONLY
);
285 snprintf(filename
,sizeof(filename
),"/%s",firmware
);
286 fd
= open(filename
, O_RDONLY
);
288 return EFILE_NOT_FOUND
;
291 read(fd
, &mi4header
, MI4_HEADER_SIZE
);
294 printf("mi4 size: %x", mi4header
.mi4size
);
296 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
297 return EFILE_TOO_BIG
;
300 printf("CRC32: %x", mi4header
.crc32
);
302 /* Rockbox model id */
303 printf("Model id: %.4s", mi4header
.model
);
305 /* Read binary type (RBOS, RBBL) */
306 printf("Binary type: %.4s", mi4header
.type
);
308 /* Load firmware file */
309 lseek(fd
, MI4_HEADER_SIZE
, SEEK_SET
);
310 rc
= read(fd
, buf
, mi4header
.mi4size
-MI4_HEADER_SIZE
);
311 if(rc
< (int)mi4header
.mi4size
-MI4_HEADER_SIZE
)
312 return EREAD_IMAGE_FAILED
;
314 /* Check CRC32 to see if we have a valid file */
315 sum
= chksum_crc32 (buf
, mi4header
.mi4size
- MI4_HEADER_SIZE
);
317 printf("Calculated CRC32: %x", sum
);
319 if(sum
!= mi4header
.crc32
)
322 if( (mi4header
.plaintext
+ MI4_HEADER_SIZE
) != mi4header
.mi4size
)
324 /* Load encrypted firmware */
325 int key_index
= tea_find_key(&mi4header
, fd
);
328 return EINVALID_FORMAT
;
330 /* Plaintext part is already loaded */
331 buf
+= mi4header
.plaintext
;
333 /* Decrypt in-place */
334 tea_decrypt_buf(buf
, buf
,
335 mi4header
.mi4size
-(mi4header
.plaintext
+MI4_HEADER_SIZE
),
336 tea_keytable
[key_index
].key
);
338 printf("%s key used", tea_keytable
[key_index
].name
);
340 /* Check decryption was successfull */
341 if(le2int(&buf
[mi4header
.length
-mi4header
.plaintext
-4]) != 0xaa55aa55)
343 return EREAD_IMAGE_FAILED
;
350 #if defined(SANSA_E200) || defined(SANSA_C200)
351 /* Load mi4 firmware from a hidden disk partition */
352 int load_mi4_part(unsigned char* buf
, struct partinfo
* pinfo
,
353 unsigned int buffer_size
, bool disable_rebuild
)
355 struct mi4header_t mi4header
;
356 struct ppmi_header_t ppmi_header
;
359 /* Read header to find out how long the mi4 file is. */
360 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
,
361 PPMI_SECTORS
, &ppmi_header
);
363 /* The first four characters at 0x80000 (sector 1024) should be PPMI*/
364 if( memcmp(ppmi_header
.magic
, "PPMI", 4) )
365 return EFILE_NOT_FOUND
;
367 printf("BL mi4 size: %x", ppmi_header
.length
);
369 /* Read mi4 header of the OF */
370 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
371 + (ppmi_header
.length
/512), MI4_HEADER_SECTORS
, &mi4header
);
373 /* We don't support encrypted mi4 files yet */
374 if( (mi4header
.plaintext
) != (mi4header
.mi4size
-MI4_HEADER_SIZE
))
375 return EINVALID_FORMAT
;
378 printf("OF mi4 size: %x", mi4header
.mi4size
);
380 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
381 return EFILE_TOO_BIG
;
384 printf("CRC32: %x", mi4header
.crc32
);
386 /* Rockbox model id */
387 printf("Model id: %.4s", mi4header
.model
);
389 /* Read binary type (RBOS, RBBL) */
390 printf("Binary type: %.4s", mi4header
.type
);
393 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
394 + (ppmi_header
.length
/512) + MI4_HEADER_SECTORS
,
395 (mi4header
.mi4size
-MI4_HEADER_SIZE
)/512, buf
);
397 /* Check CRC32 to see if we have a valid file */
398 sum
= chksum_crc32 (buf
,mi4header
.mi4size
-MI4_HEADER_SIZE
);
400 printf("Calculated CRC32: %x", sum
);
402 if(sum
!= mi4header
.crc32
)
410 printf("Disabling database rebuild");
412 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ 0x3c08, 1, block
);
414 ata_write_sectors(IF_MV2(0,) pinfo
->start
+ 0x3c08, 1, block
);
417 (void) disable_rebuild
;
430 struct partinfo
* pinfo
;
431 #if defined(SANSA_E200) || defined(SANSA_C200)
436 unsigned short* identify_info
;
439 chksum_crc32gentab ();
446 #if defined(SANSA_E200)
452 lcd_set_foreground(LCD_WHITE
);
453 lcd_set_background(LCD_BLACK
);
460 printf("Hold switch on");
461 printf("Shutting down...");
466 btn
= button_read_device();
467 #if defined(SANSA_E200) || defined(SANSA_C200)
469 while (usb_drv_powered() && usb_retry
< 5 && !usb
)
473 usb
= (usb_detect() == USB_INSERTED
);
476 btn
|= BOOTLOADER_BOOT_OF
;
478 /* Enable bootloader messages if any button is pressed */
482 lcd_setfont(FONT_SYSFIXED
);
484 printf("Rockbox boot loader");
485 printf("Version: %s", version
);
489 #if !defined(SANSA_E200) && !defined(SANSA_C200)
491 identify_info
=ata_get_identify();
493 for (i
=0; i
< 20; i
++) {
494 ((unsigned short*)buf
)[i
]=htobe16(identify_info
[i
+27]);
497 for (i
=39; i
&& buf
[i
]==' '; i
--) {
507 num_partitions
= disk_mount_all();
508 if (num_partitions
<=0)
510 error(EDISK
,num_partitions
);
513 /* Just list the first 2 partitions since we don't have any devices yet
514 that have more than that */
515 for(i
=0; i
<NUM_PARTITIONS
; i
++)
517 pinfo
= disk_partinfo(i
);
518 printf("Partition %d: 0x%02x %ld MB",
519 i
, pinfo
->type
, pinfo
->size
/ 2048);
522 if(btn
& BOOTLOADER_BOOT_OF
)
524 /* Load original mi4 firmware in to a memory buffer called loadbuffer.
525 The rest of the loading is done in crt0.S.
526 1) First try reading from the hidden partition (on Sansa only).
527 2) Next try a decrypted mi4 file in /System/OF.mi4
528 3) Finally, try a raw firmware binary in /System/OF.mi4. It should be
529 a mi4 firmware decrypted and header stripped using mi4code.
531 printf("Loading original firmware...");
533 #if defined(SANSA_E200) || defined(SANSA_C200)
534 /* First try a (hidden) firmware partition */
535 printf("Trying firmware partition");
536 pinfo
= disk_partinfo(1);
537 if(pinfo
->type
== PARTITION_TYPE_OS2_HIDDEN_C_DRIVE
)
539 rc
= load_mi4_part(loadbuffer
, pinfo
, MAX_LOADSIZE
, usb
);
541 printf("Can't load from partition");
542 printf(strerror(rc
));
544 return (void*)loadbuffer
;
547 printf("No hidden partition found.");
551 printf("Trying /System/OF.mi4");
552 rc
=load_mi4(loadbuffer
, "/System/OF.mi4", MAX_LOADSIZE
);
554 printf("Can't load /System/OF.mi4");
555 printf(strerror(rc
));
557 return (void*)loadbuffer
;
560 printf("Trying /System/OF.bin");
561 rc
=load_raw_firmware(loadbuffer
, "/System/OF.bin", MAX_LOADSIZE
);
563 printf("Can't load /System/OF.bin");
564 printf(strerror(rc
));
566 return (void*)loadbuffer
;
572 #if 0 /* e200: enable to be able to dump the hidden partition */
576 pinfo
= disk_partinfo(1);
577 fd
= open("/part.bin", O_CREAT
|O_RDWR
);
579 for(i
=0; i
<40960; i
++){
582 printf("dumping sector %d", i
);
584 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ i
, 1, sector
);
585 write(fd
,sector
,512);
590 printf("Loading Rockbox...");
591 rc
=load_mi4(loadbuffer
, BOOTFILE
, MAX_LOADSIZE
);
593 printf("Can't load %s:", BOOTFILE
);
594 printf(strerror(rc
));
597 /* Try loading rockbox from old rockbox.e200/rockbox.h10 format */
598 rc
=load_firmware(loadbuffer
, OLD_BOOTFILE
, MAX_LOADSIZE
);
600 printf("Can't load %s:", OLD_BOOTFILE
);
601 error(EBOOTFILE
, rc
);
607 return (void*)loadbuffer
;
610 #if !defined(SANSA_E200) && !defined(SANSA_C200)
611 /* These functions are present in the firmware library, but we reimplement
612 them here because the originals do a lot more than we want */
613 void usb_acknowledge(void)
617 void usb_wait_for_disconnect(void)