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 * 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.
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
23 ****************************************************************************/
39 #include "crc32-mi4.h"
43 #if defined(SANSA_E200) || defined(PHILIPS_SA9200)
45 #include "backlight-target.h"
48 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200)
51 #include "usb-target.h"
52 #if defined(SAMSUNG_YH925)
53 /* this function (in lcd-yh925.c) resets the screen orientation for the OF
54 * for use with dualbooting */
58 /* Show the Rockbox logo - in show_logo.c */
59 extern void show_logo(void);
61 /* Button definitions */
62 #if CONFIG_KEYPAD == IRIVER_H10_PAD
63 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
65 #elif CONFIG_KEYPAD == SANSA_E200_PAD
66 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
68 #elif CONFIG_KEYPAD == SANSA_C200_PAD
69 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
71 #elif CONFIG_KEYPAD == MROBE100_PAD
72 #define BOOTLOADER_BOOT_OF BUTTON_POWER
74 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
75 #define BOOTLOADER_BOOT_OF BUTTON_VOL_UP
77 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
78 #define BOOTLOADER_BOOT_OF BUTTON_MENU
80 #elif CONFIG_KEYPAD == PHILIPS_HDD6330_PAD
81 #define BOOTLOADER_BOOT_OF BUTTON_VOL_UP
83 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
84 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
86 #elif CONFIG_KEYPAD == SANSA_FUZE_PAD
87 #define BOOTLOADER_BOOT_OF BUTTON_LEFT
89 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
90 #define BOOTLOADER_BOOT_OF BUTTON_OK
94 /* Maximum allowed firmware image size. 10MB is more than enough */
95 #define MAX_LOADSIZE (10*1024*1024)
97 /* A buffer to load the original firmware or Rockbox into */
98 unsigned char *loadbuffer
= (unsigned char *)DRAM_START
;
100 /* Locations and sizes in hidden partition on Sansa */
101 #if (CONFIG_STORAGE & STORAGE_SD)
102 #define PPMI_SECTOR_OFFSET 1024
103 #define PPMI_SECTORS 1
104 #define MI4_HEADER_SECTORS 1
105 #define NUM_PARTITIONS 2
108 #define NUM_PARTITIONS 1
112 #define MI4_HEADER_SIZE 0x200
114 /* mi4 header structure */
116 unsigned char magic
[4];
123 uint32_t dsa_key
[10];
125 unsigned char type
[4];
126 unsigned char model
[4];
129 /* PPMI header structure */
130 struct ppmi_header_t
{
131 unsigned char magic
[4];
136 inline unsigned int le2int(unsigned char* buf
)
138 int32_t res
= (buf
[3] << 24) | (buf
[2] << 16) | (buf
[1] << 8) | buf
[0];
143 inline void int2le(unsigned int val
, unsigned char* addr
)
145 addr
[0] = val
& 0xFF;
146 addr
[1] = (val
>> 8) & 0xff;
147 addr
[2] = (val
>> 16) & 0xff;
148 addr
[3] = (val
>> 24) & 0xff;
156 #define NUM_KEYS (sizeof(tea_keytable)/sizeof(tea_keytable[0]))
157 struct tea_key tea_keytable
[] = {
158 { "default" , { 0x20d36cc0, 0x10e8c07d, 0xc0e7dcaa, 0x107eb080 } },
159 { "sansa", { 0xe494e96e, 0x3ee32966, 0x6f48512b, 0xa93fbb42 } },
160 { "sansa_gh", { 0xd7b10538, 0xc662945b, 0x1b3fce68, 0xf389c0e6 } },
161 { "sansa_103", { 0x1d29ddc0, 0x2579c2cd, 0xce339e1a, 0x75465dfe } },
162 { "rhapsody", { 0x7aa9c8dc, 0xbed0a82a, 0x16204cc7, 0x5904ef38 } },
163 { "p610", { 0x950e83dc, 0xec4907f9, 0x023734b9, 0x10cfb7c7 } },
164 { "p640", { 0x220c5f23, 0xd04df68e, 0x431b5e25, 0x4dcc1fa1 } },
165 { "virgin", { 0xe83c29a1, 0x04862973, 0xa9b3f0d4, 0x38be2a9c } },
166 { "20gc_eng", { 0x0240772c, 0x6f3329b5, 0x3ec9a6c5, 0xb0c9e493 } },
167 { "20gc_fre", { 0xbede8817, 0xb23bfe4f, 0x80aa682d, 0xd13f598c } },
168 { "elio_p722", { 0x6af3b9f8, 0x777483f5, 0xae8181cc, 0xfa6d8a84 } },
169 { "c200", { 0xbf2d06fa, 0xf0e23d59, 0x29738132, 0xe2d04ca7 } },
170 { "c200_103", { 0x2a7968de, 0x15127979, 0x142e60a7, 0xe49c1893 } },
171 { "c200_106", { 0xa913d139, 0xf842f398, 0x3e03f1a6, 0x060ee012 } },
172 { "view", { 0x70e19bda, 0x0c69ea7d, 0x2b8b1ad1, 0xe9767ced } },
173 { "sa9200", { 0x33ea0236, 0x9247bdc5, 0xdfaedf9f, 0xd67c9d30 } },
174 { "hdd1630", { 0x04543ced, 0xcebfdbad, 0xf7477872, 0x0d12342e } },
175 { "vibe500", { 0xe3a66156, 0x77c6b67a, 0xe821dca5, 0xca8ca37c } },
180 tea_decrypt() from http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
182 "Following is an adaptation of the reference encryption and decryption
183 routines in C, released into the public domain by David Wheeler and
188 /* NOTE: The mi4 version of TEA uses a different initial value to sum compared
189 to the reference implementation and the main loop is 8 iterations, not
193 static void tea_decrypt(uint32_t* v0
, uint32_t* v1
, uint32_t* k
) {
194 uint32_t sum
=0xF1BBCDC8, i
; /* set up */
195 uint32_t delta
=0x9E3779B9; /* a key schedule constant */
196 uint32_t k0
=k
[0], k1
=k
[1], k2
=k
[2], k3
=k
[3]; /* cache key */
197 for(i
=0; i
<8; i
++) { /* basic cycle start */
198 *v1
-= ((*v0
<<4) + k2
) ^ (*v0
+ sum
) ^ ((*v0
>>5) + k3
);
199 *v0
-= ((*v1
<<4) + k0
) ^ (*v1
+ sum
) ^ ((*v1
>>5) + k1
);
200 sum
-= delta
; /* end cycle */
204 /* mi4 files are encrypted in 64-bit blocks (two little-endian 32-bit
205 integers) and the key is incremented after each block
208 static void tea_decrypt_buf(unsigned char* src
, unsigned char* dest
, size_t n
, uint32_t * key
)
213 for (i
= 0; i
< (n
/ 8); i
++) {
217 tea_decrypt(&v0
, &v1
, key
);
225 /* Now increment the key */
239 static inline bool tea_test_key(unsigned char magic_enc
[8], uint32_t * key
, int unaligned
)
241 unsigned char magic_dec
[8];
242 tea_decrypt_buf(magic_enc
, magic_dec
, 8, key
);
244 return (le2int(&magic_dec
[4*unaligned
]) == 0xaa55aa55);
247 static int tea_find_key(struct mi4header_t
*mi4header
, int fd
)
253 unsigned char magic_enc
[8];
255 unsigned int magic_location
= mi4header
->length
-4;
258 if ( (magic_location
% 8) != 0 )
264 /* Load encrypted magic 0xaa55aa55 to check key */
265 lseek(fd
, MI4_HEADER_SIZE
+ magic_location
, SEEK_SET
);
266 rc
= read(fd
, magic_enc
, 8);
268 return EREAD_IMAGE_FAILED
;
270 printf("Searching for key:");
272 for (i
=0; i
< NUM_KEYS
&& (key_found
<0) ; i
++) {
273 key
[0] = tea_keytable
[i
].key
[0];
274 key
[1] = tea_keytable
[i
].key
[1];
275 key
[2] = tea_keytable
[i
].key
[2];
276 key
[3] = tea_keytable
[i
].key
[3];
278 /* Now increment the key */
279 for(j
=0; j
<((magic_location
-mi4header
->plaintext
)/8); j
++){
292 if (tea_test_key(magic_enc
,key
,unaligned
))
295 printf("%s...found", tea_keytable
[i
].name
);
297 /* printf("%s...failed", tea_keytable[i].name); */
305 /* Load mi4 format firmware image */
306 int load_mi4(unsigned char* buf
, char* firmware
, unsigned int buffer_size
)
309 struct mi4header_t mi4header
;
312 char filename
[MAX_PATH
];
314 snprintf(filename
,sizeof(filename
), BOOTDIR
"/%s",firmware
);
315 fd
= open(filename
, O_RDONLY
);
318 snprintf(filename
,sizeof(filename
),"/%s",firmware
);
319 fd
= open(filename
, O_RDONLY
);
321 return EFILE_NOT_FOUND
;
324 read(fd
, &mi4header
, MI4_HEADER_SIZE
);
327 printf("mi4 size: %x", mi4header
.mi4size
);
329 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
332 return EFILE_TOO_BIG
;
336 printf("CRC32: %x", mi4header
.crc32
);
338 /* Rockbox model id */
339 printf("Model id: %.4s", mi4header
.model
);
341 /* Read binary type (RBOS, RBBL) */
342 printf("Binary type: %.4s", mi4header
.type
);
344 /* Load firmware file */
345 lseek(fd
, MI4_HEADER_SIZE
, SEEK_SET
);
346 rc
= read(fd
, buf
, mi4header
.mi4size
-MI4_HEADER_SIZE
);
347 if(rc
< (int)mi4header
.mi4size
-MI4_HEADER_SIZE
)
350 return EREAD_IMAGE_FAILED
;
353 /* Check CRC32 to see if we have a valid file */
354 sum
= chksum_crc32 (buf
, mi4header
.mi4size
- MI4_HEADER_SIZE
);
356 printf("Calculated CRC32: %x", sum
);
358 if(sum
!= mi4header
.crc32
)
364 if( (mi4header
.plaintext
+ MI4_HEADER_SIZE
) != mi4header
.mi4size
)
366 /* Load encrypted firmware */
367 int key_index
= tea_find_key(&mi4header
, fd
);
372 return EINVALID_FORMAT
;
375 /* Plaintext part is already loaded */
376 buf
+= mi4header
.plaintext
;
378 /* Decrypt in-place */
379 tea_decrypt_buf(buf
, buf
,
380 mi4header
.mi4size
-(mi4header
.plaintext
+MI4_HEADER_SIZE
),
381 tea_keytable
[key_index
].key
);
383 printf("%s key used", tea_keytable
[key_index
].name
);
385 /* Check decryption was successfull */
386 if(le2int(&buf
[mi4header
.length
-mi4header
.plaintext
-4]) != 0xaa55aa55)
389 return EREAD_IMAGE_FAILED
;
397 #if (CONFIG_STORAGE & STORAGE_SD)
398 /* Load mi4 firmware from a hidden disk partition */
399 int load_mi4_part(unsigned char* buf
, struct partinfo
* pinfo
,
400 unsigned int buffer_size
, bool disable_rebuild
)
402 struct mi4header_t mi4header
;
403 struct ppmi_header_t ppmi_header
;
406 /* Read header to find out how long the mi4 file is. */
407 storage_read_sectors(pinfo
->start
+ PPMI_SECTOR_OFFSET
,
408 PPMI_SECTORS
, &ppmi_header
);
410 /* The first four characters at 0x80000 (sector 1024) should be PPMI*/
411 if( memcmp(ppmi_header
.magic
, "PPMI", 4) )
412 return EFILE_NOT_FOUND
;
414 printf("BL mi4 size: %x", ppmi_header
.length
);
416 /* Read mi4 header of the OF */
417 storage_read_sectors(pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
418 + (ppmi_header
.length
/512), MI4_HEADER_SECTORS
, &mi4header
);
420 /* We don't support encrypted mi4 files yet */
421 if( (mi4header
.plaintext
) != (mi4header
.mi4size
-MI4_HEADER_SIZE
))
422 return EINVALID_FORMAT
;
425 printf("OF mi4 size: %x", mi4header
.mi4size
);
427 if ((mi4header
.mi4size
-MI4_HEADER_SIZE
) > buffer_size
)
428 return EFILE_TOO_BIG
;
431 printf("CRC32: %x", mi4header
.crc32
);
433 /* Rockbox model id */
434 printf("Model id: %.4s", mi4header
.model
);
436 /* Read binary type (RBOS, RBBL) */
437 printf("Binary type: %.4s", mi4header
.type
);
440 storage_read_sectors(pinfo
->start
+ PPMI_SECTOR_OFFSET
+ PPMI_SECTORS
441 + (ppmi_header
.length
/512) + MI4_HEADER_SECTORS
,
442 (mi4header
.mi4size
-MI4_HEADER_SIZE
)/512, buf
);
444 /* Check CRC32 to see if we have a valid file */
445 sum
= chksum_crc32 (buf
,mi4header
.mi4size
-MI4_HEADER_SIZE
);
447 printf("Calculated CRC32: %x", sum
);
449 if(sum
!= mi4header
.crc32
)
457 printf("Disabling database rebuild");
459 storage_read_sectors(pinfo
->start
+ 0x3c08, 1, block
);
461 storage_write_sectors(pinfo
->start
+ 0x3c08, 1, block
);
464 (void) disable_rebuild
;
469 #endif /* (CONFIG_STORAGE & STORAGE_SD) */
471 #ifdef HAVE_BOOTLOADER_USB_MODE
472 /* Return USB_HANDLED if session took place else return USB_EXTRACTED */
473 static int handle_usb(int connect_timeout
)
475 static struct event_queue q SHAREDBSS_ATTR
;
476 struct queue_event ev
;
477 int usb
= USB_EXTRACTED
;
481 return USB_EXTRACTED
;
483 queue_init(&q
, true);
485 usb_start_monitoring();
487 printf("USB: Connecting");
489 if (connect_timeout
!= TIMEOUT_BLOCK
)
490 end_tick
= current_tick
+ connect_timeout
;
494 /* Sleep no longer than 1/2s */
495 queue_wait_w_tmo(&q
, &ev
, HZ
/2);
497 if (ev
.id
== SYS_USB_CONNECTED
)
499 /* Switch to verbose mode if not in it so that the status updates
502 /* Got the message - wait for disconnect */
503 printf("Bootloader USB mode");
506 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
507 usb_wait_for_disconnect(&q
);
511 if (connect_timeout
!= TIMEOUT_BLOCK
&&
512 TIME_AFTER(current_tick
, end_tick
))
514 /* Timed out waiting for the connect - will happen when connected
515 * to a charger instead of a host port and the charging pin is
516 * the same as the USB pin */
517 printf("USB: Timed out");
522 break; /* Cable pulled */
530 #elif (defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200) \
531 || defined (SANSA_VIEW)) && !defined(USE_ROCKBOX_USB)
532 /* Return USB_INSERTED if cable present */
533 static int handle_usb(int connect_timeout
)
536 int usb
= USB_EXTRACTED
;
539 while (usb_drv_powered() && usb_retry
< 5 && usb
!= USB_INSERTED
)
546 if (usb
!= USB_INSERTED
)
550 (void)connect_timeout
;
553 /* Ignore cable state */
554 static int handle_usb(int connect_timeout
)
556 return USB_EXTRACTED
;
557 (void)connect_timeout
;
559 #endif /* HAVE_BOOTLOADER_USB_MODE */
567 struct partinfo
* pinfo
;
568 #if !(CONFIG_STORAGE & STORAGE_SD)
570 unsigned short* identify_info
;
572 int usb
= USB_EXTRACTED
;
574 chksum_crc32gentab ();
579 #ifdef HAVE_BOOTLOADER_USB_MODE
580 /* loader must service interrupts */
581 enable_interrupt(IRQ_FIQ_STATUS
);
590 #ifdef HAVE_BOOTLOADER_USB_MODE
591 button_init_device();
595 #if defined(SANSA_E200) || defined(PHILIPS_SA9200)
604 printf("Hold switch on");
605 printf("Shutting down...");
610 btn
= button_read_device();
612 /* Enable bootloader messages if any button is pressed */
613 #ifdef HAVE_BOOTLOADER_USB_MODE
624 lcd_setfont(FONT_SYSFIXED
);
626 printf("Rockbox boot loader");
627 printf("Version: " RBVERSION
);
631 #if !(CONFIG_STORAGE & STORAGE_SD)
633 identify_info
=ata_get_identify();
635 for (i
=0; i
< 20; i
++) {
636 ((unsigned short*)buf
)[i
]=htobe16(identify_info
[i
+27]);
639 for (i
=39; i
&& buf
[i
]==' '; i
--) {
644 error(EATA
, i
, true);
649 num_partitions
= disk_mount_all();
650 if (num_partitions
<=0)
652 error(EDISK
,num_partitions
, true);
655 /* Just list the first 2 partitions since we don't have any devices yet
656 that have more than that */
657 for(i
=0; i
<NUM_PARTITIONS
; i
++)
659 pinfo
= disk_partinfo(i
);
660 printf("Partition %d: 0x%02x %ld MB",
661 i
, pinfo
->type
, pinfo
->size
/ 2048);
664 /* Now that storage is initialized, check for USB connection */
665 if ((btn
& BOOTLOADER_BOOT_OF
) == 0)
668 usb
= handle_usb(HZ
*2);
669 if (usb
== USB_INSERTED
)
670 btn
|= BOOTLOADER_BOOT_OF
;
673 /* Try loading Rockbox, if that fails, fall back to the OF */
674 if((btn
& BOOTLOADER_BOOT_OF
) == 0)
676 printf("Loading Rockbox...");
677 rc
= load_mi4(loadbuffer
, BOOTFILE
, MAX_LOADSIZE
);
680 bool old_verbose
= verbose
;
682 printf("Can't load " BOOTFILE
": ");
683 printf(strerror(rc
));
684 verbose
= old_verbose
;
685 btn
|= BOOTLOADER_BOOT_OF
;
692 if(btn
& BOOTLOADER_BOOT_OF
)
694 /* Load original mi4 firmware in to a memory buffer called loadbuffer.
695 The rest of the loading is done in crt0.S.
696 1) First try reading from the hidden partition (on Sansa only).
697 2) Next try a decrypted mi4 file in /System/OF.mi4
698 3) Finally, try a raw firmware binary in /System/OF.bin. It should be
699 a mi4 firmware decrypted and header stripped using mi4code.
701 printf("Loading original firmware...");
703 #if (CONFIG_STORAGE & STORAGE_SD)
704 /* First try a (hidden) firmware partition */
705 printf("Trying firmware partition");
706 pinfo
= disk_partinfo(1);
707 if(pinfo
->type
== PARTITION_TYPE_OS2_HIDDEN_C_DRIVE
)
709 rc
= load_mi4_part(loadbuffer
, pinfo
, MAX_LOADSIZE
,
710 usb
== USB_INSERTED
);
712 printf("Can't load from partition");
713 printf(strerror(rc
));
718 printf("No hidden partition found.");
722 #if defined(PHILIPS_HDD1630) || defined(PHILIPS_HDD6330) || defined(PHILIPS_SA9200)
723 printf("Trying /System/OF.ebn");
724 rc
=load_mi4(loadbuffer
, "/System/OF.ebn", MAX_LOADSIZE
);
726 printf("Can't load /System/OF.ebn");
727 printf(strerror(rc
));
733 printf("Trying /System/OF.mi4");
734 rc
=load_mi4(loadbuffer
, "/System/OF.mi4", MAX_LOADSIZE
);
736 printf("Can't load /System/OF.mi4");
737 printf(strerror(rc
));
739 #if defined(SAMSUNG_YH925)
745 printf("Trying /System/OF.bin");
746 rc
=load_raw_firmware(loadbuffer
, "/System/OF.bin", MAX_LOADSIZE
);
748 printf("Can't load /System/OF.bin");
749 printf(strerror(rc
));
751 #if defined(SAMSUNG_YH925)
761 #ifdef HAVE_BOOTLOADER_USB_MODE
763 system_prepare_fw_start();
766 return (void*)loadbuffer
;