mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-03 22:44:30 +00:00
Code Issues Projects Releases Wiki Activity

Message Queues, Threads, and surroundings cleanup (#1178)

Browse source 
* 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 2022-04-09 01:20:23 +01:00 • committed by GitHub
parent 9984c267d9
commit 7068ad3703
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
45 changed files with 311 additions and 296 deletions
Download patch file Download diff file Expand all files Collapse all files

8
format.sh
View file

@ -21,13 +21,13 @@ export -f add_final_newline
shopt -s globstar shopt -s globstar
if [ $(command -v clang-format) ] if [ $(command -v clang-format-${FORMAT_VER}) ]
then then
CLANG_FORMAT="clang-format" CLANG_FORMAT="clang-format-${FORMAT_VER}"
else else
if [ $(command -v clang-format-${FORMAT_VER}) ] if [ $(command -v clang-format) ]
then then
CLANG_FORMAT="clang-format-${FORMAT_VER}" CLANG_FORMAT="clang-format"
else else
echo "Neither clang-format nor clang-format-${FORMAT_VER} found. Exiting." echo "Neither clang-format nor clang-format-${FORMAT_VER} found. Exiting."
exit 1 exit 1

10
include/functions.h
View file

@ -31,7 +31,7 @@ void DmaMgr_Error(DmaRequest* req, const char* file, const char* errorName, cons
const char* DmaMgr_GetFileNameImpl(u32 vrom); const char* DmaMgr_GetFileNameImpl(u32 vrom);
const char* DmaMgr_GetFileName(u32 vrom); const char* DmaMgr_GetFileName(u32 vrom);
void DmaMgr_ProcessMsg(DmaRequest* req); void DmaMgr_ProcessMsg(DmaRequest* req);
void DmaMgr_ThreadEntry(void* arg0); void DmaMgr_ThreadEntry(void* arg);
s32 DmaMgr_SendRequestImpl(DmaRequest* req, u32 ram, u32 vrom, u32 size, u32 unk, OSMesgQueue* queue, OSMesg msg); s32 DmaMgr_SendRequestImpl(DmaRequest* req, u32 ram, u32 vrom, u32 size, u32 unk, OSMesgQueue* queue, OSMesg msg);
s32 DmaMgr_SendRequest0(u32 ram, u32 vrom, u32 size); s32 DmaMgr_SendRequest0(u32 ram, u32 vrom, u32 size);
void DmaMgr_Init(void); void DmaMgr_Init(void);
@ -79,7 +79,7 @@ s32 sprintf(char* dst, const char* fmt, ...);
void __osPiCreateAccessQueue(void); void __osPiCreateAccessQueue(void);
void __osPiGetAccess(void); void __osPiGetAccess(void);
void __osPiRelAccess(void); void __osPiRelAccess(void);
s32 osSendMesg(OSMesgQueue* mq, OSMesg mesg, s32 flag); s32 osSendMesg(OSMesgQueue* mq, OSMesg msg, s32 flag);
void osStopThread(OSThread* thread); void osStopThread(OSThread* thread);
void osViExtendVStart(u32 arg0); void osViExtendVStart(u32 arg0);
s32 osRecvMesg(OSMesgQueue* mq, OSMesg* msg, s32 flag); s32 osRecvMesg(OSMesgQueue* mq, OSMesg* msg, s32 flag);
@ -101,7 +101,7 @@ void __osSetSR(u32);
u32 __osGetSR(void); u32 __osGetSR(void);
void osWritebackDCache(void* vaddr, s32 nbytes); void osWritebackDCache(void* vaddr, s32 nbytes);
void* osViGetNextFramebuffer(void); void* osViGetNextFramebuffer(void);
void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgCnt); void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQueue, OSMesg* cmdBuf, s32 cmdMsgCnt);
void __osDevMgrMain(void* arg); void __osDevMgrMain(void* arg);
s32 __osPiRawStartDma(s32 dir, u32 cartAddr, void* dramAddr, size_t size); s32 __osPiRawStartDma(s32 dir, u32 cartAddr, void* dramAddr, size_t size);
u32 osVirtualToPhysical(void* vaddr); u32 osVirtualToPhysical(void* vaddr);
@ -122,7 +122,7 @@ void osInvalICache(void* vaddr, s32 nbytes);
void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count); void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count);
void osInvalDCache(void* vaddr, s32 nbytes); void osInvalDCache(void* vaddr, s32 nbytes);
s32 __osSiDeviceBusy(void); s32 __osSiDeviceBusy(void);
s32 osJamMesg(OSMesgQueue* mq, OSMesg mesg, s32 flag); s32 osJamMesg(OSMesgQueue* mq, OSMesg msg, s32 flag);
void osSetThreadPri(OSThread* thread, OSPri pri); void osSetThreadPri(OSThread* thread, OSPri pri);
OSPri osGetThreadPri(OSThread* thread); OSPri osGetThreadPri(OSThread* thread);
s32 __osEPiRawReadIo(OSPiHandle* handle, u32 devAddr, u32* data); s32 __osEPiRawReadIo(OSPiHandle* handle, u32 devAddr, u32* data);
@ -1646,7 +1646,7 @@ void PadMgr_HandlePreNMI(PadMgr* padmgr);
// This function must remain commented out, because it is called incorrectly in // This function must remain commented out, because it is called incorrectly in
// fault.c (actual bug in game), and the compiler notices and won't compile it // fault.c (actual bug in game), and the compiler notices and won't compile it
// void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode); // void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode);
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);
void Sched_SwapFrameBuffer(CfbInfo* cfbInfo); void Sched_SwapFrameBuffer(CfbInfo* cfbInfo);
void func_800C84E4(SchedContext* sc, CfbInfo* cfbInfo); void func_800C84E4(SchedContext* sc, CfbInfo* cfbInfo);
void Sched_HandleReset(SchedContext* sc); void Sched_HandleReset(SchedContext* sc);

2
include/irqmgr.h
View file

@ -40,7 +40,7 @@ typedef struct {
void IrqMgr_Init(IrqMgr* irqMgr, void* stack, OSPri pri, u8 retraceCount); void IrqMgr_Init(IrqMgr* irqMgr, void* stack, OSPri pri, u8 retraceCount);
void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQ); void IrqMgr_AddClient(IrqMgr* irqMgr, IrqMgrClient* client, OSMesgQueue* msgQueue);
void IrqMgr_RemoveClient(IrqMgr* irqMgr, IrqMgrClient* client); void IrqMgr_RemoveClient(IrqMgr* irqMgr, IrqMgrClient* client);
#endif #endif

8
include/padmgr.h
View file

@ -12,12 +12,12 @@ typedef struct {
typedef struct PadMgr { typedef struct PadMgr {
/* 0x0000 */ OSContStatus padStatus[4]; /* 0x0000 */ OSContStatus padStatus[4];
/* 0x0010 */ OSMesg serialMsgBuf[1]; /* 0x0010 */ OSMesg serialLockMsgBuf[1];
/* 0x0014 */ OSMesg lockMsgBuf[1]; /* 0x0014 */ OSMesg lockMsgBuf[1];
/* 0x0018 */ OSMesg interruptMsgBuf[4]; /* 0x0018 */ OSMesg interruptMsgBuf[4];
/* 0x0028 */ OSMesgQueue serialMsgQ; /* 0x0028 */ OSMesgQueue serialLockQueue;
/* 0x0040 */ OSMesgQueue lockMsgQ; /* 0x0040 */ OSMesgQueue lockQueue;
/* 0x0058 */ OSMesgQueue interruptMsgQ; /* 0x0058 */ OSMesgQueue interruptQueue;
/* 0x0070 */ IrqMgrClient irqClient; /* 0x0070 */ IrqMgrClient irqClient;
/* 0x0078 */ IrqMgr* irqMgr; /* 0x0078 */ IrqMgr* irqMgr;
/* 0x0080 */ OSThread thread; /* 0x0080 */ OSThread thread;

1
include/ultra64/controller.h
View file

@ -3,7 +3,6 @@
#include "message.h" #include "message.h"
#define SIAccessQueueSize 2
#define BLOCKSIZE 32 #define BLOCKSIZE 32
#define MAXCONTROLLERS 4 #define MAXCONTROLLERS 4
#define PFS_ONE_PAGE 8 #define PFS_ONE_PAGE 8

6
include/ultra64/thread.h
View file

@ -30,6 +30,7 @@ typedef union {
/* 0x00 */ f32 f_odd; /* 0x00 */ f32 f_odd;
/* 0x04 */ f32 f_even; /* 0x04 */ f32 f_even;
} f; } f;
f64 d;
} __OSfp; // size = 0x08 } __OSfp; // size = 0x08
typedef struct { typedef struct {
@ -63,4 +64,9 @@ typedef struct OSThread {
/* 0x20 */ __OSThreadContext context; /* 0x20 */ __OSThreadContext context;
} OSThread; // size = 0x1B0 } OSThread; // size = 0x1B0
typedef struct {
OSThread* next;
OSPri priority;
} __OSThreadTail; // size = 0x8
#endif #endif

2
include/ultra64/vi.h
View file

@ -64,7 +64,7 @@ typedef struct {
/* 0x08 */ OSViMode* modep; /* 0x08 */ OSViMode* modep;
/* 0x0C */ u32 features; /* 0x0C */ u32 features;
/* 0x10 */ OSMesgQueue* mq; /* 0x10 */ OSMesgQueue* mq;
/* 0x14 */ OSMesg* msg; /* 0x14 */ OSMesg msg;
/* 0x18 */ __OSViScale x; /* 0x18 */ __OSViScale x;
/* 0x24 */ __OSViScale y; /* 0x24 */ __OSViScale y;
} OSViContext; // size = 0x30 } OSViContext; // size = 0x30

4
include/variables.h
View file

@ -28,7 +28,7 @@ extern OSViMode osViModePalLan1;
extern s32 osViClock; extern s32 osViClock;
extern u32 __osShutdown; extern u32 __osShutdown;
extern OSHWIntr __OSGlobalIntMask; extern OSHWIntr __OSGlobalIntMask;
extern OSThread* __osThreadTail[]; extern __OSThreadTail __osThreadTail;
extern OSThread* __osRunQueue; extern OSThread* __osRunQueue;
extern OSThread* __osActiveQueue; extern OSThread* __osActiveQueue;
extern OSThread* __osRunningThread; extern OSThread* __osRunningThread;
@ -45,7 +45,7 @@ extern u32 __additional_scanline;
extern u8 gBuildTeam[]; extern u8 gBuildTeam[];
extern u8 gBuildDate[]; extern u8 gBuildDate[];
extern u8 gBuildMakeOption[]; extern u8 gBuildMakeOption[];
extern OSMesgQueue gPiMgrCmdQ; extern OSMesgQueue gPiMgrCmdQueue;
extern OSViMode gViConfigMode; extern OSViMode gViConfigMode;
extern u8 D_80013960; extern u8 D_80013960;
extern OSMesgQueue __osPiAccessQueue; extern OSMesgQueue __osPiAccessQueue;

67
include/z64.h
View file

@ -42,13 +42,28 @@
#define REGION_JP 2 #define REGION_JP 2
#define REGION_EU 3 #define REGION_EU 3
#define Z_PRIORITY_MAIN 10 #define THREAD_PRI_IDLE_INIT 10
#define Z_PRIORITY_GRAPH 11 #define THREAD_PRI_MAIN_INIT 10
#define Z_PRIORITY_AUDIOMGR 12 #define THREAD_PRI_DMAMGR_LOW 10 // Used when decompressing files
#define Z_PRIORITY_PADMGR 14 #define THREAD_PRI_GRAPH 11
#define Z_PRIORITY_SCHED 15 #define THREAD_PRI_AUDIOMGR 12
#define Z_PRIORITY_DMAMGR 16 #define THREAD_PRI_PADMGR 14
#define Z_PRIORITY_IRQMGR 17 #define THREAD_PRI_MAIN 15
#define THREAD_PRI_SCHED 15
#define THREAD_PRI_DMAMGR 16
#define THREAD_PRI_IRQMGR 17
#define THREAD_PRI_FAULT_CLIENT (OS_PRIORITY_APPMAX - 1)
#define THREAD_PRI_FAULT OS_PRIORITY_APPMAX
#define THREAD_ID_IDLE 1
#define THREAD_ID_FAULT 2
#define THREAD_ID_MAIN 3
#define THREAD_ID_GRAPH 4
#define THREAD_ID_SCHED 5
#define THREAD_ID_PADMGR 7
#define THREAD_ID_AUDIOMGR 10
#define THREAD_ID_DMAMGR 18
#define THREAD_ID_IRQMGR 19
#define STACK(stack, size) \ #define STACK(stack, size) \
u64 stack[ALIGN8(size) / sizeof(u64)] u64 stack[ALIGN8(size) / sizeof(u64)]
@ -118,9 +133,10 @@ typedef struct OSScTask {
/* 0x08 */ u32 flags; /* 0x08 */ u32 flags;
/* 0x0C */ CfbInfo* framebuffer; /* 0x0C */ CfbInfo* framebuffer;
/* 0x10 */ OSTask list; /* 0x10 */ OSTask list;
/* 0x50 */ OSMesgQueue* msgQ; /* 0x50 */ OSMesgQueue* msgQueue;
/* 0x54 */ OSMesg msg; /* 0x54 */ OSMesg msg;
} OSScTask; /* 0x58 */ char unk_58[0x10];
} OSScTask; // size = 0x68
typedef struct GraphicsContext { typedef struct GraphicsContext {
/* 0x0000 */ Gfx* polyOpaBuffer; // Pointer to "Zelda 0" /* 0x0000 */ Gfx* polyOpaBuffer; // Pointer to "Zelda 0"
@ -130,11 +146,11 @@ typedef struct GraphicsContext {
/* 0x0014 */ u32 unk_014; /* 0x0014 */ u32 unk_014;
/* 0x0018 */ char unk_018[0x20]; /* 0x0018 */ char unk_018[0x20];
/* 0x0038 */ OSMesg msgBuff[0x08]; /* 0x0038 */ OSMesg msgBuff[0x08];
/* 0x0058 */ OSMesgQueue* schedMsgQ; /* 0x0058 */ OSMesgQueue* schedMsgQueue;
/* 0x005C */ OSMesgQueue queue; /* 0x005C */ OSMesgQueue queue;
/* 0x0074 */ char unk_074[0x04]; /* 0x0074 */ char unk_074[0x04];
/* 0x0078 */ OSScTask task; // size of OSScTask might be wrong /* 0x0078 */ OSScTask task;
/* 0x00D0 */ char unk_0D0[0xE0]; /* 0x00E0 */ char unk_0E0[0xD0];
/* 0x01B0 */ Gfx* workBuffer; /* 0x01B0 */ Gfx* workBuffer;
/* 0x01B4 */ TwoHeadGfxArena work; /* 0x01B4 */ TwoHeadGfxArena work;
/* 0x01C4 */ char unk_01C4[0xC0]; /* 0x01C4 */ char unk_01C4[0xC0];
@ -1576,9 +1592,9 @@ typedef struct {
} FrameBufferSwap; } FrameBufferSwap;
typedef struct { typedef struct {
/* 0x0000 */ OSMesgQueue interruptQ; /* 0x0000 */ OSMesgQueue interruptQueue;
/* 0x0018 */ OSMesg intBuf[8]; /* 0x0018 */ OSMesg interruptMsgBuf[8];
/* 0x0038 */ OSMesgQueue cmdQ; /* 0x0038 */ OSMesgQueue cmdQueue;
/* 0x0050 */ OSMesg cmdMsgBuf[8]; /* 0x0050 */ OSMesg cmdMsgBuf[8];
/* 0x0070 */ OSThread thread; /* 0x0070 */ OSThread thread;
/* 0x0220 */ OSScTask* audioListHead; /* 0x0220 */ OSScTask* audioListHead;
@ -1607,18 +1623,14 @@ typedef struct {
/* 0x0000 */ IrqMgr* irqMgr; /* 0x0000 */ IrqMgr* irqMgr;
/* 0x0004 */ SchedContext* sched; /* 0x0004 */ SchedContext* sched;
/* 0x0008 */ OSScTask audioTask; /* 0x0008 */ OSScTask audioTask;
/* 0x0060 */ char unk_60[0x10];
/* 0x0070 */ AudioTask* rspTask; /* 0x0070 */ AudioTask* rspTask;
/* 0x0074 */ OSMesgQueue unk_74; /* 0x0074 */ OSMesgQueue interruptQueue;
/* 0x008C */ OSMesg unk_8C; /* 0x008C */ OSMesg interruptMsgBuf[8];
/* 0x0090 */ OSMesgQueue unk_90; /* 0x00AC */ OSMesgQueue taskQueue;
/* 0x00A8 */ OSMesg unk_A8; /* 0x00C4 */ OSMesg taskMsgBuf[1];
/* 0x00AC */ OSMesgQueue unk_AC; /* 0x00C8 */ OSMesgQueue lockQueue;
/* 0x00C4 */ OSMesg unk_C4; /* 0x00E0 */ OSMesg lockMsgBuf[1];
/* 0x00C8 */ OSMesgQueue unk_C8; /* 0x00E8 */ OSThread thread;
/* 0x00E0 */ OSMesg unk_E0;
/* 0x00E4 */ char unk_E4[0x04];
/* 0x00E8 */ OSThread unk_E8;
} AudioMgr; // size = 0x298 } AudioMgr; // size = 0x298
struct ArenaNode; struct ArenaNode;
@ -1626,7 +1638,7 @@ struct ArenaNode;
typedef struct Arena { typedef struct Arena {
/* 0x00 */ struct ArenaNode* head; /* 0x00 */ struct ArenaNode* head;
/* 0x04 */ void* start; /* 0x04 */ void* start;
/* 0x08 */ OSMesgQueue lock; /* 0x08 */ OSMesgQueue lockQueue;
/* 0x20 */ u8 unk_20; /* 0x20 */ u8 unk_20;
/* 0x21 */ u8 isInit; /* 0x21 */ u8 isInit;
/* 0x22 */ u8 flag; /* 0x22 */ u8 flag;
@ -1793,7 +1805,6 @@ typedef struct {
/* 0x28 */ u32 mode; // 0 if Y V0 is 1 and 2 if Y V0 is 2 /* 0x28 */ u32 mode; // 0 if Y V0 is 1 and 2 if Y V0 is 2
/* 0x2C */ char unk_2C[4]; /* 0x2C */ char unk_2C[4];
/* 0x30 */ OSScTask scTask; /* 0x30 */ OSScTask scTask;
/* 0x88 */ char unk_88[0x10];
/* 0x98 */ OSMesgQueue mq; /* 0x98 */ OSMesgQueue mq;
/* 0xB0 */ OSMesg msg; /* 0xB0 */ OSMesg msg;
/* 0xB4 */ JpegWork* workBuf; /* 0xB4 */ JpegWork* workBuf;

18
include/z64audio.h
View file

@ -716,7 +716,7 @@ typedef struct {
/* 0x18 */ s32 bytesRemaining; /* 0x18 */ s32 bytesRemaining;
/* 0x1C */ s8* isDone; /* 0x1C */ s8* isDone;
/* 0x20 */ SoundFontSample sample; /* 0x20 */ SoundFontSample sample;
/* 0x30 */ OSMesgQueue msgqueue; /* 0x30 */ OSMesgQueue msgQueue;
/* 0x48 */ OSMesg msg; /* 0x48 */ OSMesg msg;
/* 0x4C */ OSIoMesg ioMesg; /* 0x4C */ OSIoMesg ioMesg;
} AudioSlowLoad; // size = 0x64 } AudioSlowLoad; // size = 0x64
@ -741,7 +741,7 @@ typedef struct {
typedef struct { typedef struct {
/* 0x00 */ OSTask task; /* 0x00 */ OSTask task;
/* 0x40 */ OSMesgQueue* taskQueue; /* 0x40 */ OSMesgQueue* msgQueue;
/* 0x44 */ void* unk_44; // probably a message that gets unused. /* 0x44 */ void* unk_44; // probably a message that gets unused.
/* 0x48 */ char unk_48[0x8]; /* 0x48 */ char unk_48[0x8];
} AudioTask; // size = 0x50 } AudioTask; // size = 0x50
@ -779,12 +779,12 @@ typedef struct {
/* 0x1E18 */ OSPiHandle* cartHandle; /* 0x1E18 */ OSPiHandle* cartHandle;
/* 0x1E1C */ OSPiHandle* driveHandle; /* 0x1E1C */ OSPiHandle* driveHandle;
/* 0x1E20 */ OSMesgQueue externalLoadQueue; /* 0x1E20 */ OSMesgQueue externalLoadQueue;
/* 0x1E38 */ OSMesg externalLoadMesgBuf[0x10]; /* 0x1E38 */ OSMesg externalLoadMsgBuf[16];
/* 0x1E78 */ OSMesgQueue preloadSampleQueue; /* 0x1E78 */ OSMesgQueue preloadSampleQueue;
/* 0x1E90 */ OSMesg preloadSampleMesgBuf[0x10]; /* 0x1E90 */ OSMesg preloadSampleMsgBuf[16];
/* 0x1ED0 */ OSMesgQueue currAudioFrameDmaQueue; /* 0x1ED0 */ OSMesgQueue currAudioFrameDmaQueue;
/* 0x1EE8 */ OSMesg currAudioFrameDmaMesgBuf[0x40]; /* 0x1EE8 */ OSMesg currAudioFrameDmaMsgBuf[64];
/* 0x1FE8 */ OSIoMesg currAudioFrameDmaIoMesgBuf[0x40]; /* 0x1FE8 */ OSIoMesg currAudioFrameDmaIoMsgBuf[64];
/* 0x25E8 */ OSMesgQueue syncDmaQueue; /* 0x25E8 */ OSMesgQueue syncDmaQueue;
/* 0x2600 */ OSMesg syncDmaMesg; /* 0x2600 */ OSMesg syncDmaMesg;
/* 0x2604 */ OSIoMesg syncDmaIoMesg; /* 0x2604 */ OSIoMesg syncDmaIoMesg;
@ -876,9 +876,9 @@ typedef struct {
/* 0x5BF0 */ OSMesgQueue taskStartQueue; /* 0x5BF0 */ OSMesgQueue taskStartQueue;
/* 0x5C08 */ OSMesgQueue cmdProcQueue; /* 0x5C08 */ OSMesgQueue cmdProcQueue;
/* 0x5C20 */ OSMesgQueue audioResetQueue; /* 0x5C20 */ OSMesgQueue audioResetQueue;
/* 0x5C38 */ OSMesg taskStartMsgs[1]; /* 0x5C38 */ OSMesg taskStartMsgBuf[1];
/* 0x5C3C */ OSMesg audioResetMesgs[1]; /* 0x5C3C */ OSMesg audioResetMsgBuf[1];
/* 0x5C40 */ OSMesg cmdProcMsgs[4]; /* 0x5C40 */ OSMesg cmdProcMsgBuf[4];
/* 0x5C50 */ AudioCmd cmdBuf[0x100]; /* 0x5C50 */ AudioCmd cmdBuf[0x100];
} AudioContext; // size = 0x6450 } AudioContext; // size = 0x6450

3
src/boot/boot_main.c
View file

@ -24,6 +24,7 @@ void bootproc(void) {
Locale_Init(); Locale_Init();
StackCheck_Init(&sIdleThreadInfo, sIdleThreadStack, STACK_TOP(sIdleThreadStack), 0, 256, "idle"); StackCheck_Init(&sIdleThreadInfo, sIdleThreadStack, STACK_TOP(sIdleThreadStack), 0, 256, "idle");
osCreateThread(&sIdleThread, 1, Idle_ThreadEntry, NULL, STACK_TOP(sIdleThreadStack), Z_PRIORITY_MAIN); osCreateThread(&sIdleThread, THREAD_ID_IDLE, Idle_ThreadEntry, NULL, STACK_TOP(sIdleThreadStack),
THREAD_PRI_IDLE_INIT);
osStartThread(&sIdleThread); osStartThread(&sIdleThread);
} }

6
src/boot/idle.c
View file

@ -5,7 +5,7 @@ OSThread gMainThread;
STACK(sMainStack, 0x900); STACK(sMainStack, 0x900);
StackEntry sMainStackInfo; StackEntry sMainStackInfo;
OSMesg sPiMgrCmdBuff[50]; OSMesg sPiMgrCmdBuff[50];
OSMesgQueue gPiMgrCmdQ; OSMesgQueue gPiMgrCmdQueue;
OSViMode gViConfigMode; OSViMode gViConfigMode;
u8 D_80013960; u8 D_80013960;
@ -78,9 +78,9 @@ void Idle_ThreadEntry(void* arg) {
ViConfig_UpdateVi(1); ViConfig_UpdateVi(1);
osViBlack(1); osViBlack(1);
osViSwapBuffer(0x803DA80); //! @bug Invalid vram address (probably intended to be 0x803DA800) osViSwapBuffer(0x803DA80); //! @bug Invalid vram address (probably intended to be 0x803DA800)
osCreatePiManager(OS_PRIORITY_PIMGR, &gPiMgrCmdQ, sPiMgrCmdBuff, 50); osCreatePiManager(OS_PRIORITY_PIMGR, &gPiMgrCmdQueue, sPiMgrCmdBuff, ARRAY_COUNT(sPiMgrCmdBuff));
StackCheck_Init(&sMainStackInfo, sMainStack, STACK_TOP(sMainStack), 0, 0x400, "main"); StackCheck_Init(&sMainStackInfo, sMainStack, STACK_TOP(sMainStack), 0, 0x400, "main");
osCreateThread(&gMainThread, 3, Main_ThreadEntry, arg, STACK_TOP(sMainStack), Z_PRIORITY_MAIN); osCreateThread(&gMainThread, THREAD_ID_MAIN, Main_ThreadEntry, arg, STACK_TOP(sMainStack), THREAD_PRI_MAIN_INIT);
osStartThread(&gMainThread); osStartThread(&gMainThread);
osSetThreadPri(NULL, OS_PRIORITY_IDLE); osSetThreadPri(NULL, OS_PRIORITY_IDLE);

48
src/boot/z_std_dma.c
View file

@ -3,7 +3,7 @@
StackEntry sDmaMgrStackInfo; StackEntry sDmaMgrStackInfo;
OSMesgQueue sDmaMgrMsgQueue; OSMesgQueue sDmaMgrMsgQueue;
OSMesg sDmaMgrMsgs[0x20]; OSMesg sDmaMgrMsgBuf[32];
OSThread sDmaMgrThread; OSThread sDmaMgrThread;
STACK(sDmaMgrStack, 0x500); STACK(sDmaMgrStack, 0x500);
const char* sDmaMgrCurFileName; const char* sDmaMgrCurFileName;
@ -70,7 +70,7 @@ s32 DmaMgr_DmaRomToRam(u32 rom, u32 ram, u32 size) {
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld ノーマルＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), ioMsg.dramAddr, osSyncPrintf("%10lld ノーマルＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), ioMsg.dramAddr,
ioMsg.devAddr, ioMsg.size, gPiMgrCmdQ.validCount); ioMsg.devAddr, ioMsg.size, MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
ret = osEPiStartDma(gCartHandle, &ioMsg, OS_READ); ret = osEPiStartDma(gCartHandle, &ioMsg, OS_READ);
@ -79,12 +79,14 @@ s32 DmaMgr_DmaRomToRam(u32 rom, u32 ram, u32 size) {
} }
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld ノーマルＤＭＡ START (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), gPiMgrCmdQ.validCount); osSyncPrintf("%10lld ノーマルＤＭＡ START (%d)\n", OS_CYCLES_TO_USEC(osGetTime()),
MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
osRecvMesg(&queue, NULL, OS_MESG_BLOCK); osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld ノーマルＤＭＡ END (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), gPiMgrCmdQ.validCount); osSyncPrintf("%10lld ノーマルＤＭＡ END (%d)\n", OS_CYCLES_TO_USEC(osGetTime()),
MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
size -= buffSize; size -= buffSize;
@ -102,7 +104,7 @@ s32 DmaMgr_DmaRomToRam(u32 rom, u32 ram, u32 size) {
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld ノーマルＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), ioMsg.dramAddr, osSyncPrintf("%10lld ノーマルＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), ioMsg.dramAddr,
ioMsg.devAddr, ioMsg.size, gPiMgrCmdQ.validCount); ioMsg.devAddr, ioMsg.size, MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
ret = osEPiStartDma(gCartHandle, &ioMsg, OS_READ); ret = osEPiStartDma(gCartHandle, &ioMsg, OS_READ);
@ -112,7 +114,7 @@ s32 DmaMgr_DmaRomToRam(u32 rom, u32 ram, u32 size) {
osRecvMesg(&queue, NULL, OS_MESG_BLOCK); osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld ノーマルＤＭＡ END (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), gPiMgrCmdQ.validCount); osSyncPrintf("%10lld ノーマルＤＭＡ END (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
end: end:
@ -131,7 +133,7 @@ s32 DmaMgr_DmaHandler(OSPiHandle* pihandle, OSIoMesg* mb, s32 direction) {
if (gDmaMgrVerbose == 10) { if (gDmaMgrVerbose == 10) {
osSyncPrintf("%10lld サウンドＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), mb->dramAddr, osSyncPrintf("%10lld サウンドＤＭＡ %08x %08x %08x (%d)\n", OS_CYCLES_TO_USEC(osGetTime()), mb->dramAddr,
mb->devAddr, mb->size, gPiMgrCmdQ.validCount); mb->devAddr, mb->size, MQ_GET_COUNT(&gPiMgrCmdQueue));
} }
ret = osEPiStartDma(pihandle, mb, direction); ret = osEPiStartDma(pihandle, mb, direction);
@ -160,7 +162,6 @@ void DmaMgr_DmaFromDriveRom(u32 ram, u32 rom, u32 size) {
osEPiStartDma(handle, &ioMsg, OS_READ); osEPiStartDma(handle, &ioMsg, OS_READ);
osRecvMesg(&queue, NULL, OS_MESG_BLOCK); osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
return;
} }
void DmaMgr_Error(DmaRequest* req, const char* file, const char* errorName, const char* errorDesc) { void DmaMgr_Error(DmaRequest* req, const char* file, const char* errorName, const char* errorDesc) {
@ -280,9 +281,9 @@ void DmaMgr_ProcessMsg(DmaRequest* req) {
"圧縮されたセグメントの一部だけをＤＭＡ転送することはできません"); "圧縮されたセグメントの一部だけをＤＭＡ転送することはできません");
} }
osSetThreadPri(NULL, Z_PRIORITY_MAIN); osSetThreadPri(NULL, THREAD_PRI_DMAMGR_LOW);
Yaz0_Decompress(romStart, ram, romSize); Yaz0_Decompress(romStart, ram, romSize);
osSetThreadPri(NULL, Z_PRIORITY_DMAMGR); osSetThreadPri(NULL, THREAD_PRI_DMAMGR);
found = true; found = true;
if (0) { if (0) {
@ -308,7 +309,7 @@ void DmaMgr_ProcessMsg(DmaRequest* req) {
} }
} }
void DmaMgr_ThreadEntry(void* arg0) { void DmaMgr_ThreadEntry(void* arg) {
OSMesg msg; OSMesg msg;
DmaRequest* req; DmaRequest* req;
@ -351,19 +352,17 @@ s32 DmaMgr_SendRequestImpl(DmaRequest* req, u32 ram, u32 vrom, u32 size, u32 unk
req->notifyQueue = queue; req->notifyQueue = queue;
req->notifyMsg = msg; req->notifyMsg = msg;
if (1) { if (1 && (sDmaMgrQueueFullLogged == 0) && MQ_IS_FULL(&sDmaMgrMsgQueue)) {
if ((sDmaMgrQueueFullLogged == 0) && (sDmaMgrMsgQueue.validCount >= sDmaMgrMsgQueue.msgCount)) { sDmaMgrQueueFullLogged++;
sDmaMgrQueueFullLogged++; osSyncPrintf("%c", BEL);
osSyncPrintf("%c", BEL); osSyncPrintf(VT_FGCOL(RED));
osSyncPrintf(VT_FGCOL(RED)); osSyncPrintf("dmaEntryMsgQが一杯です。キューサイズの再検討をおすすめします。");
osSyncPrintf("dmaEntryMsgQが一杯です。キューサイズの再検討をおすすめします。"); LOG_NUM("(sizeof(dmaEntryMsgBufs) / sizeof(dmaEntryMsgBufs[0]))", ARRAY_COUNT(sDmaMgrMsgBuf), "../z_std_dma.c",
LOG_NUM("(sizeof(dmaEntryMsgBufs) / sizeof(dmaEntryMsgBufs[0]))", ARRAY_COUNT(sDmaMgrMsgs), 952);
"../z_std_dma.c", 952); osSyncPrintf(VT_RST);
osSyncPrintf(VT_RST);
}
} }
osSendMesg(&sDmaMgrMsgQueue, req, OS_MESG_BLOCK); osSendMesg(&sDmaMgrMsgQueue, (OSMesg)req, OS_MESG_BLOCK);
return 0; return 0;
} }
@ -421,9 +420,10 @@ void DmaMgr_Init(void) {
Fault_AddHungupAndCrash("../z_std_dma.c", 1055); Fault_AddHungupAndCrash("../z_std_dma.c", 1055);
} }
osCreateMesgQueue(&sDmaMgrMsgQueue, sDmaMgrMsgs, ARRAY_COUNT(sDmaMgrMsgs)); osCreateMesgQueue(&sDmaMgrMsgQueue, sDmaMgrMsgBuf, ARRAY_COUNT(sDmaMgrMsgBuf));
StackCheck_Init(&sDmaMgrStackInfo, sDmaMgrStack, STACK_TOP(sDmaMgrStack), 0, 0x100, "dmamgr"); StackCheck_Init(&sDmaMgrStackInfo, sDmaMgrStack, STACK_TOP(sDmaMgrStack), 0, 0x100, "dmamgr");
osCreateThread(&sDmaMgrThread, 0x12, DmaMgr_ThreadEntry, 0, STACK_TOP(sDmaMgrStack), Z_PRIORITY_DMAMGR); osCreateThread(&sDmaMgrThread, THREAD_ID_DMAMGR, DmaMgr_ThreadEntry, NULL, STACK_TOP(sDmaMgrStack),
THREAD_PRI_DMAMGR);
osStartThread(&sDmaMgrThread); osStartThread(&sDmaMgrThread);
} }

6
src/code/__osMalloc.c
View file

@ -56,15 +56,15 @@ void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena*
} }
void ArenaImpl_LockInit(Arena* arena) { void ArenaImpl_LockInit(Arena* arena) {
osCreateMesgQueue(&arena->lock, &sArenaLockMsg, 1); osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
} }
void ArenaImpl_Lock(Arena* arena) { void ArenaImpl_Lock(Arena* arena) {
osSendMesg(&arena->lock, NULL, OS_MESG_BLOCK); osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
} }
void ArenaImpl_Unlock(Arena* arena) { void ArenaImpl_Unlock(Arena* arena) {
osRecvMesg(&arena->lock, NULL, OS_MESG_BLOCK); osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
} }
ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) { ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {

39
src/code/audioMgr.c
View file

@ -1,11 +1,10 @@
#include "global.h" #include "global.h"
void func_800C3C80(AudioMgr* audioMgr) { void func_800C3C80(AudioMgr* audioMgr) {
AudioTask* task; AudioTask* task = audioMgr->rspTask;
task = audioMgr->rspTask; if (audioMgr->rspTask->msgQueue != NULL) {
if (audioMgr->rspTask->taskQueue != NULL) { osSendMesg(task->msgQueue, NULL, OS_MESG_BLOCK);
osSendMesg(task->taskQueue, NULL, OS_MESG_BLOCK);
} }
} }
@ -17,14 +16,14 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
} }
if (audioMgr->rspTask != NULL) { if (audioMgr->rspTask != NULL) {
audioMgr->audioTask.next = NULL; audioMgr->audioTask.next = NULL;
audioMgr->audioTask.flags = 2; audioMgr->audioTask.flags = OS_SC_NEEDS_RSP;
audioMgr->audioTask.framebuffer = NULL; audioMgr->audioTask.framebuffer = NULL;
audioMgr->audioTask.list = audioMgr->rspTask->task; audioMgr->audioTask.list = audioMgr->rspTask->task;
audioMgr->audioTask.msgQ = &audioMgr->unk_AC; audioMgr->audioTask.msgQueue = &audioMgr->taskQueue;
audioMgr->audioTask.msg = NULL; 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); Sched_SendEntryMsg(audioMgr->sched);
} }
@ -37,7 +36,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
D_8016A558 += osGetTime() - D_8016A550; D_8016A558 += osGetTime() - D_8016A550;
D_8016A550 = 0; D_8016A550 = 0;
if (audioMgr->rspTask != NULL) { if (audioMgr->rspTask != NULL) {
osRecvMesg(&audioMgr->unk_AC, NULL, OS_MESG_BLOCK); osRecvMesg(&audioMgr->taskQueue, NULL, OS_MESG_BLOCK);
func_800C3C80(audioMgr); func_800C3C80(audioMgr);
} }
audioMgr->rspTask = rspTask; audioMgr->rspTask = rspTask;
@ -58,16 +57,16 @@ void AudioMgr_ThreadEntry(void* arg0) {
Audio_Init(); Audio_Init();
AudioLoad_SetDmaHandler(DmaMgr_DmaHandler); AudioLoad_SetDmaHandler(DmaMgr_DmaHandler);
Audio_InitSound(); Audio_InitSound();
osSendMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK); osSendMesg(&audioMgr->lockQueue, NULL, OS_MESG_BLOCK);
IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->unk_74); IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->interruptQueue);
while (true) { while (true) {
osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK); osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
switch (*msg) { switch (*msg) {
case OS_SC_RETRACE_MSG: case OS_SC_RETRACE_MSG:
AudioMgr_HandleRetrace(audioMgr); AudioMgr_HandleRetrace(audioMgr);
while (audioMgr->unk_74.validCount != 0) { while (!MQ_IS_EMPTY(&audioMgr->interruptQueue)) {
osRecvMesg(&audioMgr->unk_74, (OSMesg*)&msg, OS_MESG_BLOCK); osRecvMesg(&audioMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
switch (*msg) { switch (*msg) {
case OS_SC_RETRACE_MSG: case OS_SC_RETRACE_MSG:
break; break;
@ -85,7 +84,7 @@ void AudioMgr_ThreadEntry(void* arg0) {
} }
void AudioMgr_Unlock(AudioMgr* audioMgr) { 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) { 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->irqMgr = irqMgr;
audioMgr->rspTask = NULL; audioMgr->rspTask = NULL;
osCreateMesgQueue(&audioMgr->unk_AC, &audioMgr->unk_C4, 1); osCreateMesgQueue(&audioMgr->taskQueue, audioMgr->taskMsgBuf, ARRAY_COUNT(audioMgr->taskMsgBuf));
osCreateMesgQueue(&audioMgr->unk_74, &audioMgr->unk_8C, 8); osCreateMesgQueue(&audioMgr->interruptQueue, audioMgr->interruptMsgBuf, ARRAY_COUNT(audioMgr->interruptMsgBuf));
osCreateMesgQueue(&audioMgr->unk_C8, &audioMgr->unk_E0, 1); 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); osCreateThread(&audioMgr->thread, id, AudioMgr_ThreadEntry, audioMgr, stack, pri);
osStartThread(&audioMgr->unk_E8); osStartThread(&audioMgr->thread);
} }

31
src/code/audio_load.c
View file

@ -58,7 +58,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus);
void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3); void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3);
OSMesgQueue sScriptLoadQueue; OSMesgQueue sScriptLoadQueue;
OSMesg sScriptLoadMesgBuf[0x10]; OSMesg sScriptLoadMsgBuf[16];
s8* sScriptLoadDonePointers[0x10]; s8* sScriptLoadDonePointers[0x10];
s32 sAudioLoadPad1[2]; // file padding s32 sAudioLoadPad1[2]; // file padding
@ -193,7 +193,7 @@ void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef,
dma->ttl = 3; dma->ttl = 3;
dma->devAddr = dmaDevAddr; dma->devAddr = dmaDevAddr;
dma->sizeUnused = transfer; 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, OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.currAudioFrameDmaQueue, medium,
"SUPERDMA"); "SUPERDMA");
*dmaIndexRef = dmaIndex; *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) { void AudioLoad_AsyncLoad(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
if (AudioLoad_AsyncLoadInner(tableType, id, nChunks, retData, retQueue) == NULL) { 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); ret = AudioLoad_SearchCaches(tableType, realId);
if (ret != NULL) { if (ret != NULL) {
status = 2; 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 { } else {
sp50 = AudioLoad_GetLoadTable(tableType); sp50 = AudioLoad_GetLoadTable(tableType);
size = sp50->entries[realId].size; 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[0].task.t.data_size = 0;
gAudioContext.rspTask[1].task.t.data_size = 0; gAudioContext.rspTask[1].task.t.data_size = 0;
osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1); osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1);
osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBuf, 0x40); osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMsgBuf,
osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMesgBuf, ARRAY_COUNT(gAudioContext.currAudioFrameDmaMsgBuf));
ARRAY_COUNT(gAudioContext.externalLoadMesgBuf)); osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMsgBuf,
osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMesgBuf, ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
ARRAY_COUNT(gAudioContext.externalLoadMesgBuf)); osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMsgBuf,
ARRAY_COUNT(gAudioContext.externalLoadMsgBuf));
gAudioContext.curAudioFrameDmaCount = 0; gAudioContext.curAudioFrameDmaCount = 0;
gAudioContext.sampleDmaCount = 0; gAudioContext.sampleDmaCount = 0;
gAudioContext.cartHandle = osCartRomInit(); gAudioContext.cartHandle = osCartRomInit();
@ -1161,7 +1162,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
AudioHeap_AllocPoolInit(&gAudioContext.permanentPool, temp_v0_3, D_8014A6C4.permanentPoolSize); AudioHeap_AllocPoolInit(&gAudioContext.permanentPool, temp_v0_3, D_8014A6C4.permanentPoolSize);
gAudioContextInitalized = true; gAudioContextInitalized = true;
osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK); osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
} }
void AudioLoad_InitSlowLoads(void) { void AudioLoad_InitSlowLoads(void) {
@ -1273,7 +1274,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
switch (gAudioContext.slowLoads[i].status) { switch (gAudioContext.slowLoads[i].status) {
case LOAD_STATUS_LOADING: case LOAD_STATUS_LOADING:
if (slowLoad->medium != MEDIUM_UNK) { if (slowLoad->medium != MEDIUM_UNK) {
osRecvMesg(&slowLoad->msgqueue, NULL, OS_MESG_BLOCK); osRecvMesg(&slowLoad->msgQueue, NULL, OS_MESG_BLOCK);
} }
if (resetStatus != 0) { if (resetStatus != 0) {
@ -1313,9 +1314,9 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) { void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) {
Audio_InvalDCache(slowLoad->curRamAddr, 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, 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) { void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3) {
@ -1376,7 +1377,7 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, u32 devAdd
return NULL; return NULL;
} }
osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK); osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg)asyncLoad, OS_MESG_NOBLOCK);
asyncLoad->unkMediumParam = unkMediumParam; asyncLoad->unkMediumParam = unkMediumParam;
return asyncLoad; return asyncLoad;
} }
@ -2017,5 +2018,5 @@ void AudioLoad_ProcessScriptLoads(void) {
} }
void AudioLoad_InitScriptLoads(void) { void AudioLoad_InitScriptLoads(void) {
osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMesgBuf, ARRAY_COUNT(sScriptLoadMesgBuf)); osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMsgBuf, ARRAY_COUNT(sScriptLoadMsgBuf));
} }

24
src/code/code_800E4FE0.c
View file

@ -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.rspTaskIdx ^= 1;
gAudioContext.curAIBufIdx++; gAudioContext.curAIBufIdx++;
gAudioContext.curAIBufIdx %= 3; gAudioContext.curAIBufIdx %= 3;
@ -99,7 +99,7 @@ AudioTask* func_800E5000(void) {
} }
} }
sp48 = gAudioContext.currAudioFrameDmaQueue.validCount; sp48 = MQ_GET_COUNT(&gAudioContext.currAudioFrameDmaQueue);
if (sp48 != 0) { if (sp48 != 0) {
for (i = 0; i < sp48; i++) { for (i = 0; i < sp48; i++) {
osRecvMesg(&gAudioContext.currAudioFrameDmaQueue, NULL, OS_MESG_NOBLOCK); osRecvMesg(&gAudioContext.currAudioFrameDmaQueue, NULL, OS_MESG_NOBLOCK);
@ -114,7 +114,8 @@ AudioTask* func_800E5000(void) {
if (gAudioContext.resetStatus != 0) { if (gAudioContext.resetStatus != 0) {
if (AudioHeap_ResetStep() == 0) { if (AudioHeap_ResetStep() == 0) {
if (gAudioContext.resetStatus == 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; sWaitingAudioTask = NULL;
@ -171,7 +172,7 @@ AudioTask* func_800E5000(void) {
gWaveSamples[8] = (s16*)(((u8*)func_800E4FE0) + (gAudioContext.audioRandom & 0xFFF0)); gWaveSamples[8] = (s16*)(((u8*)func_800E4FE0) + (gAudioContext.audioRandom & 0xFFF0));
index = gAudioContext.rspTaskIdx; index = gAudioContext.rspTaskIdx;
gAudioContext.currTask->taskQueue = NULL; gAudioContext.currTask->msgQueue = NULL;
gAudioContext.currTask->unk_44 = NULL; gAudioContext.currTask->unk_44 = NULL;
task = &gAudioContext.currTask->task.t; task = &gAudioContext.currTask->task.t;
@ -348,11 +349,12 @@ void Audio_InitMesgQueuesInternal(void) {
gAudioContext.taskStartQueueP = &gAudioContext.taskStartQueue; gAudioContext.taskStartQueueP = &gAudioContext.taskStartQueue;
gAudioContext.cmdProcQueueP = &gAudioContext.cmdProcQueue; gAudioContext.cmdProcQueueP = &gAudioContext.cmdProcQueue;
gAudioContext.audioResetQueueP = &gAudioContext.audioResetQueue; gAudioContext.audioResetQueueP = &gAudioContext.audioResetQueue;
osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgs, osCreateMesgQueue(gAudioContext.taskStartQueueP, gAudioContext.taskStartMsgBuf,
ARRAY_COUNT(gAudioContext.taskStartMsgs)); ARRAY_COUNT(gAudioContext.taskStartMsgBuf));
osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgs, ARRAY_COUNT(gAudioContext.cmdProcMsgs)); osCreateMesgQueue(gAudioContext.cmdProcQueueP, gAudioContext.cmdProcMsgBuf,
osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMesgs, ARRAY_COUNT(gAudioContext.cmdProcMsgBuf));
ARRAY_COUNT(gAudioContext.audioResetMesgs)); osCreateMesgQueue(gAudioContext.audioResetQueueP, gAudioContext.audioResetMsgBuf,
ARRAY_COUNT(gAudioContext.audioResetMsgBuf));
} }
void Audio_QueueCmd(u32 opArgs, void** data) { void Audio_QueueCmd(u32 opArgs, void** data) {
@ -398,7 +400,7 @@ s32 Audio_ScheduleProcessCmds(void) {
ret = ret =
osSendMesg(gAudioContext.cmdProcQueueP, 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) { if (ret != -1) {
gAudioContext.cmdRdPos = gAudioContext.cmdWrPos; gAudioContext.cmdRdPos = gAudioContext.cmdWrPos;
ret = 0; ret = 0;
@ -514,7 +516,7 @@ s32 func_800E5EDC(void) {
void func_800E5F34(void) { void func_800E5F34(void) {
// macro? // macro?
// clang-format off // 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 // clang-format on
} }

7
src/code/fault.c
View file

@ -128,8 +128,8 @@ void Fault_ClientRunTask(FaultClientTask* task) {
// Run the fault client callback on a separate thread // Run the fault client callback on a separate thread
thread = alloca(sizeof(OSThread)); thread = alloca(sizeof(OSThread));
osCreateThread(thread, 2, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp, osCreateThread(thread, THREAD_ID_FAULT, Fault_ClientProcessThread, task, sFaultInstance->clientThreadSp,
OS_PRIORITY_APPMAX - 1); THREAD_PRI_FAULT_CLIENT);
osStartThread(thread); osStartThread(thread);
} else { } else {
// Run the fault client callback on this thread // Run the fault client callback on this thread
@ -1265,7 +1265,8 @@ void Fault_Init(void) {
gFaultMgr.faultHandlerEnabled = true; gFaultMgr.faultHandlerEnabled = true;
osCreateMesgQueue(&sFaultInstance->queue, &sFaultInstance->msg, 1); osCreateMesgQueue(&sFaultInstance->queue, &sFaultInstance->msg, 1);
StackCheck_Init(&sFaultThreadInfo, &sFaultStack, STACK_TOP(sFaultStack), 0, 0x100, "fault"); 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); osStartThread(&sFaultInstance->thread);
} }

6
src/code/graph.c
View file

@ -227,7 +227,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
gfxCtx->fbIdx--; gfxCtx->fbIdx--;
} }
scTask->msgQ = &gfxCtx->queue; scTask->msgQueue = &gfxCtx->queue;
scTask->msg = NULL; scTask->msg = NULL;
cfb = &sGraphCfbInfos[sGraphCfbInfoIdx++]; cfb = &sGraphCfbInfos[sGraphCfbInfoIdx++];
@ -245,9 +245,9 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
if (1) {} 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); Sched_SendEntryMsg(&gSchedContext);
} }

10
src/code/irqmgr.c
View file

@ -50,18 +50,18 @@ u32 sIrqMgrRetraceCount = 0;
* *
* @param irqMgr the IrqMgr instance to register with. * @param irqMgr the IrqMgr instance to register with.
* @param client client to register. * @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; OSIntMask prevInt;
LogUtils_CheckNullPointer("this", irqMgr, "../irqmgr.c", 96); LogUtils_CheckNullPointer("this", irqMgr, "../irqmgr.c", 96);
LogUtils_CheckNullPointer("c", client, "../irqmgr.c", 97); 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); prevInt = osSetIntMask(OS_IM_NONE);
client->queue = msgQ; client->queue = msgQueue;
client->prev = irqMgr->clients; client->prev = irqMgr->clients;
irqMgr->clients = client; 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)); osCreateMesgQueue(&irqMgr->queue, irqMgr->msgBuf, ARRAY_COUNT(irqMgr->msgBuf));
osSetEventMesg(OS_EVENT_PRENMI, &irqMgr->queue, (OSMesg)IRQ_PRENMI_MSG); osSetEventMesg(OS_EVENT_PRENMI, &irqMgr->queue, (OSMesg)IRQ_PRENMI_MSG);
osViSetEvent(&irqMgr->queue, (OSMesg)IRQ_RETRACE_MSG, retraceCount); 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); osStartThread(&irqMgr->thread);
} }

29
src/code/main.c
View file

@ -22,8 +22,8 @@ StackEntry sAudioStackInfo;
StackEntry sPadMgrStackInfo; StackEntry sPadMgrStackInfo;
StackEntry sIrqMgrStackInfo; StackEntry sIrqMgrStackInfo;
AudioMgr gAudioMgr; AudioMgr gAudioMgr;
OSMesgQueue sSiIntMsgQ; OSMesgQueue sSerialEventQueue;
OSMesg sSiIntMsgBuf[1]; OSMesg sSerialMsgBuf[1];
void Main_LogSystemHeap(void) { void Main_LogSystemHeap(void) {
osSyncPrintf(VT_FGCOL(GREEN)); osSyncPrintf(VT_FGCOL(GREEN));
@ -35,7 +35,7 @@ void Main_LogSystemHeap(void) {
void Main(void* arg) { void Main(void* arg) {
IrqMgrClient irqClient; IrqMgrClient irqClient;
OSMesgQueue irqMgrMsgQ; OSMesgQueue irqMgrMsgQueue;
OSMesg irqMgrMsgBuf[60]; OSMesg irqMgrMsgBuf[60];
u32 systemHeapStart; u32 systemHeapStart;
u32 fb; u32 fb;
@ -69,37 +69,38 @@ void Main(void* arg) {
R_ENABLE_ARENA_DBG = 0; R_ENABLE_ARENA_DBG = 0;
osCreateMesgQueue(&sSiIntMsgQ, sSiIntMsgBuf, ARRAY_COUNT(sSiIntMsgBuf)); osCreateMesgQueue(&sSerialEventQueue, sSerialMsgBuf, ARRAY_COUNT(sSerialMsgBuf));
osSetEventMesg(OS_EVENT_SI, &sSiIntMsgQ, NULL); osSetEventMesg(OS_EVENT_SI, &sSerialEventQueue, NULL);
Main_LogSystemHeap(); Main_LogSystemHeap();
osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf)); osCreateMesgQueue(&irqMgrMsgQueue, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, STACK_TOP(sIrqMgrStack), 0, 0x100, "irqmgr"); 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" osSyncPrintf("タスクスケジューラの初期化\n"); // "Initialize the task scheduler"
StackCheck_Init(&sSchedStackInfo, sSchedStack, STACK_TOP(sSchedStack), 0, 0x100, "sched"); 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"); 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"); 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); AudioMgr_Unlock(&gAudioMgr);
StackCheck_Init(&sGraphStackInfo, sGraphStack, STACK_TOP(sGraphStack), 0, 0x100, "graph"); 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); osStartThread(&sGraphThread);
osSetThreadPri(NULL, 15); osSetThreadPri(NULL, THREAD_PRI_MAIN);
while (true) { while (true) {
msg = NULL; msg = NULL;
osRecvMesg(&irqMgrMsgQ, (OSMesg)&msg, OS_MESG_BLOCK); osRecvMesg(&irqMgrMsgQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
if (msg == NULL) { if (msg == NULL) {
break; break;
} }

70
src/code/padmgr.c
View file

@ -4,47 +4,47 @@
s32 D_8012D280 = 1; s32 D_8012D280 = 1;
OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) { OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
OSMesgQueue* ctrlrQ = NULL; OSMesgQueue* serialEventQueue = NULL;
if (D_8012D280 > 2) { if (D_8012D280 > 2) {
// "serialMsgQ Waiting for lock" // "serialMsgQ Waiting for lock"
osSyncPrintf("%2d %d serialMsgQロック待ち %08x %08x %08x\n", osGetThreadId(NULL), 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) { if (D_8012D280 > 2) {
// "serialMsgQ Locked" // "serialMsgQ Locked"
osSyncPrintf("%2d %d serialMsgQをロックしました %08x\n", osGetThreadId(NULL), 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) { if (D_8012D280 > 2) {
// "serialMsgQ Unlock" // "serialMsgQ Unlock"
osSyncPrintf("%2d %d serialMsgQロック解除します %08x %08x %08x\n", osGetThreadId(NULL), 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) { if (D_8012D280 > 2) {
// "serialMsgQ Unlocked" // "serialMsgQ Unlocked"
osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL), 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) { void PadMgr_LockPadData(PadMgr* padMgr) {
osRecvMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK); osRecvMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
} }
void PadMgr_UnlockPadData(PadMgr* padMgr) { void PadMgr_UnlockPadData(PadMgr* padMgr) {
osSendMesg(&padMgr->lockMsgQ, NULL, OS_MESG_BLOCK); osSendMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
} }
void PadMgr_RumbleControl(PadMgr* padMgr) { void PadMgr_RumbleControl(PadMgr* padMgr) {
@ -52,7 +52,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
static u32 frame; static u32 frame;
s32 temp = 1; s32 temp = 1;
s32 triedRumbleComm; s32 triedRumbleComm;
OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr); OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
s32 var4; s32 var4;
s32 i; s32 i;
@ -133,7 +133,7 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
i = frame % 4; i = frame % 4;
if (padMgr->ctrlrIsConnected[i] && (padMgr->padStatus[i].status & 1) && (padMgr->pakType[i] != 1)) { 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) { if (var4 == 0) {
padMgr->pakType[i] = 1; padMgr->pakType[i] = 1;
@ -156,15 +156,15 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
} }
frame++; frame++;
PadMgr_UnlockSerialMesgQueue(padMgr, ctrlrQ); PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
} }
void PadMgr_RumbleStop(PadMgr* padMgr) { void PadMgr_RumbleStop(PadMgr* padMgr) {
s32 i; s32 i;
OSMesgQueue* ctrlrQ = PadMgr_LockSerialMesgQueue(padMgr); OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
for (i = 0; i < 4; i++) { 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)) { if ((gFaultMgr.msgId == 0) && (padMgr->rumbleOnFrames != 0)) {
osSyncPrintf(VT_FGCOL(YELLOW)); osSyncPrintf(VT_FGCOL(YELLOW));
// "Stop vibration pack" // "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) { void PadMgr_RumbleReset(PadMgr* padMgr) {
@ -265,23 +265,23 @@ void PadMgr_ProcessInputs(PadMgr* padMgr) {
void PadMgr_HandleRetraceMsg(PadMgr* padMgr) { void PadMgr_HandleRetraceMsg(PadMgr* padMgr) {
s32 i; s32 i;
OSMesgQueue* queue = PadMgr_LockSerialMesgQueue(padMgr); OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
u32 mask; u32 mask;
osContStartReadData(queue); osContStartReadData(serialEventQueue);
if (padMgr->retraceCallback) { if (padMgr->retraceCallback) {
padMgr->retraceCallback(padMgr, padMgr->retraceCallbackValue); padMgr->retraceCallback(padMgr, padMgr->retraceCallbackValue);
} }
osRecvMesg(queue, NULL, OS_MESG_BLOCK); osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
osContGetReadData(padMgr->pads); osContGetReadData(padMgr->pads);
if (padMgr->preNMIShutdown) { if (padMgr->preNMIShutdown) {
bzero(padMgr->pads, sizeof(padMgr->pads)); bzero(padMgr->pads, sizeof(padMgr->pads));
} }
PadMgr_ProcessInputs(padMgr); PadMgr_ProcessInputs(padMgr);
osContStartQuery(queue); osContStartQuery(serialEventQueue);
osRecvMesg(queue, NULL, OS_MESG_BLOCK); osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
osContGetQuery(padMgr->padStatus); osContGetQuery(padMgr->padStatus);
PadMgr_UnlockSerialMesgQueue(padMgr, queue); PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
mask = 0; mask = 0;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
@ -351,22 +351,22 @@ void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 mode) {
} }
void PadMgr_ThreadEntry(PadMgr* padMgr) { void PadMgr_ThreadEntry(PadMgr* padMgr) {
s16* mesg = NULL; s16* msg = NULL;
s32 exit; s32 exit;
osSyncPrintf("コントローラスレッド実行開始\n"); // "Controller thread execution start" osSyncPrintf("コントローラスレッド実行開始\n"); // "Controller thread execution start"
exit = false; exit = false;
while (!exit) { while (!exit) {
if ((D_8012D280 > 2) && (padMgr->interruptMsgQ.validCount == 0)) { if ((D_8012D280 > 2) && MQ_IS_EMPTY(&padMgr->interruptQueue)) {
// "Waiting for controller thread event" // "Waiting for controller thread event"
osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime())); osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
} }
osRecvMesg(&padMgr->interruptMsgQ, (OSMesg)&mesg, OS_MESG_BLOCK); osRecvMesg(&padMgr->interruptQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
LogUtils_CheckNullPointer("msg", mesg, "../padmgr.c", 563); LogUtils_CheckNullPointer("msg", msg, "../padmgr.c", 563);
switch (*mesg) { switch (*msg) {
case OS_SC_RETRACE_MSG: case OS_SC_RETRACE_MSG:
if (D_8012D280 > 2) { if (D_8012D280 > 2) {
osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", OS_CYCLES_TO_USEC(osGetTime())); 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" 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" osSyncPrintf("パッドマネージャ作成 padmgr_Create()\n"); // "Pad Manager creation"
bzero(padMgr, sizeof(PadMgr)); bzero(padMgr, sizeof(PadMgr));
padMgr->irqMgr = irqMgr; padMgr->irqMgr = irqMgr;
osCreateMesgQueue(&padMgr->interruptMsgQ, padMgr->interruptMsgBuf, 4); osCreateMesgQueue(&padMgr->interruptQueue, padMgr->interruptMsgBuf, ARRAY_COUNT(padMgr->interruptMsgBuf));
IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptMsgQ); IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptQueue);
osCreateMesgQueue(&padMgr->serialMsgQ, padMgr->serialMsgBuf, 1); osCreateMesgQueue(&padMgr->serialLockQueue, padMgr->serialLockMsgBuf, ARRAY_COUNT(padMgr->serialLockMsgBuf));
PadMgr_UnlockSerialMesgQueue(padMgr, siIntMsgQ); PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
osCreateMesgQueue(&padMgr->lockMsgQ, padMgr->lockMsgBuf, 1); osCreateMesgQueue(&padMgr->lockQueue, padMgr->lockMsgBuf, ARRAY_COUNT(padMgr->lockMsgBuf));
PadMgr_UnlockPadData(padMgr); PadMgr_UnlockPadData(padMgr);
PadSetup_Init(siIntMsgQ, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus); PadSetup_Init(serialEventQueue, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
padMgr->nControllers = 4; padMgr->nControllers = 4;
osContSetCh(padMgr->nControllers); osContSetCh(padMgr->nControllers);

36
src/code/sched.c
View file

@ -82,12 +82,12 @@ void Sched_HandleReset(SchedContext* sc) {
if (sc->curRSPTask != NULL) { if (sc->curRSPTask != NULL) {
LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))", LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRSPGFXStartTime), "../sched.c", 427); 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) { if (sc->curRDPTask != NULL) {
LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))", LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431); 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) { u32 Sched_IsComplete(SchedContext* sc, OSScTask* task) {
if (!(task->state & (OS_SC_DP | OS_SC_SP))) { if (!(task->state & (OS_SC_DP | OS_SC_SP))) {
if (task->msgQ != NULL) { if (task->msgQueue != NULL) {
osSendMesg(task->msgQ, task->msg, OS_MESG_BLOCK); osSendMesg(task->msgQueue, task->msg, OS_MESG_BLOCK);
} }
if (task->flags & OS_SC_SWAPBUFFER) { if (task->flags & OS_SC_SWAPBUFFER) {
@ -292,10 +292,10 @@ void Sched_HandleEntry(SchedContext* sc) {
OSScTask* nextRSP = NULL; OSScTask* nextRSP = NULL;
OSScTask* nextRDP = NULL; OSScTask* nextRDP = NULL;
s32 state; s32 state;
OSMesg msg = NULL; OSScTask* task = NULL;
while (osRecvMesg(&sc->cmdQ, &msg, OS_MESG_NOBLOCK) != -1) { while (osRecvMesg(&sc->cmdQueue, (OSMesg*)&task, OS_MESG_NOBLOCK) != -1) {
Sched_QueueTask(sc, msg); Sched_QueueTask(sc, task);
} }
if (sc->doAudio != 0 && sc->curRSPTask != NULL) { if (sc->doAudio != 0 && sc->curRSPTask != NULL) {
@ -425,22 +425,20 @@ void Sched_SendEntryMsg(SchedContext* sc) {
osSyncPrintf("osScKickEntryMsg\n"); 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 Sched_ThreadEntry(void* arg) {
void* msg; OSMesg msg = NULL;
SchedContext* sc = (SchedContext*)arg; SchedContext* sc = (SchedContext*)arg;
msg = NULL;
while (true) { while (true) {
if (sLogScheduler) { if (sLogScheduler) {
// "%08d: standby" // "%08d: standby"
osSyncPrintf("%08d:待機中\n", (u32)OS_CYCLES_TO_USEC(osGetTime())); 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) { switch ((s32)msg) {
case ENTRY_MSG: case ENTRY_MSG:
@ -461,8 +459,6 @@ void Sched_ThreadEntry(void* arg) {
} }
Sched_HandleRDPDone(sc); Sched_HandleRDPDone(sc);
continue; continue;
default:
break;
} }
switch (((OSScMsg*)msg)->type) { switch (((OSScMsg*)msg)->type) {
case 1: 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) { void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr) {
bzero(sc, sizeof(SchedContext)); bzero(sc, sizeof(SchedContext));
sc->unk_24C = 1; sc->unk_24C = 1;
osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8); osCreateMesgQueue(&sc->interruptQueue, sc->interruptMsgBuf, ARRAY_COUNT(sc->interruptMsgBuf));
osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, 8); osCreateMesgQueue(&sc->cmdQueue, sc->cmdMsgBuf, ARRAY_COUNT(sc->cmdMsgBuf));
osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, RSP_DONE_MSG); osSetEventMesg(OS_EVENT_SP, &sc->interruptQueue, RSP_DONE_MSG);
osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, RDP_DONE_MSG); osSetEventMesg(OS_EVENT_DP, &sc->interruptQueue, RDP_DONE_MSG);
IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQ); IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQueue);
osCreateThread(&sc->thread, 5, Sched_ThreadEntry, sc, stack, priority); osCreateThread(&sc->thread, THREAD_ID_SCHED, Sched_ThreadEntry, sc, stack, priority);
osStartThread(&sc->thread); osStartThread(&sc->thread);
} }

4
src/code/z_jpeg.c
View file

@ -55,12 +55,12 @@ void Jpeg_ScheduleDecoderTask(JpegContext* ctx) {
ctx->scTask.next = NULL; ctx->scTask.next = NULL;
ctx->scTask.flags = OS_SC_NEEDS_RSP; ctx->scTask.flags = OS_SC_NEEDS_RSP;
ctx->scTask.msgQ = &ctx->mq; ctx->scTask.msgQueue = &ctx->mq;
ctx->scTask.msg = NULL; ctx->scTask.msg = NULL;
ctx->scTask.framebuffer = NULL; ctx->scTask.framebuffer = NULL;
ctx->scTask.list.t = sJpegTask; 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 Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK); osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK);
} }

4
src/code/z_kankyo.c
View file

@ -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 ((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++; envCtx->skyboxDmaState++;
} }
} else if (envCtx->skyboxDmaState >= SKYBOX_DMA_FILE1_DONE) { } 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; envCtx->skyboxDmaState = SKYBOX_DMA_INACTIVE;
} }
} }

7
src/code/z_msgevent.c
View file

@ -1,7 +1,6 @@
#include "global.h" #include "global.h"
void MsgEvent_SendNullTask(void) { void MsgEvent_SendNullTask(void) {
s32 pad[4];
OSScTask task; OSScTask task;
OSMesgQueue queue; OSMesgQueue queue;
OSMesg msg; OSMesg msg;
@ -9,12 +8,12 @@ void MsgEvent_SendNullTask(void) {
task.next = NULL; task.next = NULL;
task.flags = OS_SC_RCP_MASK; task.flags = OS_SC_RCP_MASK;
task.msgQ = &queue; task.msgQueue = &queue;
task.msg = NULL; task.msg = NULL;
task.framebuffer = NULL; task.framebuffer = NULL;
task.list.t.type = M_NULTASK; task.list.t.type = M_NULTASK;
osCreateMesgQueue(task.msgQ, &msg, 1); osCreateMesgQueue(task.msgQueue, &msg, 1);
osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK); osSendMesg(&gSchedContext.cmdQueue, (OSMesg)&task, OS_MESG_BLOCK);
Sched_SendEntryMsg(&gSchedContext); Sched_SendEntryMsg(&gSchedContext);
osRecvMesg(&queue, NULL, OS_MESG_BLOCK); osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
} }

2
src/code/z_player_lib.c
View file

@ -1307,7 +1307,7 @@ void Player_DrawGetItemImpl(GlobalContext* globalCtx, Player* this, Vec3f* refPo
} }
void Player_DrawGetItem(GlobalContext* globalCtx, Player* this) { 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; this->giObjectLoading = false;
Player_DrawGetItemImpl(globalCtx, this, &sGetItemRefPos, ABS(this->unk_862)); Player_DrawGetItemImpl(globalCtx, this, &sGetItemRefPos, ABS(this->unk_862));
} }

2
src/code/z_room.c
View file

@ -569,7 +569,7 @@ s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum) {
s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx) { s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx) {
if (roomCtx->status == 1) { 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->status = 0;
roomCtx->curRoom.segment = roomCtx->unk_34; roomCtx->curRoom.segment = roomCtx->unk_34;
gSegments[3] = VIRTUAL_TO_PHYSICAL(roomCtx->unk_34); gSegments[3] = VIRTUAL_TO_PHYSICAL(roomCtx->unk_34);

2
src/code/z_scene.c
View file

@ -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); 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, DmaMgr_SendRequest2(&status->dmaRequest, status->segment, objectFile->vromStart, size, 0,
&status->loadQueue, NULL, "../z_scene.c", 266); &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; status->id = -status->id;
} }
} }

10
src/code/z_ss_sram.c
View file

@ -4,7 +4,7 @@
typedef struct { typedef struct {
/* 0x00 */ OSPiHandle piHandle; /* 0x00 */ OSPiHandle piHandle;
/* 0x74 */ OSIoMesg ioMesg; /* 0x74 */ OSIoMesg ioMesg;
/* 0x8C */ OSMesgQueue mesgQ; /* 0x8C */ OSMesgQueue msgQueue;
} SsSramContext; // size = 0xA4 } SsSramContext; // size = 0xA4
SsSramContext sSsSramContext = { 0 }; SsSramContext sSsSramContext = { 0 };
@ -32,20 +32,20 @@ void SsSram_Init(u32 addr, u8 handleType, u8 handleDomain, u8 handleLatency, u8
__osRestoreInt(prevInt); __osRestoreInt(prevInt);
sSsSramContext.ioMesg.hdr.pri = OS_MESG_PRI_NORMAL; sSsSramContext.ioMesg.hdr.pri = OS_MESG_PRI_NORMAL;
sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.mesgQ; sSsSramContext.ioMesg.hdr.retQueue = &sSsSramContext.msgQueue;
sSsSramContext.ioMesg.devAddr = addr; sSsSramContext.ioMesg.devAddr = addr;
} }
} }
void SsSram_Dma(void* dramAddr, size_t size, s32 direction) { 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.dramAddr = dramAddr;
sSsSramContext.ioMesg.size = size; sSsSramContext.ioMesg.size = size;
osWritebackDCache(dramAddr, size); osWritebackDCache(dramAddr, size);
osEPiStartDma(&sSsSramContext.piHandle, &sSsSramContext.ioMesg, direction); osEPiStartDma(&sSsSramContext.piHandle, &sSsSramContext.ioMesg, direction);
osRecvMesg(&sSsSramContext.mesgQ, &mesg, OS_MESG_BLOCK); osRecvMesg(&sSsSramContext.msgQueue, &msg, OS_MESG_BLOCK);
osInvalDCache(dramAddr, size); osInvalDCache(dramAddr, size);
} }

4
src/libultra/io/contramwrite.c
View file

@ -44,10 +44,10 @@ s32 __osContRamWrite(OSMesgQueue* mq, s32 channel, u16 address, u8* buffer, s32
ret = __osSiRawStartDma(OS_WRITE, &gPifMempakBuf); ret = __osSiRawStartDma(OS_WRITE, &gPifMempakBuf);
crc = __osContDataCrc(buffer); crc = __osContDataCrc(buffer);
osRecvMesg(mq, (OSMesg*)NULL, OS_MESG_BLOCK); osRecvMesg(mq, NULL, OS_MESG_BLOCK);
ret = __osSiRawStartDma(OS_READ, &gPifMempakBuf); ret = __osSiRawStartDma(OS_READ, &gPifMempakBuf);
osRecvMesg(mq, (OSMesg*)NULL, OS_MESG_BLOCK); osRecvMesg(mq, NULL, OS_MESG_BLOCK);
ret = ((((__OSContRamHeader*)ptr)->rxsize & 0xC0) >> 4); ret = ((((__OSContRamHeader*)ptr)->rxsize & 0xC0) >> 4);
if (!ret) { if (!ret) {

16
src/libultra/io/controller.c
View file

@ -5,7 +5,7 @@ u8 __osContLastPoll;
u8 __osMaxControllers; // always 4 u8 __osMaxControllers; // always 4
OSTimer __osEepromTimer; OSTimer __osEepromTimer;
OSMesgQueue __osEepromTimerMsgQ; OSMesgQueue __osEepromTimerMsgQueue;
OSMesg __osEepromTimerMsg; OSMesg __osEepromTimerMsg;
u32 gOSContInitialized = 0; u32 gOSContInitialized = 0;
@ -13,7 +13,7 @@ u32 gOSContInitialized = 0;
#define HALF_SECOND OS_USEC_TO_CYCLES(500000) #define HALF_SECOND OS_USEC_TO_CYCLES(500000)
s32 osContInit(OSMesgQueue* mq, u8* ctlBitfield, OSContStatus* status) { s32 osContInit(OSMesgQueue* mq, u8* ctlBitfield, OSContStatus* status) {
OSMesg mesg; OSMesg msg;
s32 ret = 0; s32 ret = 0;
OSTime currentTime; OSTime currentTime;
OSTimer timer; OSTimer timer;
@ -26,20 +26,20 @@ s32 osContInit(OSMesgQueue* mq, u8* ctlBitfield, OSContStatus* status) {
gOSContInitialized = 1; gOSContInitialized = 1;
currentTime = osGetTime(); currentTime = osGetTime();
if (HALF_SECOND > currentTime) { if (HALF_SECOND > currentTime) {
osCreateMesgQueue(&timerqueue, &mesg, 1); osCreateMesgQueue(&timerqueue, &msg, 1);
osSetTimer(&timer, HALF_SECOND - currentTime, 0, &timerqueue, &mesg); osSetTimer(&timer, HALF_SECOND - currentTime, 0, &timerqueue, &msg);
osRecvMesg(&timerqueue, &mesg, OS_MESG_BLOCK); osRecvMesg(&timerqueue, &msg, OS_MESG_BLOCK);
} }
__osMaxControllers = MAXCONTROLLERS; __osMaxControllers = MAXCONTROLLERS;
__osPackRequestData(CONT_CMD_REQUEST_STATUS); __osPackRequestData(CONT_CMD_REQUEST_STATUS);
ret = __osSiRawStartDma(OS_WRITE, &__osPifInternalBuff); ret = __osSiRawStartDma(OS_WRITE, &__osPifInternalBuff);
osRecvMesg(mq, &mesg, OS_MESG_BLOCK); osRecvMesg(mq, &msg, OS_MESG_BLOCK);
ret = __osSiRawStartDma(OS_READ, &__osPifInternalBuff); ret = __osSiRawStartDma(OS_READ, &__osPifInternalBuff);
osRecvMesg(mq, &mesg, OS_MESG_BLOCK); osRecvMesg(mq, &msg, OS_MESG_BLOCK);
__osContGetInitData(ctlBitfield, status); __osContGetInitData(ctlBitfield, status);
__osContLastPoll = CONT_CMD_REQUEST_STATUS; __osContLastPoll = CONT_CMD_REQUEST_STATUS;
__osSiCreateAccessQueue(); __osSiCreateAccessQueue();
osCreateMesgQueue(&__osEepromTimerMsgQ, &__osEepromTimerMsg, 1); osCreateMesgQueue(&__osEepromTimerMsgQueue, &__osEepromTimerMsg, 1);
return ret; return ret;
} }

10
src/libultra/io/devmgr.c
View file

@ -15,7 +15,7 @@ void __osDevMgrMain(void* arg) {
ioMesg = NULL; ioMesg = NULL;
while (true) { while (true) {
osRecvMesg(arg0->cmdQueue, (OSMesg)&ioMesg, OS_MESG_BLOCK); osRecvMesg(arg0->cmdQueue, (OSMesg*)&ioMesg, OS_MESG_BLOCK);
if ((ioMesg->piHandle != NULL) && (ioMesg->piHandle->type == DEVICE_TYPE_64DD) && if ((ioMesg->piHandle != NULL) && (ioMesg->piHandle->type == DEVICE_TYPE_64DD) &&
((ioMesg->piHandle->transferInfo.cmdType == 0) || (ioMesg->piHandle->transferInfo.cmdType == 1))) { ((ioMesg->piHandle->transferInfo.cmdType == 0) || (ioMesg->piHandle->transferInfo.cmdType == 1))) {
transfer = &ioMesg->piHandle->transferInfo; transfer = &ioMesg->piHandle->transferInfo;
@ -46,7 +46,7 @@ void __osDevMgrMain(void* arg) {
HW_REG(PI_STATUS_REG, u32) = PI_STATUS_CLEAR_INTR; HW_REG(PI_STATUS_REG, u32) = PI_STATUS_CLEAR_INTR;
__osSetGlobalIntMask(0x00100C01); __osSetGlobalIntMask(0x00100C01);
} }
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK); osSendMesg(ioMesg->hdr.retQueue, (OSMesg)ioMesg, OS_MESG_NOBLOCK);
if ((phi_s2 != 1) || (ioMesg->piHandle->transferInfo.block[0].errStatus != 0)) { if ((phi_s2 != 1) || (ioMesg->piHandle->transferInfo.block[0].errStatus != 0)) {
break; break;
@ -55,7 +55,7 @@ void __osDevMgrMain(void* arg) {
phi_s2 = 0; phi_s2 = 0;
} }
osSendMesg(arg0->acccessQueue, 0, OS_MESG_NOBLOCK); osSendMesg(arg0->acccessQueue, NULL, OS_MESG_NOBLOCK);
if (ioMesg->piHandle->transferInfo.blockNum == 1) { if (ioMesg->piHandle->transferInfo.blockNum == 1) {
osYieldThread(); osYieldThread();
} }
@ -80,7 +80,7 @@ void __osDevMgrMain(void* arg) {
ioMesg->size); ioMesg->size);
break; break;
case OS_MESG_TYPE_LOOPBACK: case OS_MESG_TYPE_LOOPBACK:
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK); osSendMesg(ioMesg->hdr.retQueue, (OSMesg)ioMesg, OS_MESG_NOBLOCK);
phi_s0 = -1; phi_s0 = -1;
break; break;
default: default:
@ -90,7 +90,7 @@ void __osDevMgrMain(void* arg) {
if (phi_s0 == 0) { if (phi_s0 == 0) {
osRecvMesg(arg0->eventQueue, &sp70, OS_MESG_BLOCK); osRecvMesg(arg0->eventQueue, &sp70, OS_MESG_BLOCK);
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK); osSendMesg(ioMesg->hdr.retQueue, (OSMesg)ioMesg, OS_MESG_NOBLOCK);
osSendMesg(arg0->acccessQueue, NULL, OS_MESG_NOBLOCK); osSendMesg(arg0->acccessQueue, NULL, OS_MESG_NOBLOCK);
} }
} }

13
src/libultra/io/piacs.c
View file

@ -1,24 +1,23 @@
#include "global.h" #include "global.h"
u32 __osPiAccessQueueEnabled = 0; u32 __osPiAccessQueueEnabled = false;
OSMesg piAccessBuf[1];
OSMesg piAccessBuf;
OSMesgQueue __osPiAccessQueue; OSMesgQueue __osPiAccessQueue;
void __osPiCreateAccessQueue(void) { void __osPiCreateAccessQueue(void) {
__osPiAccessQueueEnabled = 1; __osPiAccessQueueEnabled = true;
osCreateMesgQueue(&__osPiAccessQueue, &piAccessBuf, 1); osCreateMesgQueue(&__osPiAccessQueue, piAccessBuf, ARRAY_COUNT(piAccessBuf));
osSendMesg(&__osPiAccessQueue, NULL, OS_MESG_NOBLOCK); osSendMesg(&__osPiAccessQueue, NULL, OS_MESG_NOBLOCK);
} }
void __osPiGetAccess(void) { void __osPiGetAccess(void) {
OSMesg mesg; OSMesg msg;
if (!__osPiAccessQueueEnabled) { if (!__osPiAccessQueueEnabled) {
__osPiCreateAccessQueue(); __osPiCreateAccessQueue();
} }
osRecvMesg(&__osPiAccessQueue, &mesg, OS_MESG_BLOCK); osRecvMesg(&__osPiAccessQueue, &msg, OS_MESG_BLOCK);
} }
void __osPiRelAccess(void) { void __osPiRelAccess(void) {

6
src/libultra/io/pimgr.c
View file

@ -17,13 +17,13 @@ OSPiHandle* __osCurrentHandle[] = {
&__Dom2SpeedParam, &__Dom2SpeedParam,
}; };
void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgCnt) { void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQueue, OSMesg* cmdBuf, s32 cmdMsgCnt) {
u32 prevInt; u32 prevInt;
OSPri newPri; OSPri newPri;
OSPri currentPri; OSPri currentPri;
if (!__osPiDevMgr.initialized) { if (!__osPiDevMgr.initialized) {
osCreateMesgQueue(cmdQ, cmdBuf, cmdMsgCnt); osCreateMesgQueue(cmdQueue, cmdBuf, cmdMsgCnt);
osCreateMesgQueue(&piEventQueue, piEventBuf, 1); osCreateMesgQueue(&piEventQueue, piEventBuf, 1);
if (!__osPiAccessQueueEnabled) { if (!__osPiAccessQueueEnabled) {
__osPiCreateAccessQueue(); __osPiCreateAccessQueue();
@ -39,7 +39,7 @@ void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgC
prevInt = __osDisableInt(); prevInt = __osDisableInt();
__osPiDevMgr.initialized = true; __osPiDevMgr.initialized = true;
__osPiDevMgr.cmdQueue = cmdQ; __osPiDevMgr.cmdQueue = cmdQueue;
__osPiDevMgr.mgrThread = &piThread; __osPiDevMgr.mgrThread = &piThread;
__osPiDevMgr.eventQueue = &piEventQueue; __osPiDevMgr.eventQueue = &piEventQueue;
__osPiDevMgr.acccessQueue = &__osPiAccessQueue; __osPiDevMgr.acccessQueue = &__osPiAccessQueue;

20
src/libultra/io/siacs.c
View file

@ -1,24 +1,24 @@
#include "global.h" #include "global.h"
OSMesg osSiMesgBuff[SIAccessQueueSize]; OSMesg siAccessBuf[1];
OSMesgQueue gOSSiMessageQueue; OSMesgQueue __osSiAccessQueue;
u32 gOSSiAccessQueueCreated = 0; u32 __osSiAccessQueueEnabled = false;
void __osSiCreateAccessQueue(void) { void __osSiCreateAccessQueue(void) {
gOSSiAccessQueueCreated = 1; __osSiAccessQueueEnabled = true;
osCreateMesgQueue(&gOSSiMessageQueue, &osSiMesgBuff[0], SIAccessQueueSize - 1); osCreateMesgQueue(&__osSiAccessQueue, siAccessBuf, ARRAY_COUNT(siAccessBuf));
osSendMesg(&gOSSiMessageQueue, NULL, OS_MESG_NOBLOCK); osSendMesg(&__osSiAccessQueue, NULL, OS_MESG_NOBLOCK);
} }
void __osSiGetAccess(void) { void __osSiGetAccess(void) {
OSMesg mesg; OSMesg msg;
if (!gOSSiAccessQueueCreated) { if (!__osSiAccessQueueEnabled) {
__osSiCreateAccessQueue(); __osSiCreateAccessQueue();
} }
osRecvMesg(&gOSSiMessageQueue, &mesg, OS_MESG_BLOCK); osRecvMesg(&__osSiAccessQueue, &msg, OS_MESG_BLOCK);
} }
void __osSiRelAccess(void) { void __osSiRelAccess(void) {
osSendMesg(&gOSSiMessageQueue, NULL, OS_MESG_NOBLOCK); osSendMesg(&__osSiAccessQueue, NULL, OS_MESG_NOBLOCK);
} }

10
src/libultra/io/vimgr.c
View file

@ -4,7 +4,7 @@
OSThread viThread; OSThread viThread;
STACK(viThreadStack, 0x1000); STACK(viThreadStack, 0x1000);
OSMesgQueue viEventQueue; OSMesgQueue viEventQueue;
OSMesg viEventBuf[6]; OSMesg viEventBuf[5];
OSIoMesg viRetraceMsg; OSIoMesg viRetraceMsg;
OSIoMesg viCounterMsg; OSIoMesg viCounterMsg;
OSMgrArgs __osViDevMgr = { 0 }; OSMgrArgs __osViDevMgr = { 0 };
@ -20,7 +20,7 @@ void osCreateViManager(OSPri pri) {
if (!__osViDevMgr.initialized) { if (!__osViDevMgr.initialized) {
__osTimerServicesInit(); __osTimerServicesInit();
__additional_scanline = 0; __additional_scanline = 0;
osCreateMesgQueue(&viEventQueue, viEventBuf, 5); osCreateMesgQueue(&viEventQueue, viEventBuf, ARRAY_COUNT(viEventBuf));
viRetraceMsg.hdr.type = OS_MESG_TYPE_VRETRACE; viRetraceMsg.hdr.type = OS_MESG_TYPE_VRETRACE;
viRetraceMsg.hdr.pri = OS_MESG_PRI_NORMAL; viRetraceMsg.hdr.pri = OS_MESG_PRI_NORMAL;
viRetraceMsg.hdr.retQueue = NULL; viRetraceMsg.hdr.retQueue = NULL;
@ -59,7 +59,7 @@ void viMgrMain(void* vargs) {
static u16 viRetrace; static u16 viRetrace;
OSMgrArgs* args; OSMgrArgs* args;
u32 addTime; u32 addTime;
OSIoMesg* mesg = NULL; OSIoMesg* msg = NULL;
u32 temp = 0; // always 0 u32 temp = 0; // always 0
viRetrace = __osViGetCurrentContext()->retraceCount; viRetrace = __osViGetCurrentContext()->retraceCount;
@ -70,8 +70,8 @@ void viMgrMain(void* vargs) {
args = (OSMgrArgs*)vargs; args = (OSMgrArgs*)vargs;
while (true) { while (true) {
osRecvMesg(args->eventQueue, (OSMesg)&mesg, OS_MESG_BLOCK); osRecvMesg(args->eventQueue, (OSMesg*)&msg, OS_MESG_BLOCK);
switch (mesg->hdr.type) { switch (msg->hdr.type) {
case OS_MESG_TYPE_VRETRACE: case OS_MESG_TYPE_VRETRACE:
__osViSwapContext(); __osViSwapContext();
viRetrace--; viRetrace--;

4
src/libultra/os/createmesgqueue.c
View file

@ -1,8 +1,8 @@
#include "global.h" #include "global.h"
void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count) { void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count) {
mq->mtqueue = (OSThread*)__osThreadTail; mq->mtqueue = (OSThread*)&__osThreadTail;
mq->fullqueue = (OSThread*)__osThreadTail; mq->fullqueue = (OSThread*)&__osThreadTail;
mq->validCount = 0; mq->validCount = 0;
mq->first = 0; mq->first = 0;
mq->msgCount = count; mq->msgCount = count;

10
src/libultra/os/createthread.c
View file

@ -1,8 +1,8 @@
#include "global.h" #include "global.h"
OSThread* __osThreadTail[2] = { NULL, (OSThread*)OS_PRIORITY_THREADTAIL }; __OSThreadTail __osThreadTail = { NULL, OS_PRIORITY_THREADTAIL };
OSThread* __osRunQueue = (OSThread*)__osThreadTail; OSThread* __osRunQueue = (OSThread*)&__osThreadTail;
OSThread* __osActiveQueue = (OSThread*)__osThreadTail; OSThread* __osActiveQueue = (OSThread*)&__osThreadTail;
OSThread* __osRunningThread = NULL; OSThread* __osRunningThread = NULL;
OSThread* __osFaultedThread = NULL; OSThread* __osFaultedThread = NULL;
@ -20,8 +20,8 @@ void osCreateThread(OSThread* thread, OSId id, void (*entry)(void*), void* arg,
thread->context.ra = __osCleanupThread; thread->context.ra = __osCleanupThread;
mask = OS_IM_ALL; mask = OS_IM_ALL;
thread->context.sr = (mask & OS_IM_CPU) | 2; thread->context.sr = (mask & OS_IM_CPU) | SR_EXL;
thread->context.rcp = (mask & RCP_IMASK) >> 16; thread->context.rcp = (mask & RCP_IMASK) >> RCP_IMASKSHIFT;
thread->context.fpcsr = FPCSR_FS | FPCSR_EV; thread->context.fpcsr = FPCSR_FS | FPCSR_EV;
thread->fp = 0; thread->fp = 0;
thread->state = OS_STATE_STOPPED; thread->state = OS_STATE_STOPPED;

2
src/libultra/os/jammesg.c
View file

@ -3,7 +3,7 @@
s32 osJamMesg(OSMesgQueue* mq, OSMesg msg, s32 flag) { s32 osJamMesg(OSMesgQueue* mq, OSMesg msg, s32 flag) {
register u32 prevInt = __osDisableInt(); register u32 prevInt = __osDisableInt();
while (mq->validCount >= mq->msgCount) { while (MQ_IS_FULL(mq)) {
if (flag == OS_MESG_BLOCK) { if (flag == OS_MESG_BLOCK) {
__osRunningThread->state = OS_STATE_WAITING; __osRunningThread->state = OS_STATE_WAITING;
__osEnqueueAndYield(&mq->fullqueue); __osEnqueueAndYield(&mq->fullqueue);

4
src/libultra/os/recvmesg.c
View file

@ -3,12 +3,12 @@
s32 osRecvMesg(OSMesgQueue* mq, OSMesg* msg, s32 flag) { s32 osRecvMesg(OSMesgQueue* mq, OSMesg* msg, s32 flag) {
register u32 prevInt = __osDisableInt(); register u32 prevInt = __osDisableInt();
while (mq->validCount == 0) { while (MQ_IS_EMPTY(mq)) {
if (flag == OS_MESG_NOBLOCK) { if (flag == OS_MESG_NOBLOCK) {
__osRestoreInt(prevInt); __osRestoreInt(prevInt);
return -1; return -1;
} }
__osRunningThread->state = 8; __osRunningThread->state = OS_STATE_WAITING;
__osEnqueueAndYield((OSThread**)mq); __osEnqueueAndYield((OSThread**)mq);
} }

8
src/libultra/os/sendmesg.c
View file

@ -1,12 +1,12 @@
#include "global.h" #include "global.h"
s32 osSendMesg(OSMesgQueue* mq, OSMesg mesg, s32 flag) { s32 osSendMesg(OSMesgQueue* mq, OSMesg msg, s32 flag) {
register u32 prevInt = __osDisableInt(); register u32 prevInt = __osDisableInt();
register u32 index; register u32 index;
while (mq->validCount >= mq->msgCount) { while (MQ_IS_FULL(mq)) {
if (flag == OS_MESG_BLOCK) { if (flag == OS_MESG_BLOCK) {
__osRunningThread->state = 8; __osRunningThread->state = OS_STATE_WAITING;
__osEnqueueAndYield(&mq->fullqueue); __osEnqueueAndYield(&mq->fullqueue);
} else { } else {
__osRestoreInt(prevInt); __osRestoreInt(prevInt);
@ -15,7 +15,7 @@ s32 osSendMesg(OSMesgQueue* mq, OSMesg mesg, s32 flag) {
} }
index = (mq->first + mq->validCount) % mq->msgCount; index = (mq->first + mq->validCount) % mq->msgCount;
mq->msg[index] = mesg; mq->msg[index] = msg;
mq->validCount++; mq->validCount++;
if (mq->mtqueue->next != NULL) { if (mq->mtqueue->next != NULL) {

4
src/libultra/os/setthreadpri.c
View file

@ -9,12 +9,12 @@ void osSetThreadPri(OSThread* thread, OSPri pri) {
if (thread->priority != pri) { if (thread->priority != pri) {
thread->priority = pri; thread->priority = pri;
if (thread != __osRunningThread && thread->state != 1) { if (thread != __osRunningThread && thread->state != OS_STATE_STOPPED) {
__osDequeueThread(thread->queue, thread); __osDequeueThread(thread->queue, thread);
__osEnqueueThread(thread->queue, thread); __osEnqueueThread(thread->queue, thread);
} }
if (__osRunningThread->priority < __osRunQueue->priority) { if (__osRunningThread->priority < __osRunQueue->priority) {
__osRunningThread->state = 2; __osRunningThread->state = OS_STATE_RUNNABLE;
__osEnqueueAndYield(&__osRunQueue); __osEnqueueAndYield(&__osRunQueue);
} }
} }

12
src/libultra/os/startthread.c
View file

@ -4,16 +4,16 @@ void osStartThread(OSThread* thread) {
register u32 prevInt = __osDisableInt(); register u32 prevInt = __osDisableInt();
switch (thread->state) { switch (thread->state) {
case 8: case OS_STATE_WAITING:
thread->state = 2; thread->state = OS_STATE_RUNNABLE;
__osEnqueueThread(&__osRunQueue, thread); __osEnqueueThread(&__osRunQueue, thread);
break; break;
case 1: case OS_STATE_STOPPED:
if (thread->queue == NULL || thread->queue == &__osRunQueue) { if (thread->queue == NULL || thread->queue == &__osRunQueue) {
thread->state = 2; thread->state = OS_STATE_RUNNABLE;
__osEnqueueThread(&__osRunQueue, thread); __osEnqueueThread(&__osRunQueue, thread);
} else { } else {
thread->state = 8; thread->state = OS_STATE_WAITING;
__osEnqueueThread(thread->queue, thread); __osEnqueueThread(thread->queue, thread);
__osEnqueueThread(&__osRunQueue, __osPopThread(thread->queue)); __osEnqueueThread(&__osRunQueue, __osPopThread(thread->queue));
} }
@ -24,7 +24,7 @@ void osStartThread(OSThread* thread) {
__osDispatchThread(); __osDispatchThread();
} else { } else {
if (__osRunningThread->priority < __osRunQueue->priority) { if (__osRunningThread->priority < __osRunQueue->priority) {
__osRunningThread->state = 2; __osRunningThread->state = OS_STATE_RUNNABLE;
__osEnqueueAndYield(&__osRunQueue); __osEnqueueAndYield(&__osRunQueue);
} }
} }

12
src/libultra/os/stopthread.c
View file

@ -5,19 +5,19 @@ void osStopThread(OSThread* thread) {
register u32 state; register u32 state;
if (thread == NULL) { if (thread == NULL) {
state = 4; state = OS_STATE_RUNNING;
} else { } else {
state = thread->state; state = thread->state;
} }
switch (state) { switch (state) {
case 4: case OS_STATE_RUNNING:
__osRunningThread->state = 1; __osRunningThread->state = OS_STATE_STOPPED;
__osEnqueueAndYield(NULL); __osEnqueueAndYield(NULL);
break; break;
case 2: case OS_STATE_RUNNABLE:
case 8: case OS_STATE_WAITING:
thread->state = 1; thread->state = OS_STATE_STOPPED;
__osDequeueThread(thread->queue, thread); __osDequeueThread(thread->queue, thread);
break; break;
} }