From 6eddcd65a6d601225e388ef77361e5d63363ab97 Mon Sep 17 00:00:00 2001 From: Prakxo Date: Wed, 1 Feb 2023 21:51:32 +0100 Subject: [PATCH] finish some OS files and update readme --- README.MD | 2 +- src/dolphin/OS/OSAlarm.c | 169 ++++++++++++++++++++++++++++++++++++++ src/dolphin/OS/OSAlloc.c | 0 src/dolphin/OS/OSMemory.c | 18 ++++ src/libultra/ultra.c | 6 +- 5 files changed, 191 insertions(+), 4 deletions(-) create mode 100644 src/dolphin/OS/OSAlarm.c delete mode 100644 src/dolphin/OS/OSAlloc.c diff --git a/README.MD b/README.MD index b96c2225..2186aa74 100644 --- a/README.MD +++ b/README.MD @@ -15,7 +15,7 @@ Use `--recursive` when cloning to have ppcdis in the repository. - Dump a copy of the game and extract **main.dol** and **foresta.rel.szs**. - Decompress **foresta.rel.szs** with yaz0 found in *tools/*. - Place **main.dol** and **foresta.rel** in *dump/*. -- Place CodeWarrior 1.3.2 in *tools/1.3.2/*. +- Place CodeWarrior 1.3.2 in *tools/1.3.2/* and 1.2.5 in *tools/1.2.5/*. - Install DevkitPPC, Ninja and Python: - **Only tested with DevkitPPC r41 and Python 3.8.10**, however other versions should work fine. - Install Python modules from requirements.txt (`pip install -r requirements.txt`) diff --git a/src/dolphin/OS/OSAlarm.c b/src/dolphin/OS/OSAlarm.c new file mode 100644 index 00000000..352c2e45 --- /dev/null +++ b/src/dolphin/OS/OSAlarm.c @@ -0,0 +1,169 @@ +#include "dolphin/OS/OSAlarm.h" +#include "dolphin/OS/OSTime.h" +#inlcude "dolphin/OS/OSContext.h" + +void OSInitAlarm(void){ + + if (__OSGetExceptionHandler(8) |= DecrementerExceptionHandler){ + AlarmQueue.tail = 0; + AlarmQueue.head = 0; + __OSSetExceptionHandler(8, DecrementerExceptionHandler); + } +} +void OSCreateAlarm(OSAlarm* alarm){ + alarm->handler = NULL; +} + +static void InsertAlarm(OSAlarm* alarm, OSTime fire, OSAlarmHandler handler){ + OSAlarm* next; + OSAlarm* prev; + + if (0 < alarm->period) { + OSTime time = __OSGetSystemTime(); + + fire = alarm->start; + if (alarm->start < time) { + fire += alarm->period * ((time - alarm->start) / alarm->period + 1); + } +} + + alarm->handler = handler; + alarm->fire = fire; + + for (next = AlarmQueue.head; next; next = next->next){ + if (next->fire <= fire) { + continue; + } + alarm->prev = next->prev; + next->prev = alarm; + alarm->next = next; + prev = alarm->prev; + if (prev) { + prev->next = alarm; + } + else{ + AlarmQueue.head = alarm; + SetTimer(alarm); + } + return; + } + alarm->next = 0; + prev = AlarmQueue.tail; + AlarmQueue.tail = alarm; + alarm->prev = prev; + if (prev) { + prev->next = alarm; + } + else { + AlarmQueue.head = AlarmQueue.tail = alarm; + SetTimer(alarm); + } +} + +void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler){ + u32 res = OSDisableInterrupts(); + alarm->period = 0; + InsertAlarm(alarm, __OSGetSystemTime() + tick, handler); + OSRestoreInterrupts(res); +} + +void OSCancelAlarm(OSAlarm* alarm){ + OSAlarm* next; + BOOL res; + + res = OSDisableInterrupts(); + + if(alarm->handler == 0) { + OSRestoreInterrupts(res); + return; + } + + next = alarm->next; + if (next == 0) { + AlarmQueue.tail = alarm->prev; + } + else { + AlarmQueue.head = next; + if (next) { + SetTimer(next) + } + } + alarm->handler = 0; + + OSRestoreInterrupts(res); +} + +static void DecrementerExceptionCallback(register OSException exc, register OSContext* ctx){ + OSAlarmHandler handler; + OSTime time; + OSContext excctx; + OSAlarm* alarm; + OSAlarm* next; + + time = __OSGetSystemTime(); + alarm = AlarmQueue.head; + if (alarm == NULL){ + OSLoadContext(ctx); + } + + if (time < alarm->fire) { + SetTimer(alarm); + OSLoadContext(ctx); + } + next = alarm->next; + AlarmQueue.head = next; + if (next == NULL) { + AlarmQueue.tail = NULL; + } + else { + next->prev = NULL; + } + handler = alarm->handler; + alarm->handler = NULL; + + if (0 < alarm->period) { + InsertAlarm(alarm, 0, handler); + } + if (AlarmQueue.head) { + SetTimer(AlarmQueue.head); + } + + OSDisableScheduler(); + OSClearContext(&excctx); + OSSetCurrentContext(&excctx); + + handler(alarm, ctx); + + OSClearContext(&excctx); + OSSetCurrentContext(ctx); + OSEnableScheduler(); + + __OSReschedule(); + OSLoadContext(ctx); +} + +static asm void DecrementerExceptionHandler(register u8 type, register OSContext* ctx){ + nofralloc + stw r0, ctx->gprs[0] + stw r1, ctx->gprs[1] + stw r2, ctx->gprs[2] + stmw r6, ctx->gprs[6] + + mfspr r0, 0x391 + stw r0, ctx->gqrs[1] + mfspr r0, 0x392 + stw r0, ctx->gqrs[2] + mfspr r0, 0x393 + stw r0, ctx->gqrs[3] + mfspr r0, 0x394 + stw r0, ctx->gqrs[4] + mfspr r0, 0x395 + stw r0, ctx->gqrs[5] + mfspr r0, 0x396 + stw r0, ctx->gqrs[6] + mfspr r0, 0x397 + stw r0, ctx->gqrs[7] + + stwu r1, -8(r1) + b DecrementerExceptionCallback +} \ No newline at end of file diff --git a/src/dolphin/OS/OSAlloc.c b/src/dolphin/OS/OSAlloc.c deleted file mode 100644 index e69de29b..00000000 diff --git a/src/dolphin/OS/OSMemory.c b/src/dolphin/OS/OSMemory.c index e6973f32..bea9420a 100644 --- a/src/dolphin/OS/OSMemory.c +++ b/src/dolphin/OS/OSMemory.c @@ -2,4 +2,22 @@ u32 OSGetConsoleSimulatedMemSize(void){ return(SIM_MEM); +} +static bool OnReset(bool final){ + if (final) { + __MEMRegs[8] = 0xff; + __OSMaskInterrupts(0xF0000000); + } + return true; +} +static void MEMInterruptsHandler(__OSInterrupt interrupt, OSContext* ctx){ + u32 cause = __MEMRegs[0xf]; + u32 addr = (((u32) __MEMRegs[0x12] & 0x3ff) << 16) | __MEMRegs[0x11]; + __MEMRegs[0x10] = 0; + + if(__OSErrorTable[OS_ERROR_PROTECTION]) { + __OSErrorTable[OS_ERROR_PROTECTION](OS_ERROR_PROTECTION, ctx, cause, adr); + return; + } + __OSUnhandledException(OS_ERROR_PROTECTION, ctx, cause, addr); } \ No newline at end of file diff --git a/src/libultra/ultra.c b/src/libultra/ultra.c index 44904962..46a2b393 100644 --- a/src/libultra/ultra.c +++ b/src/libultra/ultra.c @@ -13,10 +13,10 @@ void bzero(void* __s, size_t __n) { memset(__s, 0, __n); } -/* void osWritebackDCache(void* buf, u32 len){ - DCStoreRange(); +void osWritebackDCache(void* buf, u32 len){ + DCStoreRange(buf, len); } - */ + /* s32 osGetCount(void){ return OSGetTick(); }