The-Homebrew-Cloud/diosmios
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*added DML code to SVN

Browse Source 
git-svn-id: svn://localhost/Users/andi/Downloads/code/DML@26 be6c1b03-d731-4111-a574-e37d80d43941
This commit is contained in:
crediar@rypp.net 2012-08-09 00:17:50 +00:00
parent 07de30cf8b
commit b61acfedff
24 changed files with 576 additions and 711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
Card.c
View File

@ -57,6 +57,7 @@ void CardInit( void )
write32( 0x2FA0, 0 ); write32( 0x2FA0, 0 );
} }
s32 CardFindFreeEntry( void ) s32 CardFindFreeEntry( void )
{ {
CARDStat CStat; CARDStat CStat;
@ -144,7 +145,7 @@ s32 CardFastOpenFile( u32 FileNo, CARDFileInfo *CFInfo )
{ {
CARDStat CStat; CARDStat CStat;
FIL savefile; FIL savefile;
s32 fres; s32 Slot,fres;
u32 read; u32 read;
if( FileNo >= CARD_MAX_FILES ) if( FileNo >= CARD_MAX_FILES )
@ -505,10 +506,9 @@ void CardUpdateStats( CARDStat *CStat )
CStat->offsetData = Offset; CStat->offsetData = Offset;
} }
u32 Device = 0;
void CARDUpdateRegisters( void ) void CARDUpdateRegisters( void )
{ {
u32 read; u32 read,i;
if( read32(CARD_CONTROL) != 0xdeadbeef ) if( read32(CARD_CONTROL) != 0xdeadbeef )
{ {
@ -524,20 +524,17 @@ void CARDUpdateRegisters( void )
write32( CARD_CONTROL, 0xdeadbeef ); write32( CARD_CONTROL, 0xdeadbeef );
#ifdef ACTIVITYLED if( ConfigGetConfig(DML_CFG_ACTIVITY_LED) )
set32( HW_GPIO_OUT, 1<<5 ); set32( HW_GPIO_OUT, 1<<5 );
#endif
while( read32(CARD_CMD) == 0xdeadbeef ); while( read32(CARD_CMD) == 0xdeadbeef );
write32( CARD_SCMD, read32(CARD_CMD) ); write32( CARD_SCMD, read32(CARD_CMD) );
write32( CARD_CMD, 0xdeadbeef ); write32( CARD_CMD, 0xdeadbeef );
if( read32(CARD_CMD_1) != 0xdeadbeef )
{
write32( CARD_SCMD_1, read32(CARD_CMD_1) );
write32( CARD_CMD_1, 0xdeadbeef );
}
while( read32(CARD_CMD_1) == 0xdeadbeef );
write32( CARD_SCMD_1, read32(CARD_CMD_1) );
write32( CARD_CMD_1, 0xdeadbeef );
if( read32(CARD_CMD_2) != 0xdeadbeef ) if( read32(CARD_CMD_2) != 0xdeadbeef )
{ {
write32( CARD_SCMD_2, read32(CARD_CMD_2) ); write32( CARD_SCMD_2, read32(CARD_CMD_2) );
@ -565,12 +562,9 @@ void CARDUpdateRegisters( void )
default: default:
{ {
//EXIControl(1); //EXIControl(1);
dbgprintf("CARD:Unknown CMD:%08X %08X %08X %08X %08X %08X\n", read32(CARD_SCMD), read32(CARD_SCMD_1), read32(CARD_SCMD_2), read32(CARD_SCMD_3), read32(CARD_SCMD_4), read32(CARD_SCONTROL) ); dbgprintf("CARD:Unknown CMD:%08X %08X %08X %08X %08X %08X\n", read32(CARD_SCMD), read32(CARD_SCMD_1), read32(CARD_SCMD_2), read32(CARD_SCMD_3), read32(CARD_SCMD_4), read32(CARD_SCONTROL) );
Shutdown(); Shutdown();
} break; } break;
/* CARDOpen( char *FileName ) */ /* CARDOpen( char *FileName ) */
case 0xC0: case 0xC0:
{ {
@ -942,8 +936,8 @@ void CARDUpdateRegisters( void )
#endif #endif
} break; } break;
} }
#ifdef ACTIVITYLED
clear32( HW_GPIO_OUT, 1<<5 ); if( ConfigGetConfig(DML_CFG_ACTIVITY_LED) )
#endif clear32( HW_GPIO_OUT, 1<<5 );
} }
} }

5
Card.h
View File

@ -8,9 +8,7 @@
#include "vsprintf.h" #include "vsprintf.h"
#include "HW.h" #include "HW.h"
#include "vsprintf.h" #include "vsprintf.h"
#ifdef TRIFORCE
#include "JVSIOMessage.h"
#endif
#define CARD_MAX_FILES 128 #define CARD_MAX_FILES 128
#define CARD_BASE 0x00002F60 #define CARD_BASE 0x00002F60
@ -45,7 +43,6 @@
#define CARD_XFER_SETATTRIBUTES (1 * 8 * 1024) // CARDSetAttributes[Async] #define CARD_XFER_SETATTRIBUTES (1 * 8 * 1024) // CARDSetAttributes[Async]
#define CARD_XFER_WRITE (1 * 8 * 1024) // CARDWrite[Async] #define CARD_XFER_WRITE (1 * 8 * 1024) // CARDWrite[Async]
#define CARD_FILENAME_MAX 32 #define CARD_FILENAME_MAX 32
#define CARD_ICON_MAX 8 #define CARD_ICON_MAX 8

349
CheatCode.c
View File

@ -271,178 +271,177 @@ unsigned char kenobigcDBG[4288] =
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}; };
unsigned char kenobigc[2736] =
//unsigned char kenobigc[2736] = {
//{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x21, 0x60, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x21, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x21, 0xff, 0x58, 0x90, 0x01, 0x00, 0x08,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x21, 0xff, 0x58, 0x90, 0x01, 0x00, 0x08, 0x7c, 0x08, 0x02, 0xa6, 0x90, 0x01, 0x00, 0xac, 0x7c, 0x00, 0x00, 0x26, 0x90, 0x01, 0x00, 0x0c,
// 0x7c, 0x08, 0x02, 0xa6, 0x90, 0x01, 0x00, 0xac, 0x7c, 0x00, 0x00, 0x26, 0x90, 0x01, 0x00, 0x0c, 0x7c, 0x09, 0x02, 0xa6, 0x90, 0x01, 0x00, 0x10, 0x7c, 0x01, 0x02, 0xa6, 0x90, 0x01, 0x00, 0x14,
// 0x7c, 0x09, 0x02, 0xa6, 0x90, 0x01, 0x00, 0x10, 0x7c, 0x01, 0x02, 0xa6, 0x90, 0x01, 0x00, 0x14, 0xbc, 0x61, 0x00, 0x18, 0x7f, 0x20, 0x00, 0xa6, 0x63, 0x3a, 0x20, 0x00, 0x73, 0x5a, 0xf9, 0xff,
// 0xbc, 0x61, 0x00, 0x18, 0x7f, 0x20, 0x00, 0xa6, 0x63, 0x3a, 0x20, 0x00, 0x73, 0x5a, 0xf9, 0xff, 0x7f, 0x40, 0x01, 0x24, 0xd8, 0x41, 0x00, 0x98, 0xd8, 0x61, 0x00, 0xa0, 0x3f, 0xe0, 0x80, 0x00,
// 0x7f, 0x40, 0x01, 0x24, 0xd8, 0x41, 0x00, 0x98, 0xd8, 0x61, 0x00, 0xa0, 0x3f, 0xe0, 0x80, 0x00, 0x3e, 0x80, 0xcc, 0x00, 0xa3, 0x94, 0x40, 0x10, 0x63, 0x95, 0x00, 0xff, 0xb2, 0xb4, 0x40, 0x10,
// 0x3e, 0x80, 0xcc, 0x00, 0xa3, 0x94, 0x40, 0x10, 0x63, 0x95, 0x00, 0xff, 0xb2, 0xb4, 0x40, 0x10, 0x7f, 0xa8, 0x02, 0xa6, 0x3d, 0xe0, 0x80, 0x00, 0x61, 0xef, 0x22, 0xa8, 0x63, 0xe7, 0x18, 0x08,
// 0x7f, 0xa8, 0x02, 0xa6, 0x3d, 0xe0, 0x80, 0x00, 0x61, 0xef, 0x22, 0xa8, 0x63, 0xe7, 0x18, 0x08, 0x3c, 0xc0, 0x80, 0x00, 0x7c, 0xd0, 0x33, 0x78, 0x39, 0x00, 0x00, 0x00, 0x3c, 0x60, 0x00, 0xd0,
// 0x3c, 0xc0, 0x80, 0x00, 0x7c, 0xd0, 0x33, 0x78, 0x39, 0x00, 0x00, 0x00, 0x3c, 0x60, 0x00, 0xd0, 0x60, 0x63, 0xc0, 0xde, 0x80, 0x8f, 0x00, 0x00, 0x7c, 0x03, 0x20, 0x00, 0x40, 0x82, 0x00, 0x18,
// 0x60, 0x63, 0xc0, 0xde, 0x80, 0x8f, 0x00, 0x00, 0x7c, 0x03, 0x20, 0x00, 0x40, 0x82, 0x00, 0x18, 0x80, 0x8f, 0x00, 0x04, 0x7c, 0x03, 0x20, 0x00, 0x40, 0x82, 0x00, 0x0c, 0x39, 0xef, 0x00, 0x08,
// 0x80, 0x8f, 0x00, 0x04, 0x7c, 0x03, 0x20, 0x00, 0x40, 0x82, 0x00, 0x0c, 0x39, 0xef, 0x00, 0x08, 0x48, 0x00, 0x00, 0x4c, 0x7f, 0xa8, 0x03, 0xa6, 0xb3, 0x94, 0x40, 0x10, 0xc8, 0x41, 0x00, 0x98,
// 0x48, 0x00, 0x00, 0x4c, 0x7f, 0xa8, 0x03, 0xa6, 0xb3, 0x94, 0x40, 0x10, 0xc8, 0x41, 0x00, 0x98, 0xc8, 0x61, 0x00, 0xa0, 0x7f, 0x20, 0x00, 0xa6, 0x80, 0x01, 0x00, 0xac, 0x7c, 0x08, 0x03, 0xa6,
// 0xc8, 0x61, 0x00, 0xa0, 0x7f, 0x20, 0x00, 0xa6, 0x80, 0x01, 0x00, 0xac, 0x7c, 0x08, 0x03, 0xa6, 0x80, 0x01, 0x00, 0x0c, 0x7c, 0x0f, 0xf1, 0x20, 0x80, 0x01, 0x00, 0x10, 0x7c, 0x09, 0x03, 0xa6,
// 0x80, 0x01, 0x00, 0x0c, 0x7c, 0x0f, 0xf1, 0x20, 0x80, 0x01, 0x00, 0x10, 0x7c, 0x09, 0x03, 0xa6, 0x80, 0x01, 0x00, 0x14, 0x7c, 0x01, 0x03, 0xa6, 0xb8, 0x61, 0x00, 0x18, 0x80, 0x01, 0x00, 0x08,
// 0x80, 0x01, 0x00, 0x14, 0x7c, 0x01, 0x03, 0xa6, 0xb8, 0x61, 0x00, 0x18, 0x80, 0x01, 0x00, 0x08, 0x38, 0x21, 0x00, 0xa8, 0x4c, 0x00, 0x01, 0x2c, 0x4e, 0x80, 0x00, 0x20, 0x80, 0x6f, 0x00, 0x00,
// 0x38, 0x21, 0x00, 0xa8, 0x4c, 0x00, 0x01, 0x2c, 0x4e, 0x80, 0x00, 0x20, 0x80, 0x6f, 0x00, 0x00, 0x80, 0x8f, 0x00, 0x04, 0x39, 0xef, 0x00, 0x08, 0x71, 0x09, 0x00, 0x01, 0x2f, 0x89, 0x00, 0x00,
// 0x80, 0x8f, 0x00, 0x04, 0x39, 0xef, 0x00, 0x08, 0x71, 0x09, 0x00, 0x01, 0x2f, 0x89, 0x00, 0x00, 0x39, 0x20, 0x00, 0x00, 0x54, 0x6a, 0x1f, 0x7e, 0x54, 0x65, 0x3f, 0x7e, 0x74, 0x6b, 0x10, 0x00,
// 0x39, 0x20, 0x00, 0x00, 0x54, 0x6a, 0x1f, 0x7e, 0x54, 0x65, 0x3f, 0x7e, 0x74, 0x6b, 0x10, 0x00, 0x54, 0x63, 0x01, 0xfe, 0x40, 0x82, 0x00, 0x0c, 0x54, 0xcc, 0x00, 0x0c, 0x48, 0x00, 0x00, 0x08,
// 0x54, 0x63, 0x01, 0xfe, 0x40, 0x82, 0x00, 0x0c, 0x54, 0xcc, 0x00, 0x0c, 0x48, 0x00, 0x00, 0x08, 0x7e, 0x0c, 0x83, 0x78, 0x2e, 0x05, 0x00, 0x00, 0x2c, 0x0a, 0x00, 0x01, 0x41, 0xa0, 0x00, 0x2c,
// 0x7e, 0x0c, 0x83, 0x78, 0x2e, 0x05, 0x00, 0x00, 0x2c, 0x0a, 0x00, 0x01, 0x41, 0xa0, 0x00, 0x2c, 0x41, 0xa2, 0x00, 0xe4, 0x2c, 0x0a, 0x00, 0x03, 0x41, 0xa0, 0x01, 0xac, 0x41, 0x82, 0x02, 0x50,
// 0x41, 0xa2, 0x00, 0xe4, 0x2c, 0x0a, 0x00, 0x03, 0x41, 0xa0, 0x01, 0xac, 0x41, 0x82, 0x02, 0x50, 0x2c, 0x0a, 0x00, 0x05, 0x41, 0x80, 0x02, 0xd4, 0x41, 0xa2, 0x04, 0xe0, 0x2c, 0x0a, 0x00, 0x07,
// 0x2c, 0x0a, 0x00, 0x05, 0x41, 0x80, 0x02, 0xd4, 0x41, 0xa2, 0x04, 0xe0, 0x2c, 0x0a, 0x00, 0x07, 0x41, 0xa0, 0x05, 0x0c, 0x48, 0x00, 0x05, 0xf0, 0x7d, 0x8c, 0x1a, 0x14, 0x2c, 0x05, 0x00, 0x03,
// 0x41, 0xa0, 0x05, 0x0c, 0x48, 0x00, 0x05, 0xf0, 0x7d, 0x8c, 0x1a, 0x14, 0x2c, 0x05, 0x00, 0x03, 0x41, 0x82, 0x00, 0x48, 0x41, 0x81, 0x00, 0x60, 0x40, 0xbe, 0xff, 0x84, 0x2e, 0x05, 0x00, 0x01,
// 0x41, 0x82, 0x00, 0x48, 0x41, 0x81, 0x00, 0x60, 0x40, 0xbe, 0xff, 0x84, 0x2e, 0x05, 0x00, 0x01, 0x41, 0x91, 0x00, 0x2c, 0x54, 0x8a, 0x84, 0x3e, 0x41, 0x92, 0x00, 0x10, 0x7c, 0x89, 0x61, 0xae,
// 0x41, 0x91, 0x00, 0x2c, 0x54, 0x8a, 0x84, 0x3e, 0x41, 0x92, 0x00, 0x10, 0x7c, 0x89, 0x61, 0xae, 0x39, 0x29, 0x00, 0x01, 0x48, 0x00, 0x00, 0x0c, 0x7c, 0x89, 0x63, 0x2e, 0x39, 0x29, 0x00, 0x02,
// 0x39, 0x29, 0x00, 0x01, 0x48, 0x00, 0x00, 0x0c, 0x7c, 0x89, 0x63, 0x2e, 0x39, 0x29, 0x00, 0x02, 0x35, 0x4a, 0xff, 0xff, 0x40, 0xa0, 0xff, 0xe4, 0x4b, 0xff, 0xff, 0x54, 0x55, 0x8c, 0x00, 0x3a,
// 0x35, 0x4a, 0xff, 0xff, 0x40, 0xa0, 0xff, 0xe4, 0x4b, 0xff, 0xff, 0x54, 0x55, 0x8c, 0x00, 0x3a, 0x90, 0x8c, 0x00, 0x00, 0x4b, 0xff, 0xff, 0x48, 0x7c, 0x89, 0x23, 0x78, 0x40, 0x9e, 0x04, 0xc8,
// 0x90, 0x8c, 0x00, 0x00, 0x4b, 0xff, 0xff, 0x48, 0x7c, 0x89, 0x23, 0x78, 0x40, 0x9e, 0x04, 0xc8, 0x35, 0x29, 0xff, 0xff, 0x41, 0x80, 0x04, 0xc0, 0x7c, 0xa9, 0x78, 0xae, 0x7c, 0xa9, 0x61, 0xae,
// 0x35, 0x29, 0xff, 0xff, 0x41, 0x80, 0x04, 0xc0, 0x7c, 0xa9, 0x78, 0xae, 0x7c, 0xa9, 0x61, 0xae, 0x4b, 0xff, 0xff, 0xf0, 0x39, 0xef, 0x00, 0x08, 0x40, 0xbe, 0xff, 0x24, 0x80, 0xaf, 0xff, 0xf8,
// 0x4b, 0xff, 0xff, 0xf0, 0x39, 0xef, 0x00, 0x08, 0x40, 0xbe, 0xff, 0x24, 0x80, 0xaf, 0xff, 0xf8, 0x81, 0x6f, 0xff, 0xfc, 0x54, 0xb1, 0x04, 0x3e, 0x54, 0xaa, 0x85, 0x3e, 0x54, 0xa5, 0x27, 0x3e,
// 0x81, 0x6f, 0xff, 0xfc, 0x54, 0xb1, 0x04, 0x3e, 0x54, 0xaa, 0x85, 0x3e, 0x54, 0xa5, 0x27, 0x3e, 0x2e, 0x85, 0x00, 0x01, 0x41, 0x96, 0x00, 0x10, 0x41, 0xb5, 0x00, 0x14, 0x7c, 0x89, 0x61, 0xae,
// 0x2e, 0x85, 0x00, 0x01, 0x41, 0x96, 0x00, 0x10, 0x41, 0xb5, 0x00, 0x14, 0x7c, 0x89, 0x61, 0xae, 0x48, 0x00, 0x00, 0x10, 0x7c, 0x89, 0x63, 0x2e, 0x48, 0x00, 0x00, 0x08, 0x7c, 0x89, 0x61, 0x2e,
// 0x48, 0x00, 0x00, 0x10, 0x7c, 0x89, 0x63, 0x2e, 0x48, 0x00, 0x00, 0x08, 0x7c, 0x89, 0x61, 0x2e, 0x7c, 0x84, 0x5a, 0x14, 0x7d, 0x29, 0x8a, 0x14, 0x35, 0x4a, 0xff, 0xff, 0x40, 0x80, 0xff, 0xd4,
// 0x7c, 0x84, 0x5a, 0x14, 0x7d, 0x29, 0x8a, 0x14, 0x35, 0x4a, 0xff, 0xff, 0x40, 0x80, 0xff, 0xd4, 0x4b, 0xff, 0xfe, 0xdc, 0x54, 0x69, 0x07, 0xff, 0x41, 0x82, 0x00, 0x10, 0x55, 0x08, 0xf8, 0x7e,
// 0x4b, 0xff, 0xfe, 0xdc, 0x54, 0x69, 0x07, 0xff, 0x41, 0x82, 0x00, 0x10, 0x55, 0x08, 0xf8, 0x7e, 0x71, 0x09, 0x00, 0x01, 0x2f, 0x89, 0x00, 0x00, 0x2e, 0x85, 0x00, 0x04, 0x2d, 0x8a, 0x00, 0x05,
// 0x71, 0x09, 0x00, 0x01, 0x2f, 0x89, 0x00, 0x00, 0x2e, 0x85, 0x00, 0x04, 0x2d, 0x8a, 0x00, 0x05, 0x51, 0x08, 0x08, 0x3c, 0x40, 0x9e, 0x00, 0x78, 0x41, 0x8d, 0x04, 0xb8, 0x7d, 0x8c, 0x1a, 0x14,
// 0x51, 0x08, 0x08, 0x3c, 0x40, 0x9e, 0x00, 0x78, 0x41, 0x8d, 0x04, 0xb8, 0x7d, 0x8c, 0x1a, 0x14, 0x41, 0x8c, 0x00, 0x0c, 0x41, 0x94, 0x00, 0x30, 0x48, 0x00, 0x00, 0x1c, 0x40, 0x94, 0x00, 0x10,
// 0x41, 0x8c, 0x00, 0x0c, 0x41, 0x94, 0x00, 0x30, 0x48, 0x00, 0x00, 0x1c, 0x40, 0x94, 0x00, 0x10, 0x55, 0x8c, 0x00, 0x3a, 0x81, 0x6c, 0x00, 0x00, 0x48, 0x00, 0x00, 0x1c, 0x55, 0x8c, 0x00, 0x3c,
// 0x55, 0x8c, 0x00, 0x3a, 0x81, 0x6c, 0x00, 0x00, 0x48, 0x00, 0x00, 0x1c, 0x55, 0x8c, 0x00, 0x3c, 0xa1, 0x6c, 0x00, 0x00, 0x7c, 0x89, 0x20, 0xf8, 0x55, 0x29, 0x84, 0x3e, 0x7d, 0x6b, 0x48, 0x38,
// 0xa1, 0x6c, 0x00, 0x00, 0x7c, 0x89, 0x20, 0xf8, 0x55, 0x29, 0x84, 0x3e, 0x7d, 0x6b, 0x48, 0x38, 0x54, 0x84, 0x04, 0x3e, 0x7f, 0x0b, 0x20, 0x40, 0x70, 0xa9, 0x00, 0x03, 0x41, 0x82, 0x00, 0x18,
// 0x54, 0x84, 0x04, 0x3e, 0x7f, 0x0b, 0x20, 0x40, 0x70, 0xa9, 0x00, 0x03, 0x41, 0x82, 0x00, 0x18, 0x2c, 0x09, 0x00, 0x02, 0x41, 0x82, 0x00, 0x18, 0x41, 0x81, 0x00, 0x1c, 0x40, 0x9a, 0x00, 0x20,
// 0x2c, 0x09, 0x00, 0x02, 0x41, 0x82, 0x00, 0x18, 0x41, 0x81, 0x00, 0x1c, 0x40, 0x9a, 0x00, 0x20, 0x48, 0x00, 0x00, 0x18, 0x41, 0x9a, 0x00, 0x18, 0x48, 0x00, 0x00, 0x10, 0x41, 0x99, 0x00, 0x10,
// 0x48, 0x00, 0x00, 0x18, 0x41, 0x9a, 0x00, 0x18, 0x48, 0x00, 0x00, 0x10, 0x41, 0x99, 0x00, 0x10, 0x48, 0x00, 0x00, 0x08, 0x41, 0x98, 0x00, 0x08, 0x61, 0x08, 0x00, 0x01, 0x40, 0x8e, 0xfe, 0x40,
// 0x48, 0x00, 0x00, 0x08, 0x41, 0x98, 0x00, 0x08, 0x61, 0x08, 0x00, 0x01, 0x40, 0x8e, 0xfe, 0x40, 0x41, 0x94, 0xfe, 0x3c, 0x81, 0x6f, 0xff, 0xf8, 0x40, 0x9e, 0x00, 0x20, 0x70, 0x6c, 0x00, 0x08,
// 0x41, 0x94, 0xfe, 0x3c, 0x81, 0x6f, 0xff, 0xf8, 0x40, 0x9e, 0x00, 0x20, 0x70, 0x6c, 0x00, 0x08, 0x41, 0x82, 0x00, 0x0c, 0x71, 0x0c, 0x00, 0x01, 0x41, 0x82, 0x00, 0x10, 0x39, 0x8b, 0x00, 0x10,
// 0x41, 0x82, 0x00, 0x0c, 0x71, 0x0c, 0x00, 0x01, 0x41, 0x82, 0x00, 0x10, 0x39, 0x8b, 0x00, 0x10, 0x51, 0x8b, 0x03, 0x36, 0x48, 0x00, 0x00, 0x08, 0x55, 0x6b, 0x07, 0x16, 0x91, 0x6f, 0xff, 0xf8,
// 0x51, 0x8b, 0x03, 0x36, 0x48, 0x00, 0x00, 0x08, 0x55, 0x6b, 0x07, 0x16, 0x91, 0x6f, 0xff, 0xf8, 0x4b, 0xff, 0xfe, 0x0c, 0x40, 0xbe, 0xfe, 0x08, 0x54, 0x69, 0x16, 0xba, 0x54, 0x6e, 0x87, 0xfe,
// 0x4b, 0xff, 0xfe, 0x0c, 0x40, 0xbe, 0xfe, 0x08, 0x54, 0x69, 0x16, 0xba, 0x54, 0x6e, 0x87, 0xfe, 0x2d, 0x8e, 0x00, 0x00, 0x2e, 0x05, 0x00, 0x04, 0x70, 0xae, 0x00, 0x03, 0x2e, 0x8e, 0x00, 0x02,
// 0x2d, 0x8e, 0x00, 0x00, 0x2e, 0x05, 0x00, 0x04, 0x70, 0xae, 0x00, 0x03, 0x2e, 0x8e, 0x00, 0x02, 0x41, 0x94, 0x00, 0x14, 0x41, 0x96, 0x00, 0x50, 0x7c, 0x64, 0x07, 0x34, 0x7c, 0x84, 0x7a, 0x14,
// 0x41, 0x94, 0x00, 0x14, 0x41, 0x96, 0x00, 0x50, 0x7c, 0x64, 0x07, 0x34, 0x7c, 0x84, 0x7a, 0x14, 0x48, 0x00, 0x00, 0x68, 0x54, 0x65, 0xa7, 0xff, 0x41, 0x82, 0x00, 0x0c, 0x7d, 0x27, 0x48, 0x2e,
// 0x48, 0x00, 0x00, 0x68, 0x54, 0x65, 0xa7, 0xff, 0x41, 0x82, 0x00, 0x0c, 0x7d, 0x27, 0x48, 0x2e, 0x7c, 0x84, 0x4a, 0x14, 0x41, 0x8e, 0x00, 0x08, 0x7c, 0x8c, 0x22, 0x14, 0x2e, 0x8e, 0x00, 0x01,
// 0x7c, 0x84, 0x4a, 0x14, 0x41, 0x8e, 0x00, 0x08, 0x7c, 0x8c, 0x22, 0x14, 0x2e, 0x8e, 0x00, 0x01, 0x41, 0x96, 0x00, 0x08, 0x80, 0x84, 0x00, 0x00, 0x54, 0x63, 0x67, 0xff, 0x41, 0x82, 0x00, 0x3c,
// 0x41, 0x96, 0x00, 0x08, 0x80, 0x84, 0x00, 0x00, 0x54, 0x63, 0x67, 0xff, 0x41, 0x82, 0x00, 0x3c, 0x40, 0x90, 0x00, 0x0c, 0x7c, 0x84, 0x32, 0x14, 0x48, 0x00, 0x00, 0x30, 0x7c, 0x84, 0x82, 0x14,
// 0x40, 0x90, 0x00, 0x0c, 0x7c, 0x84, 0x32, 0x14, 0x48, 0x00, 0x00, 0x30, 0x7c, 0x84, 0x82, 0x14, 0x48, 0x00, 0x00, 0x28, 0x54, 0x65, 0xa7, 0xff, 0x41, 0x82, 0x00, 0x0c, 0x7d, 0x27, 0x48, 0x2e,
// 0x48, 0x00, 0x00, 0x28, 0x54, 0x65, 0xa7, 0xff, 0x41, 0x82, 0x00, 0x0c, 0x7d, 0x27, 0x48, 0x2e, 0x7c, 0x84, 0x4a, 0x14, 0x40, 0x90, 0x00, 0x0c, 0x7c, 0xcc, 0x21, 0x2e, 0x4b, 0xff, 0xfd, 0x80,
// 0x7c, 0x84, 0x4a, 0x14, 0x40, 0x90, 0x00, 0x0c, 0x7c, 0xcc, 0x21, 0x2e, 0x4b, 0xff, 0xfd, 0x80, 0x7e, 0x0c, 0x21, 0x2e, 0x4b, 0xff, 0xfd, 0x78, 0x40, 0x90, 0x00, 0x0c, 0x7c, 0x86, 0x23, 0x78,
// 0x7e, 0x0c, 0x21, 0x2e, 0x4b, 0xff, 0xfd, 0x78, 0x40, 0x90, 0x00, 0x0c, 0x7c, 0x86, 0x23, 0x78, 0x4b, 0xff, 0xfd, 0x6c, 0x7c, 0x90, 0x23, 0x78, 0x4b, 0xff, 0xfd, 0x64, 0x54, 0x89, 0x1e, 0x78,
// 0x4b, 0xff, 0xfd, 0x6c, 0x7c, 0x90, 0x23, 0x78, 0x4b, 0xff, 0xfd, 0x64, 0x54, 0x89, 0x1e, 0x78, 0x39, 0x29, 0x00, 0x40, 0x2c, 0x05, 0x00, 0x02, 0x41, 0x80, 0x00, 0x48, 0x54, 0x6b, 0x50, 0x03,
// 0x39, 0x29, 0x00, 0x40, 0x2c, 0x05, 0x00, 0x02, 0x41, 0x80, 0x00, 0x48, 0x54, 0x6b, 0x50, 0x03, 0x41, 0x82, 0x00, 0x14, 0x41, 0x81, 0x00, 0x08, 0x48, 0x00, 0x00, 0x10, 0x41, 0xbe, 0xfd, 0x40,
// 0x41, 0x82, 0x00, 0x14, 0x41, 0x81, 0x00, 0x08, 0x48, 0x00, 0x00, 0x10, 0x41, 0xbe, 0xfd, 0x40, 0x48, 0x00, 0x00, 0x08, 0x40, 0xbe, 0xfd, 0x38, 0x2c, 0x05, 0x00, 0x03, 0x41, 0x81, 0x00, 0x10,
// 0x48, 0x00, 0x00, 0x08, 0x40, 0xbe, 0xfd, 0x38, 0x2c, 0x05, 0x00, 0x03, 0x41, 0x81, 0x00, 0x10, 0x41, 0xa2, 0x00, 0x10, 0x7d, 0xe7, 0x48, 0x2e, 0x4b, 0xff, 0xfd, 0x24, 0x7d, 0xe7, 0x49, 0x2e,
// 0x41, 0xa2, 0x00, 0x10, 0x7d, 0xe7, 0x48, 0x2e, 0x4b, 0xff, 0xfd, 0x24, 0x7d, 0xe7, 0x49, 0x2e, 0x7c, 0x64, 0x07, 0x34, 0x54, 0x84, 0x1a, 0x78, 0x7d, 0xef, 0x22, 0x14, 0x4b, 0xff, 0xfd, 0x10,
// 0x7c, 0x64, 0x07, 0x34, 0x54, 0x84, 0x1a, 0x78, 0x7d, 0xef, 0x22, 0x14, 0x4b, 0xff, 0xfd, 0x10, 0x40, 0xbe, 0xfd, 0x0c, 0x7c, 0xa7, 0x4a, 0x14, 0x40, 0x92, 0x00, 0x14, 0x54, 0x64, 0x04, 0x3e,
// 0x40, 0xbe, 0xfd, 0x0c, 0x7c, 0xa7, 0x4a, 0x14, 0x40, 0x92, 0x00, 0x14, 0x54, 0x64, 0x04, 0x3e, 0x91, 0xe5, 0x00, 0x00, 0x90, 0x85, 0x00, 0x04, 0x4b, 0xff, 0xfc, 0xf4, 0x81, 0x25, 0x00, 0x04,
// 0x91, 0xe5, 0x00, 0x00, 0x90, 0x85, 0x00, 0x04, 0x4b, 0xff, 0xfc, 0xf4, 0x81, 0x25, 0x00, 0x04, 0x2c, 0x09, 0x00, 0x00, 0x41, 0xa2, 0xfc, 0xe8, 0x39, 0x29, 0xff, 0xff, 0x91, 0x25, 0x00, 0x04,
// 0x2c, 0x09, 0x00, 0x00, 0x41, 0xa2, 0xfc, 0xe8, 0x39, 0x29, 0xff, 0xff, 0x91, 0x25, 0x00, 0x04, 0x81, 0xe5, 0x00, 0x00, 0x4b, 0xff, 0xfc, 0xd8, 0x40, 0xbe, 0xfc, 0xd4, 0x54, 0x6b, 0x16, 0xba,
// 0x81, 0xe5, 0x00, 0x00, 0x4b, 0xff, 0xfc, 0xd8, 0x40, 0xbe, 0xfc, 0xd4, 0x54, 0x6b, 0x16, 0xba, 0x7f, 0x47, 0x5a, 0x14, 0x81, 0x3a, 0x00, 0x00, 0x54, 0x6e, 0x67, 0xbe, 0x41, 0x92, 0x00, 0x84,
// 0x7f, 0x47, 0x5a, 0x14, 0x81, 0x3a, 0x00, 0x00, 0x54, 0x6e, 0x67, 0xbe, 0x41, 0x92, 0x00, 0x84, 0x2e, 0x05, 0x00, 0x05, 0x40, 0x90, 0x01, 0x74, 0x2e, 0x05, 0x00, 0x03, 0x40, 0x90, 0x00, 0x90,
// 0x2e, 0x05, 0x00, 0x05, 0x40, 0x90, 0x01, 0x74, 0x2e, 0x05, 0x00, 0x03, 0x40, 0x90, 0x00, 0x90, 0x2e, 0x05, 0x00, 0x01, 0x54, 0x65, 0x87, 0xff, 0x41, 0x82, 0x00, 0x08, 0x7c, 0x8c, 0x22, 0x14,
// 0x2e, 0x05, 0x00, 0x01, 0x54, 0x65, 0x87, 0xff, 0x41, 0x82, 0x00, 0x08, 0x7c, 0x8c, 0x22, 0x14, 0x2f, 0x0e, 0x00, 0x01, 0x40, 0x92, 0x00, 0x24, 0x41, 0xb9, 0x00, 0x18, 0x41, 0x9a, 0x00, 0x0c,
// 0x2f, 0x0e, 0x00, 0x01, 0x40, 0x92, 0x00, 0x24, 0x41, 0xb9, 0x00, 0x18, 0x41, 0x9a, 0x00, 0x0c, 0x88, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xf8, 0xa0, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xf0,
// 0x88, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xf8, 0xa0, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xf0, 0x80, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xe8, 0x54, 0x73, 0xe5, 0x3e, 0x41, 0xb9, 0x00, 0x20,
// 0x80, 0x84, 0x00, 0x00, 0x48, 0x00, 0x00, 0xe8, 0x54, 0x73, 0xe5, 0x3e, 0x41, 0xb9, 0x00, 0x20, 0x41, 0x9a, 0x00, 0x10, 0x99, 0x24, 0x00, 0x00, 0x38, 0x84, 0x00, 0x01, 0x48, 0x00, 0x00, 0x18,
// 0x41, 0x9a, 0x00, 0x10, 0x99, 0x24, 0x00, 0x00, 0x38, 0x84, 0x00, 0x01, 0x48, 0x00, 0x00, 0x18, 0xb1, 0x24, 0x00, 0x00, 0x38, 0x84, 0x00, 0x02, 0x48, 0x00, 0x00, 0x0c, 0x91, 0x24, 0x00, 0x00,
// 0xb1, 0x24, 0x00, 0x00, 0x38, 0x84, 0x00, 0x02, 0x48, 0x00, 0x00, 0x0c, 0x91, 0x24, 0x00, 0x00, 0x38, 0x84, 0x00, 0x04, 0x36, 0x73, 0xff, 0xff, 0x40, 0x80, 0xff, 0xd4, 0x4b, 0xff, 0xfc, 0x40,
// 0x38, 0x84, 0x00, 0x04, 0x36, 0x73, 0xff, 0xff, 0x40, 0x80, 0xff, 0xd4, 0x4b, 0xff, 0xfc, 0x40, 0x54, 0x65, 0x87, 0xff, 0x41, 0x82, 0x00, 0x08, 0x7c, 0x84, 0x62, 0x14, 0x71, 0xc5, 0x00, 0x01,
// 0x54, 0x65, 0x87, 0xff, 0x41, 0x82, 0x00, 0x08, 0x7c, 0x84, 0x62, 0x14, 0x71, 0xc5, 0x00, 0x01, 0x41, 0x82, 0x00, 0x9c, 0x7c, 0x84, 0x4a, 0x14, 0x48, 0x00, 0x00, 0x94, 0x54, 0x6a, 0x87, 0xbe,
// 0x41, 0x82, 0x00, 0x9c, 0x7c, 0x84, 0x4a, 0x14, 0x48, 0x00, 0x00, 0x94, 0x54, 0x6a, 0x87, 0xbe, 0x54, 0x8e, 0x16, 0xba, 0x7e, 0x67, 0x72, 0x14, 0x40, 0x92, 0x00, 0x08, 0x3a, 0x6f, 0xff, 0xfc,
// 0x54, 0x8e, 0x16, 0xba, 0x7e, 0x67, 0x72, 0x14, 0x40, 0x92, 0x00, 0x08, 0x3a, 0x6f, 0xff, 0xfc, 0x80, 0x9a, 0x00, 0x00, 0x81, 0x33, 0x00, 0x00, 0x71, 0x4b, 0x00, 0x01, 0x41, 0x82, 0x00, 0x08,
// 0x80, 0x9a, 0x00, 0x00, 0x81, 0x33, 0x00, 0x00, 0x71, 0x4b, 0x00, 0x01, 0x41, 0x82, 0x00, 0x08, 0x7c, 0x9a, 0x23, 0x78, 0x71, 0x4b, 0x00, 0x02, 0x41, 0x82, 0x00, 0x10, 0x7d, 0x33, 0x4b, 0x78,
// 0x7c, 0x9a, 0x23, 0x78, 0x71, 0x4b, 0x00, 0x02, 0x41, 0x82, 0x00, 0x10, 0x7d, 0x33, 0x4b, 0x78, 0x40, 0xb2, 0x00, 0x08, 0x7e, 0x6c, 0x9a, 0x14, 0x54, 0x65, 0x67, 0x3f, 0x2c, 0x05, 0x00, 0x09,
// 0x40, 0xb2, 0x00, 0x08, 0x7e, 0x6c, 0x9a, 0x14, 0x54, 0x65, 0x67, 0x3f, 0x2c, 0x05, 0x00, 0x09, 0x40, 0x80, 0x00, 0x54, 0x48, 0x00, 0x00, 0x79, 0x7c, 0x89, 0x22, 0x14, 0x48, 0x00, 0x00, 0x40,
// 0x40, 0x80, 0x00, 0x54, 0x48, 0x00, 0x00, 0x79, 0x7c, 0x89, 0x22, 0x14, 0x48, 0x00, 0x00, 0x40, 0x7c, 0x89, 0x21, 0xd6, 0x48, 0x00, 0x00, 0x38, 0x7d, 0x24, 0x23, 0x78, 0x48, 0x00, 0x00, 0x30,
// 0x7c, 0x89, 0x21, 0xd6, 0x48, 0x00, 0x00, 0x38, 0x7d, 0x24, 0x23, 0x78, 0x48, 0x00, 0x00, 0x30, 0x7d, 0x24, 0x20, 0x38, 0x48, 0x00, 0x00, 0x28, 0x7d, 0x24, 0x22, 0x78, 0x48, 0x00, 0x00, 0x20,
// 0x7d, 0x24, 0x20, 0x38, 0x48, 0x00, 0x00, 0x28, 0x7d, 0x24, 0x22, 0x78, 0x48, 0x00, 0x00, 0x20, 0x7d, 0x24, 0x20, 0x30, 0x48, 0x00, 0x00, 0x18, 0x7d, 0x24, 0x24, 0x30, 0x48, 0x00, 0x00, 0x10,
// 0x7d, 0x24, 0x20, 0x30, 0x48, 0x00, 0x00, 0x18, 0x7d, 0x24, 0x24, 0x30, 0x48, 0x00, 0x00, 0x10, 0x5d, 0x24, 0x20, 0x3e, 0x48, 0x00, 0x00, 0x08, 0x7d, 0x24, 0x26, 0x30, 0x90, 0x9a, 0x00, 0x00,
// 0x5d, 0x24, 0x20, 0x3e, 0x48, 0x00, 0x00, 0x08, 0x7d, 0x24, 0x26, 0x30, 0x90, 0x9a, 0x00, 0x00, 0x4b, 0xff, 0xfb, 0x8c, 0x2c, 0x05, 0x00, 0x0a, 0x41, 0x81, 0xfb, 0x84, 0xc0, 0x5a, 0x00, 0x00,
// 0x4b, 0xff, 0xfb, 0x8c, 0x2c, 0x05, 0x00, 0x0a, 0x41, 0x81, 0xfb, 0x84, 0xc0, 0x5a, 0x00, 0x00, 0xc0, 0x73, 0x00, 0x00, 0x41, 0x82, 0x00, 0x0c, 0xec, 0x43, 0x10, 0x2a, 0x48, 0x00, 0x00, 0x08,
// 0xc0, 0x73, 0x00, 0x00, 0x41, 0x82, 0x00, 0x0c, 0xec, 0x43, 0x10, 0x2a, 0x48, 0x00, 0x00, 0x08, 0xec, 0x43, 0x00, 0xb2, 0xd0, 0x5a, 0x00, 0x00, 0x4b, 0xff, 0xfb, 0x64, 0x7d, 0x48, 0x02, 0xa6,
// 0xec, 0x43, 0x00, 0xb2, 0xd0, 0x5a, 0x00, 0x00, 0x4b, 0xff, 0xfb, 0x64, 0x7d, 0x48, 0x02, 0xa6, 0x54, 0xa5, 0x1e, 0x78, 0x7d, 0x4a, 0x2a, 0x14, 0x80, 0x9a, 0x00, 0x00, 0x81, 0x33, 0x00, 0x00,
// 0x54, 0xa5, 0x1e, 0x78, 0x7d, 0x4a, 0x2a, 0x14, 0x80, 0x9a, 0x00, 0x00, 0x81, 0x33, 0x00, 0x00, 0x7d, 0x48, 0x03, 0xa6, 0x4e, 0x80, 0x00, 0x20, 0x40, 0xbe, 0xfb, 0x44, 0x54, 0x69, 0xc0, 0x3e,
// 0x7d, 0x48, 0x03, 0xa6, 0x4e, 0x80, 0x00, 0x20, 0x40, 0xbe, 0xfb, 0x44, 0x54, 0x69, 0xc0, 0x3e, 0x7d, 0x8e, 0x63, 0x78, 0x48, 0x00, 0x00, 0x35, 0x41, 0x92, 0x00, 0x0c, 0x7e, 0x31, 0x22, 0x14,
// 0x7d, 0x8e, 0x63, 0x78, 0x48, 0x00, 0x00, 0x35, 0x41, 0x92, 0x00, 0x0c, 0x7e, 0x31, 0x22, 0x14, 0x48, 0x00, 0x00, 0x08, 0x7d, 0x29, 0x22, 0x14, 0x54, 0x64, 0xc4, 0x3f, 0x38, 0xa0, 0x00, 0x00,
// 0x48, 0x00, 0x00, 0x08, 0x7d, 0x29, 0x22, 0x14, 0x54, 0x64, 0xc4, 0x3f, 0x38, 0xa0, 0x00, 0x00, 0x41, 0x82, 0xfb, 0x1c, 0x7d, 0x45, 0x88, 0xae, 0x7d, 0x45, 0x49, 0xae, 0x38, 0xa5, 0x00, 0x01,
// 0x41, 0x82, 0xfb, 0x1c, 0x7d, 0x45, 0x88, 0xae, 0x7d, 0x45, 0x49, 0xae, 0x38, 0xa5, 0x00, 0x01, 0x7c, 0x05, 0x20, 0x00, 0x4b, 0xff, 0xff, 0xec, 0x2e, 0x8a, 0x00, 0x04, 0x55, 0x31, 0x36, 0xba,
// 0x7c, 0x05, 0x20, 0x00, 0x4b, 0xff, 0xff, 0xec, 0x2e, 0x8a, 0x00, 0x04, 0x55, 0x31, 0x36, 0xba, 0x2c, 0x11, 0x00, 0x3c, 0x7e, 0x27, 0x88, 0x2e, 0x40, 0x82, 0x00, 0x08, 0x7d, 0xd1, 0x73, 0x78,
// 0x2c, 0x11, 0x00, 0x3c, 0x7e, 0x27, 0x88, 0x2e, 0x40, 0x82, 0x00, 0x08, 0x7d, 0xd1, 0x73, 0x78, 0x41, 0x96, 0x00, 0x08, 0xa2, 0x31, 0x00, 0x00, 0x55, 0x29, 0x56, 0xba, 0x2c, 0x09, 0x00, 0x3c,
// 0x41, 0x96, 0x00, 0x08, 0xa2, 0x31, 0x00, 0x00, 0x55, 0x29, 0x56, 0xba, 0x2c, 0x09, 0x00, 0x3c, 0x7d, 0x27, 0x48, 0x2e, 0x40, 0x82, 0x00, 0x08, 0x7d, 0xc9, 0x73, 0x78, 0x41, 0x96, 0x00, 0x08,
// 0x7d, 0x27, 0x48, 0x2e, 0x40, 0x82, 0x00, 0x08, 0x7d, 0xc9, 0x73, 0x78, 0x41, 0x96, 0x00, 0x08, 0xa1, 0x29, 0x00, 0x00, 0x4e, 0x80, 0x00, 0x20, 0x2c, 0x05, 0x00, 0x04, 0x40, 0x80, 0x00, 0x28,
// 0xa1, 0x29, 0x00, 0x00, 0x4e, 0x80, 0x00, 0x20, 0x2c, 0x05, 0x00, 0x04, 0x40, 0x80, 0x00, 0x28, 0x7c, 0x89, 0x23, 0x78, 0x7d, 0xc3, 0x62, 0x14, 0x55, 0xce, 0x00, 0x3c, 0x4b, 0xff, 0xff, 0xad,
// 0x7c, 0x89, 0x23, 0x78, 0x7d, 0xc3, 0x62, 0x14, 0x55, 0xce, 0x00, 0x3c, 0x4b, 0xff, 0xff, 0xad, 0x7c, 0x84, 0x20, 0xf8, 0x54, 0x84, 0x04, 0x3e, 0x7d, 0x2b, 0x20, 0x38, 0x7e, 0x24, 0x20, 0x38,
// 0x7c, 0x84, 0x20, 0xf8, 0x54, 0x84, 0x04, 0x3e, 0x7d, 0x2b, 0x20, 0x38, 0x7e, 0x24, 0x20, 0x38, 0x4b, 0xff, 0xfb, 0xc4, 0x54, 0x6b, 0xe4, 0x3e, 0x4b, 0xff, 0xfb, 0xbc, 0x7c, 0x9a, 0x23, 0x78,
// 0x4b, 0xff, 0xfb, 0xc4, 0x54, 0x6b, 0xe4, 0x3e, 0x4b, 0xff, 0xfb, 0xbc, 0x7c, 0x9a, 0x23, 0x78, 0x54, 0x84, 0x18, 0x38, 0x40, 0x92, 0x00, 0x20, 0x40, 0x9e, 0x00, 0x0c, 0x7d, 0xe8, 0x03, 0xa6,
// 0x54, 0x84, 0x18, 0x38, 0x40, 0x92, 0x00, 0x20, 0x40, 0x9e, 0x00, 0x0c, 0x7d, 0xe8, 0x03, 0xa6, 0x4e, 0x80, 0x00, 0x21, 0x7d, 0xe4, 0x7a, 0x14, 0x39, 0xef, 0x00, 0x07, 0x55, 0xef, 0x00, 0x38,
// 0x4e, 0x80, 0x00, 0x21, 0x7d, 0xe4, 0x7a, 0x14, 0x39, 0xef, 0x00, 0x07, 0x55, 0xef, 0x00, 0x38, 0x4b, 0xff, 0xfa, 0x6c, 0x2e, 0x05, 0x00, 0x03, 0x41, 0x91, 0x00, 0x5c, 0x3c, 0xa0, 0x48, 0x00,
// 0x4b, 0xff, 0xfa, 0x6c, 0x2e, 0x05, 0x00, 0x03, 0x41, 0x91, 0x00, 0x5c, 0x3c, 0xa0, 0x48, 0x00, 0x7d, 0x83, 0x62, 0x14, 0x55, 0x8c, 0x00, 0x3a, 0x40, 0x92, 0x00, 0x20, 0x40, 0xbe, 0xfa, 0x50,
// 0x7d, 0x83, 0x62, 0x14, 0x55, 0x8c, 0x00, 0x3a, 0x40, 0x92, 0x00, 0x20, 0x40, 0xbe, 0xfa, 0x50, 0x57, 0x44, 0x00, 0x3a, 0x7c, 0x8c, 0x20, 0x50, 0x50, 0x85, 0x01, 0xba, 0x50, 0x65, 0x07, 0xfe,
// 0x57, 0x44, 0x00, 0x3a, 0x7c, 0x8c, 0x20, 0x50, 0x50, 0x85, 0x01, 0xba, 0x50, 0x65, 0x07, 0xfe, 0x90, 0xac, 0x00, 0x00, 0x4b, 0xff, 0xfa, 0x38, 0x40, 0xbe, 0xff, 0xbc, 0x7d, 0x2c, 0x78, 0x50,
// 0x90, 0xac, 0x00, 0x00, 0x4b, 0xff, 0xfa, 0x38, 0x40, 0xbe, 0xff, 0xbc, 0x7d, 0x2c, 0x78, 0x50, 0x51, 0x25, 0x01, 0xba, 0x90, 0xac, 0x00, 0x00, 0x39, 0x8c, 0x00, 0x04, 0x7d, 0x6f, 0x22, 0x14,
// 0x51, 0x25, 0x01, 0xba, 0x90, 0xac, 0x00, 0x00, 0x39, 0x8c, 0x00, 0x04, 0x7d, 0x6f, 0x22, 0x14, 0x39, 0x6b, 0xff, 0xfc, 0x7d, 0x2b, 0x60, 0x50, 0x51, 0x25, 0x01, 0xba, 0x90, 0xab, 0x00, 0x00,
// 0x39, 0x6b, 0xff, 0xfc, 0x7d, 0x2b, 0x60, 0x50, 0x51, 0x25, 0x01, 0xba, 0x90, 0xab, 0x00, 0x00, 0x4b, 0xff, 0xff, 0x94, 0x2e, 0x05, 0x00, 0x06, 0x41, 0x92, 0x00, 0x28, 0x4b, 0xff, 0xfb, 0x28,
// 0x4b, 0xff, 0xff, 0x94, 0x2e, 0x05, 0x00, 0x06, 0x41, 0x92, 0x00, 0x28, 0x4b, 0xff, 0xfb, 0x28, 0x55, 0x8c, 0x84, 0x3e, 0x57, 0x44, 0x84, 0x3e, 0x57, 0x5a, 0x04, 0x3e, 0x7c, 0x0c, 0x20, 0x00,
// 0x55, 0x8c, 0x84, 0x3e, 0x57, 0x44, 0x84, 0x3e, 0x57, 0x5a, 0x04, 0x3e, 0x7c, 0x0c, 0x20, 0x00, 0x41, 0x80, 0xfb, 0xa8, 0x7c, 0x0c, 0xd0, 0x00, 0x40, 0x80, 0xfb, 0xa0, 0x4b, 0xff, 0xf9, 0xe0,
// 0x41, 0x80, 0xfb, 0xa8, 0x7c, 0x0c, 0xd0, 0x00, 0x40, 0x80, 0xfb, 0xa0, 0x4b, 0xff, 0xf9, 0xe0, 0x57, 0x45, 0xff, 0xfe, 0x68, 0xa5, 0x00, 0x01, 0x71, 0x03, 0x00, 0x01, 0x7c, 0x05, 0x18, 0x00,
// 0x57, 0x45, 0xff, 0xfe, 0x68, 0xa5, 0x00, 0x01, 0x71, 0x03, 0x00, 0x01, 0x7c, 0x05, 0x18, 0x00, 0x41, 0x82, 0x00, 0x1c, 0x51, 0x1a, 0x0f, 0xbc, 0x6b, 0x5a, 0x00, 0x02, 0x57, 0x45, 0xff, 0xff,
// 0x41, 0x82, 0x00, 0x1c, 0x51, 0x1a, 0x0f, 0xbc, 0x6b, 0x5a, 0x00, 0x02, 0x57, 0x45, 0xff, 0xff, 0x41, 0x82, 0x00, 0x08, 0x6b, 0x5a, 0x00, 0x01, 0x93, 0x4f, 0xff, 0xfc, 0x53, 0x48, 0x07, 0xfe,
// 0x41, 0x82, 0x00, 0x08, 0x6b, 0x5a, 0x00, 0x01, 0x93, 0x4f, 0xff, 0xfc, 0x53, 0x48, 0x07, 0xfe, 0x4b, 0xff, 0xf9, 0xac, 0x2c, 0x0b, 0x00, 0x00, 0x41, 0x82, 0x01, 0x38, 0x2c, 0x05, 0x00, 0x01,
// 0x4b, 0xff, 0xf9, 0xac, 0x2c, 0x0b, 0x00, 0x00, 0x41, 0x82, 0x01, 0x38, 0x2c, 0x05, 0x00, 0x01, 0x41, 0x82, 0x00, 0x18, 0x2c, 0x05, 0x00, 0x02, 0x41, 0x82, 0x00, 0x14, 0x2c, 0x05, 0x00, 0x03,
// 0x41, 0x82, 0x00, 0x18, 0x2c, 0x05, 0x00, 0x02, 0x41, 0x82, 0x00, 0x14, 0x2c, 0x05, 0x00, 0x03, 0x41, 0x82, 0x00, 0x70, 0x4b, 0xff, 0xf9, 0x40, 0x54, 0xcc, 0x00, 0x0c, 0x54, 0x97, 0x46, 0x3e,
// 0x41, 0x82, 0x00, 0x70, 0x4b, 0xff, 0xf9, 0x40, 0x54, 0xcc, 0x00, 0x0c, 0x54, 0x97, 0x46, 0x3e, 0x54, 0x98, 0xc4, 0x3e, 0x54, 0x84, 0x06, 0x3e, 0x40, 0x9e, 0x00, 0xfc, 0x56, 0xf9, 0x06, 0x31,
// 0x54, 0x98, 0xc4, 0x3e, 0x54, 0x84, 0x06, 0x3e, 0x40, 0x9e, 0x00, 0xfc, 0x56, 0xf9, 0x06, 0x31, 0x7d, 0x9a, 0x63, 0x78, 0x7f, 0x43, 0xd2, 0x14, 0x57, 0x5a, 0x00, 0x3a, 0x41, 0x82, 0x00, 0x18,
// 0x7d, 0x9a, 0x63, 0x78, 0x7f, 0x43, 0xd2, 0x14, 0x57, 0x5a, 0x00, 0x3a, 0x41, 0x82, 0x00, 0x18, 0x7e, 0xf7, 0x07, 0x74, 0x7e, 0xf7, 0x00, 0xd0, 0x1f, 0x37, 0x00, 0x02, 0x3b, 0x39, 0x00, 0x04,
// 0x7e, 0xf7, 0x07, 0x74, 0x7e, 0xf7, 0x00, 0xd0, 0x1f, 0x37, 0x00, 0x02, 0x3b, 0x39, 0x00, 0x04, 0x7f, 0x59, 0xd0, 0x50, 0x2c, 0x17, 0x00, 0x00, 0x41, 0x82, 0x00, 0x1c, 0x3b, 0x20, 0x00, 0x00,
// 0x7f, 0x59, 0xd0, 0x50, 0x2c, 0x17, 0x00, 0x00, 0x41, 0x82, 0x00, 0x1c, 0x3b, 0x20, 0x00, 0x00, 0x7e, 0xe9, 0x03, 0xa6, 0xa3, 0x7a, 0x00, 0x04, 0x7f, 0x79, 0xca, 0x78, 0x3b, 0x5a, 0x00, 0x02,
// 0x7e, 0xe9, 0x03, 0xa6, 0xa3, 0x7a, 0x00, 0x04, 0x7f, 0x79, 0xca, 0x78, 0x3b, 0x5a, 0x00, 0x02, 0x42, 0x00, 0xff, 0xf4, 0x7c, 0x18, 0xc8, 0x00, 0x40, 0x82, 0x00, 0xac, 0x4b, 0xff, 0xfe, 0x90,
// 0x42, 0x00, 0xff, 0xf4, 0x7c, 0x18, 0xc8, 0x00, 0x40, 0x82, 0x00, 0xac, 0x4b, 0xff, 0xfe, 0x90, 0x51, 0x08, 0x08, 0x3c, 0x40, 0x9e, 0x00, 0x9c, 0x54, 0x77, 0xb0, 0x03, 0x41, 0x81, 0x00, 0x88,
// 0x51, 0x08, 0x08, 0x3c, 0x40, 0x9e, 0x00, 0x9c, 0x54, 0x77, 0xb0, 0x03, 0x41, 0x81, 0x00, 0x88, 0x41, 0x80, 0x00, 0x8c, 0x54, 0x7e, 0x06, 0x3e, 0x1f, 0xde, 0x00, 0x02, 0x54, 0x97, 0x00, 0x1e,
// 0x41, 0x80, 0x00, 0x8c, 0x54, 0x7e, 0x06, 0x3e, 0x1f, 0xde, 0x00, 0x02, 0x54, 0x97, 0x00, 0x1e, 0x6e, 0xf8, 0x80, 0x00, 0x2c, 0x18, 0x00, 0x00, 0x40, 0x82, 0x00, 0x08, 0x62, 0xf7, 0x30, 0x00,
// 0x6e, 0xf8, 0x80, 0x00, 0x2c, 0x18, 0x00, 0x00, 0x40, 0x82, 0x00, 0x08, 0x62, 0xf7, 0x30, 0x00, 0x54, 0x98, 0x80, 0x1e, 0x1f, 0x3e, 0x00, 0x04, 0x7f, 0x19, 0xc0, 0x50, 0x3b, 0x20, 0x00, 0x00,
// 0x54, 0x98, 0x80, 0x1e, 0x1f, 0x3e, 0x00, 0x04, 0x7f, 0x19, 0xc0, 0x50, 0x3b, 0x20, 0x00, 0x00, 0x1f, 0x59, 0x00, 0x04, 0x7f, 0x6f, 0xd0, 0x2e, 0x7f, 0x57, 0xd0, 0x2e, 0x3b, 0x39, 0x00, 0x01,
// 0x1f, 0x59, 0x00, 0x04, 0x7f, 0x6f, 0xd0, 0x2e, 0x7f, 0x57, 0xd0, 0x2e, 0x3b, 0x39, 0x00, 0x01, 0x7c, 0x17, 0xc0, 0x40, 0x41, 0x81, 0x00, 0x34, 0x7c, 0x19, 0xf0, 0x00, 0x41, 0x81, 0x00, 0x14,
// 0x7c, 0x17, 0xc0, 0x40, 0x41, 0x81, 0x00, 0x34, 0x7c, 0x19, 0xf0, 0x00, 0x41, 0x81, 0x00, 0x14, 0x7c, 0x1a, 0xd8, 0x00, 0x41, 0x82, 0xff, 0xdc, 0x3a, 0xf7, 0x00, 0x04, 0x4b, 0xff, 0xff, 0xd0,
// 0x7c, 0x1a, 0xd8, 0x00, 0x41, 0x82, 0xff, 0xdc, 0x3a, 0xf7, 0x00, 0x04, 0x4b, 0xff, 0xff, 0xd0, 0x80, 0x6f, 0xff, 0xf8, 0x60, 0x63, 0x03, 0x00, 0x90, 0x6f, 0xff, 0xf8, 0x92, 0xef, 0xff, 0xfc,
// 0x80, 0x6f, 0xff, 0xf8, 0x60, 0x63, 0x03, 0x00, 0x90, 0x6f, 0xff, 0xf8, 0x92, 0xef, 0xff, 0xfc, 0x7e, 0xf0, 0xbb, 0x78, 0x48, 0x00, 0x00, 0x1c, 0x80, 0x6f, 0xff, 0xf8, 0x60, 0x63, 0x01, 0x00,
// 0x7e, 0xf0, 0xbb, 0x78, 0x48, 0x00, 0x00, 0x1c, 0x80, 0x6f, 0xff, 0xf8, 0x60, 0x63, 0x01, 0x00, 0x90, 0x6f, 0xff, 0xf8, 0x61, 0x08, 0x00, 0x01, 0x48, 0x00, 0x00, 0x08, 0x7c, 0x90, 0x23, 0x78,
// 0x90, 0x6f, 0xff, 0xf8, 0x61, 0x08, 0x00, 0x01, 0x48, 0x00, 0x00, 0x08, 0x7c, 0x90, 0x23, 0x78, 0x54, 0x64, 0x06, 0x3e, 0x1c, 0x84, 0x00, 0x08, 0x7d, 0xe4, 0x7a, 0x14, 0x4b, 0xff, 0xf8, 0x70,
// 0x54, 0x64, 0x06, 0x3e, 0x1c, 0x84, 0x00, 0x08, 0x7d, 0xe4, 0x7a, 0x14, 0x4b, 0xff, 0xf8, 0x70, 0x40, 0x92, 0x00, 0x0c, 0x39, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x14, 0x54, 0x69, 0x06, 0xff,
// 0x40, 0x92, 0x00, 0x0c, 0x39, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x14, 0x54, 0x69, 0x06, 0xff, 0x54, 0x65, 0x67, 0xfe, 0x7d, 0x08, 0x4c, 0x30, 0x55, 0x17, 0xff, 0xff, 0x40, 0x82, 0x00, 0x08,
// 0x54, 0x65, 0x67, 0xfe, 0x7d, 0x08, 0x4c, 0x30, 0x55, 0x17, 0xff, 0xff, 0x40, 0x82, 0x00, 0x08, 0x7d, 0x08, 0x2a, 0x78, 0x54, 0x85, 0x00, 0x1f, 0x41, 0x82, 0x00, 0x08, 0x7c, 0xa6, 0x2b, 0x78,
// 0x7d, 0x08, 0x2a, 0x78, 0x54, 0x85, 0x00, 0x1f, 0x41, 0x82, 0x00, 0x08, 0x7c, 0xa6, 0x2b, 0x78, 0x54, 0x85, 0x80, 0x1f, 0x41, 0x82, 0x00, 0x08, 0x7c, 0xb0, 0x2b, 0x78, 0x4b, 0xff, 0xf8, 0x30,
// 0x54, 0x85, 0x80, 0x1f, 0x41, 0x82, 0x00, 0x08, 0x7c, 0xb0, 0x2b, 0x78, 0x4b, 0xff, 0xf8, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
// 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
//};

4
Config.c
View File

@ -4,7 +4,7 @@ DML_CFG *DMLCfg;
void ConfigInit( DML_CFG *Cfg ) void ConfigInit( DML_CFG *Cfg )
{ {
DMLCfg = (DML_CFG*)0xFFFE4200; DMLCfg = (DML_CFG*)malloc( sizeof( DML_CFG ) );
memset32( DMLCfg, 0, sizeof(DML_CFG) ); memset32( DMLCfg, 0, sizeof(DML_CFG) );
@ -15,7 +15,7 @@ void ConfigInit( DML_CFG *Cfg )
} else { } else {
dbgprintf("No config found in RAM\n"); dbgprintf("No valid found in RAM\n");
dbgprintf("Version:%08X\n", DMLCfg->Version ); dbgprintf("Version:%08X\n", DMLCfg->Version );
dbgprintf("Config:%08X\n", DMLCfg->Config ); dbgprintf("Config:%08X\n", DMLCfg->Config );

61
DVD.c
View File

@ -6,11 +6,6 @@ static char GamePath[256];
extern FIL GameFile; extern FIL GameFile;
extern u32 FSTMode; extern u32 FSTMode;
extern u32 DOLMaxOff;
extern u32 DOLOffset;
u8 HardDriveConnected;
FATFS fatfs;
static u8 *FSTable ALIGNED(32); static u8 *FSTable ALIGNED(32);
u32 ApploaderSize=0; u32 ApploaderSize=0;
@ -22,62 +17,6 @@ u32 FCEntry=0;
FileCache FC[FILECACHE_MAX]; FileCache FC[FILECACHE_MAX];
u32 FCState[FILECACHE_MAX]; u32 FCState[FILECACHE_MAX];
void DVDInit( void )
{
int i=0;
s32 fres = FR_DISK_ERR;
int MountFail=0;
HardDriveConnected = 0;
while(!HardDriveConnected)
{
while(1)
{
fres = f_mount(0, &fatfs );
dbgprintf( "DIP:f_mount():%d\n", fres );
if( fres == FR_OK )
break;
else
MountFail++;
if( MountFail == 10 )
{
dbgprintf( "DIP:too much fail! looping now!\n");
while(1);
}
udelay(500000);
}
//try to open a file, it doesn't have to exist, just testing if FS works
FIL f;
fres = f_open( &f, "/randmb.in", FA_READ|FA_OPEN_EXISTING );
switch(fres)
{
case FR_OK:
f_close( &f );
case FR_NO_PATH:
case FR_NO_FILE:
{
HardDriveConnected = 1;
fres = FR_OK;
} break;
default:
case FR_DISK_ERR:
{
dbgprintf( "DIP: Disk error\n", fres );
while(1);
} break;
}
}
if( fres != FR_OK )
{
dbgprintf( "Could not find any USB device!");
}
return;
}
s32 DVDSelectGame( void ) s32 DVDSelectGame( void )
{ {
char *str = (char*)malloca( 256, 32 ); char *str = (char*)malloca( 256, 32 );

8
DVD.h
View File

@ -6,7 +6,6 @@
#include "Config.h" #include "Config.h"
#include "ff.h" #include "ff.h"
#include "dol.h" #include "dol.h"
#include "Drive.h"
typedef struct typedef struct
{ {
@ -17,11 +16,8 @@ typedef struct
u8 GameInfo[][0x80]; u8 GameInfo[][0x80];
} DVDConfig; } DVDConfig;
void DVDInit( void ); void DVDReadConfig( void );
void DVDReadConfig( void ); s32 DVDSelectGame( void );
s32 DVDSelectGame( void );
void DVDUpdateFSTRAM( void );
void DiscBackup( u32 FrameBuffer );
u32 FSTInit( void ); u32 FSTInit( void );
void FSTRead( char *Buffer, u32 Length, u32 Offset ); void FSTRead( char *Buffer, u32 Length, u32 Offset );

18
DVDPatches.c
View File

@ -3,8 +3,26 @@
#include "global.h" #include "global.h"
#include "asm\DVDRead.h"
#include "asm\DVDReadAsync.h"
#include "asm\DVDReadAbsAsyncPrioAsync.h"
#include "asm\mDVDReadAbsAsyncPrio.h"
#include "asm\DVDReadAbsAsyncPrio.h"
#include "asm\LDVDReadAbsAsyncPrio.h"
#include "asm\DVDReadAbsAsyncPrioForBS.h"
#include "asm\mDVDReadAbsAsyncPrioShift.h"
#include "asm\DVDReadDiscIDAsync.h"
#include "asm\DVDInquiryAsync.h" #include "asm\DVDInquiryAsync.h"
#include "asm\__DVDInterruptHandler.h"
#include "asm\DVDLowReadShift.h"
#include "asm\DVDWaitReady.h"
#include "asm\dDVDReadAbs.h"
#include "asm\DVDSeekAbsAsyncPrio.h" #include "asm\DVDSeekAbsAsyncPrio.h"
#include "asm\DVDPrepareStreamAbsAsync.h"
#include "asm\DVDStopStreamAtEndAsync.h"
#include "asm\DVDCancelStreamAsync.h"
#include "asm\DVDGetStreamPlayAddrAsync.h"
#include "asm\DVDLowRead.h"
#include "asm\padipc.h" #include "asm\padipc.h"
#endif #endif

29
Drive.c
View File

@ -73,35 +73,6 @@ u32 LowReadDiscID( void *data )
return 0; return 0;
} }
u32 LowRead( void *data, u32 Offset, u32 Length )
{
write32( 0x0D806008, 0xA8000000 );
write32( 0x0D80600C, Offset>>2 );
write32( 0x0D806010, Length );
write32( 0x0D806018, Length );
write32( 0x0D806014, (u32)data );
write32( 0x0D806000, 0x3A );
write32( 0x0D80601C, 3 );
while (1)
{
if( read32( 0x0D806000 ) & (1<<2) )
{
set32( 0x0D806000, (1<<2) );
return 1;
}
if( read32( 0x0D806000 ) & (1<<4) )
{
set32( 0x0D806000, (1<<4) );
return 0;
}
}
return 0;
}
u32 DVDEnableAudioStreaming( u32 Enable ) u32 DVDEnableAudioStreaming( u32 Enable )
{ {
write32( 0x0D806004, read32( 0x0D806004 ) ); write32( 0x0D806004, read32( 0x0D806004 ) );

413
HW.c
View File

@ -51,87 +51,88 @@ void HWRegWriteBatch( u32 A, u32 B, u32 C, u32 D, u32 delay )
// DRAMRead( 0x0163 ); // DRAMRead( 0x0163 );
// return DRAMRead( 0x0162 ); // return DRAMRead( 0x0162 );
//} //}
void SomeFuncA( void ) //void SomeFuncA( void )
{ //{
set32( 0xD80018C, 0x400 ); // set32( 0xD80018C, 0x400 );
set32( 0xD80018C, 0x800 ); // set32( 0xD80018C, 0x800 );
} //}
void SomeFuncD( void ) //void SomeFuncD( void )
{ //{
u32 cookie = *(vu32*)(0xD8001D8) & 0x7FFFFFFF; // u32 cookie = *(vu32*)(0xD8001D8) & 0x7FFFFFFF;
write32( 0xD8001D8, cookie ); // write32( 0xD8001D8, cookie );
udelay(2); // udelay(2);
//
write32( 0xD8001D8, cookie & 0xBFFFFFFF ); // write32( 0xD8001D8, cookie & 0xBFFFFFFF );
udelay(10); // udelay(10);
//
write32( 0xD8001D8, (read32(0xD8001D8) & 0xBFFFFFFF) | 0x40000000 ); // write32( 0xD8001D8, (read32(0xD8001D8) & 0xBFFFFFFF) | 0x40000000 );
udelay(50); // udelay(50);
//
write32( 0xD8001D8, (read32(0xD8001D8) & 0x7FFFFFFF) | 0x80000000 ); // write32( 0xD8001D8, (read32(0xD8001D8) & 0x7FFFFFFF) | 0x80000000 );
udelay(2); // udelay(2);
//
} //}
void EHCIInit( void ) //void EHCIInit( void )
{ //{
SomeFuncA(); // //SomeFuncA();
//
u32 HWVerFlag = ((*(vu32*)0xD800214) << 0x18) >> 0x1C; //
// u32 HWVerFlag = ((*(vu32*)0xD800214) << 0x18) >> 0x1C;
write32( 0xD800088, 0xFE ); //
udelay(2); // write32( 0xD800088, 0xFE );
// udelay(2);
SomeFuncD(); //
// SomeFuncD();
write32( 0xD800088, 0xF6 ); //
udelay(50); // write32( 0xD800088, 0xF6 );
// udelay(50);
write32( 0xD800088, 0xF4 ); //
udelay(1); // write32( 0xD800088, 0xF4 );
// udelay(1);
write32( 0xD800088, 0xF0 ); //
udelay(1); // write32( 0xD800088, 0xF0 );
// udelay(1);
write32( 0xD800088, 0x70 ); //
udelay(1); // write32( 0xD800088, 0x70 );
// udelay(1);
write32( 0xD800088, 0x60 ); //
udelay(1); // write32( 0xD800088, 0x60 );
// udelay(1);
write32( 0xD800088, 0x40 ); //
udelay(1); // write32( 0xD800088, 0x40 );
// udelay(1);
write32( 0xD800088, 0x00 ); //
udelay(1); // write32( 0xD800088, 0x00 );
// udelay(1);
write32( 0xD0400B4, 0x2214 ); //
// write32( 0xD0400B4, 0x2214 );
if( HWVerFlag == 0 ) //
{ // if( HWVerFlag == 0 )
write32( 0xD0400B0, 0x20400 ); // {
} else { // write32( 0xD0400B0, 0x20400 );
write32( 0xD0400B0, 0x20600 ); // } else {
} // write32( 0xD0400B0, 0x20600 );
// }
write32( 0xD0400A4, 0x26 ); //
udelay(1); // write32( 0xD0400A4, 0x26 );
// udelay(1);
write32( 0xD0400A4, 0x2026 ); //
udelay(1); // write32( 0xD0400A4, 0x2026 );
// udelay(1);
write32( 0xD0400A4, 0x4026 ); //
udelay(20); // write32( 0xD0400A4, 0x4026 );
// udelay(20);
write32( 0xD0400CC, 0x111 ); //
udelay(1); // write32( 0xD0400CC, 0x111 );
// udelay(1);
//set32( 0xD800194, 0x7FDFBCF ); //
// //set32( 0xD800194, 0x7FDFBCF );
write32( 0xD8001E0, 0x65244A ); //
write32( 0xD8001E4, 0x46A024 ); // write32( 0xD8001E0, 0x65244A );
// write32( 0xD8001E4, 0x46A024 );
return; //
} // return;
//}
void Shutdown( void ) void Shutdown( void )
{ {
udelay(200); udelay(200);
@ -195,13 +196,13 @@ void DRAMInit( u32 A, u32 B )
} }
void HWMAgic( u32 R0, u32 R1, u32 R2, u32 R3 ) void HWMAgic( u32 R0, u32 R1, u32 R2, u32 R3 )
{ {
u32 R10,R11,R7,R8,R9,value; u32 /*R10,R11,R7,R8,R9,*/value;
R3 = R3 << 24; R3 = R3 << 24;
SP[1] = R3 >> 24; SP[1] = R3 >> 24;
SP[2] = R0; SP[2] = R0;
R10 = (R1<<16)>>16; // R10 = (R1<<16)>>16;
//if( read32( HW_RESETS ) & 0x800 ) //if( read32( HW_RESETS ) & 0x800 )
//{ //{
@ -595,121 +596,121 @@ void MIOSUnkInit( void )
udelay(2); udelay(2);
} }
void MIOSEHCISub( void ) //void MIOSEHCISub( void )
{ //{
u32 v = read32( 0xD8001D8 ) & 0x7FFFFFFF; // u32 v = read32( 0xD8001D8 ) & 0x7FFFFFFF;
//
write32( 0xD8001D8, v ); // write32( 0xD8001D8, v );
udelay(2); // udelay(2);
//
write32( 0xD8001D8, v & 0xBFFFFFFF ); // write32( 0xD8001D8, v & 0xBFFFFFFF );
udelay(10); // udelay(10);
//
write32( 0xD8001D8, ( read32( 0xD8001D8 ) & 0xBFFFFFFF ) | 0x40000000 ); // write32( 0xD8001D8, ( read32( 0xD8001D8 ) & 0xBFFFFFFF ) | 0x40000000 );
udelay(50); // udelay(50);
//
write32( 0xD8001D8, ( read32( 0xD8001D8 ) & 0x7FFFFFFF ) | 0x80000000 ); // write32( 0xD8001D8, ( read32( 0xD8001D8 ) & 0x7FFFFFFF ) | 0x80000000 );
udelay(2); // udelay(2);
} //}
char EHCIData[] = { //char EHCIData[] = {
0x02, 0x00, 0x00, 0x00, // 0x02, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, // 0x04, 0x00, 0x00, 0x00,
0x05, 0x0F, 0x00, 0x00, // 0x05, 0x0F, 0x00, 0x00,
}; //};
void MIOSEHCISub2( u32 A ) //void MIOSEHCISub2( u32 A )
{ //{
if( A > 2 ) // if( A > 2 )
A = 2; // A = 2;
//
A <<= 2; // A <<= 2;
//
u32 R1 = *(u8*)(EHCIData+A); // u32 R1 = *(u8*)(EHCIData+A);
u32 R3 = *(u8*)(EHCIData+A+1); // u32 R3 = *(u8*)(EHCIData+A+1);
//
R1 &= 0xF; // R1 &= 0xF;
R3 &= 0xF; // R3 &= 0xF;
//
u32 R4 = R1 << 8; //u32 R4 = R1 << 8;
R3 = R3 << 0x17; // R3 = R3 << 0x17;
//
R4 = R4 | R3; // R4 = R4 | R3;
u32 R2 = R1 << 2; //u32 R2 = R1 << 2;
R2 = R2 + R1; // R2 = R2 + R1;
R4 = R4 | 0x2014; // R4 = R4 | 0x2014;
//
R2 = R2 - 4; // R2 = R2 - 4;
R2 = R2 & 0xFF; // R2 = R2 & 0xFF;
//
R2 = R2 << 8; // R2 = R2 << 8;
R2 = R2 | 0x20000; // R2 = R2 | 0x20000;
//
write32( 0xD0400B4, R4 ); // write32( 0xD0400B4, R4 );
write32( 0xD0400B0, R2 ); // write32( 0xD0400B0, R2 );
} //}
void MIOSEHCIInit( u32 A ) //void MIOSEHCIInit( u32 A )
{ //{
write32( 0xD800088, 0xFE ); // write32( 0xD800088, 0xFE );
udelay(2); // udelay(2);
//
MIOSEHCISub(); // MIOSEHCISub();
//
write32( 0xD800088, 0xF6 ); // write32( 0xD800088, 0xF6 );
udelay(50); // udelay(50);
//
write32( 0xD800088, 0xF4 ); // write32( 0xD800088, 0xF4 );
udelay(1); // udelay(1);
//
write32( 0xD800088, 0xF0 ); // write32( 0xD800088, 0xF0 );
udelay(1); // udelay(1);
//
write32( 0xD800088, 0x70 ); // write32( 0xD800088, 0x70 );
udelay(1); // udelay(1);
//
write32( 0xD800088, 0x60 ); // write32( 0xD800088, 0x60 );
udelay(1); // udelay(1);
//
write32( 0xD800088, 0x40 ); // write32( 0xD800088, 0x40 );
udelay(1); // udelay(1);
//
write32( 0xD800088, 0x00 ); // write32( 0xD800088, 0x00 );
udelay(1); // udelay(1);
//
MIOSEHCISub2( A ); // MIOSEHCISub2( A );
//
if( A > 1 ) // if( A > 1 )
{ // {
write32( 0xD0400A4, 0x23 ); // write32( 0xD0400A4, 0x23 );
udelay(1); // udelay(1);
write32( 0xD0400A4, 0x2023 ); // write32( 0xD0400A4, 0x2023 );
udelay(1); // udelay(1);
write32( 0xD0400A4, 0x4023 ); // write32( 0xD0400A4, 0x4023 );
udelay(20); // udelay(20);
} else { // } else {
write32( 0xD0400A4, 0x26 ); // write32( 0xD0400A4, 0x26 );
udelay(1); // udelay(1);
write32( 0xD0400A4, 0x2026 ); // write32( 0xD0400A4, 0x2026 );
udelay(1); // udelay(1);
write32( 0xD0400A4, 0x4026 ); // write32( 0xD0400A4, 0x4026 );
udelay(20); // udelay(20);
} // }
//
write32( 0xD0400CC, 0x111 ); // write32( 0xD0400CC, 0x111 );
//
} //}
void MIOSEHCIInit2( void ) //void MIOSEHCIInit2( void )
{ //{
GetRevision( SP+1, SP ); // GetRevision( SP+1, SP );
//
if( SP[1] <= 1 ) // if( SP[1] <= 1 )
{ // {
write32( 0xD8001E0, 0x65244A ); // write32( 0xD8001E0, 0x65244A );
write32( 0xD8001E4, 0x46A024 ); // write32( 0xD8001E4, 0x46A024 );
return; // return;
} // }
//
// dbgprintf("Unsupported CPU version!\n"); //// dbgprintf("Unsupported CPU version!\n");
//
} //}
void MIOSHWInit( u32 A, u32 B ) void MIOSHWInit( u32 A, u32 B )
{ {
GetRevision( SP+1, SP ); GetRevision( SP+1, SP );
@ -720,11 +721,11 @@ void MIOSHWInit( u32 A, u32 B )
MIOSUnkInit(); MIOSUnkInit();
MIOSEHCIInit( SP[1] ); //MIOSEHCIInit( SP[1] );
set32( HW_RESETS, 0x7FDFBCF ); set32( HW_RESETS, 0x7FDFBCF );
MIOSEHCIInit2(); //MIOSEHCIInit2();
} }
void UNKInit( u32 A, u32 B ) void UNKInit( u32 A, u32 B )
{ {
@ -926,7 +927,7 @@ void MEMInitLow( void )
write32( 0x00F0, 0x01800000 ); write32( 0x00F0, 0x01800000 );
write32( 0x0030, 0x00000000 ); write32( 0x0030, 0x00000000 );
write32( 0x0034, 0x81800000 ); write32( 0x0034, 0x01800000 );
write32( 0x00D0, 16*1024*1024 ); //Set ARAM size write32( 0x00D0, 16*1024*1024 ); //Set ARAM size
@ -945,11 +946,11 @@ void MEMInitLow( void )
DRAMCTRLWrite( 0x4A, 0x0E ); DRAMCTRLWrite( 0x4A, 0x0E );
DRAMCTRLWrite( 0x0F, 0x08 ); DRAMCTRLWrite( 0x0F, 0x08 );
DRAMCTRLWrite( 0x03, 0x0E ); DRAMCTRLWrite( 0x03, 0x0E );
//DRAMCTRLWrite( 0x49, 0x0E ); DRAMCTRLWrite( 0x49, 0x0E );
//udelay(2); udelay(2);
//DRAMCTRLWrite( 0x49, 0x0F ); DRAMCTRLWrite( 0x49, 0x0F );
//udelay(2); udelay(2);
DRAMWrite( 0x113, 631 ); DRAMWrite( 0x113, 631 );
@ -1030,7 +1031,7 @@ void MEMInitLow( void )
val |= 0x00000040; val |= 0x00000040;
val &= ~0x00200000; val &= ~0x00200000;
val |= 0x00200000; //val |= 0x00200000; // Enable DVD-R access by NOT setting this bit
val &= ~0x00400000; val &= ~0x00400000;
val |= 0x00400000; val |= 0x00400000;
val &= ~0x00001000; val &= ~0x00001000;

13
Makefile
View File

@ -9,21 +9,20 @@ CFLAGS += -fno-builtin-memcpy -fno-builtin-memset -fno-builtin-toupper -fno-buil
ASFLAGS = -mbig-endian -mcpu=arm926ej-s ASFLAGS = -mbig-endian -mcpu=arm926ej-s
LDFLAGS = -nostartfiles -nodefaultlibs -mbig-endian -Wl,-T,iosmodule.ld,-Map,iosmodule.map -n LDFLAGS = -nostartfiles -nodefaultlibs -mbig-endian -Wl,-T,diosmioslite.ld,-Map,diosmioslite.map -n
LIBS = -lgcc LIBS = -lgcc
TARGET = iosmodule.elf TARGET = diosmioslite.elf
OBJECTS = start.o utils_asm.o HW.o Card.o memory.o memory_asm.o Config.o common.o ff.o diskio.o alloc.o Drive.o DVD.o dip.o Patches.o main.o vsprintf.o string.o tiny_ehci_glue.o usb_os.o OBJECTS = start.o utils_asm.o HW.o Card.o memory.o memory_asm.o Config.o common.o sdhc.o ff.o sdmmc.o diskio.o alloc.o Drive.o DVD.o dip.o Patches.o main.o vsprintf.o string.o
.PHONY: FORCE .PHONY: FORCE
all: $(TARGET) all: $(TARGET)
$(TARGET) : iosmodule.ld $(OBJECTS) $(TARGET) : diosmioslite.ld $(OBJECTS)
@echo "LD $@" @echo "LD $@"
@$(LD) $(LDFLAGS) $(OBJECTS) $(LIBS) -o $@ @$(LD) $(LDFLAGS) $(OBJECTS) $(LIBS) -o $@
@echo $(SSTRIP) -s $@ @$(SSTRIP) -s $@
%.o : %.s %.o : %.s
@echo "AS $@" @echo "AS $@"
@ -47,7 +46,9 @@ $(TARGET) : iosmodule.ld $(OBJECTS)
@echo "DEP $@" @echo "DEP $@"
@touch $@ @touch $@
ifneq ($(MAKECMDGOALS),clean)
-include $(OBJECTS:.o=.d) -include $(OBJECTS:.o=.d)
endif
clean: clean:
-rm -f *.elf *.o *.bin *.d *.map -rm -f *.elf *.o *.bin *.d *.map

19
Patches.c
View File

@ -148,7 +148,7 @@ FuncPattern FPatterns[] =
{ 0x3B0, 87, 13, 27, 17, 25, (u8*)NULL, 0xdead000B, "PADRead C", 2, 0 }, { 0x3B0, 87, 13, 27, 17, 25, (u8*)NULL, 0xdead000B, "PADRead C", 2, 0 },
{ 0x334, 78, 7, 20, 17, 19, (u8*)NULL, 0xdead000B, "PADRead D", 2, 0 }, { 0x334, 78, 7, 20, 17, 19, (u8*)NULL, 0xdead000B, "PADRead D", 2, 0 },
}; };
FuncPattern CPatterns[] = FuncPattern CPatterns[] =
{ {
@ -485,6 +485,7 @@ void DoCardPatches( char *ptr, u32 size, u32 SectionOffset )
} }
return; return;
} }
void DoPatches( char *ptr, u32 size, u32 SectionOffset ) void DoPatches( char *ptr, u32 size, u32 SectionOffset )
{ {
@ -517,9 +518,11 @@ void DoPatches( char *ptr, u32 size, u32 SectionOffset )
write32(0x00003194, 0x48000028); write32(0x00003194, 0x48000028);
} }
// Reset Found // Reset Found
for( k=0; k < sizeof(FPatterns)/sizeof(FuncPattern); ++k ) for( k=0; k < sizeof(FPatterns)/sizeof(FuncPattern); ++k )
FPatterns[k].Found = 0; FPatterns[k].Found = 0;
if( ConfigGetConfig(DML_CFG_NMM) ) if( ConfigGetConfig(DML_CFG_NMM) )
DoCardPatches( ptr, size, SectionOffset ); DoCardPatches( ptr, size, SectionOffset );
@ -643,14 +646,14 @@ void DoPatches( char *ptr, u32 size, u32 SectionOffset )
u32 DBGSize; u32 DBGSize;
//if( ConfigGetConfig( DML_CFG_DEBUGGER ) ) if( ConfigGetConfig( DML_CFG_DEBUGGER ) )
//{ {
memcpy( (void*)0x1800, kenobigcDBG, sizeof(kenobigcDBG) ); memcpy( (void*)0x1800, kenobigcDBG, sizeof(kenobigcDBG) );
DBGSize = sizeof(kenobigcDBG); DBGSize = sizeof(kenobigcDBG);
//} else { } else {
// memcpy( (void*)0x1800, kenobigc, sizeof(kenobigc) ); memcpy( (void*)0x1800, kenobigc, sizeof(kenobigc) );
// DBGSize = sizeof(kenobigc); DBGSize = sizeof(kenobigc);
//} }
if( ConfigGetConfig(DML_CFG_DEBUGWAIT) ) if( ConfigGetConfig(DML_CFG_DEBUGWAIT) )
write32( P2C(read32(0x1808)), 1 ); write32( P2C(read32(0x1808)), 1 );

41
alloc.c
View File

@ -1,43 +1,36 @@
#include "alloc.h" #include "alloc.h"
#include "vsprintf.h" #include "vsprintf.h"
u8 *RAM;//[_AHEAP_SIZE_TOTAL]; u8 *RAM;
HeapInfoEntry *HeapInfoEntries=(HeapInfoEntry *)NULL; HeapInfoEntry *HeapInfoEntries=NULL;
extern u32 DRAMRead( u32 a ); extern u32 DRAMRead( u32 a );
extern void DRAMWrite( u32 a, u32 b ); extern void DRAMWrite( u32 a, u32 b );
void HeapInit( u8 *Offset ) void HeapInit( void )
{ {
//RAM = (u8*)0xFFFE4000; RAM = (u8*)0xFFFE4000;
//RAM = (u8*)0x13600000;
//RAM = (u8*)0x00600000;
RAM = Offset;
HeapInfoEntries = (HeapInfoEntry*)(RAM+_AHEAP_SIZE); HeapInfoEntries = (HeapInfoEntry*)(RAM+_AHEAP_SIZE);
memset32( HeapInfoEntries, 0, _AHEAP_INFO_SIZE ); memset32( HeapInfoEntries, 0, _AHEAP_INFO_SIZE );
while( HeapInfoEntries[0].Offset != 0 ) while( HeapInfoEntries[0].Offset != 0 )
{ {
EXIControl(1); dbgprintf("Failed to clear memory!");
dbgprintf("Alloc:Failed to clear memory!:%08X", HeapInfoEntries[0].Offset );
Shutdown(); Shutdown();
} }
// dbgprintf("Cleared 0x%04X bytes Space for %d allocs\n", _AHEAP_INFO_SIZE, _AHEAP_INFO_SIZE / 8 ); //dbgprintf("Cleared 0x%04X bytes Space for %d allocs\n", _AHEAP_INFO_SIZE, _AHEAP_INFO_SIZE / 8 );
} }
void *malloc( u32 _size ) void *malloc( u32 size )
{ {
if( _size == 0 ) if( size == 0 )
return NULL; return NULL;
if( _size > _AHEAP_SIZE ) if( size > _AHEAP_SIZE )
return NULL; return NULL;
//align size to 32, easy cheat toallow all allocs to be aligned easily //align size to 32, easy cheat to allow all allocs to be aligned easily
u32 size = (_size+0x1F) & (~0x1F); size = (size+0x1F) & (~0x1F);
//find a free entry to be used //find a free entry to be used
u32 entry = 0xdeadbeef; u32 entry = 0xdeadbeef;
@ -51,16 +44,14 @@ void *malloc( u32 _size )
break; break;
} }
} }
if( entry == 0xdeadbeef ) if( entry == 0xdeadbeef )
{ {
EXIControl(1); dbgprintf("run out of entries!\n");
dbgprintf("Alloc: run out of entries!\n"); return NULL;
while(1);
} }
//dbgprintf("Alloc:Using entry:%d to alloc %u(%u) bytes...\n", entry, size, _size ); //dbgprintf("Using entry:%d to alloc %d bytes...\n", entry, size );
//Now we search a used entry //Now we search a used entry
u32 used_entry = 0xdeadbeef; u32 used_entry = 0xdeadbeef;
@ -177,7 +168,7 @@ find_space:
if( used_entry != 0xdeadbeef ) if( used_entry != 0xdeadbeef )
goto find_space; goto find_space;
dbgprintf("Alloc:failed to alloc %d bytes\n", size ); dbgprintf("failed to alloc %d bytes\n", size );
return NULL; return NULL;
} }

4
alloc.h
View File

@ -5,7 +5,7 @@
#ifndef _ALLOC_ #ifndef _ALLOC_
#define _ALLOC_ #define _ALLOC_
#define _AHEAP_SIZE_TOTAL 0x3000 #define _AHEAP_SIZE_TOTAL 0x4000
#define _AHEAP_INFO_SIZE 0x0100 #define _AHEAP_INFO_SIZE 0x0100
#define _AHEAP_SIZE _AHEAP_SIZE_TOTAL-_AHEAP_INFO_SIZE #define _AHEAP_SIZE _AHEAP_SIZE_TOTAL-_AHEAP_INFO_SIZE
@ -15,7 +15,7 @@ typedef struct
u32 Size; u32 Size;
} HeapInfoEntry; } HeapInfoEntry;
void HeapInit( u8 *Offset ); void HeapInit( void );
void *malloc( u32 size ); void *malloc( u32 size );
void *malloca( u32 size, u32 align ); void *malloca( u32 size, u32 align );
void free( void *ptr ); void free( void *ptr );

14
dip.c
View File

@ -37,6 +37,7 @@ char *getfilenamebyoffset(u32 offset)
return (char*)NULL; return (char*)NULL;
} }
void DIInit( void ) void DIInit( void )
{ {
memset32( (void*)DI_BASE, 0xdeadbeef, 0x30 ); memset32( (void*)DI_BASE, 0xdeadbeef, 0x30 );
@ -44,8 +45,6 @@ void DIInit( void )
write32( DI_SCONFIG, 0xFF ); write32( DI_SCONFIG, 0xFF );
write32( DI_SCOVER, 0 ); write32( DI_SCOVER, 0 );
write32( HW_TIMER, 0 );
} }
u32 DIUpdateRegisters( void ) u32 DIUpdateRegisters( void )
{ {
@ -53,7 +52,7 @@ u32 DIUpdateRegisters( void )
static u32 PatchState = 0; static u32 PatchState = 0;
static u32 DOLReadSize = 0; static u32 DOLReadSize = 0;
static u32 PSOHack = 0; static u32 PSOHack = 0;
if( read32(DI_CONTROL) != 0xdeadbeef ) if( read32(DI_CONTROL) != 0xdeadbeef )
{ {
write32( DI_SCONTROL, read32(DI_CONTROL) & 3 ); write32( DI_SCONTROL, read32(DI_CONTROL) & 3 );
@ -102,7 +101,7 @@ u32 DIUpdateRegisters( void )
write32( DI_SIMM, read32(DI_IMM) ); write32( DI_SIMM, read32(DI_IMM) );
write32( DI_IMM, 0xdeadbeef ); write32( DI_IMM, 0xdeadbeef );
} }
switch( read32(DI_SCMD_0) >> 24 ) switch( read32(DI_SCMD_0) >> 24 )
{ {
case 0xA7: case 0xA7:
@ -330,12 +329,5 @@ u32 DIUpdateRegisters( void )
} }
} }
if( (u64)read32(HW_TIMER) >= 2 * 60 * 243000000LL / 128 )
{
USBStorage_Read_Sectors( 23, 1, (void*)0x1000 );
write32( HW_TIMER, 0 );
}
return 0; return 0;
} }

1
dip.h
View File

@ -13,7 +13,6 @@
#include "Config.h" #include "Config.h"
#include "DVD.h" #include "DVD.h"
#include "elf.h" #include "elf.h"
#include "usbstorage.h"
enum opcodes enum opcodes
{ {

53
diskio.c
View File

@ -1,55 +1,30 @@
#include "diskio.h" #include "diskio.h"
#include "string.h" #include "string.h"
#include "sdmmc.h"
#include "memory.h" #include "memory.h"
extern u32 IsInit;
DSTATUS disk_initialize( BYTE drv ) DSTATUS disk_initialize( BYTE drv )
{ {
s32 r, s_cnt; if (sdmmc_check_card() == SDMMC_NO_CARD)
u32 s_size; return STA_NOINIT;
while( 1 )
{
udelay( 50000 );
tiny_ehci_init();
int ret = -ENODEV;
do {
udelay( 4000 );
ret = ehci_discover();
} while( ret == -ENODEV );
dbgprintf("ehci_discover():%d\n", ret );
r = USBStorage_Init();
if( r == 0 )
break;
}
s_cnt = USBStorage_Get_Capacity( &s_size );
dbgprintf( "DIP: Drive size: %dMB SectorSize:%d\n", s_cnt / 1024 * s_size / 1024, s_size);
return r;
sdmmc_ack_card();
return disk_status(drv);
} }
DSTATUS disk_status( BYTE drv ) DSTATUS disk_status( BYTE drv )
{ {
(void)drv; (void)drv;
return 0; if (sdmmc_check_card() == SDMMC_INSERTED)
return 0;
else
return STA_NODISK;
} }
DRESULT disk_read( BYTE drv, BYTE *buff, DWORD sector, BYTE count ) DRESULT disk_read( BYTE drv, BYTE *buff, DWORD sector, BYTE count )
{ {
u8 *buffer = (u8*)buff; u8 *buffer = (u8*)buff;
//dbgprintf("disk_read( %d, %d, %p, %p)\n", sector, count, buff, buffer ); //dbgprintf("sdmmc_read( %d, %d, %p, %p)\n", sector, count, buff, buffer );
if( (u32)buff & 0xF0000000 ) if( (u32)buff & 0xF0000000 )
{ {
@ -61,7 +36,7 @@ DRESULT disk_read( BYTE drv, BYTE *buff, DWORD sector, BYTE count )
if( (count-i) < Blocks ) if( (count-i) < Blocks )
Blocks = (count-i); Blocks = (count-i);
USBStorage_Read_Sectors( sector + i, Blocks, buffer ); sdmmc_read( sector + i, Blocks, buffer );
memcpy( buff + i * 512, buffer, Blocks * 512 ); memcpy( buff + i * 512, buffer, Blocks * 512 );
i+=Blocks; i+=Blocks;
@ -70,7 +45,7 @@ DRESULT disk_read( BYTE drv, BYTE *buff, DWORD sector, BYTE count )
break; break;
} }
} else { } else {
USBStorage_Read_Sectors( sector, count, buffer ); sdmmc_read( sector, count, buffer );
dc_flushrange( buffer, count*512 ); dc_flushrange( buffer, count*512 );
ahb_flush_from( AHB_SDHC ); ahb_flush_from( AHB_SDHC );
} }
@ -89,12 +64,12 @@ DRESULT disk_write( BYTE drv, const BYTE *buff, DWORD sector, BYTE count )
for( i=0; i < count; ++i ) for( i=0; i < count; ++i )
{ {
memcpy( buffer, (void*)buff + i * 512, 512 ); memcpy( buffer, (void*)buff + i * 512, 512 );
USBStorage_Write_Sectors( sector + i, 1, buffer ); sdmmc_write( sector + i, 1, buffer );
} }
} else { } else {
ahb_flush_to( AHB_SDHC ); ahb_flush_to( AHB_SDHC );
USBStorage_Write_Sectors( sector, count, buffer ); sdmmc_write( sector, count, buffer );
} }

64
diskio.h
View File

@ -1,31 +1,14 @@
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
/ Low level disk interface modlue include file R0.07 (C)ChaN, 2009 / Low level disk interface modlue include file
/----------------------------------------------------------------------- /-----------------------------------------------------------------------*/
/ FatFs module is an open source project to implement FAT file system to small
/ embedded systems. It is opened for education, research and development under
/ license policy of following trems.
/
/ Copyright (C) 2009, ChaN, all right reserved.
/
/ * The FatFs module is a free software and there is no warranty.
/ * You can use, modify and/or redistribute it for personal, non-profit or
/ commercial use without any restriction under your responsibility.
/ * Redistributions of source code must retain the above copyright notice.
/
/----------------------------------------------------------------------------*/
// original source: http://elm-chan.org/fsw/ff/00index_e.html
#ifndef _DISKIO #ifndef _DISKIO
#define _READONLY 0 /* 1: Read-only mode */ #define _READONLY 0 /* 1: Remove write functions */
#define _USE_IOCTL 1 #define _USE_IOCTL 1 /* 1: Use disk_ioctl fucntion */
#include "integer.h" #include "integer.h"
#include "string.h"
#include "ehci.h"
#include "alloc.h"
#include "tiny_ehci_glue.h"
#include "dip.h"
/* Status of Disk Functions */ /* Status of Disk Functions */
typedef BYTE DSTATUS; typedef BYTE DSTATUS;
@ -43,15 +26,15 @@ typedef enum {
/*---------------------------------------*/ /*---------------------------------------*/
/* Prototypes for disk control functions */ /* Prototypes for disk control functions */
int assign_drives (int, int);
DSTATUS disk_initialize (BYTE); DSTATUS disk_initialize (BYTE);
DSTATUS disk_status (BYTE); DSTATUS disk_status (BYTE);
DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE); DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
#if _READONLY == 0 #if _READONLY == 0
DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE); DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
#endif #endif
#if _USE_IOCTL == 1
DRESULT disk_ioctl (BYTE, BYTE, void*); DRESULT disk_ioctl (BYTE, BYTE, void*);
#endif
/* Disk Status Bits (DSTATUS) */ /* Disk Status Bits (DSTATUS) */
@ -61,10 +44,35 @@ DRESULT disk_ioctl (BYTE, BYTE, void*);
#define STA_PROTECT 0x04 /* Write protected */ #define STA_PROTECT 0x04 /* Write protected */
#if _USE_IOCTL == 1 /* Command code for disk_ioctrl fucntion */
/* Command code for disk_ioctl() */
#define CTRL_SYNC 0 /* Mandatory for write functions */ /* Generic command (defined for FatFs) */
#endif #define CTRL_SYNC 0 /* Flush disk cache (for write functions) */
#define GET_SECTOR_COUNT 1 /* Get media size (for only f_mkfs()) */
#define GET_SECTOR_SIZE 2 /* Get sector size (for multiple sector size (_MAX_SS >= 1024)) */
#define GET_BLOCK_SIZE 3 /* Get erase block size (for only f_mkfs()) */
#define CTRL_ERASE_SECTOR 4 /* Force erased a block of sectors (for only _USE_ERASE) */
/* Generic command */
#define CTRL_POWER 5 /* Get/Set power status */
#define CTRL_LOCK 6 /* Lock/Unlock media removal */
#define CTRL_EJECT 7 /* Eject media */
/* MMC/SDC specific ioctl command */
#define MMC_GET_TYPE 10 /* Get card type */
#define MMC_GET_CSD 11 /* Get CSD */
#define MMC_GET_CID 12 /* Get CID */
#define MMC_GET_OCR 13 /* Get OCR */
#define MMC_GET_SDSTAT 14 /* Get SD status */
/* ATA/CF specific ioctl command */
#define ATA_GET_REV 20 /* Get F/W revision */
#define ATA_GET_MODEL 21 /* Get model name */
#define ATA_GET_SN 22 /* Get serial number */
/* NAND specific ioctl command */
#define NAND_FORMAT 30 /* Create physical format */
#define _DISKIO #define _DISKIO
#endif #endif

6
elfloader/Makefile
View File

@ -1,6 +1,6 @@
include starlet.mk include ../starlet.mk
CFLAGS += -fpic -fno-builtin-memcpy CFLAGS += -fpic
LDSCRIPT = stub.ld LDSCRIPT = stub.ld
LIBS = -lgcc LIBS = -lgcc
@ -8,7 +8,7 @@ TARGET = elfloader.elf
TARGET_BIN = elfloader.bin TARGET_BIN = elfloader.bin
OBJS = start.o stub.o string.o utils.o OBJS = start.o stub.o string.o utils.o
include common.mk include ../common.mk
all: $(TARGET_BIN) all: $(TARGET_BIN)

2
global.h
View File

@ -15,7 +15,7 @@
#define PADHOOK 1 #define PADHOOK 1
#define CONFIG_VERSION 0x00000002 #define CONFIG_VERSION 0x00000002
#define DM_VERSION 0x00020002 #define DML_VERSION 0x00020002
#define DI_SUCCESS 1 #define DI_SUCCESS 1
#define DI_ERROR 2 #define DI_ERROR 2

105
main.c
View File

@ -1,6 +1,6 @@
/* /*
DIOS MIOS - Gamecube USB loader for Nintendo Wii DIOS MIOS Lite - Gamecube SD loader for Nintendo Wii
Copyright (C) 2010-2012 crediar Copyright (C) 2010-2012 crediar
@ -17,30 +17,28 @@ Copyright (C) 2010-2012 crediar
#include "Patches.h" #include "Patches.h"
#include "Config.h" #include "Config.h"
#include "Card.h" #include "Card.h"
#include "sdhc.h"
#include "DVD.h" #include "DVD.h"
#include "Drive.h" #include "Drive.h"
#include "dip.h" #include "dip.h"
char __aeabi_unwind_cpp_pr0[0]; char __aeabi_unwind_cpp_pr0[0];
void Syscall( u32 a, u32 b, u32 c, u32 d ) void Syscall( u32 a, u32 b, u32 c, u32 d )
{ {
dbgprintf("Syscall,%d,%d,%d,%d\n", a, b, c, d); //dbgprintf("Syscall,%d,%d,%d,%d\n", a, b, c, d);
return; return;
} }
void SWI( u32 a, u32 b ) void SWI( u32 a, u32 b )
{ {
dbgprintf("SWI:%X,%X\n", a, b ); //dbgprintf("SWI:%X,%X\n", a, b );
return; return;
} }
void PrefetchAbort( void ) void PrefetchAbort( void )
{ {
u32 val; EXIControl(1);
__asm("mov %0,lr": "=r" (val) ); dbgprintf("PrefetchAbort\n");
*(vu32*)0xD800070 |= 1;
dbgprintf("PrefetchAbort LR:%08x\n", val-8 );
while(1); while(1);
return; return;
} }
@ -52,13 +50,13 @@ void DataAbort( u32 a, u32 b, u32 c, u32 d, u32 e, u32 f, u32 g, u32 h )
*(vu32*)0xD800070 |= 1; *(vu32*)0xD800070 |= 1;
dbgprintf("DataAbort: LR:%08x, %x, %x, %x, %x, %x, %x, %x\n",val-8,b,c,d,e,f,g,h); dbgprintf("DataAbort: LR:%08x, %x, %x, %x, %x, %x, %x, %x\n",val,b,c,d,e,f,g,h);
Shutdown(); Shutdown();
} }
void IRQHandler( void ) void IRQHandler( void )
{ {
u32 IRQs = read32(HW_ARMIRQFLAG) /*& read32(HW_ARMIRQMASK)*/; u32 IRQs = read32(HW_ARMIRQFLAG) /*& read32(HW_ARMIRQMASK)*/;
if( IRQs & IRQ_GPIO1 ) // Starlet GPIO IRQ if( IRQs & IRQ_GPIO1 ) // Starlet GPIO IRQ
{ {
if( read32(HW_GPIO_INTFLAG) & (1) ) if( read32(HW_GPIO_INTFLAG) & (1) )
@ -85,18 +83,12 @@ void IRQHandler( void )
while(1); while(1);
} }
} else if( IRQs & IRQ_RESET )
{
;
} else {
set32( HW_EXICTRL, 1 );
udelay(1000);
dbgprintf("IRQ:%08X %08X\n", read32(HW_ARMIRQFLAG), read32(HW_GPIO_INTFLAG) );
set32( HW_EXICTRL, 0 );
} }
//Clear IRQ Flags
write32( HW_ARMIRQFLAG, read32(HW_ARMIRQFLAG) );
write32( HW_GPIO_INTFLAG, read32(HW_GPIO_INTFLAG) );
return; return;
} }
void FIQHandler( void ) void FIQHandler( void )
@ -122,9 +114,13 @@ void SysShutdown( void )
} }
u32 fail; u32 fail;
FIL Log;
int main( int argc, char *argv[] ) int main( int argc, char *argv[] )
{ {
FATFS fatfs;
s32 fres = 0;
udelay(800); udelay(800);
#ifndef REALNAND #ifndef REALNAND
@ -158,53 +154,41 @@ int main( int argc, char *argv[] )
MIOSInit(); MIOSInit();
#ifdef DEBUG #ifdef DEBUG
dbgprintf("DIOS-MIOS [DEBUG] v%d.%d\n", DM_VERSION>>16, DM_VERSION & 0xFFFF ); dbgprintf("DIOS-MIOS Lite [DEBUG] v%d.%d\n", DML_VERSION>>16, DML_VERSION & 0xFFFF );
#else #else
#ifdef REALNAND #ifdef REALNAND
dbgprintf("DIOS-MIOS v%d.%db\n", DM_VERSION>>16, DM_VERSION & 0xFFFF ); dbgprintf("DIOS-MIOS Lite v%d.%db\n", DML_VERSION>>16, DML_VERSION & 0xFFFF );
#else #else
dbgprintf("DIOS-MIOS v%d.%da\n", DM_VERSION>>16, DM_VERSION & 0xFFFF ); dbgprintf("DIOS-MIOS Lite v%d.%da\n", DML_VERSION>>16, DML_VERSION & 0xFFFF );
#endif #endif
#endif #endif
dbgprintf("Built: " __DATE__ " " __TIME__ "\n"); dbgprintf("Built: " __DATE__ " " __TIME__ "\n");
dbgprintf("This software is licensed under GPLv3, for more details visit:\nhttp://code.google.com/p/diosmios\n"); dbgprintf("This software is licensed under GPLv3, for more details visit:\nhttp://code.google.com/p/diosmioslite\n");
//dbgprintf("CPU Ver:%d.%d\n", SP[1], SP[0] );
//dbgprintf("MEMInitLow()...\n"); //dbgprintf("MEMInitLow()...\n");
MEMInitLow(); MEMInitLow();
// EHCI //EHCIInit();
//dbgprintf("EHCIInit()\n");
*(vu32*)0x0D0400A4 = 0x00004026;
*(vu32*)0x0D0400B0 = 0x0002422E;
*(vu32*)0x0D0400B4 = 0x03802E14;
// DDR control
*(vu16*)0x0D8B4034 = 0x0000;
*(vu16*)0x0D8B403C = 0x0000;
*(vu16*)0x0D8B4034 = 0x0000;
*(vu16*)0x0D8B403C = 0x0000;
*(vu16*)0x0D8B4040 = 0x0000;
*(vu16*)0x0D8B4044 = 0x0000;
*(vu16*)0x0D8B4048 = 0x0000;
*(vu16*)0x0D8B404C = 0x0000;
*(vu16*)0x0D8B4050 = 0x0000;
*(vu16*)0x0D8B4054 = 0x13EB;
*(vu16*)0x0D8B4058 = 0x09B5;
*(vu16*)0x0D8B4060 = 0x0000;
*(vu16*)0x0D8B4064 = 0x0000;
*(vu16*)0x0D8B420C = 0x3620;
*(vu16*)0x0D8B4220 = 0xF000;
udelay(8000); udelay(8000);
HeapInit( (u8*)0x13600000 ); HeapInit();
//dbgprintf("HeapInit()\n");
set32( HW_EXICTRL, 1 );
sdhc_init();
DVDInit(); //dbgprintf("f_mount()");
fres = f_mount(0, &fatfs );
//dbgprintf(":%d\n", fres );
if( fres != FR_OK )
{
dbgprintf("Error: Could not mount fatfs, ret: %d\n", fres);
Shutdown();
}
set32( HW_EXICTRL, 1 );
ConfigInit( (DML_CFG*)0x01200000 ); ConfigInit( (DML_CFG*)0x01200000 );
@ -226,22 +210,11 @@ int main( int argc, char *argv[] )
DIInit(); DIInit();
//Switch mem2 to ARAM
DRAMCTRLWrite( 0x49, 0x0E );
udelay(2);
DRAMCTRLWrite( 0x49, 0x0F );
udelay(2);
HeapInit( (u8*)0xFFFE5000 );
write32( HW_PPCIRQFLAG, read32(HW_PPCIRQFLAG) ); write32( HW_PPCIRQFLAG, read32(HW_PPCIRQFLAG) );
write32( HW_ARMIRQFLAG, read32(HW_ARMIRQFLAG) ); write32( HW_ARMIRQFLAG, read32(HW_ARMIRQFLAG) );
set32( HW_PPCIRQMASK, (1<<31) ); set32( HW_PPCIRQMASK, (1<<31) );
set32( HW_IPC_PPCCTRL, 0x30 ); set32( HW_IPC_PPCCTRL, 0x30 );
write32( 0x0D806008, 0 );
EXIControl(0); EXIControl(0);

13
usb.h
View File

@ -62,7 +62,6 @@ typedef struct _usbctrlrequest {
u8 bRequestType; u8 bRequestType;
u8 bRequest; u8 bRequest;
u16 wValue; u16 wValue;
u16 wIndex; u16 wIndex;
u16 wLength; u16 wLength;
} ATTRIBUTE_PACKED usbctrlrequest; } ATTRIBUTE_PACKED usbctrlrequest;
@ -73,10 +72,8 @@ typedef struct _usbendpointdesc
u8 bDescriptorType; u8 bDescriptorType;
u8 bEndpointAddress; u8 bEndpointAddress;
u8 bmAttributes; u8 bmAttributes;
u16 wMaxPacketSize; u16 wMaxPacketSize;
u8 bInterval; u8 bInterval;
u8 pad;
} ATTRIBUTE_PACKED usb_endpointdesc; } ATTRIBUTE_PACKED usb_endpointdesc;
typedef struct _usbinterfacedesc typedef struct _usbinterfacedesc
@ -85,12 +82,10 @@ typedef struct _usbinterfacedesc
u8 bDescriptorType; u8 bDescriptorType;
u8 bInterfaceNumber; u8 bInterfaceNumber;
u8 bAlternateSetting; u8 bAlternateSetting;
u8 bNumEndpoints; u8 bNumEndpoints;
u8 bInterfaceClass; u8 bInterfaceClass;
u8 bInterfaceSubClass; u8 bInterfaceSubClass;
u8 bInterfaceProtocol; u8 bInterfaceProtocol;
u8 iInterface; u8 iInterface;
struct _usbendpointdesc *endpoints; struct _usbendpointdesc *endpoints;
} ATTRIBUTE_PACKED usb_interfacedesc; } ATTRIBUTE_PACKED usb_interfacedesc;
@ -100,12 +95,10 @@ typedef struct _usbconfdesc
u8 bLength; u8 bLength;
u8 bDescriptorType; u8 bDescriptorType;
u16 wTotalLength; u16 wTotalLength;
u8 bNumInterfaces; u8 bNumInterfaces;
u8 bConfigurationValue; u8 bConfigurationValue;
u8 iConfiguration; u8 iConfiguration;
u8 bmAttributes; u8 bmAttributes;
u8 bMaxPower; u8 bMaxPower;
struct _usbinterfacedesc *interfaces; struct _usbinterfacedesc *interfaces;
} ATTRIBUTE_PACKED usb_configurationdesc; } ATTRIBUTE_PACKED usb_configurationdesc;
@ -115,19 +108,15 @@ typedef struct _usbdevdesc
u8 bLength; u8 bLength;
u8 bDescriptorType; u8 bDescriptorType;
u16 bcdUSB; u16 bcdUSB;
u8 bDeviceClass; u8 bDeviceClass;
u8 bDeviceSubClass; u8 bDeviceSubClass;
u8 bDeviceProtocol; u8 bDeviceProtocol;
u8 bMaxPacketSize0; u8 bMaxPacketSize0;
u16 idVendor; u16 idVendor;
u16 idProduct; u16 idProduct;
u16 bcdDevice; u16 bcdDevice;
u8 iManufacturer; u8 iManufacturer;
u8 iProduct; u8 iProduct;
u8 iSerialNumber; u8 iSerialNumber;
u8 bNumConfigurations; u8 bNumConfigurations;
struct _usbconfdesc *configurations; struct _usbconfdesc *configurations;

1
usbstorage.h
View File

@ -47,7 +47,6 @@ typedef struct
} usbstorage_handle; } usbstorage_handle;
s32 USBStorage_Initialize(void); s32 USBStorage_Initialize(void);
void switchbuf(void);
s32 USBStorage_Open(usbstorage_handle *dev, struct ehci_device *fd); s32 USBStorage_Open(usbstorage_handle *dev, struct ehci_device *fd);
s32 USBStorage_Close(usbstorage_handle *dev); s32 USBStorage_Close(usbstorage_handle *dev);

7
utils.h
View File

@ -182,13 +182,6 @@ static inline u32 get_cpsr(void)
return data; return data;
} }
#define STACK_ALIGN(type, name, cnt, alignment) \
u8 _al__##name[((sizeof(type)*(cnt)) + (alignment) + \
(((sizeof(type)*(cnt))%(alignment)) > 0 ? ((alignment) - \
((sizeof(type)*(cnt))%(alignment))) : 0))]; \
type *name = (type*)(((u32)(_al__##name)) + ((alignment) - (( \
(u32)(_al__##name))&((alignment)-1))))
#define swab32(x) ((u32)( \ #define swab32(x) ((u32)( \
(((u32)(x) & (u32)0x000000ffUL) << 24) | \ (((u32)(x) & (u32)0x000000ffUL) << 24) | \
(((u32)(x) & (u32)0x0000ff00UL) << 8) | \ (((u32)(x) & (u32)0x0000ff00UL) << 8) | \

27
vsprintf.c
View File

@ -362,8 +362,35 @@ void GeckoSendBuffer( char *buffer )
return; return;
} }
extern FIL Log;
//static char buffer[128] ALIGNED(32);
int dbgprintf( const char *fmt, ...) int dbgprintf( const char *fmt, ...)
{ {
//va_list args;
//
//va_start(args, fmt);
//vsprintf(buffer, fmt, args);
//va_end(args);
//// Only write debug output to usb gecko when possible
//if( read32( 0x0D800070 ) & 1 )
//{
// GeckoSendBuffer( buffer );
//} else {
// u32 read;
// u32 fres = f_open( &Log, "/dm.log", FA_READ|FA_WRITE|FA_OPEN_ALWAYS );
// if( fres != FR_OK )
// {
// write32( 0x0D800070, 1 );
// dbgprintf("f_open():%d\n", fres );
// }
// f_lseek( &Log, Log.fsize );
// f_write( &Log, buffer, strlen(buffer), &read );
// f_close( &Log );
//}
return 1; return 1;
} }