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) || defined(PHILIPS_SA9200)
39 #include "backlight-target.h"
41 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200)
46 /* Show the Rockbox logo - in show_logo.c */
47 extern int show_logo(void);
49 /* Button definitions */
50 #if CONFIG_KEYPAD == IRIVER_H10_PAD
51 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
53 #elif CONFIG_KEYPAD == SANSA_E200_PAD
54 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
56 #elif CONFIG_KEYPAD == SANSA_C200_PAD
57 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
59 #elif CONFIG_KEYPAD == MROBE100_PAD
60 #define BOOTLOADER_BOOT_OF BUTTON_POWER
62 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
63 #define BOOTLOADER_BOOT_OF BUTTON_VOL_UP
66 /* Maximum allowed firmware image size. 10MB is more than enough */
67 #define MAX_LOADSIZE (10*1024*1024)
69 /* A buffer to load the original firmware or Rockbox into */
70 unsigned char *loadbuffer
= (unsigned char *)DRAM_START
;
72 /* Bootloader version */
73 char version
[] = APPSVERSION
;
75 /* Locations and sizes in hidden partition on Sansa */
76 #if defined(HAVE_ATA_SD)
77 #define PPMI_SECTOR_OFFSET 1024
78 #define PPMI_SECTORS 1
79 #define MI4_HEADER_SECTORS 1
80 #define NUM_PARTITIONS 2
83 #define NUM_PARTITIONS 1
87 #define MI4_HEADER_SIZE 0x200
89 /* mi4 header structure */
91 unsigned char magic
[4];
100 unsigned char type
[4];
101 unsigned char model
[4];
104 /* PPMI header structure */
105 struct ppmi_header_t
{
106 unsigned char magic
[4];
111 inline unsigned int le2int(unsigned char* buf
)
113 int32_t res
= (buf
[3] << 24) | (buf
[2] << 16) | (buf
[1] << 8) | buf
[0];
118 inline void int2le(unsigned int val
, unsigned char* addr
)
120 addr
[0] = val
& 0xFF;
121 addr
[1] = (val
>> 8) & 0xff;
122 addr
[2] = (val
>> 16) & 0xff;
123 addr
[3] = (val
>> 24) & 0xff;
131 #define NUM_KEYS (sizeof(tea_keytable)/sizeof(tea_keytable[0]))
132 struct tea_key tea_keytable
[] = {
133 { "default" , { 0x20d36cc0, 0x10e8c07d, 0xc0e7dcaa, 0x107eb080 } },
134 { "sansa", { 0xe494e96e, 0x3ee32966, 0x6f48512b, 0xa93fbb42 } },
135 { "sansa_gh", { 0xd7b10538, 0xc662945b, 0x1b3fce68, 0xf389c0e6 } },
136 { "sansa_103", { 0x1d29ddc0, 0x2579c2cd, 0xce339e1a, 0x75465dfe } },
137 { "rhapsody", { 0x7aa9c8dc, 0xbed0a82a, 0x16204cc7, 0x5904ef38 } },
138 { "p610", { 0x950e83dc, 0xec4907f9, 0x023734b9, 0x10cfb7c7 } },
139 { "p640", { 0x220c5f23, 0xd04df68e, 0x431b5e25, 0x4dcc1fa1 } },
140 { "virgin", { 0xe83c29a1, 0x04862973, 0xa9b3f0d4, 0x38be2a9c } },
141 { "20gc_eng", { 0x0240772c, 0x6f3329b5, 0x3ec9a6c5, 0xb0c9e493 } },
142 { "20gc_fre", { 0xbede8817, 0xb23bfe4f, 0x80aa682d, 0xd13f598c } },
143 { "elio_p722", { 0x6af3b9f8, 0x777483f5, 0xae8181cc, 0xfa6d8a84 } },
144 { "c200", { 0xbf2d06fa, 0xf0e23d59, 0x29738132, 0xe2d04ca7 } },
145 { "c200_103", { 0x2a7968de, 0x15127979, 0x142e60a7, 0xe49c1893 } },
146 { "c200_106", { 0xa913d139, 0xf842f398, 0x3e03f1a6, 0x060ee012 } },
147 { "view", { 0x70e19bda, 0x0c69ea7d, 0x2b8b1ad1, 0xe9767ced } },
148 { "sa9200", { 0x33ea0236, 0x9247bdc5, 0xdfaedf9f, 0xd67c9d30 } },
153 tea_decrypt() from http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
155 "Following is an adaptation of the reference encryption and decryption
156 routines in C, released into the public domain by David Wheeler and
161 /* NOTE: The mi4 version of TEA uses a different initial value to sum compared
162 to the reference implementation and the main loop is 8 iterations, not
166 static void tea_decrypt(uint32_t* v0
, uint32_t* v1
, uint32_t* k
) {
167 uint32_t sum
=0xF1BBCDC8, i
; /* set up */
168 uint32_t delta
=0x9E3779B9; /* a key schedule constant */
169 uint32_t k0
=k
[0], k1
=k
[1], k2
=k
[2], k3
=k
[3]; /* cache key */
170 for(i
=0; i
<8; i
++) { /* basic cycle start */
171 *v1
-= ((*v0
<<4) + k2
) ^ (*v0
+ sum
) ^ ((*v0
>>5) + k3
);
172 *v0
-= ((*v1
<<4) + k0
) ^ (*v1
+ sum
) ^ ((*v1
>>5) + k1
);
173 sum
-= delta
; /* end cycle */
177 /* mi4 files are encrypted in 64-bit blocks (two little-endian 32-bit
178 integers) and the key is incremented after each block
181 static void tea_decrypt_buf(unsigned char* src
, unsigned char* dest
, size_t n
, uint32_t * key
)
186 for (i
= 0; i
< (n
/ 8); i
++) {
190 tea_decrypt(&v0
, &v1
, key
);
198 /* Now increment the key */
212 static inline bool tea_test_key(unsigned char magic_enc
[8], uint32_t * key
, int unaligned
)
214 unsigned char magic_dec
[8];
215 tea_decrypt_buf(magic_enc
, magic_dec
, 8, key
);
217 return (le2int(&magic_dec
[4*unaligned
]) == 0xaa55aa55);
220 static int tea_find_key(struct mi4header_t
*mi4header
, int fd
)
226 unsigned char magic_enc
[8];
228 unsigned int magic_location
= mi4header
->length
-4;
231 if ( (magic_location
% 8) != 0 )
237 /* Load encrypted magic 0xaa55aa55 to check key */
238 lseek(fd
, MI4_HEADER_SIZE
+ magic_location
, SEEK_SET
);
239 rc
= read(fd
, magic_enc
, 8);
241 return EREAD_IMAGE_FAILED
;
243 printf("Searching for key:");
245 for (i
=0; i
< NUM_KEYS
&& (key_found
<0) ; i
++) {
246 key
[0] = tea_keytable
[i
].key
[0];
247 key
[1] = tea_keytable
[i
].key
[1];
248 key
[2] = tea_keytable
[i
].key
[2];
249 key
[3] = tea_keytable
[i
].key
[3];
251 /* Now increment the key */
252 for(j
=0; j
<((magic_location
-mi4header
->plaintext
)/8); j
++){
265 if (tea_test_key(magic_enc
,key
,unaligned
))
268 printf("%s...found", tea_keytable
[i
].name
);
270 /* printf("%s...failed", tea_keytable[i].name); */
278 /* Load mi4 format firmware image */
279 int load_mi4(unsigned char* buf
, char* firmware
, unsigned int buffer_size
)
282 struct mi4header_t mi4header
;
285 char filename
[MAX_PATH
];
287 snprintf(filename
,sizeof(filename
),"/.rockbox/%s",firmware
);
288 fd
= open(filename
, O_RDONLY
);
291 snprintf(filename
,sizeof(filename
),"/%s",firmware
);
292 fd
= open(filename
, O_RDONLY
);
294 return EFILE_NOT_FOUND
;
297 read(fd
, &mi4header
, MI4_HEADER_SIZE
);
300 printf("mi4 size: %x", mi4header
.mi4size
);
302 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
303 return EFILE_TOO_BIG
;
306 printf("CRC32: %x", mi4header
.crc32
);
308 /* Rockbox model id */
309 printf("Model id: %.4s", mi4header
.model
);
311 /* Read binary type (RBOS, RBBL) */
312 printf("Binary type: %.4s", mi4header
.type
);
314 /* Load firmware file */
315 lseek(fd
, MI4_HEADER_SIZE
, SEEK_SET
);
316 rc
= read(fd
, buf
, mi4header
.mi4size
-MI4_HEADER_SIZE
);
317 if(rc
< (int)mi4header
.mi4size
-MI4_HEADER_SIZE
)
318 return EREAD_IMAGE_FAILED
;
320 /* Check CRC32 to see if we have a valid file */
321 sum
= chksum_crc32 (buf
, mi4header
.mi4size
- MI4_HEADER_SIZE
);
323 printf("Calculated CRC32: %x", sum
);
325 if(sum
!= mi4header
.crc32
)
328 if( (mi4header
.plaintext
+ MI4_HEADER_SIZE
) != mi4header
.mi4size
)
330 /* Load encrypted firmware */
331 int key_index
= tea_find_key(&mi4header
, fd
);
334 return EINVALID_FORMAT
;
336 /* Plaintext part is already loaded */
337 buf
+= mi4header
.plaintext
;
339 /* Decrypt in-place */
340 tea_decrypt_buf(buf
, buf
,
341 mi4header
.mi4size
-(mi4header
.plaintext
+MI4_HEADER_SIZE
),
342 tea_keytable
[key_index
].key
);
344 printf("%s key used", tea_keytable
[key_index
].name
);
346 /* Check decryption was successfull */
347 if(le2int(&buf
[mi4header
.length
-mi4header
.plaintext
-4]) != 0xaa55aa55)
349 return EREAD_IMAGE_FAILED
;
356 #if defined(HAVE_ATA_SD)
357 /* Load mi4 firmware from a hidden disk partition */
358 int load_mi4_part(unsigned char* buf
, struct partinfo
* pinfo
,
359 unsigned int buffer_size
, bool disable_rebuild
)
361 struct mi4header_t mi4header
;
362 struct ppmi_header_t ppmi_header
;
365 /* Read header to find out how long the mi4 file is. */
366 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
,
367 PPMI_SECTORS
, &ppmi_header
);
369 /* The first four characters at 0x80000 (sector 1024) should be PPMI*/
370 if( memcmp(ppmi_header
.magic
, "PPMI", 4) )
371 return EFILE_NOT_FOUND
;
373 printf("BL mi4 size: %x", ppmi_header
.length
);
375 /* Read mi4 header of the OF */
376 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
377 + (ppmi_header
.length
/512), MI4_HEADER_SECTORS
, &mi4header
);
379 /* We don't support encrypted mi4 files yet */
380 if( (mi4header
.plaintext
) != (mi4header
.mi4size
-MI4_HEADER_SIZE
))
381 return EINVALID_FORMAT
;
384 printf("OF mi4 size: %x", mi4header
.mi4size
);
386 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
387 return EFILE_TOO_BIG
;
390 printf("CRC32: %x", mi4header
.crc32
);
392 /* Rockbox model id */
393 printf("Model id: %.4s", mi4header
.model
);
395 /* Read binary type (RBOS, RBBL) */
396 printf("Binary type: %.4s", mi4header
.type
);
399 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
400 + (ppmi_header
.length
/512) + MI4_HEADER_SECTORS
,
401 (mi4header
.mi4size
-MI4_HEADER_SIZE
)/512, buf
);
403 /* Check CRC32 to see if we have a valid file */
404 sum
= chksum_crc32 (buf
,mi4header
.mi4size
-MI4_HEADER_SIZE
);
406 printf("Calculated CRC32: %x", sum
);
408 if(sum
!= mi4header
.crc32
)
416 printf("Disabling database rebuild");
418 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ 0x3c08, 1, block
);
420 ata_write_sectors(IF_MV2(0,) pinfo
->start
+ 0x3c08, 1, block
);
423 (void) disable_rebuild
;
436 struct partinfo
* pinfo
;
437 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200)
442 unsigned short* identify_info
;
445 chksum_crc32gentab ();
456 #if defined(SANSA_E200) || defined(PHILIPS_SA9200)
465 printf("Hold switch on");
466 printf("Shutting down...");
471 btn
= button_read_device();
473 /* Enable bootloader messages if any button is pressed */
479 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200)
480 #if !defined(USE_ROCKBOX_USB)
482 while (usb_drv_powered() && usb_retry
< 5 && !usb
)
486 usb
= (usb_detect() == USB_INSERTED
);
489 btn
|= BOOTLOADER_BOOT_OF
;
490 #endif /* USE_ROCKBOX_USB */
493 lcd_setfont(FONT_SYSFIXED
);
495 printf("Rockbox boot loader");
496 printf("Version: %s", version
);
500 #if !defined(HAVE_ATA_SD)
502 identify_info
=ata_get_identify();
504 for (i
=0; i
< 20; i
++) {
505 ((unsigned short*)buf
)[i
]=htobe16(identify_info
[i
+27]);
508 for (i
=39; i
&& buf
[i
]==' '; i
--) {
518 num_partitions
= disk_mount_all();
519 if (num_partitions
<=0)
521 error(EDISK
,num_partitions
);
524 /* Just list the first 2 partitions since we don't have any devices yet
525 that have more than that */
526 for(i
=0; i
<NUM_PARTITIONS
; i
++)
528 pinfo
= disk_partinfo(i
);
529 printf("Partition %d: 0x%02x %ld MB",
530 i
, pinfo
->type
, pinfo
->size
/ 2048);
533 if(btn
& BOOTLOADER_BOOT_OF
)
535 /* Load original mi4 firmware in to a memory buffer called loadbuffer.
536 The rest of the loading is done in crt0.S.
537 1) First try reading from the hidden partition (on Sansa only).
538 2) Next try a decrypted mi4 file in /System/OF.mi4
539 3) Finally, try a raw firmware binary in /System/OF.mi4. It should be
540 a mi4 firmware decrypted and header stripped using mi4code.
542 printf("Loading original firmware...");
544 #if defined(HAVE_ATA_SD)
545 /* First try a (hidden) firmware partition */
546 printf("Trying firmware partition");
547 pinfo
= disk_partinfo(1);
548 if(pinfo
->type
== PARTITION_TYPE_OS2_HIDDEN_C_DRIVE
)
550 rc
= load_mi4_part(loadbuffer
, pinfo
, MAX_LOADSIZE
, usb
);
552 printf("Can't load from partition");
553 printf(strerror(rc
));
555 return (void*)loadbuffer
;
558 printf("No hidden partition found.");
562 printf("Trying /System/OF.mi4");
563 rc
=load_mi4(loadbuffer
, "/System/OF.mi4", MAX_LOADSIZE
);
565 printf("Can't load /System/OF.mi4");
566 printf(strerror(rc
));
568 return (void*)loadbuffer
;
571 printf("Trying /System/OF.bin");
572 rc
=load_raw_firmware(loadbuffer
, "/System/OF.bin", MAX_LOADSIZE
);
574 printf("Can't load /System/OF.bin");
575 printf(strerror(rc
));
577 return (void*)loadbuffer
;
583 #if 0 /* e200: enable to be able to dump the hidden partition */
587 pinfo
= disk_partinfo(1);
588 fd
= open("/part.bin", O_CREAT
|O_RDWR
);
590 for(i
=0; i
<40960; i
++){
593 printf("dumping sector %d", i
);
595 ata_read_sectors(IF_MV2(0,) pinfo
->start
+ i
, 1, sector
);
596 write(fd
,sector
,512);
601 printf("Loading Rockbox...");
602 rc
=load_mi4(loadbuffer
, BOOTFILE
, MAX_LOADSIZE
);
604 printf("Can't load %s:", BOOTFILE
);
605 printf(strerror(rc
));
608 /* Try loading rockbox from old rockbox.e200/rockbox.h10 format */
609 rc
=load_firmware(loadbuffer
, OLD_BOOTFILE
, MAX_LOADSIZE
);
611 printf("Can't load %s:", OLD_BOOTFILE
);
612 error(EBOOTFILE
, rc
);
618 return (void*)loadbuffer
;
621 #if !defined(SANSA_E200) && !defined(SANSA_C200) && !defined(PHILIPS_SA9200)
622 /* These functions are present in the firmware library, but we reimplement
623 them here because the originals do a lot more than we want */
624 void usb_acknowledge(void)
628 void usb_wait_for_disconnect(void)