int main(void)
{
#ifdef NUT_OS
NutRegisterDevice(&DEV_CONSOLE, 0, 0);
freopen(DEV_CONSOLE.dev_name, "w", stdout);
#endif
puts("uHTTP form sample\nBuild " __DATE__ " " __TIME__);
#ifdef NUT_OS
NutRegisterDevice(&DEV_ETHER, 0, 0);
NutDhcpIfConfig(DEV_ETHER_NAME, NULL, 60000);
NutRegisterDevice(&devUrom, 0, 0);
#endif
StreamInit();
MediaTypeInitDefaults();
HttpRegisterRedir("", "/index.html", 301);
HttpRegisterCgiFunction("getform.cgi", CgiGetForm);
HttpRegisterCgiFunction("postform.cgi", CgiPostForm);
HttpRegisterMediaType("cgi", NULL, NULL, HttpCgiFunctionHandler);
StreamClientAccept(HttpdClientHandler, NULL);
puts("Exit");
#ifdef NUT_OS
for (;;) ;
#endif
return 0;
}
CEXIMic::CEXIMic(int index) : slot(index)
{
m_position = 0;
command = 0;
status.U16 = 0;
sample_rate = rate_base;
buff_size = ring_base;
buff_size_samples = buff_size / sample_size;
ring_pos = 0;
std::memset(ring_buffer, 0, sizeof(ring_buffer));
next_int_ticks = 0;
StreamInit();
}
msg_t HttpTask (void *p)
{
(void)p;
chRegSetThreadName("HttpTask");
/*
* Initialize the TCP socket interface.
*/
StreamInit();
/*
* Register media type defaults. These are configurable
* in include/cfg/http.h or the Nut/OS Configurator.
*/
MediaTypeInitDefaults();
HttpRegisterRedir("", "/index.html", 301);
HttpRegisterCgiFunction("clock.cgi", CgiClock);
HttpRegisterCgiFunction("getform.cgi", CgiGetForm);
HttpRegisterCgiFunction("postform.cgi", CgiPostForm);
HttpRegisterMediaType("cgi", NULL, NULL, HttpCgiFunctionHandler);
/*
* Wait for a client (browser) and handle its request.
* This function will only return on unrecoverable errors.
*/
StreamClientAccept(HttpdClientHandler, NULL);
/* Typically this point will be never reached. */
while(1)
{
chThdSleepMilliseconds(500);
}
return(0);
} /* HttpTask */
int _main( int argc, char *argv[] )
{
//BSS is in DATA section so IOS doesnt touch it, we need to manually clear it
//dbgprintf("memset32(%08x, 0, %08x)\n", &__bss_start, &__bss_end - &__bss_start);
memset32(&__bss_start, 0, &__bss_end - &__bss_start);
sync_after_write(&__bss_start, &__bss_end - &__bss_start);
s32 ret = 0;
u32 DI_Thread = 0;
u8 MessageHeap[0x10];
BootStatus(0, 0, 0);
thread_set_priority( 0, 0x79 ); // do not remove this, this waits for FS to be ready!
thread_set_priority( 0, 0x50 );
thread_set_priority( 0, 0x79 );
//Disable AHBPROT
EnableAHBProt(-1);
//Load IOS Modules
ES_Init( MessageHeap );
//Early HID for loader
HIDInit();
//Enable DVD Access
write32(HW_DIFLAGS, read32(HW_DIFLAGS) & ~DI_DISABLEDVD);
dbgprintf("Sending signal to loader\r\n");
BootStatus(1, 0, 0);
mdelay(10);
//Loader running, selects games
while(1)
{
sync_before_read((void*)RESET_STATUS, 0x20);
vu32 reset_status = read32(RESET_STATUS);
if(reset_status != 0)
{
if(reset_status == 0x0DEA)
break; //game selected
else if(reset_status == 0x1DEA)
goto DoIOSBoot; //exit
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
}
HIDUpdateRegisters(1);
mdelay(10);
}
ConfigSyncBeforeRead();
u32 UseUSB = ConfigGetConfig(NIN_CFG_USB);
SetDiskFunctions(UseUSB);
BootStatus(2, 0, 0);
if(UseUSB)
{
ret = USBStorage_Startup();
dbgprintf("USB:Drive size: %dMB SectorSize:%d\r\n", s_cnt / 1024 * s_size / 1024, s_size);
}
else
{
s_size = PAGE_SIZE512; //manually set s_size
ret = SDHCInit();
}
if(ret != 1)
{
dbgprintf("Device Init failed:%d\r\n", ret );
BootStatusError(-2, ret);
mdelay(4000);
Shutdown();
}
//Verification if we can read from disc
if(memcmp(ConfigGetGamePath(), "di", 3) == 0)
RealDI_Init(); //will shutdown on fail
BootStatus(3, 0, 0);
fatfs = (FATFS*)malloca( sizeof(FATFS), 32 );
s32 res = f_mount( fatfs, fatDevName, 1 );
if( res != FR_OK )
{
dbgprintf("ES:f_mount() failed:%d\r\n", res );
BootStatusError(-3, res);
mdelay(4000);
Shutdown();
}
BootStatus(4, 0, 0);
BootStatus(5, 0, 0);
FIL fp;
s32 fres = f_open_char(&fp, "/bladie", FA_READ|FA_OPEN_EXISTING);
switch(fres)
{
case FR_OK:
f_close(&fp);
case FR_NO_PATH:
case FR_NO_FILE:
{
fres = FR_OK;
} break;
default:
case FR_DISK_ERR:
{
BootStatusError(-5, fres);
mdelay(4000);
Shutdown();
} break;
}
if(!UseUSB) //Use FAT values for SD
s_cnt = fatfs->n_fatent * fatfs->csize;
BootStatus(6, s_size, s_cnt);
BootStatus(7, s_size, s_cnt);
ConfigInit();
if (ConfigGetConfig(NIN_CFG_LOG))
SDisInit = 1; // Looks okay after threading fix
dbgprintf("Game path: %s\r\n", ConfigGetGamePath());
BootStatus(8, s_size, s_cnt);
memset32((void*)RESET_STATUS, 0, 0x20);
sync_after_write((void*)RESET_STATUS, 0x20);
memset32((void*)0x13002800, 0, 0x30);
sync_after_write((void*)0x13002800, 0x30);
memset32((void*)0x13160000, 0, 0x20);
sync_after_write((void*)0x13160000, 0x20);
memset32((void*)0x13026500, 0, 0x100);
sync_after_write((void*)0x13026500, 0x100);
BootStatus(9, s_size, s_cnt);
DIRegister();
DI_Thread = thread_create(DIReadThread, NULL, ((u32*)&__di_stack_addr), ((u32)(&__di_stack_size)) / sizeof(u32), 0x78, 1);
thread_continue(DI_Thread);
DIinit(true);
BootStatus(10, s_size, s_cnt);
GCAMInit();
EXIInit();
BootStatus(11, s_size, s_cnt);
SIInit();
StreamInit();
PatchInit();
//Tell PPC side we are ready!
cc_ahbMemFlush(1);
mdelay(1000);
BootStatus(0xdeadbeef, s_size, s_cnt);
mdelay(1000); //wait before hw flag changes
dbgprintf("Kernel Start\r\n");
//write32( 0x1860, 0xdeadbeef ); // Clear OSReport area
//sync_after_write((void*)0x1860, 0x20);
u32 Now = read32(HW_TIMER);
u32 PADTimer = Now;
u32 DiscChangeTimer = Now;
u32 ResetTimer = Now;
u32 InterruptTimer = Now;
USBReadTimer = Now;
u32 Reset = 0;
bool SaveCard = false;
if( ConfigGetConfig(NIN_CFG_LED) )
{
set32(HW_GPIO_ENABLE, GPIO_SLOT_LED);
clear32(HW_GPIO_DIR, GPIO_SLOT_LED);
clear32(HW_GPIO_OWNER, GPIO_SLOT_LED);
}
set32(HW_GPIO_ENABLE, GPIO_SENSOR_BAR);
clear32(HW_GPIO_DIR, GPIO_SENSOR_BAR);
clear32(HW_GPIO_OWNER, GPIO_SENSOR_BAR);
set32(HW_GPIO_OUT, GPIO_SENSOR_BAR); //turn on sensor bar
write32( HW_PPCIRQMASK, (1<<30) );
write32( HW_PPCIRQFLAG, read32(HW_PPCIRQFLAG) );
//This bit seems to be different on japanese consoles
u32 ori_ppcspeed = read32(HW_PPCSPEED);
if((ConfigGetGameID() & 0xFF) == 'J')
set32(HW_PPCSPEED, (1<<17));
else
clear32(HW_PPCSPEED, (1<<17));
u32 ori_widesetting = read32(0xd8006a0);
if(IsWiiU)
{
if( ConfigGetConfig(NIN_CFG_WIIU_WIDE) )
write32(0xd8006a0, 0x30000004);
else
write32(0xd8006a0, 0x30000002);
mask32(0xd8006a8, 0, 2);
}
while (1)
{
_ahbMemFlush(0);
//Does interrupts again if needed
if(TimerDiffTicks(InterruptTimer) > 15820) //about 120 times a second
{
sync_before_read((void*)INT_BASE, 0x80);
if((read32(RSW_INT) & 2) || (read32(DI_INT) & 4) ||
(read32(SI_INT) & 8) || (read32(EXI_INT) & 0x10))
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
InterruptTimer = read32(HW_TIMER);
}
#ifdef PATCHALL
if (EXI_IRQ == true)
{
if(EXICheckTimer())
EXIInterrupt();
}
#endif
if (SI_IRQ != 0)
{
if ((TimerDiffTicks(PADTimer) > 7910) || (SI_IRQ & 0x2)) // about 240 times a second
{
SIInterrupt();
PADTimer = read32(HW_TIMER);
}
}
if(DI_IRQ == true)
{
if(DiscCheckAsync())
DIInterrupt();
else
udelay(200); //let the driver load data
}
else if(SaveCard == true) /* DI IRQ indicates we might read async, so dont write at the same time */
{
if(TimerDiffSeconds(Now) > 2) /* after 3 second earliest */
{
EXISaveCard();
SaveCard = false;
}
}
else if(UseUSB && TimerDiffSeconds(USBReadTimer) > 149) /* Read random sector every 2 mins 30 secs */
{
DIFinishAsync(); //if something is still running
DI_CallbackMsg.result = -1;
sync_after_write(&DI_CallbackMsg, 0x20);
IOS_IoctlAsync( DI_Handle, 2, NULL, 0, NULL, 0, DI_MessageQueue, &DI_CallbackMsg );
DIFinishAsync();
USBReadTimer = read32(HW_TIMER);
}
udelay(10); //wait for other threads
//Baten Kaitos save hax
/*if( read32(0) == 0x474B4245 )
{
if( read32( 0x0073E640 ) == 0xFFFFFFFF )
{
write32( 0x0073E640, 0 );
}
}*/
if( WaitForRealDisc == 1 )
{
if(RealDI_NewDisc())
{
DiscChangeTimer = read32(HW_TIMER);
WaitForRealDisc = 2; //do another flush round, safety!
}
}
else if( WaitForRealDisc == 2 )
{
if(TimerDiffSeconds(DiscChangeTimer))
{
//identify disc after flushing everything
RealDI_Identify(false);
//clear our fake regs again
sync_before_read((void*)DI_BASE, 0x40);
write32(DI_IMM, 0);
write32(DI_COVER, 0);
sync_after_write((void*)DI_BASE, 0x40);
//mask and clear interrupts
write32( DIP_STATUS, 0x54 );
//disable cover irq which DIP enabled
write32( DIP_COVER, 4 );
DIInterrupt();
WaitForRealDisc = 0;
}
}
if ( DiscChangeIRQ == 1 )
{
DiscChangeTimer = read32(HW_TIMER);
DiscChangeIRQ = 2;
}
else if ( DiscChangeIRQ == 2 )
{
if ( TimerDiffSeconds(DiscChangeTimer) > 2 )
{
DIInterrupt();
DiscChangeIRQ = 0;
}
}
_ahbMemFlush(1);
DIUpdateRegisters();
#ifdef PATCHALL
EXIUpdateRegistersNEW();
GCAMUpdateRegisters();
BTUpdateRegisters();
HIDUpdateRegisters(0);
if(DisableSIPatch == 0) SIUpdateRegisters();
#endif
StreamUpdateRegisters();
CheckOSReport();
if(EXICheckCard())
{
Now = read32(HW_TIMER);
SaveCard = true;
}
sync_before_read((void*)RESET_STATUS, 0x20);
vu32 reset_status = read32(RESET_STATUS);
if (reset_status == 0x1DEA)
{
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
DIFinishAsync();
break;
}
if (reset_status == 0x3DEA)
{
if (Reset == 0)
{
dbgprintf("Fake Reset IRQ\n");
write32( RSW_INT, 0x2 ); // Reset irq
sync_after_write( (void*)RSW_INT, 0x20 );
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
Reset = 1;
}
}
else if (Reset == 1)
{
write32( RSW_INT, 0x10000 ); // send pressed
sync_after_write( (void*)RSW_INT, 0x20 );
ResetTimer = read32(HW_TIMER);
Reset = 2;
}
/* The cleanup is not connected to the button press */
if (Reset == 2)
{
if (TimerDiffTicks(ResetTimer) > 949219) //free after half a second
{
write32( RSW_INT, 0 ); // done, clear
sync_after_write( (void*)RSW_INT, 0x20 );
Reset = 0;
}
}
if(reset_status == 0x4DEA)
PatchGame();
if(reset_status == 0x5DEA)
{
SetIPL();
PatchGame();
}
if(reset_status == 0x6DEA)
{
SetIPL_TRI();
write32(RESET_STATUS, 0);
sync_after_write((void*)RESET_STATUS, 0x20);
}
if(read32(HW_GPIO_IN) & GPIO_POWER)
{
DIFinishAsync();
#ifdef PATCHALL
BTE_Shutdown();
#endif
Shutdown();
}
//sync_before_read( (void*)0x1860, 0x20 );
//if( read32(0x1860) != 0xdeadbeef )
//{
// if( read32(0x1860) != 0 )
// {
// dbgprintf( (char*)(P2C(read32(0x1860))),
// (char*)(P2C(read32(0x1864))),
// (char*)(P2C(read32(0x1868))),
// (char*)(P2C(read32(0x186C))),
// (char*)(P2C(read32(0x1870))),
// (char*)(P2C(read32(0x1874)))
// );
// }
// write32(0x1860, 0xdeadbeef);
// sync_after_write( (void*)0x1860, 0x20 );
//}
cc_ahbMemFlush(1);
}
//if( UseHID )
HIDClose();
IOS_Close(DI_Handle); //close game
thread_cancel(DI_Thread, 0);
DIUnregister();
/* reset time */
while(1)
{
sync_before_read( (void*)RESET_STATUS, 0x20 );
if(read32(RESET_STATUS) == 0x2DEA)
break;
wait_for_ppc(1);
}
if( ConfigGetConfig(NIN_CFG_LED) )
clear32(HW_GPIO_OUT, GPIO_SLOT_LED);
if( ConfigGetConfig(NIN_CFG_MEMCARDEMU) )
EXIShutdown();
if (ConfigGetConfig(NIN_CFG_LOG))
closeLog();
#ifdef PATCHALL
BTE_Shutdown();
#endif
//unmount FAT device
free(fatfs);
fatfs = NULL;
f_mount(NULL, fatDevName, 1);
if(UseUSB)
USBStorage_Shutdown();
else
SDHCShutdown();
//make sure we set that back to the original
write32(HW_PPCSPEED, ori_ppcspeed);
if(IsWiiU)
{
write32(0xd8006a0, ori_widesetting);
mask32(0xd8006a8, 0, 2);
}
DoIOSBoot:
sync_before_read((void*)0x13003000, 0x420);
IOSBoot((char*)0x13003020, 0, read32(0x13003000));
return 0;
}
int _main( int argc, char *argv[] )
{
//BSS is in DATA section so IOS doesnt touch it, we need to manually clear it
//dbgprintf("memset32(%08x, 0, %08x)\n", &__bss_start, &__bss_end - &__bss_start);
memset32(&__bss_start, 0, &__bss_end - &__bss_start);
sync_after_write(&__bss_start, &__bss_end - &__bss_start);
s32 ret = 0;
u32 HID_Thread = 0, DI_Thread = 0;
u8 MessageHeap[0x10];
//u32 MessageQueue=0xFFFFFFFF;
BootStatus(0, 0, 0);
thread_set_priority( 0, 0x79 ); // do not remove this, this waits for FS to be ready!
thread_set_priority( 0, 0x50 );
thread_set_priority( 0, 0x79 );
//MessageQueue = ES_Init( MessageHeap );
ES_Init( MessageHeap );
BootStatus(1, 0, 0);
#ifndef NINTENDONT_USB
BootStatus(2, 0, 0);
ret = SDHCInit();
if(!ret)
{
dbgprintf("SD:SDHCInit() failed:%d\r\n", ret );
BootStatusError(-2, ret);
mdelay(2000);
Shutdown();
}
#endif
BootStatus(3, 0, 0);
fatfs = (FATFS*)malloca( sizeof(FATFS), 32 );
s32 res = f_mount( 0, fatfs );
if( res != FR_OK )
{
dbgprintf("ES:f_mount() failed:%d\r\n", res );
BootStatusError(-3, res);
mdelay(2000);
Shutdown();
}
BootStatus(4, 0, 0);
BootStatus(5, 0, 0);
int MountFail = 0;
s32 fres = -1;
FIL fp;
while(fres != FR_OK)
{
fres = f_open(&fp, "/bladie", FA_READ|FA_OPEN_EXISTING);
switch(fres)
{
case FR_OK:
f_close(&fp);
case FR_NO_PATH:
case FR_NO_FILE:
{
fres = FR_OK;
} break;
default:
case FR_DISK_ERR:
{
f_mount(0, NULL); //unmount drive todo: retry could never work
MountFail++;
if(MountFail == 10)
{
BootStatusError(-5, fres);
mdelay(2000);
Shutdown();
}
mdelay(5);
} break;
}
if(STATUS_ERROR == -7) { // FS check timed out on PPC side
dbgprintf("FS check timed out\r\n");
mdelay(3000);
Shutdown();
}
}
#ifndef NINTENDONT_USB
s_size = 512;
s_cnt = fatfs->n_fatent * fatfs->csize;
#endif
BootStatus(6, s_size, s_cnt);
#ifdef NINTENDONT_USB
s32 r = LoadModules(55);
//dbgprintf("ES:ES_LoadModules(%d):%d\r\n", 55, r );
if( r < 0 )
{
BootStatusError(-6, r);
mdelay(2000);
Shutdown();
}
#endif
BootStatus(7, s_size, s_cnt);
ConfigInit();
if (ConfigGetConfig(NIN_CFG_LOG))
SDisInit = 1; // Looks okay after threading fix
dbgprintf("Game path: %s\r\n", ConfigGetGamePath());
BootStatus(8, s_size, s_cnt);
memset32((void*)0x13002800, 0, 0x30);
sync_after_write((void*)0x13002800, 0x30);
memset32((void*)0x13160000, 0, 0x20);
sync_after_write((void*)0x13160000, 0x20);
memset32((void*)0x13026500, 0, 0x100);
sync_after_write((void*)0x13026500, 0x100);
bool UseHID = ConfigGetConfig(NIN_CFG_HID);
if( UseHID )
{
ret = HIDInit();
if(ret < 0 )
{
dbgprintf("ES:HIDInit() failed\r\n" );
BootStatusError(-8, ret);
mdelay(2000);
Shutdown();
}
write32(0x13003004, 0);
sync_after_write((void*)0x13003004, 0x20);
HID_Thread = thread_create(HID_Run, NULL, HID_ThreadStack, 0x400, 0x78, 1);
thread_continue(HID_Thread);
}
BootStatus(9, s_size, s_cnt);
DIRegister();
DI_Thread = thread_create(DIReadThread, NULL, DI_ThreadStack, 0x400, 0x78, 1);
thread_continue(DI_Thread);
DIinit(true);
BootStatus(10, s_size, s_cnt);
GCAMInit();
EXIInit();
ret = Check_Cheats();
if(ret < 0 )
{
dbgprintf("Check_Cheats failed\r\n" );
BootStatusError(-10, ret);
mdelay(4000);
Shutdown();
}
BootStatus(11, s_size, s_cnt);
bool PatchSI = !ConfigGetConfig(NIN_CFG_NATIVE_SI);
if (PatchSI)
SIInit();
StreamInit();
PatchInit();
//This bit seems to be different on japanese consoles
u32 ori_ppcspeed = read32(HW_PPCSPEED);
if((ConfigGetGameID() & 0xFF) == 'J')
set32(HW_PPCSPEED, (1<<17));
else
clear32(HW_PPCSPEED, (1<<17));
//write32( 0x1860, 0xdeadbeef ); // Clear OSReport area
//Tell PPC side we are ready!
cc_ahbMemFlush(1);
mdelay(1000);
BootStatus(0xdeadbeef, s_size, s_cnt);
u32 Now = read32(HW_TIMER);
u32 PADTimer = Now;
u32 DiscChangeTimer = Now;
u32 ResetTimer = Now;
#ifdef NINTENDONT_USB
u32 USBReadTimer = Now;
#endif
u32 Reset = 0;
bool SaveCard = false;
if( ConfigGetConfig(NIN_CFG_LED) )
{
set32(HW_GPIO_ENABLE, GPIO_SLOT_LED);
clear32(HW_GPIO_DIR, GPIO_SLOT_LED);
clear32(HW_GPIO_OWNER, GPIO_SLOT_LED);
}
EnableAHBProt(-1); //disable AHBPROT
write32(0xd8006a0, 0x30000004), mask32(0xd8006a8, 0, 2); //widescreen fix
while (1)
{
_ahbMemFlush(0);
//Check this. Purpose is to send another interrupt if wasn't processed
/*if (((read32(0x14) != 0) || (read32(0x13026514) != 0))
&& (read32(HW_ARMIRQFLAG) & (1 << 30)) == 0)
{
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
}*/
#ifdef PATCHALL
if (EXI_IRQ == true)
{
if(EXICheckTimer())
EXIInterrupt();
}
#endif
if ((PatchSI) && (SI_IRQ != 0))
{
if (((read32(HW_TIMER) - PADTimer) > 7910) || (SI_IRQ & 0x2)) // about 240 times a second
{
SIInterrupt();
PADTimer = read32(HW_TIMER);
}
}
if(DI_IRQ == true)
{
if(DI_CallbackMsg.result == 0)
DIInterrupt();
}
else if(SaveCard == true) /* DI IRQ indicates we might read async, so dont write at the same time */
{
if((read32(HW_TIMER) - Now) / 1898437 > 2) /* after 3 second earliest */
{
EXISaveCard();
SaveCard = false;
}
}
#ifdef NINTENDONT_USB
else if((read32(HW_TIMER) - USBReadTimer) / 1898437 > 9) /* Read random sector after about 10 seconds */
{
DI_CallbackMsg.result = -1;
sync_after_write(&DI_CallbackMsg, 0x20);
IOS_IoctlAsync( DI_Handle, 2, NULL, 0, NULL, 0, DI_MessageQueue, &DI_CallbackMsg );
while(DI_CallbackMsg.result)
{
udelay(10); //wait for other threads
BTUpdateRegisters();
}
USBReadTimer = read32(HW_TIMER);
}
#endif
udelay(10); //wait for other threads
//Baten Kaitos save hax
/*if( read32(0) == 0x474B4245 )
{
if( read32( 0x0073E640 ) == 0xFFFFFFFF )
{
write32( 0x0073E640, 0 );
}
}*/
if ( DiscChangeIRQ == 1 )
{
DiscChangeTimer = read32(HW_TIMER);
DiscChangeIRQ = 2;
}
else if ( DiscChangeIRQ == 2 )
{
if ( (read32(HW_TIMER) - DiscChangeTimer ) > 2 * 243000000 / 128)
{
//dbgprintf("DIP:IRQ mon!\r\n");
set32( DI_SSTATUS, 0x3A );
sync_after_write((void*)DI_SSTATUS, 4);
DIInterrupt();
DiscChangeIRQ = 0;
}
}
_ahbMemFlush(1);
DIUpdateRegisters();
#ifdef PATCHALL
EXIUpdateRegistersNEW();
GCAMUpdateRegisters();
BTUpdateRegisters();
#endif
StreamUpdateRegisters();
CheckOSReport();
if(EXICheckCard())
{
Now = read32(HW_TIMER);
SaveCard = true;
}
if (PatchSI)
{
SIUpdateRegisters();
if (read32(DIP_IMM) == 0x1DEA)
{
DIFinishAsync();
break;
}
if (read32(DIP_IMM) == 0x3DEA)
{
if (Reset == 0)
{
dbgprintf("Fake Reset IRQ\n");
write32(EXI2DATA, 0x2); // Reset irq
write32(HW_IPC_ARMCTRL, (1 << 0) | (1 << 4)); //throw irq
Reset = 1;
}
}
else if (Reset == 1)
{
write32(EXI2DATA, 0x10000); // send pressed
ResetTimer = read32(HW_TIMER);
Reset = 2;
}
/* The cleanup is not connected to the button press */
if (Reset == 2)
{
if ((read32(HW_TIMER) - ResetTimer) / 949219 > 0) //free after half a second
{
write32(EXI2DATA, 0); // done, clear
write32(DIP_IMM, 0);
Reset = 0;
}
}
}
if(read32(DIP_IMM) == 0x4DEA)
PatchGame();
CheckPatchPrs();
if(read32(HW_GPIO_IN) & GPIO_POWER)
{
DIFinishAsync();
#ifdef PATCHALL
BTE_Shutdown();
#endif
Shutdown();
}
//sync_before_read( (void*)0x1860, 0x20 );
//if( read32(0x1860) != 0xdeadbeef )
//{
// if( read32(0x1860) != 0 )
// {
// dbgprintf( (char*)(P2C(read32(0x1860))),
// (char*)(P2C(read32(0x1864))),
// (char*)(P2C(read32(0x1868))),
// (char*)(P2C(read32(0x186C))),
// (char*)(P2C(read32(0x1870))),
// (char*)(P2C(read32(0x1874)))
// );
// }
// write32(0x1860, 0xdeadbeef);
// sync_after_write( (void*)0x1860, 0x20 );
//}
cc_ahbMemFlush(1);
}
if( UseHID )
{
/* we're done reading inputs */
thread_cancel(HID_Thread, 0);
}
IOS_Close(DI_Handle); //close game
thread_cancel(DI_Thread, 0);
DIUnregister();
write32( DIP_IMM, 0 );
/* reset time */
while(1)
{
if(read32(DIP_IMM) == 0x2DEA)
break;
wait_for_ppc(1);
}
if( ConfigGetConfig(NIN_CFG_LED) )
clear32(HW_GPIO_OUT, GPIO_SLOT_LED);
if( ConfigGetConfig(NIN_CFG_MEMCARDEMU) )
EXIShutdown();
if (ConfigGetConfig(NIN_CFG_LOG))
closeLog();
#ifdef PATCHALL
BTE_Shutdown();
#endif
//unmount FAT device
f_mount(0, NULL);
#ifndef NINTENDONT_USB
SDHCShutdown();
#endif
//make sure we set that back to the original
write32(HW_PPCSPEED, ori_ppcspeed);
IOSBoot((char*)0x13003020, 0, read32(0x13003000));
return 0;
}
static int
EncodeOptimizeBest(DmtxByteList *input, DmtxByteList *output, int sizeIdxRequest, int fnc1)
{
enum SchemeState state;
int inputNext, c40ValueCount, textValueCount, x12ValueCount;
int sizeIdx;
DmtxEncodeStream *winner;
DmtxPassFail passFail;
DmtxEncodeStream streamsBest[SchemeStateCount];
DmtxEncodeStream streamsTemp[SchemeStateCount];
DmtxByte outputsBestStorage[SchemeStateCount][4096];
DmtxByte outputsTempStorage[SchemeStateCount][4096];
DmtxByte ctxTempStorage[4];
DmtxByteList outputsBest[SchemeStateCount];
DmtxByteList outputsTemp[SchemeStateCount];
DmtxByteList ctxTemp = dmtxByteListBuild(ctxTempStorage, sizeof(ctxTempStorage));
/* Initialize all streams with their own output storage */
for(state = 0; state < SchemeStateCount; state++)
{
outputsBest[state] = dmtxByteListBuild(outputsBestStorage[state], sizeof(outputsBestStorage[state]));
outputsTemp[state] = dmtxByteListBuild(outputsTempStorage[state], sizeof(outputsTempStorage[state]));
streamsBest[state] = StreamInit(input, &(outputsBest[state]));
streamsTemp[state] = StreamInit(input, &(outputsTemp[state]));
streamsBest[state].fnc1 = fnc1;
streamsTemp[state].fnc1 = fnc1;
}
c40ValueCount = textValueCount = x12ValueCount = 0;
for(inputNext = 0; inputNext < input->length; inputNext++)
{
StreamAdvanceFromBest(streamsTemp, streamsBest, AsciiFull, sizeIdxRequest);
AdvanceAsciiCompact(streamsTemp, streamsBest, AsciiCompactOffset0, inputNext, sizeIdxRequest);
AdvanceAsciiCompact(streamsTemp, streamsBest, AsciiCompactOffset1, inputNext, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, C40Offset0, inputNext, c40ValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, C40Offset1, inputNext, c40ValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, C40Offset2, inputNext, c40ValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, TextOffset0, inputNext, textValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, TextOffset1, inputNext, textValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, TextOffset2, inputNext, textValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, X12Offset0, inputNext, x12ValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, X12Offset1, inputNext, x12ValueCount, sizeIdxRequest);
AdvanceCTX(streamsTemp, streamsBest, X12Offset2, inputNext, x12ValueCount, sizeIdxRequest);
AdvanceEdifact(streamsTemp, streamsBest, EdifactOffset0, inputNext, sizeIdxRequest);
AdvanceEdifact(streamsTemp, streamsBest, EdifactOffset1, inputNext, sizeIdxRequest);
AdvanceEdifact(streamsTemp, streamsBest, EdifactOffset2, inputNext, sizeIdxRequest);
AdvanceEdifact(streamsTemp, streamsBest, EdifactOffset3, inputNext, sizeIdxRequest);
StreamAdvanceFromBest(streamsTemp, streamsBest, Base256, sizeIdxRequest);
/* Overwrite best streams with new results */
for(state = 0; state < SchemeStateCount; state++)
{
if(streamsBest[state].status != DmtxStatusComplete)
StreamCopy(&(streamsBest[state]), &(streamsTemp[state]));
}
dmtxByteListClear(&ctxTemp);
PushCTXValues(&ctxTemp, input->b[inputNext], DmtxSchemeC40, &passFail, fnc1);
c40ValueCount += ((passFail == DmtxPass) ? ctxTemp.length : 1);
dmtxByteListClear(&ctxTemp);
PushCTXValues(&ctxTemp, input->b[inputNext], DmtxSchemeText, &passFail, fnc1);
textValueCount += ((passFail == DmtxPass) ? ctxTemp.length : 1);
dmtxByteListClear(&ctxTemp);
PushCTXValues(&ctxTemp, input->b[inputNext], DmtxSchemeX12, &passFail, fnc1);
x12ValueCount += ((passFail == DmtxPass) ? ctxTemp.length : 1);
#if DUMPSTREAMS
DumpStreams(streamsBest);
#endif
}
/* Choose the overall winner */
winner = NULL;
for(state = 0; state < SchemeStateCount; state++)
{
if(streamsBest[state].status == DmtxStatusComplete)
{
if(winner == NULL || streamsBest[state].output->length < winner->output->length)
winner = &(streamsBest[state]);
}
}
/* Copy winner to output */
if(winner == NULL)
{
sizeIdx = DmtxUndefined;
}
else
{
dmtxByteListCopy(output, winner->output, &passFail);
sizeIdx = (passFail == DmtxPass) ? winner->sizeIdx : DmtxUndefined;
}
return sizeIdx;
}
int SessionInit( CapEnv* env, TcpSession* sess, DSSL_Pkt* pkt, NM_SessionType s_type )
{
int is_server = 0;
memset( sess, 0, sizeof(*sess) );
sess->type = s_type;
if( s_type != eSessionTypeSSL && s_type != eSessionTypeTcp ) return NM_ERROR( DSSL_E_INVALID_PARAMETER );
switch( pkt->tcp_header->th_flags & ~(TH_ECNECHO | TH_CWR) )
{
case TH_SYN:
StreamInit( &sess->clientStream, sess,
INADDR_IP( pkt->ip_header->ip_src ), PKT_TCP_SPORT( pkt ), tcpSynSent );
StreamInit( &sess->serverStream, sess,
INADDR_IP( pkt->ip_header->ip_dst ), PKT_TCP_DPORT( pkt ), tcpListen );
is_server = 0;
break;
case TH_SYN | TH_ACK:
StreamInit( &sess->serverStream, sess,
INADDR_IP( pkt->ip_header->ip_src ), PKT_TCP_SPORT( pkt ), tcpSynReceived );
StreamInit( &sess->clientStream, sess,
INADDR_IP( pkt->ip_header->ip_dst ), PKT_TCP_DPORT( pkt ), tcpSynSent );
is_server = 1;
break;
default:
StreamInit( &sess->serverStream, sess,
INADDR_IP( pkt->ip_header->ip_src ), PKT_TCP_SPORT( pkt ), tcpEstablished );
StreamInit( &sess->clientStream, sess,
INADDR_IP( pkt->ip_header->ip_dst ), PKT_TCP_DPORT( pkt ), tcpEstablished );
/*
This connection has already been established. Can't reassemble the SSL session from the middle,
hence ignore this session.
*/
if( sess->type == eSessionTypeSSL ) sess->type = eSessionTypeNull;
break;
}
/* set up the decoders */
switch( sess->type )
{
case eSessionTypeTcp:
sess->OnNewPacket = OnNewPlainTextPacket;
break;
case eSessionTypeSSL:
/* create SSL session */
if( env->ssl_env != NULL )
{
sess->ssl_session = DSSL_EnvCreateSession( env->ssl_env,
&pkt->ip_header->ip_dst, PKT_TCP_DPORT( pkt ) );
}
else
{
sess->ssl_session = NULL;
}
/* set packet callback */
if( sess->ssl_session != NULL )
{
sess->OnNewPacket = OnNewSSLPacket;
DSSL_SessionSetCallback( sess->ssl_session, sess->data_callback,
sess->error_callback, sess->user_data );
}
else
{
sess->type = eSessionTypeNull; /* TODO: report error? */
}
break;
case eSessionTypeNull:
break;
default:
_ASSERT( FALSE );
break;
}
return DSSL_RC_OK;
}
