mirror of
https://github.com/zeldaret/oot.git
synced 2025-07-06 07:56:32 +00:00
Message Queues, Threads, and surroundings cleanup (#1178)
* message queues, threads, and surroundings cleanup * Format, make the formatter prefer clang-format-11 if found * Fix __osThreadTail type * Q -> Queue, thread defines renamed * Reformat, add missing NULL * Suggested changes and further casting cleanup * Reformat * padmgr name fixes
This commit is contained in:
Tharo
GitHub
parent
9984c267d9
commit
7068ad3703
45 changed files with 311 additions and 296 deletions
|
|
@ -56,15 +56,15 @@ void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena*
|
|||
}
|
||||
|
||||
void ArenaImpl_LockInit(Arena* arena) {
|
||||
osCreateMesgQueue(&arena->lock, &sArenaLockMsg, 1);
|
||||
osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
|
||||
}
|
||||
|
||||
void ArenaImpl_Lock(Arena* arena) {
|
||||
osSendMesg(&arena->lock, NULL, OS_MESG_BLOCK);
|
||||
osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void ArenaImpl_Unlock(Arena* arena) {
|
||||
osRecvMesg(&arena->lock, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
|
||||
|
|
|
|||
|
|
@ -1,11 +1,10 @@
|
|||
#include "global.h"
|
||||
|
||||
void func_800C3C80(AudioMgr* audioMgr) {
|
||||
AudioTask* task;
|
||||
AudioTask* task = audioMgr->rspTask;
|
||||
|
||||
task = audioMgr->rspTask;
|
||||
if (audioMgr->rspTask->taskQueue != NULL) {
|
||||
osSendMesg(task->taskQueue, NULL, OS_MESG_BLOCK);
|
||||
if (audioMgr->rspTask->msgQueue != NULL) {
|
||||
osSendMesg(task->msgQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -17,14 +16,14 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
|
|||
}
|
||||
if (audioMgr->rspTask != NULL) {
|
||||
audioMgr->audioTask.next = NULL;
|
||||
audioMgr->audioTask.flags = 2;
|
||||
audioMgr->audioTask.flags = OS_SC_NEEDS_RSP;
|
||||
audioMgr->audioTask.framebuffer = NULL;
|
||||
|
||||
audioMgr->audioTask.list = audioMgr->rspTask->task;
|
||||
audioMgr->audioTask.msgQ = &audioMgr->unk_AC;
|
||||
audioMgr->audioTask.msgQueue = &audioMgr->taskQueue;
|
||||
|
||||
audioMgr->audioTask.msg = NULL;
|
||||
osSendMesg(&audioMgr->sched->cmdQ, &audioMgr->audioTask, OS_MESG_BLOCK);
|
||||
osSendMesg(&audioMgr->sched->cmdQueue, (OSMesg)&audioMgr->audioTask, OS_MESG_BLOCK);
|
||||
Sched_SendEntryMsg(audioMgr->sched);
|
||||
}
|
||||
|
||||
|
|
@ -37,7 +36,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
|
|||
D_8016A558 += osGetTime() - D_8016A550;
|
||||
D_8016A550 = 0;
|
||||
if (audioMgr->rspTask != NULL) {
|
||||
osRecvMesg(&audioMgr->unk_AC, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(&audioMgr->taskQueue, NULL, OS_MESG_BLOCK);
|
||||
func_800C3C80(audioMgr);
|
||||
}
|
||||
audioMgr->rspTask = rspTask;
|
||||
|
|
@ -58,16 +57,16 @@ void AudioMgr_ThreadEntry(void* arg0) {
|
|||
Audio_Init();
|
||||
AudioLoad_SetDmaHandler(DmaMgr_DmaHandler);
|
||||
Audio_InitSound();
|
||||
osSendMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK);
|
||||
IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->unk_74);
|
||||
osSendMesg(&audioMgr->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->interruptQueue);
|
||||
|
||||
while (true) {
|
||||
osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
switch (*msg) {
|
||||
case OS_SC_RETRACE_MSG:
|
||||
AudioMgr_HandleRetrace(audioMgr);
|
||||
while (audioMgr->unk_74.validCount != 0) {
|
||||
osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
while (!MQ_IS_EMPTY(&audioMgr->interruptQueue)) {
|
||||
osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
switch (*msg) {
|
||||
case OS_SC_RETRACE_MSG:
|
||||
break;
|
||||
|
|
@ -85,7 +84,7 @@ void AudioMgr_ThreadEntry(void* arg0) {
|
|||
}
|
||||
|
||||
void AudioMgr_Unlock(AudioMgr* audioMgr) {
|
||||
osRecvMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(&audioMgr->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void AudioMgr_Init(AudioMgr* audioMgr, void* stack, OSPri pri, OSId id, SchedContext* sched, IrqMgr* irqMgr) {
|
||||
|
|
@ -95,12 +94,12 @@ void AudioMgr_Init(AudioMgr* audioMgr, void* stack, OSPri pri, OSId id, SchedCon
|
|||
audioMgr->irqMgr = irqMgr;
|
||||
audioMgr->rspTask = NULL;
|
||||
|
||||
osCreateMesgQueue(&audioMgr->unk_AC, &audioMgr->unk_C4, 1);
|
||||
osCreateMesgQueue(&audioMgr->unk_74, &audioMgr->unk_8C, 8);
|
||||
osCreateMesgQueue(&audioMgr->unk_C8, &audioMgr->unk_E0, 1);
|
||||
osCreateMesgQueue(&audioMgr->taskQueue, audioMgr->taskMsgBuf, ARRAY_COUNT(audioMgr->taskMsgBuf));
|
||||
osCreateMesgQueue(&audioMgr->interruptQueue, audioMgr->interruptMsgBuf, ARRAY_COUNT(audioMgr->interruptMsgBuf));
|
||||
osCreateMesgQueue(&audioMgr->lockQueue, audioMgr->lockMsgBuf, ARRAY_COUNT(audioMgr->lockMsgBuf));
|
||||
|
||||
osSendMesg(&audioMgr->unk_AC, NULL, OS_MESG_BLOCK);
|
||||
osSendMesg(&audioMgr->taskQueue, NULL, OS_MESG_BLOCK);
|
||||
|
||||
osCreateThread(&audioMgr->unk_E8, id, AudioMgr_ThreadEntry, audioMgr, stack, pri);
|
||||
osStartThread(&audioMgr->unk_E8);
|
||||
osCreateThread(&audioMgr->thread, id, AudioMgr_ThreadEntry, audioMgr, stack, pri);
|
||||
osStartThread(&audioMgr->thread);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus);
|
|||
void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3);
|
||||
|
||||
OSMesgQueue sScriptLoadQueue;
|
||||
OSMesg sScriptLoadMesgBuf[0x10];
|
||||
OSMesg sScriptLoadMsgBuf[16];
|
||||
s8* sScriptLoadDonePointers[0x10];
|
||||
s32 sAudioLoadPad1[2]; // file padding
|
||||
|
||||
|
|
@ -193,7 +193,7 @@ void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef,
|
|||
dma->ttl = 3;
|
||||
dma->devAddr = dmaDevAddr;
|
||||
dma->sizeUnused = transfer;
|
||||
AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMesgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
|
||||
AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMsgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
|
||||
OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.currAudioFrameDmaQueue, medium,
|
||||
"SUPERDMA");
|
||||
*dmaIndexRef = dmaIndex;
|
||||
|
|
@ -442,7 +442,7 @@ s32 AudioLoad_SyncLoadInstrument(s32 fontId, s32 instId, s32 drumId) {
|
|||
|
||||
void AudioLoad_AsyncLoad(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
|
||||
if (AudioLoad_AsyncLoadInner(tableType, id, nChunks, retData, retQueue) == NULL) {
|
||||
osSendMesg(retQueue, 0xFFFFFFFF, OS_MESG_NOBLOCK);
|
||||
osSendMesg(retQueue, (OSMesg)0xFFFFFFFF, OS_MESG_NOBLOCK);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -967,7 +967,7 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData,
|
|||
ret = AudioLoad_SearchCaches(tableType, realId);
|
||||
if (ret != NULL) {
|
||||
status = 2;
|
||||
osSendMesg(retQueue, MK_ASYNC_MSG(retData, 0, 0, 0), OS_MESG_NOBLOCK);
|
||||
osSendMesg(retQueue, (OSMesg)MK_ASYNC_MSG(retData, 0, 0, 0), OS_MESG_NOBLOCK);
|
||||
} else {
|
||||
sp50 = AudioLoad_GetLoadTable(tableType);
|
||||
size = sp50->entries[realId].size;
|
||||
|
|
@ -1106,11 +1106,12 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
|
|||
gAudioContext.rspTask[0].task.t.data_size = 0;
|
||||
gAudioContext.rspTask[1].task.t.data_size = 0;
|
||||
osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1);
|
||||
osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBuf, 0x40);
|
||||
osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMesgBuf,
|
||||
ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
|
||||
osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMesgBuf,
|
||||
ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
|
||||
osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.currAudioFrameDmaMsgBuf));
|
||||
osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
|
||||
osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
|
||||
gAudioContext.curAudioFrameDmaCount = 0;
|
||||
gAudioContext.sampleDmaCount = 0;
|
||||
gAudioContext.cartHandle = osCartRomInit();
|
||||
|
|
@ -1161,7 +1162,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
|
|||
|
||||
AudioHeap_AllocPoolInit(&gAudioContext.permanentPool, temp_v0_3, D_8014A6C4.permanentPoolSize);
|
||||
gAudioContextInitalized = true;
|
||||
osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
|
||||
osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
|
||||
}
|
||||
|
||||
void AudioLoad_InitSlowLoads(void) {
|
||||
|
|
@ -1273,7 +1274,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
|
|||
switch (gAudioContext.slowLoads[i].status) {
|
||||
case LOAD_STATUS_LOADING:
|
||||
if (slowLoad->medium != MEDIUM_UNK) {
|
||||
osRecvMesg(&slowLoad->msgqueue, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(&slowLoad->msgQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
if (resetStatus != 0) {
|
||||
|
|
@ -1313,9 +1314,9 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
|
|||
|
||||
void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) {
|
||||
Audio_InvalDCache(slowLoad->curRamAddr, size);
|
||||
osCreateMesgQueue(&slowLoad->msgqueue, &slowLoad->msg, 1);
|
||||
osCreateMesgQueue(&slowLoad->msgQueue, &slowLoad->msg, 1);
|
||||
AudioLoad_Dma(&slowLoad->ioMesg, OS_MESG_PRI_NORMAL, 0, slowLoad->curDevAddr, slowLoad->curRamAddr, size,
|
||||
&slowLoad->msgqueue, slowLoad->medium, "SLOWCOPY");
|
||||
&slowLoad->msgQueue, slowLoad->medium, "SLOWCOPY");
|
||||
}
|
||||
|
||||
void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3) {
|
||||
|
|
@ -1376,7 +1377,7 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, u32 devAdd
|
|||
return NULL;
|
||||
}
|
||||
|
||||
osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK);
|
||||
osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg)asyncLoad, OS_MESG_NOBLOCK);
|
||||
asyncLoad->unkMediumParam = unkMediumParam;
|
||||
return asyncLoad;
|
||||
}
|
||||
|
|
@ -2017,5 +2018,5 @@ void AudioLoad_ProcessScriptLoads(void) {
|
|||
}
|
||||
|
||||
void AudioLoad_InitScriptLoads(void) {
|
||||
osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMesgBuf, ARRAY_COUNT(sScriptLoadMesgBuf));
|
||||
osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMsgBuf, ARRAY_COUNT(sScriptLoadMsgBuf));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ AudioTask* func_800E5000(void) {
|
|||
}
|
||||
}
|
||||
|
||||
osSendMesg(gAudioContext.taskStartQueueP, gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
|
||||
osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
|
||||
gAudioContext.rspTaskIdx ^= 1;
|
||||
gAudioContext.curAIBufIdx++;
|
||||
gAudioContext.curAIBufIdx %= 3;
|
||||
|
|
@ -99,7 +99,7 @@ AudioTask* func_800E5000(void) {
|
|||
}
|
||||
}
|
||||
|
||||
sp48 = gAudioContext.currAudioFrameDmaQueue.validCount;
|
||||
sp48 = MQ_GET_COUNT(&gAudioContext.currAudioFrameDmaQueue);
|
||||
if (sp48 != 0) {
|
||||
for (i = 0; i < sp48; i++) {
|
||||
osRecvMesg(&gAudioContext.currAudioFrameDmaQueue, NULL, OS_MESG_NOBLOCK);
|
||||
|
|
@ -114,7 +114,8 @@ AudioTask* func_800E5000(void) {
|
|||
if (gAudioContext.resetStatus != 0) {
|
||||
if (AudioHeap_ResetStep() == 0) {
|
||||
if (gAudioContext.resetStatus == 0) {
|
||||
osSendMesg(gAudioContext.audioResetQueueP, gAudioContext.audioResetSpecIdToLoad, OS_MESG_NOBLOCK);
|
||||
osSendMesg(gAudioContext.audioResetQueueP, (OSMesg)(u32)gAudioContext.audioResetSpecIdToLoad,
|
||||
OS_MESG_NOBLOCK);
|
||||
}
|
||||
|
||||
sWaitingAudioTask = NULL;
|
||||
|
|
@ -171,7 +172,7 @@ AudioTask* func_800E5000(void) {
|
|||
gWaveSamples[8] = (s16*)(((u8*)func_800E4FE0) + (gAudioContext.audioRandom & 0xFFF0));
|
||||
|
||||
index = gAudioContext.rspTaskIdx;
|
||||
gAudioContext.currTask->taskQueue = NULL;
|
||||
gAudioContext.currTask->msgQueue = NULL;
|
||||
gAudioContext.currTask->unk_44 = NULL;
|
||||
|
||||
task = &gAudioContext.currTask->task.t;
|
||||
|
|
@ -348,11 +349,12 @@ void Audio_InitMesgQueuesInternal(void) {
|
|||
gAudioContext.taskStartQueueP = &gAudioContext.taskStartQueue;
|
||||
gAudioContext.cmdProcQueueP = &gAudioContext.cmdProcQueue;
|
||||
gAudioContext.audioResetQueueP = &gAudioContext.audioResetQueue;
|
||||
osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgs,
|
||||
ARRAY_COUNT(gAudioContext.taskStartMsgs));
|
||||
osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgs, ARRAY_COUNT(gAudioContext.cmdProcMsgs));
|
||||
osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMesgs,
|
||||
ARRAY_COUNT(gAudioContext.audioResetMesgs));
|
||||
osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.taskStartMsgBuf));
|
||||
osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.cmdProcMsgBuf));
|
||||
osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMsgBuf,
|
||||
ARRAY_COUNT(gAudioContext.audioResetMsgBuf));
|
||||
}
|
||||
|
||||
void Audio_QueueCmd(u32 opArgs, void** data) {
|
||||
|
|
@ -398,7 +400,7 @@ s32 Audio_ScheduleProcessCmds(void) {
|
|||
|
||||
ret =
|
||||
osSendMesg(gAudioContext.cmdProcQueueP,
|
||||
(void*)(((gAudioContext.cmdRdPos & 0xFF) << 8) | (gAudioContext.cmdWrPos & 0xFF)), OS_MESG_NOBLOCK);
|
||||
(OSMesg)(((gAudioContext.cmdRdPos & 0xFF) << 8) | (gAudioContext.cmdWrPos & 0xFF)), OS_MESG_NOBLOCK);
|
||||
if (ret != -1) {
|
||||
gAudioContext.cmdRdPos = gAudioContext.cmdWrPos;
|
||||
ret = 0;
|
||||
|
|
@ -514,7 +516,7 @@ s32 func_800E5EDC(void) {
|
|||
void func_800E5F34(void) {
|
||||
// macro?
|
||||
// clang-format off
|
||||
s32 chk = -1; s32 sp28; do {} while (osRecvMesg(gAudioContext.audioResetQueueP, (OSMesg*)&sp28, OS_MESG_NOBLOCK) != chk);
|
||||
s32 chk = -1; OSMesg msg; do {} while (osRecvMesg(gAudioContext.audioResetQueueP, &msg, OS_MESG_NOBLOCK) != chk);
|
||||
// clang-format on
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -128,8 +128,8 @@ void Fault_ClientRunTask(FaultClientTask* task) {
|
|||
// Run the fault client callback on a separate thread
|
||||
thread = alloca(sizeof(OSThread));
|
||||
|
||||
osCreateThread(thread, 2, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp,
|
||||
OS_PRIORITY_APPMAX - 1);
|
||||
osCreateThread(thread, THREAD_ID_FAULT, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp,
|
||||
THREAD_PRI_FAULT_CLIENT);
|
||||
osStartThread(thread);
|
||||
} else {
|
||||
// Run the fault client callback on this thread
|
||||
|
|
@ -1265,7 +1265,8 @@ void Fault_Init(void) {
|
|||
gFaultMgr.faultHandlerEnabled = true;
|
||||
osCreateMesgQueue(&sFaultInstance->queue, &sFaultInstance->msg, 1);
|
||||
StackCheck_Init(&sFaultThreadInfo, &sFaultStack, STACK_TOP(sFaultStack), 0, 0x100, "fault");
|
||||
osCreateThread(&sFaultInstance->thread, 2, Fault_ThreadEntry, 0, STACK_TOP(sFaultStack), OS_PRIORITY_APPMAX);
|
||||
osCreateThread(&sFaultInstance->thread, THREAD_ID_FAULT, Fault_ThreadEntry, 0, STACK_TOP(sFaultStack),
|
||||
THREAD_PRI_FAULT);
|
||||
osStartThread(&sFaultInstance->thread);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -227,7 +227,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
|
|||
gfxCtx->fbIdx--;
|
||||
}
|
||||
|
||||
scTask->msgQ = &gfxCtx->queue;
|
||||
scTask->msgQueue = &gfxCtx->queue;
|
||||
scTask->msg = NULL;
|
||||
|
||||
cfb = &sGraphCfbInfos[sGraphCfbInfoIdx++];
|
||||
|
|
@ -245,9 +245,9 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
|
|||
|
||||
if (1) {}
|
||||
|
||||
gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
|
||||
gfxCtx->schedMsgQueue = &gSchedContext.cmdQueue;
|
||||
|
||||
osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
|
||||
osSendMesg(&gSchedContext.cmdQueue, (OSMesg)scTask, OS_MESG_BLOCK);
|
||||
Sched_SendEntryMsg(&gSchedContext);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -50,18 +50,18 @@ u32 sIrqMgrRetraceCount = 0;
|
|||
*
|
||||
* @param irqMgr the IrqMgr instance to register with.
|
||||
* @param client client to register.
|
||||
* @param msgQ message queue to send notifications of interrupts to, associated with the client.
|
||||
* @param msgQueue message queue to send notifications of interrupts to, associated with the client.
|
||||
*/
|
||||
void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQ) {
|
||||
void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQueue) {
|
||||
OSIntMask prevInt;
|
||||
|
||||
LogUtils_CheckNullPointer("this", irqMgr, "../irqmgr.c", 96);
|
||||
LogUtils_CheckNullPointer("c", client, "../irqmgr.c", 97);
|
||||
LogUtils_CheckNullPointer("msgQ", msgQ, "../irqmgr.c", 98);
|
||||
LogUtils_CheckNullPointer("msgQ", msgQueue, "../irqmgr.c", 98);
|
||||
|
||||
prevInt = osSetIntMask(OS_IM_NONE);
|
||||
|
||||
client->queue = msgQ;
|
||||
client->queue = msgQueue;
|
||||
client->prev = irqMgr->clients;
|
||||
irqMgr->clients = client;
|
||||
|
||||
|
|
@ -298,6 +298,6 @@ void IrqMgr_Init(IrqMgr* irqMgr, void* stack, OSPri pri, u8 retraceCount) {
|
|||
osCreateMesgQueue(&irqMgr->queue, irqMgr->msgBuf, ARRAY_COUNT(irqMgr->msgBuf));
|
||||
osSetEventMesg(OS_EVENT_PRENMI, &irqMgr->queue, (OSMesg)IRQ_PRENMI_MSG);
|
||||
osViSetEvent(&irqMgr->queue, (OSMesg)IRQ_RETRACE_MSG, retraceCount);
|
||||
osCreateThread(&irqMgr->thread, 19, IrqMgr_ThreadEntry, irqMgr, stack, pri);
|
||||
osCreateThread(&irqMgr->thread, THREAD_ID_IRQMGR, IrqMgr_ThreadEntry, irqMgr, stack, pri);
|
||||
osStartThread(&irqMgr->thread);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@ StackEntry sAudioStackInfo;
|
|||
StackEntry sPadMgrStackInfo;
|
||||
StackEntry sIrqMgrStackInfo;
|
||||
AudioMgr gAudioMgr;
|
||||
OSMesgQueue sSiIntMsgQ;
|
||||
OSMesg sSiIntMsgBuf[1];
|
||||
OSMesgQueue sSerialEventQueue;
|
||||
OSMesg sSerialMsgBuf[1];
|
||||
|
||||
void Main_LogSystemHeap(void) {
|
||||
osSyncPrintf(VT_FGCOL(GREEN));
|
||||
|
|
@ -35,7 +35,7 @@ void Main_LogSystemHeap(void) {
|
|||
|
||||
void Main(void* arg) {
|
||||
IrqMgrClient irqClient;
|
||||
OSMesgQueue irqMgrMsgQ;
|
||||
OSMesgQueue irqMgrMsgQueue;
|
||||
OSMesg irqMgrMsgBuf[60];
|
||||
u32 systemHeapStart;
|
||||
u32 fb;
|
||||
|
|
@ -69,37 +69,38 @@ void Main(void* arg) {
|
|||
|
||||
R_ENABLE_ARENA_DBG = 0;
|
||||
|
||||
osCreateMesgQueue(&sSiIntMsgQ, sSiIntMsgBuf, ARRAY_COUNT(sSiIntMsgBuf));
|
||||
osSetEventMesg(OS_EVENT_SI, &sSiIntMsgQ, NULL);
|
||||
osCreateMesgQueue(&sSerialEventQueue, sSerialMsgBuf, ARRAY_COUNT(sSerialMsgBuf));
|
||||
osSetEventMesg(OS_EVENT_SI, &sSerialEventQueue, NULL);
|
||||
|
||||
Main_LogSystemHeap();
|
||||
|
||||
osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
|
||||
osCreateMesgQueue(&irqMgrMsgQueue, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
|
||||
StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, STACK_TOP(sIrqMgrStack), 0, 0x100, "irqmgr");
|
||||
IrqMgr_Init(&gIrqMgr, STACK_TOP(sIrqMgrStack), Z_PRIORITY_IRQMGR, 1);
|
||||
IrqMgr_Init(&gIrqMgr, STACK_TOP(sIrqMgrStack), THREAD_PRI_IRQMGR, 1);
|
||||
|
||||
osSyncPrintf("タスクスケジューラの初期化\n"); // "Initialize the task scheduler"
|
||||
StackCheck_Init(&sSchedStackInfo, sSchedStack, STACK_TOP(sSchedStack), 0, 0x100, "sched");
|
||||
Sched_Init(&gSchedContext, STACK_TOP(sSchedStack), Z_PRIORITY_SCHED, D_80013960, 1, &gIrqMgr);
|
||||
Sched_Init(&gSchedContext, STACK_TOP(sSchedStack), THREAD_PRI_SCHED, D_80013960, 1, &gIrqMgr);
|
||||
|
||||
IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
|
||||
IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQueue);
|
||||
|
||||
StackCheck_Init(&sAudioStackInfo, sAudioStack, STACK_TOP(sAudioStack), 0, 0x100, "audio");
|
||||
AudioMgr_Init(&gAudioMgr, STACK_TOP(sAudioStack), Z_PRIORITY_AUDIOMGR, 10, &gSchedContext, &gIrqMgr);
|
||||
AudioMgr_Init(&gAudioMgr, STACK_TOP(sAudioStack), THREAD_PRI_AUDIOMGR, THREAD_ID_AUDIOMGR, &gSchedContext,
|
||||
&gIrqMgr);
|
||||
|
||||
StackCheck_Init(&sPadMgrStackInfo, sPadMgrStack, STACK_TOP(sPadMgrStack), 0, 0x100, "padmgr");
|
||||
PadMgr_Init(&gPadMgr, &sSiIntMsgQ, &gIrqMgr, 7, Z_PRIORITY_PADMGR, STACK_TOP(sPadMgrStack));
|
||||
PadMgr_Init(&gPadMgr, &sSerialEventQueue, &gIrqMgr, THREAD_ID_PADMGR, THREAD_PRI_PADMGR, STACK_TOP(sPadMgrStack));
|
||||
|
||||
AudioMgr_Unlock(&gAudioMgr);
|
||||
|
||||
StackCheck_Init(&sGraphStackInfo, sGraphStack, STACK_TOP(sGraphStack), 0, 0x100, "graph");
|
||||
osCreateThread(&sGraphThread, 4, Graph_ThreadEntry, arg, STACK_TOP(sGraphStack), Z_PRIORITY_GRAPH);
|
||||
osCreateThread(&sGraphThread, THREAD_ID_GRAPH, Graph_ThreadEntry, arg, STACK_TOP(sGraphStack), THREAD_PRI_GRAPH);
|
||||
osStartThread(&sGraphThread);
|
||||
osSetThreadPri(NULL, 15);
|
||||
osSetThreadPri(NULL, THREAD_PRI_MAIN);
|
||||
|
||||
while (true) {
|
||||
msg = NULL;
|
||||
osRecvMesg(&irqMgrMsgQ, (OSMesg)&msg, OS_MESG_BLOCK);
|
||||
osRecvMesg(&irqMgrMsgQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
if (msg == NULL) {
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,47 +4,47 @@
|
|||
s32 D_8012D280 = 1;
|
||||
|
||||
OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
|
||||
OSMesgQueue* ctrlrQ = NULL;
|
||||
OSMesgQueue* serialEventQueue = NULL;
|
||||
|
||||
if (D_8012D280 > 2) {
|
||||
// "serialMsgQ Waiting for lock"
|
||||
osSyncPrintf("%2d %d serialMsgQロック待ち %08x %08x %08x\n", osGetThreadId(NULL),
|
||||
padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, &ctrlrQ);
|
||||
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, &serialEventQueue);
|
||||
}
|
||||
|
||||
osRecvMesg(&padMgr->serialMsgQ, (OSMesg)&ctrlrQ, OS_MESG_BLOCK);
|
||||
osRecvMesg(&padMgr->serialLockQueue, (OSMesg*)&serialEventQueue, OS_MESG_BLOCK);
|
||||
|
||||
if (D_8012D280 > 2) {
|
||||
// "serialMsgQ Locked"
|
||||
osSyncPrintf("%2d %d serialMsgQをロックしました %08x\n", osGetThreadId(NULL),
|
||||
padMgr->serialMsgQ.validCount, ctrlrQ);
|
||||
MQ_GET_COUNT(&padMgr->serialLockQueue), serialEventQueue);
|
||||
}
|
||||
|
||||
return ctrlrQ;
|
||||
return serialEventQueue;
|
||||
}
|
||||
|
||||
void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* ctrlrQ) {
|
||||
void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue) {
|
||||
if (D_8012D280 > 2) {
|
||||
// "serialMsgQ Unlock"
|
||||
osSyncPrintf("%2d %d serialMsgQロック解除します %08x %08x %08x\n", osGetThreadId(NULL),
|
||||
padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, ctrlrQ);
|
||||
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
|
||||
}
|
||||
|
||||
osSendMesg(&padMgr->serialMsgQ, ctrlrQ, OS_MESG_BLOCK);
|
||||
osSendMesg(&padMgr->serialLockQueue, (OSMesg)serialEventQueue, OS_MESG_BLOCK);
|
||||
|
||||
if (D_8012D280 > 2) {
|
||||
// "serialMsgQ Unlocked"
|
||||
osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL),
|
||||
padMgr->serialMsgQ.validCount, padMgr, &padMgr->serialMsgQ, ctrlrQ);
|
||||
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
|
||||
}
|
||||
}
|
||||
|
||||
void PadMgr_LockPadData(PadMgr* padMgr) {
|
||||
osRecvMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void PadMgr_UnlockPadData(PadMgr* padMgr) {
|
||||
osSendMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK);
|
||||
osSendMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void PadMgr_RumbleControl(PadMgr* padMgr) {
|
||||
|
|
@ -52,7 +52,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
|
|||
static u32 frame;
|
||||
s32 temp = 1;
|
||||
s32 triedRumbleComm;
|
||||
OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
s32 var4;
|
||||
s32 i;
|
||||
|
||||
|
|
@ -133,7 +133,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
|
|||
i = frame % 4;
|
||||
|
||||
if (padMgr->ctrlrIsConnected[i] && (padMgr->padStatus[i].status & 1) && (padMgr->pakType[i] != 1)) {
|
||||
var4 = osMotorInit(ctrlrQ, &padMgr->pfs[i], i);
|
||||
var4 = osMotorInit(serialEventQueue, &padMgr->pfs[i], i);
|
||||
|
||||
if (var4 == 0) {
|
||||
padMgr->pakType[i] = 1;
|
||||
|
|
@ -156,15 +156,15 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
|
|||
}
|
||||
|
||||
frame++;
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, ctrlrQ);
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
|
||||
}
|
||||
|
||||
void PadMgr_RumbleStop(PadMgr* padMgr) {
|
||||
s32 i;
|
||||
OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (osMotorInit(ctrlrQ, &padMgr->pfs[i], i) == 0) {
|
||||
if (osMotorInit(serialEventQueue, &padMgr->pfs[i], i) == 0) {
|
||||
if ((gFaultMgr.msgId == 0) && (padMgr->rumbleOnFrames != 0)) {
|
||||
osSyncPrintf(VT_FGCOL(YELLOW));
|
||||
// "Stop vibration pack"
|
||||
|
|
@ -176,7 +176,7 @@ void PadMgr_RumbleStop(PadMgr* padMgr) {
|
|||
}
|
||||
}
|
||||
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, ctrlrQ);
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
|
||||
}
|
||||
|
||||
void PadMgr_RumbleReset(PadMgr* padMgr) {
|
||||
|
|
@ -265,23 +265,23 @@ void PadMgr_ProcessInputs(PadMgr* padMgr) {
|
|||
|
||||
void PadMgr_HandleRetraceMsg(PadMgr* padMgr) {
|
||||
s32 i;
|
||||
OSMesgQueue* queue = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
|
||||
u32 mask;
|
||||
|
||||
osContStartReadData(queue);
|
||||
osContStartReadData(serialEventQueue);
|
||||
if (padMgr->retraceCallback) {
|
||||
padMgr->retraceCallback(padMgr, padMgr->retraceCallbackValue);
|
||||
}
|
||||
osRecvMesg(queue, NULL, OS_MESG_BLOCK);
|
||||
osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
|
||||
osContGetReadData(padMgr->pads);
|
||||
if (padMgr->preNMIShutdown) {
|
||||
bzero(padMgr->pads, sizeof(padMgr->pads));
|
||||
}
|
||||
PadMgr_ProcessInputs(padMgr);
|
||||
osContStartQuery(queue);
|
||||
osRecvMesg(queue, NULL, OS_MESG_BLOCK);
|
||||
osContStartQuery(serialEventQueue);
|
||||
osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
|
||||
osContGetQuery(padMgr->padStatus);
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, queue);
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
|
||||
|
||||
mask = 0;
|
||||
for (i = 0; i < 4; i++) {
|
||||
|
|
@ -351,22 +351,22 @@ void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 mode) {
|
|||
}
|
||||
|
||||
void PadMgr_ThreadEntry(PadMgr* padMgr) {
|
||||
s16* mesg = NULL;
|
||||
s16* msg = NULL;
|
||||
s32 exit;
|
||||
|
||||
osSyncPrintf("コントローラスレッド実行開始\n"); // "Controller thread execution start"
|
||||
|
||||
exit = false;
|
||||
while (!exit) {
|
||||
if ((D_8012D280 > 2) && (padMgr->interruptMsgQ.validCount == 0)) {
|
||||
if ((D_8012D280 > 2) && MQ_IS_EMPTY(&padMgr->interruptQueue)) {
|
||||
// "Waiting for controller thread event"
|
||||
osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
|
||||
}
|
||||
|
||||
osRecvMesg(&padMgr->interruptMsgQ, (OSMesg)&mesg, OS_MESG_BLOCK);
|
||||
LogUtils_CheckNullPointer("msg", mesg, "../padmgr.c", 563);
|
||||
osRecvMesg(&padMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
|
||||
LogUtils_CheckNullPointer("msg", msg, "../padmgr.c", 563);
|
||||
|
||||
switch (*mesg) {
|
||||
switch (*msg) {
|
||||
case OS_SC_RETRACE_MSG:
|
||||
if (D_8012D280 > 2) {
|
||||
osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
|
||||
|
|
@ -393,19 +393,19 @@ void PadMgr_ThreadEntry(PadMgr* padMgr) {
|
|||
osSyncPrintf("コントローラスレッド実行終了\n"); // "Controller thread execution end"
|
||||
}
|
||||
|
||||
void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* siIntMsgQ, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack) {
|
||||
void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* serialEventQueue, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack) {
|
||||
osSyncPrintf("パッドマネージャ作成 padmgr_Create()\n"); // "Pad Manager creation"
|
||||
|
||||
bzero(padMgr, sizeof(PadMgr));
|
||||
padMgr->irqMgr = irqMgr;
|
||||
|
||||
osCreateMesgQueue(&padMgr->interruptMsgQ, padMgr->interruptMsgBuf, 4);
|
||||
IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptMsgQ);
|
||||
osCreateMesgQueue(&padMgr->serialMsgQ, padMgr->serialMsgBuf, 1);
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, siIntMsgQ);
|
||||
osCreateMesgQueue(&padMgr->lockMsgQ, padMgr->lockMsgBuf, 1);
|
||||
osCreateMesgQueue(&padMgr->interruptQueue, padMgr->interruptMsgBuf, ARRAY_COUNT(padMgr->interruptMsgBuf));
|
||||
IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptQueue);
|
||||
osCreateMesgQueue(&padMgr->serialLockQueue, padMgr->serialLockMsgBuf, ARRAY_COUNT(padMgr->serialLockMsgBuf));
|
||||
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
|
||||
osCreateMesgQueue(&padMgr->lockQueue, padMgr->lockMsgBuf, ARRAY_COUNT(padMgr->lockMsgBuf));
|
||||
PadMgr_UnlockPadData(padMgr);
|
||||
PadSetup_Init(siIntMsgQ, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
|
||||
PadSetup_Init(serialEventQueue, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
|
||||
|
||||
padMgr->nControllers = 4;
|
||||
osContSetCh(padMgr->nControllers);
|
||||
|
|
|
|||
|
|
@ -82,12 +82,12 @@ void Sched_HandleReset(SchedContext* sc) {
|
|||
if (sc->curRSPTask != NULL) {
|
||||
LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
|
||||
OS_CYCLES_TO_USEC(now - sRSPGFXStartTime), "../sched.c", 427);
|
||||
osSendMesg(&sc->interruptQ, RSP_DONE_MSG, OS_MESG_NOBLOCK);
|
||||
osSendMesg(&sc->interruptQueue, (OSMesg)RSP_DONE_MSG, OS_MESG_NOBLOCK);
|
||||
}
|
||||
if (sc->curRDPTask != NULL) {
|
||||
LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
|
||||
OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431);
|
||||
osSendMesg(&sc->interruptQ, RDP_DONE_MSG, OS_MESG_NOBLOCK);
|
||||
osSendMesg(&sc->interruptQueue, (OSMesg)RDP_DONE_MSG, OS_MESG_NOBLOCK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -231,8 +231,8 @@ void func_800C8BC4(SchedContext* sc, OSScTask* task) {
|
|||
|
||||
u32 Sched_IsComplete(SchedContext* sc, OSScTask* task) {
|
||||
if (!(task->state & (OS_SC_DP | OS_SC_SP))) {
|
||||
if (task->msgQ != NULL) {
|
||||
osSendMesg(task->msgQ, task->msg, OS_MESG_BLOCK);
|
||||
if (task->msgQueue != NULL) {
|
||||
osSendMesg(task->msgQueue, task->msg, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
if (task->flags & OS_SC_SWAPBUFFER) {
|
||||
|
|
@ -292,10 +292,10 @@ void Sched_HandleEntry(SchedContext* sc) {
|
|||
OSScTask* nextRSP = NULL;
|
||||
OSScTask* nextRDP = NULL;
|
||||
s32 state;
|
||||
OSMesg msg = NULL;
|
||||
OSScTask* task = NULL;
|
||||
|
||||
while (osRecvMesg(&sc->cmdQ, &msg, OS_MESG_NOBLOCK) != -1) {
|
||||
Sched_QueueTask(sc, msg);
|
||||
while (osRecvMesg(&sc->cmdQueue, (OSMesg*)&task, OS_MESG_NOBLOCK) != -1) {
|
||||
Sched_QueueTask(sc, task);
|
||||
}
|
||||
|
||||
if (sc->doAudio != 0 && sc->curRSPTask != NULL) {
|
||||
|
|
@ -425,22 +425,20 @@ void Sched_SendEntryMsg(SchedContext* sc) {
|
|||
osSyncPrintf("osScKickEntryMsg\n");
|
||||
}
|
||||
|
||||
osSendMesg(&sc->interruptQ, ENTRY_MSG, OS_MESG_BLOCK);
|
||||
osSendMesg(&sc->interruptQueue, (OSMesg)ENTRY_MSG, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void Sched_ThreadEntry(void* arg) {
|
||||
void* msg;
|
||||
OSMesg msg = NULL;
|
||||
SchedContext* sc = (SchedContext*)arg;
|
||||
|
||||
msg = NULL;
|
||||
|
||||
while (true) {
|
||||
if (sLogScheduler) {
|
||||
// "%08d: standby"
|
||||
osSyncPrintf("%08d:待機中\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
|
||||
}
|
||||
|
||||
osRecvMesg(&sc->interruptQ, &msg, OS_MESG_BLOCK);
|
||||
osRecvMesg(&sc->interruptQueue, &msg, OS_MESG_BLOCK);
|
||||
|
||||
switch ((s32)msg) {
|
||||
case ENTRY_MSG:
|
||||
|
|
@ -461,8 +459,6 @@ void Sched_ThreadEntry(void* arg) {
|
|||
}
|
||||
Sched_HandleRDPDone(sc);
|
||||
continue;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
switch (((OSScMsg*)msg)->type) {
|
||||
case 1:
|
||||
|
|
@ -481,11 +477,11 @@ void Sched_ThreadEntry(void* arg) {
|
|||
void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr) {
|
||||
bzero(sc, sizeof(SchedContext));
|
||||
sc->unk_24C = 1;
|
||||
osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8);
|
||||
osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, 8);
|
||||
osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, RSP_DONE_MSG);
|
||||
osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, RDP_DONE_MSG);
|
||||
IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQ);
|
||||
osCreateThread(&sc->thread, 5, Sched_ThreadEntry, sc, stack, priority);
|
||||
osCreateMesgQueue(&sc->interruptQueue, sc->interruptMsgBuf, ARRAY_COUNT(sc->interruptMsgBuf));
|
||||
osCreateMesgQueue(&sc->cmdQueue, sc->cmdMsgBuf, ARRAY_COUNT(sc->cmdMsgBuf));
|
||||
osSetEventMesg(OS_EVENT_SP, &sc->interruptQueue, RSP_DONE_MSG);
|
||||
osSetEventMesg(OS_EVENT_DP, &sc->interruptQueue, RDP_DONE_MSG);
|
||||
IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQueue);
|
||||
osCreateThread(&sc->thread, THREAD_ID_SCHED, Sched_ThreadEntry, sc, stack, priority);
|
||||
osStartThread(&sc->thread);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,12 +55,12 @@ void Jpeg_ScheduleDecoderTask(JpegContext* ctx) {
|
|||
|
||||
ctx->scTask.next = NULL;
|
||||
ctx->scTask.flags = OS_SC_NEEDS_RSP;
|
||||
ctx->scTask.msgQ = &ctx->mq;
|
||||
ctx->scTask.msgQueue = &ctx->mq;
|
||||
ctx->scTask.msg = NULL;
|
||||
ctx->scTask.framebuffer = NULL;
|
||||
ctx->scTask.list.t = sJpegTask;
|
||||
|
||||
osSendMesg(&gSchedContext.cmdQ, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
|
||||
osSendMesg(&gSchedContext.cmdQueue, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
|
||||
Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
|
||||
osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -731,11 +731,11 @@ void Environment_UpdateSkybox(u8 skyboxId, EnvironmentContext* envCtx, SkyboxCon
|
|||
}
|
||||
|
||||
if ((envCtx->skyboxDmaState == SKYBOX_DMA_FILE1_START) || (envCtx->skyboxDmaState == SKYBOX_DMA_FILE2_START)) {
|
||||
if (osRecvMesg(&envCtx->loadQueue, 0, OS_MESG_NOBLOCK) == 0) {
|
||||
if (osRecvMesg(&envCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
|
||||
envCtx->skyboxDmaState++;
|
||||
}
|
||||
} else if (envCtx->skyboxDmaState >= SKYBOX_DMA_FILE1_DONE) {
|
||||
if (osRecvMesg(&envCtx->loadQueue, 0, OS_MESG_NOBLOCK) == 0) {
|
||||
if (osRecvMesg(&envCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
|
||||
envCtx->skyboxDmaState = SKYBOX_DMA_INACTIVE;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
#include "global.h"
|
||||
|
||||
void MsgEvent_SendNullTask(void) {
|
||||
s32 pad[4];
|
||||
OSScTask task;
|
||||
OSMesgQueue queue;
|
||||
OSMesg msg;
|
||||
|
|
@ -9,12 +8,12 @@ void MsgEvent_SendNullTask(void) {
|
|||
|
||||
task.next = NULL;
|
||||
task.flags = OS_SC_RCP_MASK;
|
||||
task.msgQ = &queue;
|
||||
task.msgQueue = &queue;
|
||||
task.msg = NULL;
|
||||
task.framebuffer = NULL;
|
||||
task.list.t.type = M_NULTASK;
|
||||
osCreateMesgQueue(task.msgQ, &msg, 1);
|
||||
osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK);
|
||||
osCreateMesgQueue(task.msgQueue, &msg, 1);
|
||||
osSendMesg(&gSchedContext.cmdQueue, (OSMesg)&task, OS_MESG_BLOCK);
|
||||
Sched_SendEntryMsg(&gSchedContext);
|
||||
osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1307,7 +1307,7 @@ void Player_DrawGetItemImpl(GlobalContext* globalCtx, Player* this, Vec3f* refPo
|
|||
}
|
||||
|
||||
void Player_DrawGetItem(GlobalContext* globalCtx, Player* this) {
|
||||
if (!this->giObjectLoading || !osRecvMesg(&this->giObjectLoadQueue, NULL, OS_MESG_NOBLOCK)) {
|
||||
if (!this->giObjectLoading || osRecvMesg(&this->giObjectLoadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
|
||||
this->giObjectLoading = false;
|
||||
Player_DrawGetItemImpl(globalCtx, this, &sGetItemRefPos, ABS(this->unk_862));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -569,7 +569,7 @@ s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum) {
|
|||
|
||||
s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx) {
|
||||
if (roomCtx->status == 1) {
|
||||
if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK)) {
|
||||
if (osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
|
||||
roomCtx->status = 0;
|
||||
roomCtx->curRoom.segment = roomCtx->unk_34;
|
||||
gSegments[3] = VIRTUAL_TO_PHYSICAL(roomCtx->unk_34);
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ void Object_UpdateBank(ObjectContext* objectCtx) {
|
|||
osSyncPrintf("OBJECT EXCHANGE BANK-%2d SIZE %8.3fK SEG=%08x\n", i, size / 1024.0f, status->segment);
|
||||
DmaMgr_SendRequest2(&status->dmaRequest, status->segment, objectFile->vromStart, size, 0,
|
||||
&status->loadQueue, NULL, "../z_scene.c", 266);
|
||||
} else if (!osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK)) {
|
||||
} else if (osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK) == 0) {
|
||||
status->id = -status->id;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
typedef struct {
|
||||
/* 0x00 */ OSPiHandle piHandle;
|
||||
/* 0x74 */ OSIoMesg ioMesg;
|
||||
/* 0x8C */ OSMesgQueue mesgQ;
|
||||
/* 0x8C */ OSMesgQueue msgQueue;
|
||||
} SsSramContext; // size = 0xA4
|
||||
|
||||
SsSramContext sSsSramContext = { 0 };
|
||||
|
|
@ -32,20 +32,20 @@ void SsSram_Init(u32 addr, u8 handleType, u8 handleDomain, u8 handleLatency, u8
|
|||
__osRestoreInt(prevInt);
|
||||
|
||||
sSsSramContext.ioMesg.hdr.pri = OS_MESG_PRI_NORMAL;
|
||||
sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.mesgQ;
|
||||
sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.msgQueue;
|
||||
sSsSramContext.ioMesg.devAddr = addr;
|
||||
}
|
||||
}
|
||||
|
||||
void SsSram_Dma(void* dramAddr, size_t size, s32 direction) {
|
||||
OSMesg mesg;
|
||||
OSMesg msg;
|
||||
|
||||
osCreateMesgQueue(&sSsSramContext.mesgQ, &mesg, 1);
|
||||
osCreateMesgQueue(&sSsSramContext.msgQueue, &msg, 1);
|
||||
sSsSramContext.ioMesg.dramAddr = dramAddr;
|
||||
sSsSramContext.ioMesg.size = size;
|
||||
osWritebackDCache(dramAddr, size);
|
||||
osEPiStartDma(&sSsSramContext.piHandle, &sSsSramContext.ioMesg, direction);
|
||||
osRecvMesg(&sSsSramContext.mesgQ, &mesg, OS_MESG_BLOCK);
|
||||
osRecvMesg(&sSsSramContext.msgQueue, &msg, OS_MESG_BLOCK);
|
||||
osInvalDCache(dramAddr, size);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue