mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-07-08 22:44:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

Revolution WPAD work (#3078)

Browse Source 
* WPAD mostly matching, likely equivalent

* Implement WPADEncrypt (mostly taken from SMG1 decomp)

* Implement WPADHidParser

* Add wpad_debug_msg stub

* Fix WUD file paths in splits

* Fix WPAD regressions in Shield/ShieldD
This commit is contained in:
Max Roncace
2026-02-01 20:33:08 -05:00
committed by GitHub
parent 21de544196
commit f5dbf1d827
42 changed files with 5328 additions and 680 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/revolution/homebuttonLib/HBMController.cpp
+12 -12
View File
@@ -126,43 +126,43 @@ namespace homebutton {
u32 t = con->kpad->ex_status.cl.trig;
u32 r = con->kpad->ex_status.cl.release;
if (h & WPAD_BUTTON_CL_A) {
if (h & WPAD_CL_BUTTON_A) {
mHBController.hold |= WPAD_BUTTON_A;
}
if (t & WPAD_BUTTON_CL_A) {
if (t & WPAD_CL_BUTTON_A) {
mHBController.trig |= WPAD_BUTTON_A;
}
if (r & WPAD_BUTTON_CL_A) {
if (r & WPAD_CL_BUTTON_A) {
mHBController.release |= WPAD_BUTTON_A;
}
if (h & WPAD_BUTTON_CL_PLUS) {
if (h & WPAD_CL_BUTTON_PLUS) {
mHBController.hold |= WPAD_BUTTON_PLUS;
}
if (t & WPAD_BUTTON_CL_PLUS) {
if (t & WPAD_CL_BUTTON_PLUS) {
mHBController.trig |= WPAD_BUTTON_PLUS;
}
if (r & WPAD_BUTTON_CL_PLUS) {
if (r & WPAD_CL_BUTTON_PLUS) {
mHBController.release |= WPAD_BUTTON_PLUS;
}
if (h & WPAD_BUTTON_CL_MINUS) {
if (h & WPAD_CL_BUTTON_MINUS) {
mHBController.hold |= WPAD_BUTTON_MINUS;
}
if (t & WPAD_BUTTON_CL_MINUS) {
if (t & WPAD_CL_BUTTON_MINUS) {
mHBController.trig |= WPAD_BUTTON_MINUS;
}
if (r & WPAD_BUTTON_CL_MINUS) {
if (r & WPAD_CL_BUTTON_MINUS) {
mHBController.release |= WPAD_BUTTON_MINUS;
}
if (h & WPAD_BUTTON_CL_HOME) {
if (h & WPAD_CL_BUTTON_HOME) {
mHBController.hold |= WPAD_BUTTON_HOME;
}
if (t & WPAD_BUTTON_CL_HOME) {
if (t & WPAD_CL_BUTTON_HOME) {
mHBController.trig |= WPAD_BUTTON_HOME;
}
if (r & WPAD_BUTTON_CL_HOME) {
if (r & WPAD_CL_BUTTON_HOME) {
mHBController.release |= WPAD_BUTTON_HOME;
}
}
src/revolution/os/OSStateTM.c
-4
View File
@@ -210,10 +210,6 @@ s32 __OSUnRegisterStateEvent(void) {
return ret;
}
void ACRWriteReg(u32 param_0, u32 param_1) {
__IPCRegs[param_0 >> 2] = param_1;
}
// NONMATCHING - extra branch
static int AccessVIDimRegs(void) {
int res;
src/revolution/sc/scapi.c
+24
View File
@@ -121,3 +121,27 @@ u32 SCGetCounterBias(void) {
return bias;
}
u8 SCGetWpadSensorBarPosition(void) {
// NONMATCHING
}
u8 SCGetWpadMotorMode(void) {
// NONMATCHING
}
u8 SCGetWpadSpeakerVolume(void) {
// NONMATCHING
}
u8 SCGetBtDpdSensibility(void) {
// NONMATCHING
}
BOOL SCSetWpadSpeakerVolume(u8 volume) {
// NONMATCHING
}
BOOL SCSetWpadMotorMode(u8 mode) {
// NONMATCHING
}
src/revolution/vi/__vi.h
+2
View File
@@ -17,6 +17,8 @@ void __VIInit(VITVMode mode);
void __VISetAdjustingValues(s16 x, s16 y);
void __VIGetAdjustingValues(s16* x, s16* y);
void __VIGetCurrentPosition(s16* x, s16* y);
BOOL __VIResetSIIdle();
BOOL __VIResetRFIdle();
BOOL __VIResetDev0Idle();
/* vi3in1.c */
src/revolution/vi/vi.c
+11 -2
View File
@@ -1682,8 +1682,12 @@ BOOL VIEnableDimming(BOOL enable) {
return old;
}
void VIResetDimmingCount() {
__VIResetDev0Idle();
BOOL VIResetDimmingCount() {
return __VIResetDev0Idle();
}
BOOL VIResetRFIdle() {
return __VIResetRFIdle();
}
BOOL VIEnableDVDStopMotor(BOOL enable) {
@@ -1697,6 +1701,11 @@ BOOL __VIResetSIIdle() {
return TRUE;
}
BOOL __VIResetRFIdle() {
__VIDimmingFlag_RF_IDLE = 0;
return TRUE;
}
BOOL __VIResetDev0Idle() {
__VIDimmingFlag_DEV_IDLE[0] = 0;
return TRUE;
src/revolution/wpad/WPAD.c
+2378 -271
View File
File diff suppressed because it is too large Load Diff
src/revolution/wpad/WPADEncrypt.c
+265
View File
@@ -0,0 +1,265 @@
#include <revolution/wpad/__wpad.h>
#include "cstring"
static u8 SEED;
static u8 NUM_A;
static u8 NUM_B;
static u8 NUM_C;
static u8 base[0x2A] = {
0xA8, 0x77, 0xA6, 0xE0, 0xF7, 0x43,
0x5A, 0x35, 0x85, 0xE2, 0x72, 0x97,
0x8F, 0xB7, 0x1A, 0x62, 0x87, 0x38,
0x0D, 0x67, 0xC7, 0xBE, 0x4F, 0x3E,
0x20, 0x76, 0x37, 0x8F, 0x68, 0xB7,
0xA9, 0x26, 0x3F, 0x2B, 0x10, 0xE3,
0x30, 0x7E, 0x90, 0x0E, 0x85, 0x0A,
};
static u8 tb[0x900] = {
0x70, 0x51, 0x03, 0x86, 0x40, 0x0D, 0x4F, 0xEB, 0x3E, 0xCC, 0xD1, 0x87, 0x35, 0xBD, 0xF5, 0x0B,
0x5E, 0xD0, 0xF8, 0xF2, 0xD5, 0xE2, 0x6C, 0x31, 0x0C, 0xAD, 0xFC, 0x21, 0xC3, 0x78, 0xC1, 0x06,
0xC2, 0x4C, 0x55, 0xE6, 0x4A, 0x34, 0x48, 0x11, 0x1E, 0xDA, 0xE7, 0x1A, 0x84, 0xA0, 0x96, 0xA7,
0xE3, 0x7F, 0xAF, 0x63, 0x9C, 0xFA, 0x23, 0x5B, 0x79, 0xC8, 0x9E, 0xBA, 0xB2, 0xC9, 0x22, 0x12,
0x4B, 0xB3, 0xA1, 0xB6, 0x32, 0x49, 0xA2, 0xE1, 0x89, 0x39, 0x10, 0x66, 0xC5, 0x07, 0x8F, 0x54,
0xEA, 0x91, 0xCA, 0x3F, 0xF9, 0x19, 0xF0, 0xD7, 0x46, 0xBC, 0x28, 0x1B, 0x61, 0xE8, 0x2F, 0x6A,
0xAE, 0x9D, 0xF6, 0x4E, 0x09, 0x14, 0x77, 0x4D, 0xDB, 0x1F, 0x2E, 0x7B, 0x7C, 0xF1, 0x43, 0xA3,
0x00, 0xB8, 0x13, 0x8C, 0x85, 0xB9, 0x29, 0x75, 0x88, 0xFD, 0xD2, 0x56, 0x1C, 0x50, 0x97, 0x41,
0xE5, 0x3B, 0x60, 0xB5, 0xC0, 0x64, 0xEE, 0x98, 0xD6, 0x2D, 0x25, 0xA4, 0xAA, 0xCD, 0x7D, 0xA8,
0x83, 0xC6, 0xAB, 0xBE, 0x44, 0x99, 0x26, 0x3C, 0xCE, 0x9F, 0xBF, 0xD3, 0xCB, 0x76, 0x7A, 0x7E,
0x82, 0x01, 0x8A, 0x9A, 0x80, 0x1D, 0x0E, 0xB0, 0x5C, 0xD4, 0x38, 0x62, 0xF4, 0x30, 0xE0, 0x8E,
0x53, 0xB7, 0x02, 0x57, 0xAC, 0xA6, 0x52, 0x0A, 0x6D, 0x92, 0x65, 0x17, 0x24, 0x33, 0x45, 0x72,
0x74, 0xB1, 0xB4, 0xF7, 0x5D, 0xED, 0x2C, 0xFF, 0x47, 0x37, 0x5A, 0x90, 0xBB, 0xDF, 0x2A, 0x16,
0x59, 0x95, 0xD9, 0xC4, 0x27, 0x67, 0x73, 0xC7, 0x68, 0xFE, 0xA5, 0xDD, 0x6B, 0x5F, 0x93, 0xD8,
0xEC, 0x05, 0x3A, 0x8D, 0x6E, 0xFB, 0x3D, 0xA9, 0x69, 0x36, 0xF3, 0x94, 0xDE, 0xEF, 0x15, 0x6F,
0x8B, 0x9B, 0x08, 0x0F, 0xDC, 0x81, 0x18, 0x20, 0x04, 0xE4, 0x71, 0xCF, 0xE9, 0x2B, 0x42, 0x58,
0x01, 0xA0, 0xA9, 0x62, 0xD6, 0x3F, 0x85, 0xA7, 0xB6, 0xD4, 0xFA, 0x15, 0x66, 0x17, 0x09, 0xBD,
0x5D, 0x14, 0x34, 0x26, 0x59, 0x72, 0x91, 0x54, 0x06, 0x4F, 0xF8, 0xB0, 0x5B, 0x74, 0x93, 0x99,
0x8C, 0xF2, 0x45, 0xCD, 0xEA, 0x4E, 0xAD, 0x10, 0x4A, 0xE5, 0xCA, 0xEE, 0xDF, 0xC6, 0x6F, 0x9F,
0x88, 0x8E, 0x02, 0xCC, 0x08, 0xA8, 0x77, 0x94, 0x6D, 0x21, 0xB1, 0x28, 0xE4, 0x39, 0x79, 0x96,
0x60, 0x71, 0x81, 0x16, 0x2E, 0xE6, 0x78, 0xB9, 0xC4, 0x46, 0x9A, 0x42, 0xAE, 0xB7, 0x7C, 0x43,
0xB3, 0x22, 0x1A, 0x86, 0xC2, 0x32, 0x3D, 0x2D, 0x9C, 0xD2, 0x29, 0xE9, 0x63, 0x9B, 0xD1, 0x31,
0x38, 0x5E, 0x1E, 0x36, 0x41, 0xBB, 0x03, 0x18, 0x2B, 0x3E, 0xBF, 0x68, 0x61, 0xFC, 0x52, 0xC0,
0xDE, 0xE0, 0x0A, 0x58, 0x13, 0x5A, 0x00, 0xBE, 0x1C, 0x90, 0x0E, 0x53, 0x12, 0xFD, 0xE2, 0x6E,
0xBA, 0xCE, 0x24, 0x27, 0x44, 0x7F, 0x87, 0xA3, 0xA1, 0xD5, 0x50, 0x40, 0xE3, 0xF9, 0x83, 0xF7,
0xC7, 0xA2, 0x35, 0xC8, 0xDB, 0x19, 0xAB, 0x2F, 0x11, 0x25, 0xED, 0x33, 0x9E, 0x55, 0xE1, 0x48,
0xAF, 0x73, 0x84, 0xDA, 0x2A, 0xAA, 0x51, 0xEB, 0x9D, 0x95, 0xB2, 0xCB, 0xE7, 0x70, 0x80, 0xFE,
0x4C, 0x65, 0x04, 0xEF, 0xC5, 0xF1, 0xC3, 0x3A, 0xB4, 0xF5, 0x5F, 0x23, 0x89, 0xDD, 0x30, 0xA5,
0x8B, 0xD3, 0xF6, 0xDC, 0x4D, 0x64, 0xD7, 0xF0, 0x8F, 0xEC, 0x56, 0x37, 0x5C, 0xA4, 0x0D, 0x07,
0x76, 0x8A, 0x2C, 0x0B, 0xB5, 0xD8, 0xC1, 0x1F, 0xE8, 0x3B, 0xF4, 0x4B, 0x1B, 0x47, 0x6C, 0x49,
0x67, 0x7B, 0x92, 0xCF, 0x75, 0x7E, 0x20, 0xD9, 0x7D, 0x3C, 0x97, 0x7A, 0xD0, 0x05, 0x6B, 0x0F,
0x1D, 0xFB, 0x82, 0x98, 0x57, 0x8D, 0xF3, 0x6A, 0xBC, 0xAC, 0xC9, 0xA6, 0xFF, 0xB8, 0x69, 0x0C,
0x4C, 0x4D, 0x72, 0x07, 0x5A, 0x49, 0x33, 0x8D, 0xA2, 0xAB, 0x46, 0x3D, 0x63, 0x0D, 0xA0, 0x97,
0xFF, 0xF0, 0xF5, 0xFA, 0xC0, 0xE9, 0xDB, 0x62, 0xE4, 0xE1, 0x74, 0x43, 0xDC, 0x86, 0x18, 0x29,
0x37, 0xF4, 0x06, 0xE2, 0xED, 0x6F, 0x90, 0x48, 0x1E, 0x2D, 0x1D, 0xEA, 0x73, 0x94, 0x54, 0xDF,
0x25, 0xF6, 0x47, 0x27, 0xD9, 0x11, 0x77, 0xC9, 0x84, 0x1C, 0x5B, 0x5C, 0x51, 0x81, 0xA6, 0x22,
0x3E, 0x24, 0x96, 0xC8, 0x8A, 0xEC, 0x82, 0x7C, 0x09, 0xB8, 0x45, 0x4A, 0x57, 0xBB, 0x2F, 0x50,
0x75, 0x8E, 0x61, 0x70, 0x8C, 0x6C, 0xAF, 0xD0, 0xFD, 0xB4, 0x1B, 0xAE, 0xDE, 0xFE, 0x3B, 0xB5,
0x36, 0xBD, 0x55, 0x01, 0x0E, 0x9C, 0x41, 0x56, 0x5F, 0xB3, 0x26, 0x03, 0x83, 0xBA, 0x13, 0x4B,
0xCA, 0xC5, 0x0A, 0xF8, 0x60, 0xA5, 0xB9, 0xC7, 0xC3, 0x98, 0x32, 0xFB, 0x12, 0xF9, 0xA7, 0x92,
0xAA, 0x68, 0xF3, 0x78, 0x7E, 0x05, 0x20, 0x21, 0x02, 0xE8, 0xBF, 0xF2, 0xB0, 0x59, 0x8F, 0xD2,
0xCB, 0x87, 0x65, 0x15, 0xF1, 0x1A, 0xB2, 0x30, 0xAD, 0xEE, 0x58, 0xA3, 0x8B, 0x66, 0x1F, 0x2C,
0xD7, 0x5D, 0x19, 0x85, 0xA8, 0xE6, 0xD3, 0x6B, 0xA1, 0x0C, 0x91, 0x93, 0x6A, 0x5E, 0x0B, 0x79,
0xE3, 0xDD, 0x00, 0x4F, 0x3C, 0x89, 0x6E, 0x71, 0x69, 0xA9, 0xAC, 0x40, 0xE5, 0x99, 0x28, 0xC6,
0x31, 0x4E, 0x7A, 0xCD, 0x08, 0x9E, 0x7D, 0xEF, 0x17, 0xFC, 0x88, 0xD8, 0xA4, 0x6D, 0x44, 0x95,
0xD1, 0xB7, 0xD4, 0x9B, 0xBE, 0x2A, 0x34, 0x64, 0x2B, 0xCF, 0x2E, 0xEB, 0x38, 0xCE, 0x23, 0xE0,
0x3A, 0x3F, 0xF7, 0x7B, 0x9F, 0x10, 0x53, 0xBC, 0x52, 0x67, 0x16, 0xE7, 0x80, 0x76, 0x04, 0xC4,
0xB6, 0xC1, 0xC2, 0x7F, 0x9A, 0xDA, 0xD5, 0x39, 0x42, 0x14, 0x9D, 0xB1, 0x0F, 0x35, 0xD6, 0xCC,
0xB9, 0xDA, 0x38, 0x0C, 0xA2, 0x9C, 0x09, 0x1F, 0x06, 0xB1, 0xB6, 0xFD, 0x1A, 0x69, 0x23, 0x30,
0xC4, 0xDE, 0x01, 0xD1, 0xF4, 0x58, 0x29, 0x37, 0x1C, 0x7D, 0xD5, 0xBF, 0xFF, 0xBD, 0xC8, 0xC9,
0xCF, 0x65, 0xBE, 0x7B, 0x78, 0x97, 0x98, 0x67, 0x08, 0xB3, 0x26, 0x57, 0xF7, 0xFA, 0x40, 0xAD,
0x8E, 0x75, 0xA6, 0x7C, 0xDB, 0x91, 0x8B, 0x51, 0x99, 0xD4, 0x17, 0x7A, 0x90, 0x8D, 0xCE, 0x63,
0xCB, 0x4E, 0xA0, 0xAB, 0x18, 0x3A, 0x5B, 0x50, 0x7F, 0x21, 0x74, 0xC1, 0xBB, 0xB8, 0xB7, 0xBA,
0x0B, 0x35, 0x95, 0x31, 0x59, 0x9A, 0x4D, 0x04, 0x07, 0x1E, 0x5A, 0x76, 0x13, 0xF3, 0x71, 0x83,
0xF0, 0x86, 0x03, 0xA8, 0x39, 0x42, 0xAA, 0x28, 0xE6, 0xE4, 0xD8, 0x5D, 0xD3, 0xD0, 0x6E, 0x6F,
0x96, 0xFB, 0x5E, 0xBC, 0x56, 0xC2, 0x5F, 0x85, 0x9B, 0xE7, 0xAF, 0xD2, 0x3B, 0x84, 0x6A, 0xA7,
0x53, 0xC5, 0x44, 0x49, 0xA5, 0xF9, 0x36, 0x72, 0x3D, 0x2C, 0xD9, 0x1B, 0xA1, 0xF5, 0x4F, 0x93,
0x9D, 0x68, 0x47, 0x41, 0x16, 0xCA, 0x2A, 0x4C, 0xA3, 0x87, 0xD6, 0xE5, 0x19, 0x2E, 0x77, 0x15,
0x6D, 0x70, 0xC0, 0xDF, 0xB2, 0x00, 0x46, 0xED, 0xC6, 0x6C, 0x43, 0x60, 0x92, 0x2D, 0xA9, 0x22,
0x45, 0x8F, 0x34, 0x55, 0xAE, 0xA4, 0x0A, 0x66, 0x32, 0xE0, 0xDC, 0x02, 0xAC, 0xE8, 0x20, 0x8C,
0x89, 0x62, 0x4A, 0xFE, 0xEE, 0xC3, 0xE3, 0x3C, 0xF1, 0x79, 0x05, 0xE9, 0xF6, 0x27, 0x33, 0xCC,
0xF2, 0x9E, 0x11, 0x81, 0x7E, 0x80, 0x10, 0x8A, 0x82, 0x9F, 0x48, 0x0D, 0xD7, 0xB4, 0xFC, 0x2F,
0xB5, 0xC7, 0xDD, 0x88, 0x14, 0x6B, 0x2B, 0x54, 0xEA, 0x1D, 0x94, 0x5C, 0xB0, 0xEF, 0x12, 0x24,
0xCD, 0xEB, 0xE1, 0xE2, 0x64, 0x73, 0x3F, 0x0E, 0x52, 0x61, 0x25, 0x3E, 0xF8, 0x0F, 0x4B, 0xEC,
0xC0, 0x00, 0x30, 0xF6, 0x02, 0x49, 0x3D, 0x10, 0x6E, 0x20, 0xC9, 0xA6, 0x2F, 0xFE, 0x2C, 0x2B,
0x75, 0x2E, 0x45, 0x26, 0xAB, 0x48, 0xA9, 0x80, 0xFC, 0x04, 0xCC, 0xD3, 0xB5, 0xBA, 0xA3, 0x38,
0x31, 0x7D, 0x01, 0xD9, 0xA7, 0x7B, 0x96, 0xB6, 0x63, 0x69, 0x4E, 0xF7, 0xDE, 0xE0, 0x78, 0xCA,
0x50, 0xAA, 0x41, 0x91, 0x65, 0x88, 0xE4, 0x21, 0x85, 0xDA, 0x3A, 0x27, 0xBE, 0x1C, 0x3E, 0x42,
0x5E, 0x17, 0x52, 0x7F, 0x1F, 0x89, 0x24, 0x6F, 0x8F, 0x5C, 0x67, 0x74, 0x0E, 0x12, 0x87, 0x8D,
0xE9, 0x34, 0xED, 0x73, 0xC4, 0xF8, 0x61, 0x5B, 0x05, 0xDF, 0x59, 0x4C, 0x97, 0x79, 0x83, 0x18,
0xA4, 0x55, 0x95, 0xEB, 0xBD, 0x53, 0xF5, 0xF1, 0x57, 0x66, 0x46, 0x9F, 0xB2, 0x81, 0x09, 0x51,
0x86, 0x22, 0x16, 0xDD, 0x23, 0x93, 0x76, 0x29, 0xC2, 0xD7, 0x1D, 0xD4, 0xBF, 0x36, 0x3F, 0xEA,
0x4B, 0x11, 0x32, 0xB9, 0x62, 0x54, 0x60, 0xD6, 0x6D, 0x43, 0x9A, 0x0D, 0x92, 0x9C, 0xB0, 0xEF,
0x58, 0x6C, 0x9D, 0x77, 0x2D, 0x70, 0xFA, 0xF3, 0xB3, 0x0B, 0xE2, 0x40, 0x7E, 0xF4, 0x8A, 0xE5,
0x8C, 0x3C, 0x56, 0x71, 0xD1, 0x64, 0xE1, 0x82, 0x0A, 0xCB, 0x13, 0x15, 0x90, 0xEC, 0x03, 0x99,
0xAF, 0x14, 0x5D, 0x0F, 0x33, 0x4A, 0x94, 0xA5, 0xA8, 0x35, 0x1B, 0xE3, 0x6A, 0xC6, 0x28, 0xFF,
0x4D, 0xE7, 0x25, 0x84, 0xAC, 0x08, 0xAE, 0xC5, 0xA2, 0x2A, 0xB8, 0x37, 0x0C, 0x7A, 0xA0, 0xC3,
0xCE, 0xAD, 0x06, 0x1A, 0x9E, 0x8B, 0xFB, 0xD5, 0xF0, 0xC1, 0x1E, 0xD0, 0xB4, 0x9B, 0xB1, 0x44,
0xF2, 0x47, 0xC7, 0x68, 0xCF, 0x72, 0xBB, 0x4F, 0x5A, 0xF9, 0xDC, 0x6B, 0xDB, 0xD2, 0xE8, 0x7C,
0xC8, 0xEE, 0x98, 0xA1, 0xE6, 0xD8, 0x39, 0x07, 0x5F, 0xFD, 0x8E, 0x19, 0xB7, 0x3B, 0xBC, 0xCD,
0x7C, 0xE3, 0x81, 0x73, 0xB2, 0x11, 0xBF, 0x6F, 0x20, 0x98, 0xFE, 0x75, 0x96, 0xEF, 0x6C, 0xDA,
0x50, 0xE1, 0x09, 0x72, 0x54, 0x45, 0xBA, 0x34, 0x80, 0x5B, 0xED, 0x3E, 0x53, 0x2C, 0x87, 0xA4,
0x57, 0xF3, 0x33, 0x3F, 0x3C, 0xB7, 0x67, 0xB4, 0xA3, 0x25, 0x60, 0x4F, 0x07, 0x6B, 0x1B, 0x47,
0x15, 0x0F, 0xE4, 0x0A, 0xEA, 0xD1, 0x32, 0x78, 0x36, 0x49, 0x8D, 0x4B, 0xD2, 0xBC, 0xA5, 0xDC,
0x1D, 0x0D, 0x4D, 0xCD, 0x9A, 0x82, 0x5F, 0xFC, 0x94, 0x65, 0xBE, 0xE2, 0xF4, 0xC9, 0x1E, 0x44,
0xCB, 0x9E, 0x0C, 0x64, 0x71, 0x26, 0x63, 0xB3, 0x14, 0xE8, 0x40, 0x70, 0x8A, 0x0E, 0x19, 0x42,
0x6D, 0xAC, 0x88, 0x10, 0x5C, 0xDF, 0x41, 0xA9, 0xAD, 0xE5, 0xFB, 0x74, 0xCC, 0xD5, 0x06, 0x8E,
0x59, 0x86, 0xCE, 0x1F, 0x3D, 0x76, 0xE0, 0x8F, 0xB9, 0x77, 0x27, 0x7B, 0xA6, 0xD8, 0x29, 0xD3,
0xEC, 0xB8, 0x13, 0xF7, 0xFA, 0xC3, 0x51, 0x6A, 0xDE, 0x4A, 0x5A, 0xEB, 0xC2, 0x8B, 0x23, 0x48,
0x92, 0xCF, 0x62, 0xA8, 0x99, 0xF8, 0xD0, 0x2E, 0x85, 0x61, 0x43, 0xC8, 0xBD, 0xF0, 0x05, 0x93,
0xCA, 0x4E, 0xF1, 0x7D, 0x30, 0xFD, 0xC4, 0x69, 0x66, 0x2F, 0x08, 0xB1, 0x52, 0xF9, 0x21, 0xE6,
0x7A, 0x2B, 0xDD, 0x39, 0x84, 0xFF, 0xC0, 0x91, 0xD6, 0x37, 0xD4, 0x7F, 0x2D, 0x9B, 0x5D, 0xA1,
0x3B, 0x6E, 0xB5, 0xC5, 0x46, 0x04, 0xF5, 0x90, 0xEE, 0x7E, 0x83, 0x1C, 0x03, 0x56, 0xB6, 0xAA,
0x00, 0x17, 0x01, 0x35, 0x55, 0x79, 0x0B, 0x12, 0xBB, 0x1A, 0x31, 0xE7, 0x02, 0x28, 0x16, 0xC1,
0xF6, 0xA2, 0xDB, 0x18, 0x9C, 0x89, 0x68, 0x38, 0x97, 0xAB, 0xC7, 0x2A, 0xD7, 0x3A, 0xF2, 0xC6,
0x24, 0x4C, 0xB0, 0x58, 0xA0, 0x22, 0x5E, 0x9D, 0xD9, 0xA7, 0xE9, 0xAE, 0xAF, 0x8C, 0x95, 0x9F,
0x28, 0xB7, 0x20, 0xD7, 0xB0, 0x30, 0xC3, 0x09, 0x19, 0xC0, 0x67, 0xD6, 0x00, 0x3C, 0x7E, 0xE7,
0xE9, 0xF4, 0x08, 0x5A, 0xF8, 0xB8, 0x2E, 0x05, 0xA6, 0x25, 0x9E, 0x5C, 0xD8, 0x15, 0x0D, 0xE1,
0xF6, 0x11, 0x54, 0x6B, 0xCD, 0x21, 0x46, 0x66, 0x5E, 0x84, 0xAD, 0x06, 0x38, 0x29, 0x44, 0xC5,
0xA2, 0xCE, 0xF1, 0xAA, 0xC1, 0x40, 0x71, 0x86, 0xB5, 0xEF, 0xFC, 0x36, 0xA8, 0xCB, 0x0A, 0x48,
0x27, 0x45, 0x64, 0xA3, 0xAF, 0x8C, 0xB2, 0xC6, 0x9F, 0x07, 0x89, 0xDC, 0x17, 0xD3, 0x49, 0x79,
0xFB, 0xFE, 0x1D, 0xD0, 0xB9, 0x88, 0x43, 0x52, 0xBC, 0x01, 0x78, 0x2B, 0x7D, 0x94, 0xC7, 0x0E,
0xDE, 0xA5, 0xD5, 0x9B, 0xCC, 0xF7, 0x61, 0x7A, 0xC2, 0x74, 0x81, 0x39, 0x03, 0xAB, 0x96, 0xA0,
0x37, 0xBD, 0x2D, 0x72, 0x75, 0x3F, 0xC9, 0xD4, 0x8E, 0x6F, 0xF9, 0x8D, 0xED, 0x62, 0xDB, 0x1C,
0xDF, 0x04, 0xAC, 0x1B, 0x6C, 0x14, 0x4B, 0x63, 0xF0, 0xBF, 0xB4, 0x82, 0xEC, 0x7B, 0x1A, 0x59,
0x92, 0xD2, 0x10, 0x60, 0xB6, 0x3D, 0x5F, 0xE6, 0x80, 0x6E, 0x70, 0xC4, 0xF2, 0x35, 0xD9, 0x7C,
0xEE, 0xE5, 0x41, 0xA4, 0x5B, 0x50, 0xDD, 0xBB, 0x4C, 0xF3, 0x1F, 0x9D, 0x5D, 0x57, 0x55, 0x51,
0x97, 0xE3, 0x58, 0x42, 0x4D, 0x9C, 0x73, 0xBA, 0xC8, 0x77, 0x31, 0x69, 0x26, 0xAE, 0xEA, 0x8A,
0xDA, 0x22, 0xB3, 0x87, 0x56, 0xFA, 0x93, 0x0B, 0x34, 0x16, 0x33, 0xE8, 0xE4, 0x53, 0xBE, 0xA9,
0xB1, 0x3A, 0x3E, 0xF5, 0x90, 0x6A, 0xCF, 0x3B, 0x12, 0xFD, 0x8F, 0x9A, 0xA7, 0x47, 0x91, 0x99,
0xEB, 0x0F, 0x24, 0xFF, 0x23, 0x18, 0x85, 0x4E, 0x7F, 0x0C, 0xE0, 0xA1, 0xE2, 0xD1, 0x2C, 0x2A,
0x4A, 0x02, 0x4F, 0x1E, 0x95, 0x68, 0x8B, 0x98, 0x83, 0x6D, 0x76, 0xCA, 0x65, 0x32, 0x13, 0x2F,
0xC3, 0x82, 0x9A, 0xA4, 0xBA, 0x81, 0x60, 0x37, 0x34, 0x35, 0xFC, 0x80, 0xA8, 0x51, 0x65, 0x67,
0xED, 0x30, 0x5F, 0x10, 0xD3, 0x4A, 0x27, 0x2F, 0x13, 0xB9, 0x2A, 0xD2, 0xCC, 0xE1, 0xEF, 0xAE,
0xEB, 0xBE, 0xF4, 0xBD, 0xCF, 0x43, 0xB3, 0xC5, 0x88, 0x84, 0xB7, 0xDD, 0x39, 0x40, 0xCE, 0x48,
0x6D, 0x9B, 0x72, 0x61, 0x7E, 0xE7, 0xA1, 0x4E, 0x53, 0x2E, 0x77, 0x3B, 0xE2, 0xC9, 0x36, 0x22,
0x1B, 0x6E, 0x73, 0xB1, 0x03, 0xB2, 0x4C, 0x87, 0xA9, 0xD4, 0x4D, 0x0F, 0xD8, 0x15, 0x6C, 0xAA,
0x18, 0xF6, 0x49, 0x57, 0x5D, 0xFB, 0x7A, 0x14, 0x94, 0x63, 0xA0, 0x11, 0xB0, 0x9E, 0xDE, 0x05,
0x46, 0xC8, 0xEE, 0x47, 0xDB, 0xDC, 0x24, 0x89, 0x9C, 0x91, 0x97, 0x29, 0xE9, 0x7B, 0xC1, 0x07,
0x1E, 0xB8, 0xFD, 0xFE, 0xAC, 0xC6, 0x62, 0x98, 0x4F, 0xF1, 0x79, 0xE0, 0xE8, 0x6B, 0x78, 0x56,
0xB6, 0x8D, 0x04, 0x50, 0x86, 0xCA, 0x6F, 0x20, 0xE6, 0xEA, 0xE5, 0x76, 0x17, 0x1C, 0x74, 0x7F,
0xBC, 0x0D, 0x2C, 0x85, 0xF7, 0x66, 0x96, 0xE4, 0x8B, 0x75, 0x3F, 0x4B, 0xD9, 0x38, 0xAF, 0x7C,
0xDA, 0x0B, 0x83, 0x2D, 0x31, 0x32, 0xA2, 0xF5, 0x1D, 0x59, 0x41, 0x45, 0xBF, 0x3C, 0x1F, 0xF8,
0xF9, 0x8A, 0xD0, 0x16, 0x25, 0x69, 0x12, 0x99, 0x9D, 0x21, 0x95, 0xAB, 0x01, 0xA6, 0xD7, 0xB5,
0xC0, 0x7D, 0xFF, 0x58, 0x0E, 0x3A, 0x92, 0xD1, 0x55, 0xE3, 0x08, 0x9F, 0xD6, 0x3E, 0x52, 0x8E,
0xFA, 0xA3, 0xC7, 0x02, 0xCD, 0xDF, 0x8F, 0x64, 0x19, 0x8C, 0xF3, 0xA7, 0x0C, 0x5E, 0x0A, 0x6A,
0x09, 0xF0, 0x93, 0x5B, 0x42, 0xC2, 0x06, 0x23, 0xEC, 0x71, 0xAD, 0xB4, 0xCB, 0xBB, 0x70, 0x28,
0xD5, 0x1A, 0x5C, 0x33, 0x68, 0x5A, 0x00, 0x44, 0x90, 0xA5, 0xC4, 0x26, 0x3D, 0x2B, 0xF2, 0x54,
0x96, 0xAD, 0xDA, 0x1F, 0xED, 0x33, 0xE1, 0x81, 0x69, 0x08, 0x0D, 0x0A, 0xDB, 0x35, 0x77, 0x9A,
0x64, 0xD1, 0xFC, 0x78, 0xAA, 0x1B, 0xD0, 0x67, 0xA0, 0xDD, 0xFA, 0x6C, 0x63, 0x71, 0x05, 0x84,
0x17, 0x6A, 0x89, 0x4F, 0x66, 0x7F, 0xC6, 0x50, 0x55, 0x92, 0x6F, 0xBD, 0xE7, 0xD2, 0x40, 0x72,
0x8D, 0xBB, 0xEC, 0x06, 0x42, 0x8A, 0xE4, 0x88, 0x9D, 0x7E, 0x7A, 0x82, 0x27, 0x13, 0x41, 0x1A,
0xAF, 0xC8, 0xA4, 0x76, 0xB4, 0xC2, 0xFE, 0x6D, 0x1C, 0xD9, 0x61, 0x30, 0xB3, 0x7C, 0xEA, 0xF7,
0x29, 0x0F, 0xF2, 0x3B, 0x51, 0xC1, 0xDE, 0x5F, 0xE5, 0x2A, 0x2F, 0x99, 0x0B, 0x5D, 0xA3, 0x2B,
0x4A, 0xAB, 0x95, 0xA5, 0xD3, 0x58, 0x56, 0xEE, 0x28, 0x31, 0x00, 0xCC, 0x15, 0x46, 0xCA, 0xE6,
0x86, 0x38, 0x3C, 0x65, 0xF5, 0xE3, 0x9F, 0xD6, 0x5B, 0x09, 0x49, 0x83, 0x70, 0x2D, 0x53, 0xA9,
0x7D, 0xE2, 0xC4, 0xAC, 0x8E, 0x5E, 0xB8, 0x25, 0xF4, 0xB9, 0x57, 0xF3, 0xF1, 0x68, 0x47, 0xB2,
0xA2, 0x59, 0x20, 0xCE, 0x34, 0x79, 0x5C, 0x90, 0x0E, 0x1E, 0xBE, 0xD5, 0x22, 0x23, 0xB1, 0xC9,
0x18, 0x62, 0x16, 0x2E, 0x91, 0x3E, 0x07, 0x8F, 0xD8, 0x3F, 0x93, 0x3D, 0xD4, 0x9B, 0xDF, 0x85,
0x21, 0xFB, 0x11, 0x74, 0x97, 0xC7, 0xD7, 0xDC, 0x4C, 0x19, 0x45, 0x98, 0xE9, 0x43, 0x02, 0x4B,
0xBC, 0xC3, 0x04, 0x9C, 0x6B, 0xF0, 0x75, 0x52, 0xA7, 0x26, 0xF6, 0xC5, 0xBA, 0xCF, 0xB0, 0xB7,
0xAE, 0x5A, 0xA1, 0xBF, 0x03, 0x8B, 0x80, 0x12, 0x6E, 0x0C, 0xEB, 0xF9, 0xC0, 0x44, 0x24, 0xEF,
0x10, 0xF8, 0xA8, 0x8C, 0xE8, 0x7B, 0xFF, 0x9E, 0x2C, 0xCD, 0x60, 0x36, 0x87, 0xB5, 0x94, 0xA6,
0x54, 0x73, 0x3A, 0x14, 0x4E, 0x01, 0x1D, 0xB6, 0xFD, 0x37, 0x48, 0x4D, 0x39, 0xCB, 0xE0, 0x32,
};
static u8 random() {
SEED = (u8)(((u32)SEED * NUM_A + NUM_B) % NUM_C);
return SEED;
}
static u8 ror(u8 src, u8 rot) {
u8 ret;
u8 rt;
rt = (u8)(rot % 8);
ret = (u8)(src >> rt | src << (8 - rt));
return ret;
}
static u8 rol(u8 src, u8 rol) {
u8 ret;
u8 rl;
rl = (u8)(rol % 8);
ret = (u8)(src << rl | src >> (8 - rl));
return ret;
}
void WPADiCreateKey(s32 chan) {
BOOL enable;
WPADControlBlock* p_wpd = _wpdcb[chan];
u8 idx;
u8 baseIdx;
u8 tblRnd[10];
u8 ft[8];
u8 sb[8];
u8 key[6];
u8 i;
SEED = (u8)((OSGetTick() >> 8) & 0xff);
NUM_A = (u8)((OSGetTick() >> 16) & 0x3f);
NUM_B = (u8)((OSGetTick() >> 24) & 0x4c);
NUM_C = 0xff;
idx = (u8)(random() % 7);
baseIdx = (u8)(idx * 6);
for (i = 0; i < 10; i++) {
tblRnd[i] = tb[random()];
}
enable = OSDisableInterrupts();
key[0] = (u8)((ror((u8)(base[baseIdx] ^ tb[tblRnd[5]]), tb[tblRnd[2]]) - tb[tblRnd[9]]) ^ tb[tblRnd[4]]);
key[1] = (u8)((ror((u8)(base[baseIdx + 1] ^ tb[tblRnd[1]]), tb[tblRnd[0]]) - tb[tblRnd[5]]) ^ tb[tblRnd[7]]);
key[2] = (u8)((ror((u8)(base[baseIdx + 2] ^ tb[tblRnd[6]]), tb[tblRnd[8]]) - tb[tblRnd[2]]) ^ tb[tblRnd[0]]);
key[3] = (u8)((ror((u8)(base[baseIdx + 3] ^ tb[tblRnd[4]]), tb[tblRnd[7]]) - tb[tblRnd[3]]) ^ tb[tblRnd[2]]);
key[4] = (u8)((ror((u8)(base[baseIdx + 4] ^ tb[tblRnd[1]]), tb[tblRnd[6]]) - tb[tblRnd[3]]) ^ tb[tblRnd[4]]);
key[5] = (u8)((ror((u8)(base[baseIdx + 5] ^ tb[tblRnd[7]]), tb[tblRnd[8]]) - tb[tblRnd[5]]) ^ tb[tblRnd[9]]);
ft[0] = (u8)(tb[(idx + 1) * 256 + key[4]] ^ tb[(idx + 2) * 256 + tblRnd[3]]);
ft[1] = (u8)(tb[(idx + 1) * 256 + key[2]] ^ tb[(idx + 2) * 256 + tblRnd[5]]);
ft[2] = (u8)(tb[(idx + 1) * 256 + key[5]] ^ tb[(idx + 2) * 256 + tblRnd[7]]);
ft[3] = (u8)(tb[(idx + 1) * 256 + key[0]] ^ tb[(idx + 2) * 256 + tblRnd[2]]);
ft[4] = (u8)(tb[(idx + 1) * 256 + key[1]] ^ tb[(idx + 2) * 256 + tblRnd[4]]);
ft[5] = (u8)(tb[(idx + 1) * 256 + key[3]] ^ tb[(idx + 2) * 256 + tblRnd[9]]);
ft[6] = (u8)(tb[(idx + 1) * 256 + tblRnd[0]] ^ tb[(idx + 2) * 256 + tblRnd[6]]);
ft[7] = (u8)(tb[(idx + 1) * 256 + tblRnd[1]] ^ tb[(idx + 2) * 256 + tblRnd[8]]);
sb[0] = (u8)(tb[(idx + 1) * 256 + key[0]] ^ tb[(idx + 2) * 256 + tblRnd[1]]);
sb[1] = (u8)(tb[(idx + 1) * 256 + key[5]] ^ tb[(idx + 2) * 256 + tblRnd[4]]);
sb[2] = (u8)(tb[(idx + 1) * 256 + key[3]] ^ tb[(idx + 2) * 256 + tblRnd[0]]);
sb[3] = (u8)(tb[(idx + 1) * 256 + key[2]] ^ tb[(idx + 2) * 256 + tblRnd[9]]);
sb[4] = (u8)(tb[(idx + 1) * 256 + key[4]] ^ tb[(idx + 2) * 256 + tblRnd[7]]);
sb[5] = (u8)(tb[(idx + 1) * 256 + key[1]] ^ tb[(idx + 2) * 256 + tblRnd[8]]);
sb[6] = (u8)(tb[(idx + 1) * 256 + tblRnd[3]] ^ tb[(idx + 2) * 256 + tblRnd[5]]);
sb[7] = (u8)(tb[(idx + 1) * 256 + tblRnd[2]] ^ tb[(idx + 2) * 256 + tblRnd[6]]);
for (i = 0; i < 10; i++) {
p_wpd->key[i] = tblRnd[9 - i];
}
for (i = 0; i < 6; i++) {
p_wpd->key[i + 10] = key[5 - i];
}
memcpy(p_wpd->ft, ft, 8);
memcpy(p_wpd->sb, sb, 8);
OSRestoreInterrupts(enable);
}
void WPADiDecode(s32 chan, void* p_buf, u16 len, u16 offset) {
WPADControlBlock* p_wpd = _wpdcb[chan];
u8 idx;
u8* ptr;
u16 i;
ptr = (u8*)p_buf;
for (i = 0; i < len; i++) {
idx = (u8)((offset + i) % 8);
ptr[i] = (u8)((ptr[i] ^ p_wpd->sb[idx]) + p_wpd->ft[idx]);
}
}
src/revolution/wpad/WPADHIDParser.c
+1667
View File
File diff suppressed because it is too large Load Diff
src/revolution/wpad/WPADMem.c
+3
View File
@@ -0,0 +1,3 @@
#include <revolution/wpad/__wpad.h>
WPADMEMControlBlock _wmb[WPAD_MAX_CONTROLLERS];
src/revolution/wpad/__wpad.h
+300 -150
View File
@@ -190,7 +190,7 @@ extern "C" {
#define RPT3E_DPD1 1
#define RPT3E_DPD1_OFFSET 13
/* Report 0x3e: Buttons, Accelerometer (Interleaved 2), IR Camera (Full 2,
/* Report 0x3f: Buttons, Accelerometer (Interleaved 2), IR Camera (Full 2,
* 18 bytes)
*/
#define RPTID_DATA_BTN_ACC_DPD18_2 0x3f
@@ -226,13 +226,15 @@ extern "C" {
*/
// Speaker register addresses
#define WM_REG_SPEAKER_01 WM_EXT_REG_ADDR(SPEAKER, 0x01)
#define WM_REG_SPEAKER_08 WM_EXT_REG_ADDR(SPEAKER, 0x08)
#define WM_REG_SPEAKER_09 WM_EXT_REG_ADDR(SPEAKER, 0x09)
#define SPK_RST_REG WM_EXT_REG_ADDR(SPEAKER, 0x01)
#define SPK_CTRL_REG WM_EXT_REG_ADDR(SPEAKER, 0x08)
#define SPK_CLK_REG WM_EXT_REG_ADDR(SPEAKER, 0x09)
// Extension register addresses
#define WM_REG_EXTENSION_CONFIG WM_EXT_REG_ADDR(EXTENSION, 0x20)
#define WM_REG_EXTENSION_40 WM_EXT_REG_ADDR(EXTENSION, 0x40)
#define WM_REG_EXTENSION_46 WM_EXT_REG_ADDR(EXTENSION, 0x46)
#define WM_REG_EXTENSION_4C WM_EXT_REG_ADDR(EXTENSION, 0x4c)
#define WM_REG_EXTENSION_CERT_PARAM WM_EXT_REG_ADDR(EXTENSION, 0x50)
#define WM_REG_EXTENSION_F0 WM_EXT_REG_ADDR(EXTENSION, 0xf0)
#define WM_REG_EXTENSION_CERT_CHALLENGE WM_EXT_REG_ADDR(EXTENSION, 0xf1)
@@ -266,39 +268,129 @@ extern "C" {
#define WPAD_NZFILTER_MPLS 3
#define WPAD_MAX_NZFILTERS 4
#define WPAD_DPD_IMG_RESO_WX 1024
#define WPAD_DPD_IMG_RESO_WY 768
#define WPAD_STATE_DISABLED 0
#define WPAD_STATE_ENABLING 1
#define WPAD_STATE_ENABLED 2
#define WPAD_STATE_SETUP 3
#define WPAD_STATE_DISABLING 4
#define WPAD_BATTERY_LEVEL_CRITICAL 0
#define WPAD_BATTERY_LEVEL_LOW 1
#define WPAD_BATTERY_LEVEL_MEDIUM 2
#define WPAD_BATTERY_LEVEL_HIGH 3
#define WPAD_BATTERY_LEVEL_MAX 4
#define WPAD_RADIO_QUALITY_GOOD 0 // 80+
#define WPAD_RADIO_QUALITY_BAD 1 // 80-
struct WPADCmd {
/* 0x00 */ u32 reportID;
/* 0x04 */ u8 dataBuf[RPT_MAX_SIZE];
/* 0x1a */ u16 dataLength;
/* 0x1c */ void* dstBuf;
/* 0x20 */ u16 readLength;
/* 0x24 */ u32 readAddress;
/* 0x28 */ WPADInfo* statusReportOut;
/* 0x2c */ WPADCallback cmdCB;
}; // size 0x30
struct WPADCmdQueue {
/* 0x00 */ s8 indexOut;
/* 0x01 */ s8 indexIn;
/* 0x04 */ struct WPADCmd* queue;
/* 0x08 */ u32 length;
}; // size 0x0c
#define WPAD_SENSOR_BAR_POS_BOTTOM 0
#define WPAD_SENSOR_BAR_POS_TOP 1
struct WPADDevConfig {
/* 0x00 */ DPDObject dpd[WPAD_MAX_DPD_OBJECTS];
/* 0x20 */ s16 accX0g;
/* 0x22 */ s16 accY0g;
/* 0x24 */ s16 accZ0g;
/* 0x26 */ s16 accX1g;
/* 0x28 */ s16 accY1g;
/* 0x2a */ s16 accZ1g;
/* 0x2c */ u8 motor;
/* 0x2d */ u8 volume;
/* 0x30 */ u8 pad0_[2];
};
#define WPAD_RX_DATASIZE 96
#define WPAD_COMMAND_CMD_MAX_LEN 24
#if PLATFORM_SHIELD
#define WPAD_COMMAND_EXT_MAX_LEN 12
#else
#define WPAD_COMMAND_EXT_MAX_LEN 8
#endif
#define WPAD_COMMAND_BUF_LEN 22
#define WPAD_I2CDEV_SEL_MASK (u32)(0xFF000000)
#define WPAD_I2CDEV_DADR_MASK (u32)(0x00FF0000)
#define WPAD_I2CDEV_UADR_MASK (u32)(0x0000FF00)
#define WPAD_I2CDEV_LADR_MASK (u32)(0x000000FF)
#define WPAD_WRITE_LEN_MASK (u16)(0x001F)
#define WPAD_READ_ULEN_MASK (u16)(0xFF00)
#define WPAD_READ_LLEN_MASK (u16)(0x00FF)
#define SPK_CLK_OFF 0x00
#define SPK_CLK_ON 0x01
#define SPK_DERESET 0x01
#if SDK_AUG2010
#define SPK_RESET 0x80
#else
#define SPK_RESET 0x08
#endif
#define SPK_CTRL_PLAY 0x01
// Utility macros to help with SDK version differences
#if SDK_AUG2010
#define DIFF_COUNT_DPD(p_wpd) (p_wpd->filterDiff[WPAD_NZFILTER_DPD])
#define HYST_COUNT_DPD(p_wpd) (p_wpd->filterSame[WPAD_NZFILTER_DPD])
#define DIFF_COUNT_ACC(p_wpd) (p_wpd->filterDiff[WPAD_NZFILTER_ACC])
#define HYST_COUNT_ACC(p_wpd) (p_wpd->filterSame[WPAD_NZFILTER_ACC])
#define DIFF_COUNT_FS_ACC(p_wpd) (p_wpd->filterDiff[WPAD_NZFILTER_EXT])
#define HYST_COUNT_FS_ACC(p_wpd) (p_wpd->filterSame[WPAD_NZFILTER_EXT])
#else
#define DIFF_COUNT_DPD(p_wpd) (p_wpd->diffCountDpd)
#define HYST_COUNT_DPD(p_wpd) (p_wpd->hystCountDpd)
#define DIFF_COUNT_ACC(p_wpd) (p_wpd->diffCountAcc)
#define HYST_COUNT_ACC(p_wpd) (p_wpd->hystCountAcc)
#define DIFF_COUNT_FS_ACC(p_wpd) (p_wpd->diffCountfsAcc)
#define HYST_COUNT_FS_ACC(p_wpd) (p_wpd->hystCountfsAcc)
#endif
typedef struct WPADUnkStatus {
/* 0x00 */ WPADStatus base;
/* 0x2A */ u8 field_0x2a[0x60 - 0x2a];
} WPADUnkStatus;
typedef struct WPADMEMGameInfo {
/* 0x00 */ OSTime calendarTimeTick;
/* 0x08 */ u16 gameTitle[17];
/* 0x2A */ char gameId[4];
/* 0x2E */ u8 gameType;
/* 0x2F */ u8 checkSum;
/* 0x30 */ u8 reserved[8];
} WPADMEMGameInfo;
typedef struct WPADMemBlock {
/* 0x00 */ BOOL busy;
/* 0x04 */ const u8* data;
/* 0x08 */ BOOL len;
/* 0x0C */ BOOL addr;
/* 0x10 */ WPADCallback* cb;
} WPADMemBlock;
typedef struct WPADCommand {
/* 0x00 */ u32 command;
/* 0x04 */ u8 data[22];
/* 0x1A */ u16 len;
/* 0x1C */ void* readBuf;
/* 0x20 */ u16 readLen;
/* 0x24 */ u32 readAddr;
/* 0x28 */ WPADInfo* info;
/* 0x2C */ WPADCallback callback;
} WPADCommand;
typedef struct WPADCmdQueue {
/* 0x00 */ s8 head;
/* 0x01 */ s8 tail;
/* 0x04 */ WPADCommand* cmd;
/* 0x08 */ u32 cmdlen;
} WPADCmdQueue;
typedef struct WPADDevConfig {
/* 0x00 */ DPDObject obj[WPAD_DPD_MAX_OBJECTS];
/* 0x20 */ WPADAcc acc_0g;
/* 0x26 */ WPADAcc acc_1g;
/* 0x2C */ u8 motor;
/* 0x2D */ u8 volume;
/* 0x2E */ u8 unk_0x2e[0x30 - 0x2e];
} WPADDevConfig;
typedef struct WPADStick {
/* 0x00 */ s16 x;
/* 0x02 */ s16 x_min;
/* 0x04 */ s16 x_max;
/* 0x06 */ s16 y;
/* 0x08 */ s16 y_min;
/* 0x0A */ s16 y_max;
} WPADStick;
typedef struct WPADMplsCalibration {
/* 0x00 */ f32 pitchZero;
@@ -310,109 +402,84 @@ typedef struct WPADMplsCalibration {
/* 0x18 */ s32 degrees;
} WPADMplsCalibration;
struct WPADExtConfig {
union {
struct WPADFSConfig {
/* 0x00 */ s16 stickXCenter;
/* 0x02 */ s16 at_0x02;
/* 0x04 */ s16 at_0x04;
/* 0x06 */ s16 stickYCenter;
/* 0x08 */ s16 at_0x08;
/* 0x0a */ s16 at_0x0a;
/* 0x0c */ s16 accX0g;
/* 0x0e */ s16 accY0g;
/* 0x10 */ s16 accZ0g;
/* 0x12 */ s16 accX1g;
/* 0x14 */ s16 accY1g;
/* 0x16 */ s16 accZ1g;
} fs; // size 0x1a
typedef struct WPADFsConfig {
/* 0x00 */ WPADStick stick;
/* 0x0C */ WPADAcc acc_0g;
/* 0x12 */ WPADAcc acc_1g;
} WPADFsConfig;
struct WPADCLConfig {
/* 0x00 */ s16 lStickXCenter;
/* 0x02 */ s16 at_0x02;
/* 0x04 */ s16 at_0x04;
/* 0x06 */ s16 lStickYCenter;
/* 0x08 */ s16 at_0x08;
/* 0x0a */ s16 at_0x0a;
/* 0x0c */ s16 rStickXCenter;
/* 0x0e */ s16 at_0x0e;
/* 0x10 */ s16 at_0x10;
/* 0x12 */ s16 rStickYCenter;
/* 0x14 */ s16 at_0x14;
/* 0x16 */ s16 at_0x16;
/* 0x18 */ u8 triggerLZero;
/* 0x19 */ u8 triggerRZero;
} cl; // size 0x1a
u8 forceUnionSize_[0x1c]; // alignment?
}; // size 0x1c
typedef struct WPADClConfig {
/* 0x00 */ WPADStick lstk;
/* 0x0C */ WPADStick rstk;
/* 0x18 */ u8 triggerL;
/* 0x19 */ u8 triggerR;
} WPADClConfig;
typedef struct WPADExtConfig {
/* 0x00 */ union {
WPADFsConfig fs;
WPADClConfig cl;
u8 bytes[0x1c];
};
#if SDK_AUG2010
struct WPADMplsConfig {
/* 0x00 */ WPADMplsCalibration high;
/* 0x1c */ WPADMplsCalibration low;
/* 0x38 */ u32 calibCRC;
/* 0x3c */ u16 calibID;
} /* 0x1a */ mpls;
}; // size 0x5c
#endif
} WPADExtConfig;
typedef struct WPADGameInfo {
/* 0x00 */ OSTime timestamp;
/* 0x08 */ u16 gameTitle[16 + 1];
/* 0x2a */ char gameCode[4];
/* 0x2e */ u8 gameType;
/* 0x2f */ u8 checksum;
u8 _pad0[8];
} WPADGameInfo; // size 0x38
struct WPADMemBlock {
/* 0x00 */ BOOL busy;
/* 0x04 */ u8 const* data;
/* 0x08 */ u16 len;
/* 0x0c */ u32 addr;
/* 0x10 */ WPADCallback* cb;
}; // size 0x14
typedef struct /* possibly untagged, like kpad */ {
/* 0x000 */ WPADGameInfo gameInfo;
/* 0x038 */ s32 at_0x038[2]; /* unknown */ // WPADResult[2]? see __wpadGetGameInfo
/* 0x040 */ u8 rxBufMain[RX_BUFFER_SIZE];
/* 0x0a0 */ u8 rxBufs[2][RX_BUFFER_SIZE];
/* 0x160 */ struct WPADCmdQueue stdCmdQueue;
/* 0x16c */ struct WPADCmd stdCmdQueueList[24];
/* 0x5ec */ struct WPADCmdQueue extCmdQueue;
/* 0x16c */ struct WPADCmd extCmdQueueList[12];
/* 0x838 */ WPADInfo info;
/* 0x850 */ WPADInfo* infoOut;
/* 0x854 */ struct WPADDevConfig devConfig;
/* 0x884 */ struct WPADExtConfig extConfig;
/* 0x8e0 */ WPADCallback cmdBlkCB;
/* 0x8e4 */ WPADExtensionCallback extensionCB;
/* 0x8e8 */ WPADConnectCallback connectCB;
/* 0x8ec */ WPADSamplingCallback samplingCB;
/* 0x8f0 */ void* samplingBuf;
/* 0x8f4 */ u32 samplingBufIndex;
/* 0x8f8 */ u32 samplingBufSize;
/* 0x8fc */ u32 dataFormat;
/* 0x900 */ s32 status;
/* 0x904 */ u8 statusReqBusy;
/* 0x905 */ u8 devType;
/* 0x906 */ u8 devMode;
/* 0x907 */ s8 devHandle;
typedef struct WPADControlBlock {
/* 0x000 */ WPADMEMGameInfo gameInfo;
/* 0x038 */ s32 gameInfoErr[2];
/* 0x040 */ WPADUnkStatus prBuf[1];
/* 0x0A0 */ WPADUnkStatus rxBufs[2];
/* 0x160 */ WPADCmdQueue stdCmdQueue;
/* 0x16C */ WPADCommand stdCmdQueueList[WPAD_COMMAND_CMD_MAX_LEN];
/* 0x5EC */ WPADCmdQueue extCmdQueue;
/* 0x5F8 */ WPADCommand extCmdQueueList[WPAD_COMMAND_EXT_MAX_LEN];
/* 0x778 */ WPADInfo info;
/* 0x790 */ WPADInfo* infoOut;
/* 0x794 */ WPADDevConfig devConf;
/* 0x7C4 */ WPADExtConfig extConf;
/* 0x7DC */ WPADCallback cmdBlkCallback;
/* 0x7E0 */ WPADExtensionCallback extensionCallback;
/* 0x7E4 */ WPADConnectCallback connectCallback;
/* 0x7E8 */ WPADSamplingCallback samplingCallback;
/* 0x7EC */ void* samplingBufs_ptr;
/* 0x7F0 */ u32 samplingBufIndex;
/* 0x7F4 */ u32 samplingBufLength;
/* 0x7F8 */ u32 dataFormat;
/* 0x7FC */ s32 status;
/* 0x800 */ u8 statusReqBusy;
/* 0x801 */ u8 devType;
/* 0x802 */ u8 devMode;
/* 0x803 */ s8 devHandle;
#if SDK_AUG2010
/* 0x908 */ int at_0x908; /* unknown */
/* 0x90c */ u8 rxBufIndex;
/* 0x90d */ s8 at_0x90d; /* unknown */
/* 0x90e */ u8 defaultDpdSize; // maybe?
/* 0x90e */ u8 dpdDummyObjSize; // maybe?
/* 0x90f */ u8 currentDpdCommand;
/* 0x910 */ u8 pendingDpdCommand;
/* 0x911 */ u8 radioQuality;
/* 0x912 */ u8 radioQualityOkMs; // see __wpadCalcRadioQuality
/* 0x913 */ u8 audioFrames;
/* 0x914 */ u32 motorBusy;
/* 0x918 */ BOOL motorRunning;
/* 0x91c */ BOOL used;
/* 0x920 */ BOOL handshakeFinished;
/* 0x924 */ int configIndex;
/* 0x928 */ OSThreadQueue threadQueue; /* purpose unknown */
#else
/* 0x804 */ u16 dpdDummyObjSize;
/* 0x806 */ u8 rxBufIndex;
/* 0x807 */ u8 reqVolume;
/* 0x808 */ WPADCallback reqVolCb;
#endif
/* 0x80C */ u8 radioQuality;
/* 0x80D */ u8 radioQualityOkMs; // see __wpadCalcRadioQuality
/* 0x80E */ u8 audioFrames;
/* 0x810 */ BOOL motorBusy;
/* 0x814 */ BOOL motorRunning;
/* 0x818 */ BOOL used;
/* 0x81C */ BOOL handshakeFinished;
/* 0x820 */ BOOL oldFw;
/* 0x824 */ OSThreadQueue threadQueue;
#if SDK_AUG2010
/* 0x930 */ WPADCallback vsmCallback;
/* 0x934 */ u8 controlMplsBusy;
/* 0x935 */ u8 mplsCBReadBuf[2];
@@ -436,26 +503,36 @@ typedef struct /* possibly untagged, like kpad */ {
/* 0x994 */ u32 certLintY[1 + 16 + 1];
/* 0x994 */ u32 certLintBig[LINT_NUM_MAX_BUFSIZ];
/* 0xae4 */ int at_0xae4; /* unknown */
/* 0xae8 */ OSTime lastControllerDataUpdate;
#endif
/* 0x830 */ OSTime lastUpdateTime;
#if SDK_AUG2010
/* 0xaf0 */ u16 filterDiff[WPAD_MAX_NZFILTERS];
/* 0xaf8 */ u16 filterSame[WPAD_MAX_NZFILTERS];
/* 0xb00 */ OSTime lastReportSendTime;
/* 0xb08 */ u8 at_0xb08; /* unknown */
/* 0xb09 */ u8 calibrated;
/* 0xb0a */ u16 recalibHoldMs;
/* 0xb0c */ u8 encryptionKey[16];
/* 0xb1c */ u8 decryptAddTable[8];
/* 0xb24 */ u8 decryptXorTable[8];
/* 0xb2c */ u8 wmReadDataBuf[64];
/* 0xb6c */ u8* wmReadDataPtr;
/* 0xb70 */ u32 wmReadAddress;
/* 0xb74 */ int wmReadHadError;
/* 0xb78 */ u16 wmReadLength;
/* 0xb7a */ s8 at_0xb7a; /* unknown */
/* 0xb7b */ u8 radioSensitivity;
/* 0xb7c */ u16 copyOutCount;
/* 0xb7e */ u8 sleeping;
/* 0xb7f */ u8 lastReportID;
#else
/* 0x838 */ u16 diffCountDpd;
/* 0x83A */ u16 hystCountDpd;
/* 0x83C */ u16 diffCountAcc;
/* 0x83E */ u16 hystCountAcc;
/* 0x840 */ u16 diffCountfsAcc;
/* 0x842 */ u16 hystCountfsAcc;
#endif
/* 0x844 */ OSTime lastReportSendTime;
/* 0x850 */ u8 cmdTimeoutAction;
/* 0x851 */ u8 calibrated;
/* 0x852 */ u16 recalibrateCount;
/* 0x854 */ u8 key[16];
/* 0x864 */ u8 ft[8];
/* 0x86C */ u8 sb[8];
/* 0x874 */ u8 wmReadDataBuf[64];
/* 0x8B4 */ void* wmReadDataPtr;
/* 0x8B8 */ u32 wmReadAddr;
/* 0x8BC */ s32 wmReadErr;
/* 0x8C0 */ u16 wmReadLength;
/* 0x8C2 */ u8 keyIdx;
/* 0x8C3 */ u8 radioSensitivity;
/* 0x8C4 */ u16 packetCnt;
/* 0x8C6 */ u8 disconnect;
/* 0x8C7 */ u8 lastReportId;
/* 0xb80 */ WPADCallback getInfoCB;
/* 0xb84 */ u8 getInfoBusy;
/* 0xb85 */ u8 extState;
@@ -464,7 +541,7 @@ typedef struct /* possibly untagged, like kpad */ {
/* 0xb88 */ u8 savedDevType; // maybe?
/* 0xb89 */ u8 extWasDisconnected;
/* 0xb8a */ s16 reconnectExtMs;
/* 0xb8c */ struct WPADMemBlock memBlock;
/* 0xb8c */ WPADMemBlock memBlock;
/* 0xba0 */ WPADCallback controlMplsCB;
/* 0xba4 */ u8 parseMPBuf;
/* 0xba5 */ u8 certProbeByte;
@@ -474,7 +551,7 @@ typedef struct /* possibly untagged, like kpad */ {
/* 0xbac */ u8 mplsCBState;
/* 0xbad */ u8 mplsUptimeMs;
/* 0xbae */ s8 certMayVerifyByCalibBlock;
u8 pad0_[2]; /* unknown (can't be alignment) */
/* 0xbaf */ u8 unk_0xbaf[0xbb1 - 0xbaf]; /* unknown (can't be alignment) */
/* 0xbb1 */ u8 certProbeStartingValue;
/* 0xbb2 */ u16 lastMplsCalibID;
/* 0xbb4 */ u32 lastMplsCalibCRC;
@@ -484,17 +561,90 @@ typedef struct /* possibly untagged, like kpad */ {
/* 0xbbb */ u8 extDevType;
/* 0xbbc */ u8 currPwmDuty;
/* 0xbbd */ u8 pendingPwmDuty;
u8 pad1_[2]; /* unknown (can't be alignment) */
/* 0xbbe */ u8 unk_0xbbe[0xbc0 - 0xbbe]; /* unknown (can't be alignment) */
/* 0xbc0 */ u8 extDataBuf[32];
} ATTRIBUTE_ALIGN(32) wpad_cb_st; // size 0xbe0
} WPADControlBlock;
BOOL WPADiIsAvailableCmdQueue(struct WPADCmdQueue* cmdQueue, s8 num);
BOOL WPADiSendWriteDataCmd(struct WPADCmdQueue* cmdQueue, u8 cmd, u32 address, WPADCallback cb);
BOOL WPADiSendWriteData(struct WPADCmdQueue* cmdQueue, void const* p_buf, u16 len, u32 address, WPADCallback cb);
BOOL WPADiSendStreamData(struct WPADCmdQueue* cmdQueue, void const* p_buf, u16 len);
BOOL WPADiSendMuteSpeaker(struct WPADCmdQueue* cmdQueue, BOOL muted, WPADCallback cb);
BOOL WPADiSendEnableSpeaker(struct WPADCmdQueue* cmdQueue, BOOL enabled, WPADCallback cb);
BOOL WPADiSendGetContStat(struct WPADCmdQueue* cmdQueue, WPADInfo* infoOut, WPADCallback cb);
typedef struct WPADMEMControlBlock {
/* 0x00 */ BOOL used;
/* 0x04 */ u8* p_buf;
/* 0x08 */ u16 len;
/* 0x0C */ u32 addr;
/* 0x10 */ WPADCallback callback;
} WPADMEMControlBlock;
struct WPADCmd {
/* 0x00 */ u32 reportID;
/* 0x04 */ u8 dataBuf[RPT_MAX_SIZE];
/* 0x1a */ u16 dataLength;
/* 0x1c */ void* dstBuf;
/* 0x20 */ u16 readLength;
/* 0x24 */ u32 readAddress;
/* 0x28 */ WPADInfo* statusReportOut;
/* 0x2c */ WPADCallback cmdCB;
}; // size 0x30
extern WPADMEMControlBlock _wmb[WPAD_MAX_CONTROLLERS];
#if SDK_AUG2010
extern WPADControlBlock* __rvl_p_wpadcb[WPAD_MAX_CONTROLLERS];
#define _wpdcb __rvl_p_wpadcb
#else
extern WPADControlBlock* _wpdcb[WPAD_MAX_CONTROLLERS];
#endif
/* WPAD.c */
void WPADiCreateKey(s32);
void WPADiCreateKeyFor3rd(s32);
s32 WPADiHIDParser(u8 chan, u8* p_rpt);
void WPADiClearQueue(WPADCmdQueue* queue);
BOOL WPADiSendSetReportType(WPADCmdQueue* queue, u32 fmt, WPADCallback callback);
BOOL WPADiSendWriteDataCmd(WPADCmdQueue* queue, u8 cmd, u32 addr, WPADCallback callback);
BOOL WPADiSendReadData(WPADCmdQueue* queue, void* p_buf, u16 len, u32 addr, WPADCallback callback);
BOOL WPADiSendWriteData(WPADCmdQueue* queue, void* p_buf, u16 len, u32 addr, WPADCallback callback);
void WPADiCopyOut(s32 chan);
u32 WPADGetLatestIndexInBuf(s32 chan, void* buf);
void WPADiExcludeButton(s32 chan);
s32 WPADiGetStatus(s32 chan);
void WPADiShutdown(BOOL exec);
void WPADiDisconnect(s32 chan, BOOL polite);
BOOL WPADiSendSetPort(WPADCmdQueue* queue, u8 pattern, WPADCallback callback);
BOOL WPADiSendDPDCSB(WPADCmdQueue* queue, BOOL enable, WPADCallback callback);
#if SDK_AUG2010
BOOL WPADiSendGetContStat(WPADCmdQueue* queue, WPADInfo* info, WPADCallback callback);
#else
BOOL WPADiSendGetContStat(WPADCmdQueue* queue, WPADInfo* info, u32 addr, WPADCallback callback);
#endif
void WPADiCheckContInputs(s32 chan);
s32 WPADiRetrieveChannel(u8 dev_handle);
s32 WPADiSendData(s32 chan, WPADCommand cmd);
BOOL WPADiGetCommand(WPADCmdQueue* queue, WPADCommand* cmd);
BOOL WPADiPopCommand(WPADCmdQueue* queue);
BOOL __wpadPushCommand(WPADCmdQueue* queue, WPADCommand cmd);
BOOL WPADiProcessCommand(s32 chan);
BOOL WPADiProcessExtCommand(s32 chan);
void WPADiRumbleMotor(s32 chan, BOOL sendCmd);
void WPADiRadioSensitivity(s32 chan);
void WPADiContMapTableUpdate(void);
void WPADiAfh(void);
void WPADiGetScSettings(void);
void WPADiConnCallback(u8 dev_handle, u8 open);
void WPADiRecvCallback(u8 dev_handle, u8* p_rpt, u16);
/* WPADEncrypt.c */
void WPADiCreateKey(s32 chan);
void WPADiDecode(s32 chan, void* p_buf, u16 len, u16 offset);
/* wpad_debug_msg.c */
void DEBUGPrint(const char* fmt, ...);
#ifdef __cplusplus
}
src/revolution/wpad/wpad_debug_msg.c
+5
View File
@@ -0,0 +1,5 @@
#include <revolution/wpad/__wpad.h>
void DEBUGPrint(const char* fmt, ...) {
// NONMATCHING
}
src/revolution/wpad/WUD.c → src/revolution/wud/WUD.c
+12 -2
View File
@@ -1,7 +1,9 @@
#include <revolution/os.h>
#include <revolution/wpad/wud.h>
#include <revolution/wud/WUD.h>
#include <revolution/os.h>
#include <revolution/wud/debug_msg.h>
#include "__wud.h"
#include "types.h"
wud_cb_st __rvl_wudcb;
@@ -61,3 +63,11 @@ u16 WUDiGetQueueSizeForHandle(u8 dev_handle) {
u16 WUDiGetNotAckNumForHandle(u8 dev_handle) {
return _dev_handle_notack_num[dev_handle];
}
BOOL WUDStartSyncSimple(void) {
// NONMATCHING
}
BOOL WUDStartFastSyncSimple(void) {
// NONMATCHING
}
src/revolution/wpad/__wud.h → src/revolution/wud/__wud.h
-1
View File
@@ -3,7 +3,6 @@
#include <revolution/os.h>
#include <revolution/wpad/bte.h>
#include <revolution/wpad/wud.h>
#ifdef __cplusplus
extern "C" {
src/revolution/wud/debug_msg.c
+6
View File
@@ -0,0 +1,6 @@
#include <revolution/wud/debug_msg.h>
void WUD_DEBUGPrint(const char* msg, ...) {
// NONMATCHING
}