1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-15 04:14:34 +00:00

padmgr and related (#71)

* In process of moving changes over from old repo

* Merged in changes

* Finished import of padmgr changes from old repo

* Adjusted some volatile

* Improving padmgr volatile situation

* Almost matched osReadMempak

* Working on osMempakDataCRC

* Explanations and equivalents but no matches for osMempakAddrCRC and osMempakDataCRC

* OK after merge

* Matched osMempakAddrCRC and osMempakDataCRC

* Matched osReadMempak

* Updated PadMgr function names to be less like original code

* Changed variable names to make them further from original code

* Changed names and it stopped matching

* Undid clang-format steamrollering whitespace memes

* Cleaned up Input names

* More formatting changes

* Moved padmgr to z64.h, deleted padmgr.h
This commit is contained in:
silv3rwing07 2020-04-14 10:17:25 -07:00 committed by GitHub
parent 16646aa34d
commit 5aef81071e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
45 changed files with 640 additions and 789 deletions

View file

@ -4,11 +4,10 @@
#include <PR/os_cont.h>
#include <ultra64/controller.h>
#include <padmgr.h>
s32 D_8012D280 = 1;
OSMesgQueue* PadMgr_LockGetControllerQueue(PadMgr* padmgr) {
OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padmgr) {
OSMesgQueue* ctrlrqueue = NULL;
if (D_8012D280 > 2) {
@ -28,7 +27,7 @@ OSMesgQueue* PadMgr_LockGetControllerQueue(PadMgr* padmgr) {
return ctrlrqueue;
}
void PadMgr_UnlockReleaseControllerQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue) {
void PadMgr_UnlockSerialMesgQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue) {
if (D_8012D280 > 2) {
// EUC-JP: ロック解除します | Unlock
osSyncPrintf("%2d %d serialMsgQロック解除します %08x %08x %08x\n", osGetThreadId(NULL),
@ -44,193 +43,347 @@ void PadMgr_UnlockReleaseControllerQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue
}
}
void PadMgr_Lock2(PadMgr* padmgr) {
void PadMgr_LockPadData(PadMgr* padmgr) {
osRecvMesg(&padmgr->queue2, NULL, OS_MESG_BLOCK);
}
void PadMgr_Unlock2(PadMgr* padmgr) {
void PadMgr_UnlockPadData(PadMgr* padmgr) {
osSendMesg(&padmgr->queue2, NULL, OS_MESG_BLOCK);
}
#ifdef NON_MATCHING
// regalloc and minor ordering differences
void func_800C740C(PadMgr* padmgr) {
static u32 D_8012D284 = 0;
void PadMgr_RumbleControl(PadMgr* padmgr) {
static u32 errcnt = 0;
static u32 D_8016A4F0;
s32 temp;
s32 var1;
s32 triedRumbleComm;
OSMesgQueue* ctrlrqueue;
s32 var3;
s32 ctrlr;
s32 var4;
s32 i;
temp = 1;
ctrlrqueue = PadMgr_LockGetControllerQueue(padmgr);
var1 = 0;
ctrlrqueue = PadMgr_LockSerialMesgQueue(padmgr);
triedRumbleComm = 0;
for (i = 0; i < 4; i++) {
if (padmgr->unk_2AA[i] != 0) {
if (padmgr->ctrlrIsConnected[i] != 0) {
if (padmgr->pad_status[i].status & 1) {
if (padmgr->unk_2AE[i] == temp) {
if (padmgr->unk_2B2[i] != 0) {
if (padmgr->unk_2B6[i] < 3) {
if (padmgr->pakType[i] == temp) {
if (padmgr->rumbleEnable[i] != 0) {
if (padmgr->rumbleCounter[i] < 3) {
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック ぶるぶるぶるぶる");
osSyncPrintf(VT_RST);
if (osSetVibration(&padmgr->unk_controller[i], temp) != 0) {
padmgr->unk_2AE[i] = 0;
if (osSetRumble(&padmgr->unk_controller[i], temp) != 0) {
padmgr->pakType[i] = 0;
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
osSyncPrintf(VT_RST);
} else {
padmgr->unk_2B6[i] = 3;
padmgr->rumbleCounter[i] = 3;
}
var1 = 1;
triedRumbleComm = 1;
}
} else {
if (padmgr->unk_2B6[i] != 0) {
if (padmgr->rumbleCounter[i] != 0) {
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
osSyncPrintf(VT_RST);
if (osSetVibration(&padmgr->unk_controller[i], 0) != 0) {
padmgr->unk_2AE[i] = 0;
if (osSetRumble(&padmgr->unk_controller[i], 0) != 0) {
padmgr->pakType[i] = 0;
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
osSyncPrintf(VT_RST);
} else {
padmgr->unk_2B6[i]--;
padmgr->rumbleCounter[i]--;
}
var1 = 1;
triedRumbleComm = 1;
}
}
}
} else {
if (padmgr->unk_2AE[i] != 0) {
if (padmgr->unk_2AE[i] == 1) {
if (padmgr->pakType[i] != 0) {
if (padmgr->pakType[i] == 1) {
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックが抜かれたようです");
osSyncPrintf(VT_RST);
padmgr->unk_2AE[i] = 0;
padmgr->pakType[i] = 0;
} else {
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1,
"振動パックではないコントローラパックが抜かれたようです");
osSyncPrintf(VT_RST);
padmgr->unk_2AE[i] = 0;
padmgr->pakType[i] = 0;
}
}
}
}
}
if (!var1) {
var3 = D_8016A4F0 % 4;
if (!triedRumbleComm) {
ctrlr = D_8016A4F0 % 4;
if ((padmgr->unk_2AA[var3] != 0) && (padmgr->pad_status[var3].status & 1) && (padmgr->unk_2AE[var3] != 1)) {
var4 = osProbeVibrationPack(ctrlrqueue, &padmgr->unk_controller[var3], var3);
if ((padmgr->ctrlrIsConnected[ctrlr] != 0) && (padmgr->pad_status[ctrlr].status & 1) &&
(padmgr->pakType[ctrlr] != 1)) {
var4 = osProbeRumblePak(ctrlrqueue, &padmgr->unk_controller[ctrlr], ctrlr);
if (var4 == 0) {
padmgr->unk_2AE[var3] = 1;
osSetVibration(&padmgr->unk_controller[var3], 1);
osSetVibration(&padmgr->unk_controller[var3], 0);
padmgr->pakType[ctrlr] = 1;
osSetRumble(&padmgr->unk_controller[ctrlr], 1);
osSetRumble(&padmgr->unk_controller[ctrlr], 0);
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "振動パックを認識しました");
osSyncPrintf("padmgr: %dコン: %s\n", ctrlr + 1, "振動パックを認識しました");
osSyncPrintf(VT_RST);
} else if (var4 == 11) {
padmgr->unk_2AE[var3] = 2;
padmgr->pakType[ctrlr] = 2;
} else if (var4 == 4) {
LOG_NUM("++errcnt", ++D_8012D284, "../padmgr.c", 282);
LOG_NUM("++errcnt", ++errcnt, "../padmgr.c", 282);
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "コントローラパックの通信エラー");
osSyncPrintf("padmgr: %dコン: %s\n", ctrlr + 1, "コントローラパックの通信エラー");
osSyncPrintf(VT_RST);
}
}
}
D_8016A4F0++;
PadMgr_UnlockReleaseControllerQueue(padmgr, ctrlrqueue);
PadMgr_UnlockSerialMesgQueue(padmgr, ctrlrqueue);
}
#else
u32 D_8012D284 = 0;
u32 D_8012D284 = 0; // errcnt
u32 D_8016A4F0;
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C740C.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/PadMgr_RumbleControl.s")
#endif
// func_800A2300 in 1.0
void func_800C7818(PadMgr* padmgr) {
void PadMgr_RumbleStop(PadMgr* padmgr) {
s32 i;
OSMesgQueue* ctrlrqueue;
ctrlrqueue = PadMgr_LockGetControllerQueue(padmgr);
ctrlrqueue = PadMgr_LockSerialMesgQueue(padmgr);
for (i = 0; i < 4; i++) {
if (osProbeVibrationPack(ctrlrqueue, &padmgr->unk_controller[i], i) == 0) {
if ((gFaultStruct.msgId == 0) && (padmgr->unk_45D != 0)) {
if (osProbeRumblePak(ctrlrqueue, &padmgr->unk_controller[i], i) == 0) {
if ((gFaultStruct.msgId == 0) && (padmgr->rumbleOnFrames != 0)) {
osSyncPrintf(VT_FGCOL(YELLOW));
// EUC-JP: コン | 'Con'? , EUC-JP: 振動パック 停止 | Stop vibration pack
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
osSyncPrintf(VT_RST);
}
osSetVibration(&padmgr->unk_controller[i], 0);
osSetRumble(&padmgr->unk_controller[i], 0);
}
}
PadMgr_UnlockReleaseControllerQueue(padmgr, ctrlrqueue);
PadMgr_UnlockSerialMesgQueue(padmgr, ctrlrqueue);
}
void func_800C7928(PadMgr* padmgr) {
padmgr->unk_45C = 3;
void PadMgr_RumbleReset(PadMgr* padmgr) {
padmgr->rumbleOffFrames = 3;
}
void func_800C7934(PadMgr* padmgr, u32 a1, u32 a2) {
padmgr->unk_2B2[a1] = a2;
padmgr->unk_45D = 0xF0;
void PadMgr_RumbleSetSingle(PadMgr* padmgr, u32 ctrlr, u32 rumble) {
padmgr->rumbleEnable[ctrlr] = rumble;
padmgr->rumbleOnFrames = 0xF0;
}
// 800A23CC in 1.0
void PadMgr_RumbleSet(PadMgr* padmgr, u8* ctrlrRumbles) {
s32 i;
for (i = 0; i < 4; ++i) {
padmgr->rumbleEnable[i] = ctrlrRumbles[i];
}
padmgr->rumbleOnFrames = 0xF0;
}
#if 0
void PadMgr_ProcessInputs(PadMgr* padmgr) {
/*
void *sp34;
s32 temp_s1;
s32 temp_v0_5;
u16 temp_a1;
u16 temp_v1_2;
u8 temp_v0;
void *temp_v0_2;
void *temp_v0_3;
void *temp_v0_4;
void *temp_v1;
void *phi_s0;
void *phi_s3;
s32 phi_s2;
s32 phi_s1;
*/
Input* input;
PadState* padnow1; //name from debug string
s32 i;
PadMgr_LockPadData(padmgr);
input = padmgr->inputs; //s0
padnow1 = padmgr->pads; //s3
for(i=0; i<padmgr->ncontrollers; ++i, ++input, ++padnow1){
input->prev.in = input->cur.in;
input->prev.status = input->cur.status;
temp_v0 = phi_s3->unk4;
switch(padnow1->errno){
case 0:
input->cur.in = padnow1->input;
input->cur.status = padnow1->status;
if (padmgr->ctrlrIsConnected[i] == 0) {
padmgr->ctrlrIsConnected[i] = 1;
osSyncPrintf(&D_80145AF0); //"\x1b[33m"
osSyncPrintf(&D_80145AF8, phi_s2 + 1, &D_80145B0C); //"padmgr: %dCon: %s\n" : "Recognized"
osSyncPrintf(&D_80145B1C); //"\x1b[m"
}
break;
case 4:
input->cur.in = input->prev.in;
input->cur.status = input->prev.status;
LogUtils_LogThreadId(&D_80145B20, 0x17c); //"../padmgr.c"
osSyncPrintf(&D_80145B2C, padmgr->ctrlrIsConnected[i]); //"this->ctrlrIsConnected[i] = %d\n"
osSyncPrintf(&D_80145B48); //"\x1b[33m"
osSyncPrintf(&D_80145B50, temp_s1, &D_80145B64); //"padmgr: %dCon: %s\n" : "Overrun error occurred"
osSyncPrintf(&D_80145B80); //"\x1b[m"
break;
case 8:
input->cur.in.button = 0;
input->cur.in.x = 0;
input->cur.in.y = 0;
temp_v0_2 = arg0 + phi_s2;
input->cur.errno = padnow1->errno;
if (temp_v0_2->ctrlrIsConnected != 0){
temp_v0_2->ctrlrIsConnected = 0;
temp_v0_2->pakType = 0;
temp_v0_2->rumbleCounter = 0xff;
osSyncPrintf(&D_80145B84); //"\x1b[33m"
osSyncPrintf(&D_80145B8C, phi_s2 + 1, &D_80145BA0); //"padmgr: %dCon: %s\n" : "Do not respond"
osSyncPrintf(&D_80145BB0); //"\x1b[m"
}
break;
default:
LogUtils_LogThreadId(&D_80145BB4, 0x18c); //"../padmgr.c"
osSyncPrintf(&D_80145BC0, padnow1->errno); //"padnow1->errno = %x\n"
Fault_AddHungupAndCrash(&D_80145BD8, 0x18d); //"../padmgr.c"
}
input->press.in.button = input->cur.in.button & (input->prev.in.button ^ input->cur.in.button);
input->rel.in.button = input->prev.in.button & (input->prev.in.button ^ input->cur.in.button);
func_800FCC6C(input);
input->press.in.x = (input->cur.in.x - input->prev.in.x) + input->press.in.x;
input->press.in.y = (input->cur.in.y - input->prev.in.y) + input->press.in.y;
}
PadMgr_UnlockPadData(arg0);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/PadMgr_ProcessInputs.s")
#endif
void PadMgr_HandleRetraceMsg(PadMgr* padmgr) {
OSMesgQueue* queue; // s1
u32 i;
u32 mask;
queue = PadMgr_LockSerialMesgQueue(padmgr);
osContStartReadData(queue);
if (padmgr->retraceCallback) {
padmgr->retraceCallback(padmgr, padmgr->retraceCallbackValue);
}
osRecvMesg(queue, NULL, OS_MESG_BLOCK);
osContGetReadData(&padmgr->pads[0]);
if (padmgr->preNMIShutdown) {
bzero(&padmgr->pads[0], 0x18);
}
PadMgr_ProcessInputs(padmgr);
func_80103210(queue);
osRecvMesg(queue, NULL, OS_MESG_BLOCK);
func_8010328C(padmgr);
PadMgr_UnlockSerialMesgQueue(padmgr, queue);
mask = 0;
for (i = 0; i - 4 != 0; ++i) {
if (padmgr->pad_status[i].errno == 0) {
if (padmgr->pad_status[i].type - 5 == 0) {
mask |= 1 << i;
} else {
LogUtils_LogThreadId("../padmgr.c", 0x1ca);
osSyncPrintf("this->pad_status[i].type = %x\n", padmgr->pad_status[i].type);
// EUC-JP: 知らない種類のコントローラが接続されています | An unknown type of controller is connected
osSyncPrintf("知らない種類のコントローラが接続されています\n");
}
}
}
padmgr->validCtrlrsMask = mask;
if (gFaultStruct.msgId) {
PadMgr_RumbleStop(padmgr);
} else if (padmgr->rumbleOffFrames > 0) {
--padmgr->rumbleOffFrames;
PadMgr_RumbleStop(padmgr);
} else if (padmgr->rumbleOnFrames == 0) {
PadMgr_RumbleStop(padmgr);
} else if (!padmgr->preNMIShutdown) {
PadMgr_RumbleControl(padmgr);
--padmgr->rumbleOnFrames;
}
}
void PadMgr_HandlePreNMI(PadMgr* padmgr) {
osSyncPrintf("padmgr_HandlePreNMI()\n");
padmgr->preNMIShutdown = 1;
PadMgr_RumbleReset(padmgr);
}
#ifdef NON_MATCHING
// minor ordering difference
// 800A23CC in 1.0
void func_800C7948(PadMgr* padmgr, u8* a1) {
padmgr->unk_2B2[0] = a1[0];
padmgr->unk_2B2[1] = a1[1];
padmgr->unk_2B2[2] = a1[2];
padmgr->unk_2B2[3] = a1[3];
// Regalloc differences
void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode) {
u32 i;
Input* pmInputs;
Input* newin;
padmgr->unk_45D = 0xF0; // NON MATCHING - T0 and T9 are reordered for some reason
PadMgr_LockPadData(padmgr);
pmInputs = padmgr->inputs;
newin = inputs;
for (i = 0; i < 4; ++i) {
if (mode) {
*newin = *pmInputs;
pmInputs->press.in.button = 0;
pmInputs->press.in.x = 0;
pmInputs->press.in.y = 0;
pmInputs->rel.in.button = 0;
} else {
// Correct instructions, wrong regalloc
newin->prev = newin->cur;
newin->cur = pmInputs->cur;
newin->press.in.button = newin->cur.in.button & (newin->prev.in.button ^ newin->cur.in.button);
newin->rel.in.button = newin->prev.in.button & (newin->prev.in.button ^ newin->cur.in.button);
func_800FCC6C(newin);
newin->press.in.x = (newin->cur.in.x - newin->prev.in.x) + newin->press.in.x;
newin->press.in.y = (newin->cur.in.y - newin->prev.in.y) + newin->press.in.y;
}
++pmInputs;
++newin;
}
PadMgr_UnlockPadData(padmgr);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7948.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/PadMgr_RequestPadData.s")
#endif
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7974.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7C14.s")
void func_800C7DD0(PadMgr* padmgr) {
osSyncPrintf("padmgr_HandlePreNMI()\n");
padmgr->unk_45E = 1;
func_800C7928(padmgr);
}
#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7E08.s")
// void func_800C7E08(Input*, u32);
// 800A2918 in 1.0
void PadMgr_Run(PadMgr* padmgr) {
void PadMgr_MainProc(PadMgr* padmgr) {
s16* mesg;
s32 bVar2;
s32 exit;
mesg = NULL;
// EUC-JP: コントローラスレッド実行開始 | Start of controller thread execution
osSyncPrintf("コントローラスレッド実行開始\n");
bVar2 = 0;
exit = 0;
while (bVar2 == 0) {
while (!exit) {
if ((D_8012D280 > 2) && (padmgr->queue3.validCount == 0)) {
// EUC-JP: コントローラスレッドイベント待ち | Waiting for controller thread event
osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
@ -245,7 +398,7 @@ void PadMgr_Run(PadMgr* padmgr) {
osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
}
func_800C7C14(padmgr);
PadMgr_HandleRetraceMsg(padmgr);
if (D_8012D280 > 2) {
osSyncPrintf("padmgr_HandleRetraceMsg END %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
@ -253,10 +406,10 @@ void PadMgr_Run(PadMgr* padmgr) {
break;
case OS_SC_PRE_NMI_MSG:
func_800C7DD0(padmgr);
PadMgr_HandlePreNMI(padmgr);
break;
case OS_SC_NMI_MSG:
bVar2 = 1;
exit = 1;
break;
}
}
@ -267,7 +420,7 @@ void PadMgr_Run(PadMgr* padmgr) {
}
// func_800A2A14 in 1.0
void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* ctrlrqueue, UNK_TYPE arg2, OSId id, OSPri priority, void* stack) {
void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* siIntMsgQ, UNK_TYPE arg2, OSId id, OSPri priority, void* stack) {
// EUC-JP: パッドマネージャ作成 | Create pad manager
osSyncPrintf("パッドマネージャ作成 padmgr_Create()\n");
bzero(padmgr, sizeof(PadMgr));
@ -276,14 +429,14 @@ void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* ctrlrqueue, UNK_TYPE arg2, OSId id
osCreateMesgQueue(&padmgr->queue3, padmgr->msgbuf3, 4);
IrqMgr_AddClient(padmgr->unk_78, &padmgr->unk_70, &padmgr->queue3);
osCreateMesgQueue(&padmgr->queue1, padmgr->msgbuf1, 1);
PadMgr_UnlockReleaseControllerQueue(padmgr, ctrlrqueue);
PadMgr_UnlockSerialMesgQueue(padmgr, siIntMsgQ);
osCreateMesgQueue(&padmgr->queue2, padmgr->msgbuf2, 1);
PadMgr_Unlock2(padmgr);
func_800FCD40(ctrlrqueue, &padmgr->unk_2A8, padmgr);
PadMgr_UnlockPadData(padmgr);
func_800FCD40(siIntMsgQ, &padmgr->validCtrlrsMask, padmgr);
padmgr->unk_2A9 = 4;
func_80104D00(padmgr->unk_2A9);
padmgr->ncontrollers = 4;
func_80104D00(padmgr->ncontrollers);
osCreateThread(&padmgr->thread, id, PadMgr_Run, padmgr, stack, priority);
osCreateThread(&padmgr->thread, id, PadMgr_MainProc, padmgr, stack, priority);
osStartThread(&padmgr->thread);
}