Port a bunch of libultra files from sm64

src/boot_O2_g3/boot_0x80080060.c

@@ -3,11 +3,11 @@
 
 void start(void) {
     StackCheck_Init(&bootStackEntry, (u32)bootStack, (u32)&bootStack[1024], 0, -1, "boot");
-    osMemSize = func_8008D350();
+    osMemSize = osGetMemSize();
     func_800818F4();
     osInitialize();
     osUnmapTLBAll();
-    D_80096B40 = func_80092920();
+    D_80096B40 = osCartRomInit();
     StackCheck_Init(&idleStackEntry, (u32)idleStack, (u32)&idleStack[1024], 0, 256, "idle");
     osCreateThread(&idleOSThread, 1, (osCreateThread_func)Idle_ThreadEntry, 0, &idleStack[1024], 12);
     osStartThread(&idleOSThread);

src/boot_O2_g3/boot_0x800805E0.c

@@ -10,7 +10,7 @@ UNK_RET func_800805E0(UNK_TYPE a0) {
             osViSetMode(&osViModeMpalLan1);
             break;
         case 0:
-            osViSetMode(&D_80097590);
+            osViSetMode(&osViModePalLan1);
             break;
         case 1:
             default:

src/boot_O2_g3/z_std_dma.c

@@ -2,7 +2,6 @@
 #include <global.h>
 
 s32 Dmamgr_DoDmaTransfer(u32 a0, void* a1, u32 a2) {
-    u32 spPad;
     OSIoMesg sp60;
     OSMesgQueue sp48;
     OSMesg sp44;

src/libultra/gu/coss.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+short coss(unsigned short x) {
+    return sins(x + 0x4000);
+}

src/libultra/gu/ortho.c

@@ -0,0 +1,26 @@
+#include <ultra64.h>
+#include <global.h>
+
+void guOrthoF(float m[4][4], float l, float r, float b, float t, float n, float f, float scale) {
+    int i;
+    int j;
+    guMtxIdentF(m);
+    m[0][0] = 2 / (r - l);
+    m[1][1] = 2 / (t - b);
+    m[2][2] = -2 / (f - n);
+    m[3][0] = -(r + l) / (r - l);
+    m[3][1] = -(t + b) / (t - b);
+    m[3][2] = -(f + n) / (f - n);
+    m[3][3] = 1;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++) {
+            m[i][j] *= scale;
+        }
+    }
+}
+
+void guOrtho(Mtx *m, float l, float r, float b, float t, float n, float f, float scale) {
+    float mf[4][4];
+    guOrthoF(mf, l, r, b, t, n, f, scale);
+    guMtxF2L(mf, m);
+}

src/libultra/gu/rotate.c

@@ -0,0 +1,52 @@
+#include <ultra64.h>
+#include <global.h>
+
+void guRotateF(float m[4][4], float a, float x, float y, float z) {
+// TODO move in .data section
+//    static float dtor;
+    float sine;
+    float cosine;
+    float ab;
+    float bc;
+    float ca;
+    float t;
+    float xs;
+    float ys;
+    float zs;
+
+    guNormalize(&x, &y, &z);
+
+    a = a * D_80097F90;
+
+    sine = __sinf(a);
+    cosine = __cosf(a);
+
+    ab = x * y * (1 - cosine);
+    bc = y * z * (1 - cosine);
+    ca = z * x * (1 - cosine);
+
+    guMtxIdentF(m);
+
+    xs = x * sine;
+    ys = y * sine;
+    zs = z * sine;
+
+    t = x * x;
+    m[0][0] = (1 - t) * cosine + t;
+    m[2][1] = bc - xs;
+    m[1][2] = bc + xs;
+    t = y * y;
+    m[1][1] = (1 - t) * cosine + t;
+    m[2][0] = ca + ys;
+    m[0][2] = ca - ys;
+    t = z * z;
+    m[2][2] = (1 - t) * cosine + t;
+    m[1][0] = ab - zs;
+    m[0][1] = ab + zs;
+}
+
+void guRotate(Mtx *m, float a, float x, float y, float z) {
+    float mf[4][4];
+    guRotateF(mf, a, x, y, z);
+    guMtxF2L(mf, m);
+}

src/libultra/gu/visetevent.c

@@ -0,0 +1,12 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViSetEvent(OSMesgQueue *mq, OSMesg m, u32 retraceCount) {
+    register u32 saveMask = __osDisableInt();
+
+    __osViNext->msgq = mq;
+    __osViNext->msg = m;
+    __osViNext->retraceCount = retraceCount;
+
+    __osRestoreInt(saveMask);
+}

src/libultra/io/aigetlen.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+u32 osAiGetLength(void) {
+    return *(u32*)0xA4500004;
+}

src/libultra/io/contreaddata.c

@@ -0,0 +1,64 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 osContStartReadData(OSMesgQueue* mq) {
+    s32 ret;
+    int i;
+
+    __osSiGetAccess();
+
+    if (__osContLastCmd != 1) {
+        __osPackReadData();
+        __osSiRawStartDma(1, &__osContPifRam);
+        osRecvMesg(mq, NULL, 1);
+    }
+
+    ret = __osSiRawStartDma(0, &__osContPifRam);
+    __osContLastCmd = 1;
+
+    __osSiRelAccess();
+
+    return ret;
+}
+
+void osContGetReadData(OSContPad* data) {
+    u8* ptr;
+    __OSContReadFormat readformat;
+    int i;
+
+    ptr = (u8*)__osContPifRam.ramarray;
+    for (i = 0; i < __osMaxControllers; i++, ptr += sizeof(__OSContReadFormat), data++) {
+        readformat = *(__OSContReadFormat*)ptr;
+        data->errno = (readformat.rxsize & 0xc0) >> 4;
+        if (data->errno == 0) {
+            data->button = readformat.button;
+            data->stick_x = readformat.stick_x;
+            data->stick_y = readformat.stick_y;
+        }
+    };
+}
+
+void __osPackReadData() {
+    u8* ptr;
+    __OSContReadFormat readformat;
+    int i;
+
+    ptr = (u8*)__osContPifRam.ramarray;
+    for (i = 0; i < 0xF; i++) {
+        __osContPifRam.ramarray[i] = 0;
+    }
+
+    __osContPifRam.pifstatus = 1;
+    readformat.dummy = 255;
+    readformat.txsize = 1;
+    readformat.rxsize = 4;
+    readformat.cmd = 1;
+    readformat.button = 65535;
+    readformat.stick_x = -1;
+    readformat.stick_y = -1;
+    for (i = 0; i < __osMaxControllers; i++) {
+        *(__OSContReadFormat*)ptr = readformat;
+        ptr+=sizeof(__OSContReadFormat);
+    }
+    *ptr = 254;
+}

src/libultra/io/contsetch.c

@@ -0,0 +1,16 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 osContSetCh(u8 ch) {
+    __osSiGetAccess();
+
+    if (4 < ch) {
+        __osMaxControllers = 4;
+    } else {
+        __osMaxControllers = ch;
+    }
+    __osContLastCmd = -2;
+
+    __osSiRelAccess();
+    return 0;
+}

src/libultra/io/dpgetstat.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+u32 osDpGetStatus(void) {
+    return *(u32*)0xA410000C;
+}

src/libultra/io/dpsetstat.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osDpSetStatus(u32 data) {
+    *(u32*)0xA410000C = data;
+}

src/libultra/io/epidma.c

@@ -0,0 +1,25 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 osEPiStartDma(OSPiHandle* pihandle, OSIoMesg* mb, s32 direction) {
+    register s32 result;
+
+    if (!__osPiDevMgr.active) {
+        return -1;
+    }
+
+    mb->piHandle = pihandle;
+
+    if (direction == 0) {
+        mb->hdr.type = 15;
+    } else {
+        mb->hdr.type = 16;
+    }
+
+    if (mb->hdr.pri == 1) {
+        result = osJamMesg(osPiGetCmdQueue(), mb, 0);
+    } else {
+        result = osSendMesg(osPiGetCmdQueue(), mb, 0);
+    }
+    return result;
+}

src/libultra/io/piacs.c

@@ -0,0 +1,20 @@
+#include <ultra64.h>
+#include <global.h>
+
+void __osPiCreateAccessQueue(void) {
+    __osPiAccessQueueEnabled = 1;
+    osCreateMesgQueue(&__osPiAccessQueue, D_8009E3F0, 1);
+    osSendMesg(&__osPiAccessQueue, NULL, 0);
+}
+
+void __osPiGetAccess(void) {
+    OSMesg dummyMesg;
+    if (!__osPiAccessQueueEnabled) {
+        __osPiCreateAccessQueue();
+    }
+    osRecvMesg(&__osPiAccessQueue, &dummyMesg, 1);
+}
+
+void __osPiRelAccess(void) {
+    osSendMesg(&__osPiAccessQueue, NULL, 0);
+}

src/libultra/io/pigetcmdq.c

@@ -0,0 +1,10 @@
+#include <ultra64.h>
+#include <global.h>
+
+OSMesgQueue* osPiGetCmdQueue(void) {
+    if (!__osPiDevMgr.active) {
+        return NULL;
+    }
+
+    return __osPiDevMgr.cmdQueue;
+}

src/libultra/io/pimgr.c

@@ -0,0 +1,37 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgCnt) {
+    u32 savedMask;
+    OSPri oldPri;
+    OSPri myPri;
+
+    if (!__osPiDevMgr.active) {
+        osCreateMesgQueue(cmdQ, cmdBuf, cmdMsgCnt);
+        osCreateMesgQueue(&D_8009E3D0, D_8009E3E8, 1);
+        if (!__osPiAccessQueueEnabled) {
+            __osPiCreateAccessQueue();
+        }
+        osSetEventMesg(8, &D_8009E3D0, (OSMesg) 0x22222222);
+        oldPri = -1;
+        myPri = osGetThreadPri(NULL);
+        if (myPri < pri) {
+            oldPri = myPri;
+            osSetThreadPri(NULL, pri);
+        }
+        savedMask = __osDisableInt();
+        __osPiDevMgr.active = 1;
+        __osPiDevMgr.thread = &D_8009D220;
+        __osPiDevMgr.cmdQueue = cmdQ;
+        __osPiDevMgr.evtQueue = &D_8009E3D0;
+        __osPiDevMgr.acsQueue = &__osPiAccessQueue;
+        __osPiDevMgr.dma = (s32(*)(void))osPiRawStartDma;
+        __osPiDevMgr.unk18 = (s32(*)(void))func_800900C0;
+        osCreateThread(&D_8009D220, 0, __osDevMgrMain, (void *) &__osPiDevMgr, &piManagerStack[4096], pri);
+        osStartThread(&D_8009D220);
+        __osRestoreInt(savedMask);
+        if (oldPri != -1) {
+            osSetThreadPri(NULL, oldPri);
+        }
+    }
+}

src/libultra/io/pirawdma.c

@@ -0,0 +1,27 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 osPiRawStartDma(s32 direction, u32 devAddr, void* dramAddr, u32 size) {
+    register int stat;
+
+    stat = *(vu32*)0xA4600010;
+    while (stat & (2 | 1)) {
+        stat = *(vu32*)0xA4600010;
+    }
+
+    *(u32*)0xA4600000 = osVirtualToPhysical(dramAddr);
+
+    *(u32*)0xA4600004 = ((osRomBase | devAddr) & 0x1fffffff);
+
+    switch (direction) {
+    case 0:
+        *(u32*)0xA460000C = size - 1;
+        break;
+    case 1:
+        *(u32*)0xA4600008 = size - 1;
+        break;
+    default:
+        return -1;
+    }
+    return 0;
+}

src/libultra/io/si.c

@@ -0,0 +1,12 @@
+#include <ultra64.h>
+#include <global.h>
+
+int __osSiDeviceBusy() {
+    register u32 status;
+    status = *(u32*)0xA4800018;
+    if (status & 3) {
+        return 1;
+    } else {
+        return 0;
+    }
+}

src/libultra/io/siacs.c

@@ -0,0 +1,20 @@
+#include <ultra64.h>
+#include <global.h>
+
+void __osSiCreateAccessQueue() {
+    __osSiAccessQueueEnabled = 1;
+    osCreateMesgQueue(&__osSiAccessQueue, siAccessBuf, 1);
+    osSendMesg(&__osSiAccessQueue, NULL, 0);
+}
+
+void __osSiGetAccess(void) {
+    OSMesg dummyMesg;
+    if (!__osSiAccessQueueEnabled) {
+        __osSiCreateAccessQueue();
+    }
+    osRecvMesg(&__osSiAccessQueue, &dummyMesg, 1);
+}
+
+void __osSiRelAccess(void) {
+    osSendMesg(&__osSiAccessQueue, NULL, 0);
+}

src/libultra/io/sirawdma.c

@@ -0,0 +1,25 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 __osSiRawStartDma(s32 direction, void* dramAddr) {
+    if ((*(u32*)0xA4800018 & 0x3) != 0) {
+        return -1;
+    }
+
+    if (direction == 1) {
+        osWritebackDCache(dramAddr, 64);
+    }
+
+    *(u32*)0xA4800000 = osVirtualToPhysical(dramAddr);
+
+    if (direction == 0) {
+        *(u32*)0xA4800004 = 0x1FC007C0;
+    } else {
+        *(u32*)0xA4800010 = 0x1FC007C0;
+    }
+
+    if (direction == 0) {
+        osInvalDCache(dramAddr, 64);
+    }
+    return 0;
+}

src/libultra/io/sirawread.c

@@ -0,0 +1,10 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 __osSiRawReadIo(u32 devAddr, u32* data) {
+    if (__osSiDeviceBusy()) {
+        return -1;
+    }
+    *data = *(u32*)(devAddr | 0xA0000000);
+    return 0;
+}

src/libultra/io/sptaskyield.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osSpTaskYield(void) {
+    __osSpSetStatus(0x400);
+}

src/libultra/io/sptaskyielded.c

@@ -0,0 +1,18 @@
+#include <ultra64.h>
+#include <global.h>
+
+OSYieldResult osSpTaskYielded(OSTask* task) {
+    s32 status;
+    OSYieldResult result;
+    status = __osSpGetStatus();
+    if (status & 0x100) {
+        result = 1;
+    } else {
+        result = 0;
+    }
+    if (status & 0x80) {
+        task->t.flags |= result;
+        task->t.flags &= ~(2);
+    }
+    return result;
+}

src/libultra/io/vi.c

@@ -0,0 +1,28 @@
+#include <ultra64.h>
+#include <global.h>
+
+void __osViInit(void) {
+    bzero(D_80098060, sizeof(D_80098060));
+    __osViCurr = &D_80098060[0];
+    __osViNext = &D_80098060[1];
+    __osViNext->retraceCount = 1;
+    __osViCurr->retraceCount = 1;
+    __osViNext->framep = (void*)0x80000000;
+    __osViCurr->framep = (void*)0x80000000;
+
+    if (osTvType == 0) {
+        __osViNext->modep = &osViModePalLan1;
+    } else if (osTvType == 2) {
+        __osViNext->modep = &osViModeMpalLan1;
+    } else {
+        __osViNext->modep = &osViModeNtscLan1;
+    }
+
+    __osViNext->state = 0x20;
+    __osViNext->control = __osViNext->modep->comRegs.ctrl;
+
+    while (*(vu32*)0xA4400010 > 10);
+    *(vu32*)0xA4400000 = 0;
+
+    __osViSwapContext();
+}

src/libultra/io/vigetnextframebuf.c

@@ -0,0 +1,15 @@
+#include <ultra64.h>
+#include <global.h>
+
+void* osViGetNextFramebuffer(void) {
+    register u32 saveMask;
+    void* framep;
+
+    saveMask = __osDisableInt();
+
+    framep = __osViNext->framep;
+
+    __osRestoreInt(saveMask);
+
+    return framep;
+}

src/libultra/io/virepeatline.c

@@ -0,0 +1,16 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViRepeatLine(u8 active) {
+    register u32 saveMask;
+
+    saveMask = __osDisableInt();
+
+    if (active) {
+        __osViNext->state |= 0x20;
+    } else {
+        __osViNext->state &= 0xffdf;
+    }
+
+    __osRestoreInt(saveMask);
+}

src/libultra/io/visetmode.c

@@ -0,0 +1,14 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViSetMode(OSViMode* modep) {
+    register u32 saveMask;
+
+    saveMask = __osDisableInt();
+
+    __osViNext->modep = modep;
+    __osViNext->state = 1;
+    __osViNext->control = __osViNext->modep->comRegs.ctrl;
+
+    __osRestoreInt(saveMask);
+}

src/libultra/io/visetspecial.c

@@ -0,0 +1,39 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViSetSpecialFeatures(u32 func) {
+    register u32 saveMask = __osDisableInt();
+
+    if (func & 1) {
+        __osViNext->control |= 8;
+    }
+    if (func & 2) {
+        __osViNext->control &= ~8;
+    }
+    if (func & 4) {
+        __osViNext->control |= 4;
+    }
+    if (func & 8) {
+
+        __osViNext->control &= ~4;
+    }
+    if (func & 0x10) {
+
+        __osViNext->control |= 0x10;
+    }
+    if (func & 0x20) {
+
+        __osViNext->control &= ~0x10;
+    }
+    if (func & 0x40) {
+        __osViNext->control |= 0x10000;
+        __osViNext->control &= ~0x300;
+    }
+    if (func & 0x80) {
+        __osViNext->control &= ~0x10000;
+        __osViNext->control |= __osViNext->modep->comRegs.ctrl & 0x300;
+    }
+    __osViNext->state |= 8;
+
+    __osRestoreInt(saveMask);
+}

src/libultra/io/visetxscale.c

@@ -0,0 +1,18 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViSetXScale(f32 value) {
+    register u32 nomValue;
+    register u32 saveMask;
+
+    saveMask = __osDisableInt();
+
+    __osViNext->x.factor = value;
+
+    __osViNext->state |= 0x2;
+
+    nomValue = __osViNext->modep->comRegs.xScale & 0xfff;
+    __osViNext->x.scale = (u32)(__osViNext->x.factor * nomValue) & 0xFFF;
+
+    __osRestoreInt(saveMask);
+}

src/libultra/io/visetyscale.c

@@ -3,12 +3,12 @@
 #include <viint.h>
 #include <assert.h>
 
-void osViSetYScale(f32 f12) {
+void osViSetYScale(f32 value) {
     register u32 saveMask;
 
     saveMask = __osDisableInt();
 
-    __osViNext->y.factor = f12;
+    __osViNext->y.factor = value;
 
     __osViNext->state |= 0x4;
 

src/libultra/io/viswapbuf.c

@@ -0,0 +1,12 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osViSwapBuffer(void* frameBufPtr) {
+
+    u32 saveMask = __osDisableInt();
+
+    __osViNext->framep = frameBufPtr;
+    __osViNext->state |= 0x10;
+
+    __osRestoreInt(saveMask);
+}

src/libultra/libc/ldiv.c

@@ -0,0 +1,28 @@
+#include <ultra64.h>
+#include <global.h>
+
+ldiv_t ldiv(long numer, long denom) {
+    ldiv_t val;
+
+    val.quot = numer / denom;
+    val.rem = numer - denom * val.quot;
+    if (val.quot < 0 && val.rem > 0) {
+        val.quot++;
+        val.rem -= denom;
+    }
+
+    return val;
+}
+
+lldiv_t lldiv(long long numer, long long denom) {
+    lldiv_t val;
+
+    val.quot = numer / denom;
+    val.rem = numer - denom * val.quot;
+    if (val.quot < 0 && val.rem > 0) {
+        val.quot++;
+        val.rem -= denom;
+    }
+
+    return val;
+}

src/libultra/libc/ll.c

@@ -0,0 +1,47 @@
+#include <ultra64.h>
+#include <global.h>
+
+long long __ull_rshift(unsigned long long left, unsigned long long right) {
+    return left >> right;
+}
+
+unsigned long long __ull_rem(unsigned long long left, unsigned long long right) {
+    return left % right;
+}
+
+unsigned long long __ull_div(unsigned long long left, unsigned long long right) {
+    return left / right;
+}
+
+long long __ll_lshift(long long left, long long right) {
+    return left << right;
+}
+
+long long __ll_rem(long long left, unsigned long long right) {
+    return left % right;
+}
+
+long long __ll_div(long long left, long long right) {
+    return left / right;
+}
+
+long long __ll_mul(long long left, long long right) {
+    return left * right;
+}
+
+void __ull_divremi(unsigned long long *quotient, unsigned long long *remainder, unsigned long long dividend, unsigned short divisor) {
+    *quotient = dividend / divisor;
+    *remainder = dividend % divisor;
+}
+
+long long __ll_mod(long long left, long long right) {
+    long long rem = left % right;
+    if ((rem < 0 && right > 0) || (rem > 0 && right < 0)) {
+        rem += right;
+    }
+    return rem;
+}
+
+long long __ll_rshift(long long left, long long right) {
+    return left >> right;
+}

src/libultra/libc/llcvt.c

@@ -0,0 +1,34 @@
+#include <ultra64.h>
+#include <global.h>
+
+long long __d_to_ll(double d) {
+    return d;
+}
+
+long long __f_to_ll(float f) {
+    return f;
+}
+
+unsigned long long __d_to_ull(double d) {
+    return d;
+}
+
+unsigned long long __f_to_ull(float f) {
+    return f;
+}
+
+double __ll_to_d(long long s) {
+    return s;
+}
+
+float __ll_to_f(long long s) {
+    return s;
+}
+
+double __ull_to_d(unsigned long long u) {
+    return u;
+}
+
+float __ull_to_f(unsigned long long u) {
+    return u;
+}

src/libultra/os/createmesgqueue.c

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

src/libultra/os/getactivequeue.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+OSThread* __osGetActiveQueue(void){
+    return __osActiveQueue;
+}

src/libultra/os/getmemsize.c

@@ -1,7 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-u32 func_8008D350(void) {
+u32 osGetMemSize(void) {
     u32* spC;
     u32 sp8;
     u32 sp4;

src/libultra/os/gettime.c

@@ -0,0 +1,19 @@
+#include <ultra64.h>
+#include <global.h>
+
+OSTime osGetTime(void) {
+    u32 CurrentCount;
+    u32 elapseCount;
+    OSTime sp28;
+    register u32 savedMask;
+
+    savedMask = __osDisableInt();
+
+    CurrentCount = osGetCount();
+    elapseCount = CurrentCount - __osBaseCounter;
+    sp28 = __osCurrentTime;
+
+    __osRestoreInt(savedMask);
+
+    return elapseCount + sp28;
+}

src/libultra/os/initialize.c

@@ -2,16 +2,16 @@
 #include <osint.h>
 
 void func_8008A660(void) {
-    D_8009D134 = 7;
-    D_8009D135 = *(u32*)0xA4600014;
-    D_8009D138 = *(u32*)0xA4600018;
-    D_8009D136 = *(u32*)0xA460001C;
-    D_8009D137 = *(u32*)0xA4600020;
-    D_8009D1AC = 7;
-    D_8009D1AD = *(u32*)0xA4600024;
-    D_8009D1B0 = *(u32*)0xA4600028;
-    D_8009D1AE = *(u32*)0xA460002C;
-    D_8009D1AF = *(u32*)0xA4600030;
+    D_8009D130.type = 7;
+    D_8009D130.latency = *(u32*)0xA4600014;
+    D_8009D130.pageSize = *(u32*)0xA4600018;
+    D_8009D130.relDuration = *(u32*)0xA460001C;
+    D_8009D130.pulse = *(u32*)0xA4600020;
+    D_8009D1A8.type = 7;
+    D_8009D1A8.latency = *(u32*)0xA4600024;
+    D_8009D1A8.pageSize = *(u32*)0xA4600028;
+    D_8009D1A8.relDuration = *(u32*)0xA460002C;
+    D_8009D1A8.pulse = *(u32*)0xA4600030;
 }
 
 u64 D_80097E50; // this has to be defined in this file for func_8008A6FC to match

src/libultra/os/settime.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osSetTime(OSTime ticks) {
+    __osCurrentTime = ticks;
+}

src/libultra/os/settimer.c

@@ -0,0 +1,42 @@
+#include <ultra64.h>
+#include <global.h>
+
+int osSetTimer(OSTimer* t, OSTime value, OSTime interval, OSMesgQueue* mq, OSMesg msg) {
+    OSTime tim;
+    OSTimer* spC;
+    u32 sp14;
+    u32 sp10;
+    u32 saveMask;
+
+    t->next = NULL;
+    t->prev = NULL;
+    t->interval = interval;
+    if (value != 0) {
+        t->value = value;
+    } else {
+        t->value = interval;
+    }
+    t->mq = mq;
+    t->msg = msg;
+
+    saveMask = __osDisableInt();
+
+    if (__osTimerList->next != __osTimerList) {
+        if (0);
+        spC = __osTimerList->next;
+        sp14 = osGetCount();
+        sp10 = sp14 - __osTimerCounter;
+        if (sp10 < spC->value) {
+            spC->value -= sp10;
+        } else {
+            spC->value = 1;
+        }
+    }
+
+    tim = __osInsertTimer(t);
+    __osSetTimerIntr(__osTimerList->next->value);
+
+    __osRestoreInt(saveMask);
+
+    return 0;
+}

src/libultra/os/timerintr.c

@@ -0,0 +1,98 @@
+#include <ultra64.h>
+#include <global.h>
+
+OSTime __osCurrentTime;
+u32 __osBaseCounter;
+u32 __osViIntrCount;
+u32 __osTimerCounter;
+
+void __osTimerServicesInit(void) {
+    __osCurrentTime = 0;
+    __osBaseCounter = 0;
+    __osViIntrCount = 0;
+    __osTimerList->prev = __osTimerList;
+    __osTimerList->next = __osTimerList->prev;
+    __osTimerList->value = 0;
+    __osTimerList->interval = __osTimerList->value;
+    __osTimerList->mq = NULL;
+    __osTimerList->msg = NULL;
+}
+
+void __osTimerInterrupt(void) {
+    OSTimer* t;
+    u32 count;
+    u32 elapsed_cycles;
+    if (__osTimerList->next == __osTimerList) {
+        return;
+    }
+    while (1) {
+        t = __osTimerList->next;
+        if (t == __osTimerList) {
+            __osSetCompare(0);
+            __osTimerCounter = 0;
+            break;
+        }
+        count = osGetCount();
+        elapsed_cycles = count - __osTimerCounter;
+        __osTimerCounter = count;
+        if (elapsed_cycles < t->value) {
+            t->value -= elapsed_cycles;
+            __osSetTimerIntr(t->value);
+            return;
+        } else {
+            t->prev->next = t->next;
+            t->next->prev = t->prev;
+            t->next = NULL;
+            t->prev = NULL;
+            if (t->mq != NULL) {
+                osSendMesg(t->mq, t->msg, 0);
+            }
+            if (t->interval != 0) {
+                t->value = t->interval;
+                __osInsertTimer(t);
+            }
+        }
+    }
+}
+
+void __osSetTimerIntr(OSTime tim) {
+    OSTime NewTime;
+    u32 savedMask;
+
+    if (tim < 468) {
+        tim = 468;
+    }
+
+    savedMask = __osDisableInt();
+
+    __osTimerCounter = osGetCount();
+    NewTime = tim + __osTimerCounter;
+    __osSetCompare(NewTime);
+
+    __osRestoreInt(savedMask);
+}
+
+OSTime __osInsertTimer(OSTimer* t) {
+    OSTimer* timep;
+    OSTime tim;
+    u32 savedMask;
+
+    savedMask = __osDisableInt();
+
+    for (timep = __osTimerList->next, tim = t->value; timep != __osTimerList && tim > timep->value;
+         tim -= timep->value, timep = timep->next) {
+        ;
+    }
+    t->value = tim;
+    if (timep != __osTimerList) {
+        timep->value -= tim;
+    }
+    t->next = timep;
+    t->prev = timep->prev;
+    timep->prev->next = t;
+    timep->prev = t;
+
+    __osRestoreInt(savedMask);
+
+    return tim;
+}

src/libultra/os/yieldthread.c

@@ -0,0 +1,11 @@
+#include <ultra64.h>
+#include <global.h>
+
+void osYieldThread(void) {
+    register u32 saveMask = __osDisableInt();
+
+    __osRunningThread->state = 2;
+    __osEnqueueAndYield(&__osRunQueue);
+
+    __osRestoreInt(saveMask);
+}

src/libultra/rmon/sprintf.c

@@ -0,0 +1,26 @@
+#include <ultra64.h>
+#include <global.h>
+
+void* proutSprintf(void* dst, char* fmt, size_t size) {
+    return (char*)memcpy(dst, fmt, size) + size;
+}
+
+int vsprintf(char* dst, char* fmt, va_list args) {
+    int ans = _Printf(&proutSprintf, dst, fmt, args);
+    if (ans > -1) {
+        dst[ans] = 0;
+    }
+    return ans;
+}
+
+int sprintf(char* dst, char* fmt, ...) {
+    int ans;
+    va_list ap;
+    va_start(ap, fmt);
+
+    ans = _Printf(&proutSprintf, dst, fmt, ap);
+    if (ans > -1) {
+        dst[ans] = 0;
+    }
+    return ans;
+}

src/libultra/rmon/xprintf.c

@@ -0,0 +1,233 @@
+#include <ultra64.h>
+#include <global.h>
+
+#define ATOI(i, a)                                                                                     \
+    for (i = 0; *a >= '0' && *a <= '9'; a++)                                                           \
+        if (i < 999)                                                                                   \
+            i = *a + i * 10 - '0';
+#define _PROUT(fmt, _size)                                                                        \
+    if (_size > 0) {                                                                                   \
+        arg = (void*)pfn(arg, fmt, _size);                                                                  \
+        if (arg != 0)                                                                                  \
+            x.nchar += _size;                                                                        \
+        else                                                                                           \
+            return x.nchar;                                                                          \
+    }
+#define _PAD(m, src, extracond)                                                                       \
+    if (extracond && m > 0) {                                                                          \
+        int i;                                                                                         \
+        int j;                                                                                         \
+        for (j = m; j > 0; j -= i) {                                                                   \
+            if ((u32) j > 32)                                                                          \
+                i = 32;                                                                                \
+            else                                                                                       \
+                i = j;                                                                                 \
+            _PROUT(src, i);                                                                       \
+        }                                                                                              \
+    }
+
+#define FLAGS_SPACE 1
+#define FLAGS_PLUS 2
+#define FLAGS_MINUS 4
+#define FLAGS_HASH 8
+#define FLAGS_ZERO 16
+
+// TODO .data section should be included after boot .data is split
+//char spaces[] = "                                ";
+//char zeroes[] = "00000000000000000000000000000000";
+
+int _Printf(printf_func pfn, void* arg, char* fmt, va_list ap) {
+    _Pft x;
+    x.nchar = 0;
+    while (1) {
+        unsigned char* s;
+        unsigned char c;
+        unsigned char* t;
+
+        static const char fchar[] = " +-#0";
+        static const u32 fbit[] = { FLAGS_SPACE, FLAGS_PLUS, FLAGS_MINUS, FLAGS_HASH, FLAGS_ZERO, 0 };
+
+        unsigned char ac[0x20];
+
+        s = fmt;
+        while ((c = *s) != 0 && c != '%') {
+            s++;
+        }
+        _PROUT(fmt, s - fmt);
+        if (c == 0) {
+            return x.nchar;
+        }
+        fmt = (char *) ++s;
+        x.flags = 0;
+        // TODO the cast isn't necessary because strchr should take it in as const, but it currently doesn't
+        for (; (t = strchr((char*)fchar, *s)) != NULL; s++) {
+            x.flags |= fbit[t - fchar];
+        }
+        if (*s == '*') {
+            x.width = va_arg(ap, s32);
+            if (x.width < 0) {
+                x.width = -x.width;
+                x.flags |= FLAGS_MINUS;
+            }
+            s++;
+        } else {
+            ATOI(x.width, s);
+        }
+        if (*s != '.') {
+            x.prec = -1;
+        } else {
+            s++;
+            if (*s == '*') {
+                x.prec = va_arg(ap, s32);
+                s++;
+            } else {
+                ATOI(x.prec, s);
+            }
+        }
+        if (strchr("hlL", *s) != NULL) {
+            x.qual = *s++;
+        } else {
+            x.qual = 0;
+        }
+
+        if (x.qual == 'l' && *s == 'l') {
+            x.qual = 'L';
+            s++;
+        }
+        _Putfld(&x, &ap, *s, ac);
+        x.width -= x.n0 + x.nz0 + x.n1 + x.nz1
+                      + x.n2 + x.nz2;
+        _PAD(x.width, spaces, !(x.flags & FLAGS_MINUS));
+        _PROUT((char *) ac, x.n0);
+        _PAD(x.nz0, zeroes, 1);
+        _PROUT(x.s, x.n1);
+        _PAD(x.nz1, zeroes, 1);
+        _PROUT((char *) (&x.s[x.n1]), x.n2)
+        _PAD(x.nz2, zeroes, 1);
+        _PAD(x.width, spaces, x.flags & FLAGS_MINUS);
+        fmt = (char *) s + 1;
+    }
+}
+
+void _Putfld(_Pft* px, va_list* pap, unsigned char code, unsigned char* ac) {
+    px->n0 = px->nz0 = px->n1 = px->nz1 = px->n2 =
+        px->nz2 = 0;
+
+    switch (code) {
+
+        case 'c':
+            ac[px->n0++] = va_arg(*pap, u32);
+            break;
+
+        case 'd':
+        case 'i':
+            if (px->qual == 'l') {
+                px->v.ll = va_arg(*pap, s32);
+            } else if (px->qual == 'L') {
+                px->v.ll = va_arg(*pap, s64);
+            } else {
+                px->v.ll = va_arg(*pap, s32);
+            }
+
+            if (px->qual == 'h') {
+                px->v.ll = (s16) px->v.ll;
+            }
+
+            if (px->v.ll < 0) {
+                ac[px->n0++] = '-';
+            } else if (px->flags & FLAGS_PLUS) {
+                ac[px->n0++] = '+';
+            } else if (px->flags & FLAGS_SPACE) {
+                ac[px->n0++] = ' ';
+            }
+
+            px->s = (char *) &ac[px->n0];
+
+            _Litob(px, code);
+            break;
+
+        case 'x':
+        case 'X':
+        case 'u':
+        case 'o':
+            if (px->qual == 'l') {
+                px->v.ll = va_arg(*pap, s32);
+            } else if (px->qual == 'L') {
+                px->v.ll = va_arg(*pap, s64);
+            } else {
+                px->v.ll = va_arg(*pap, s32);
+            }
+
+            if (px->qual == 'h') {
+                px->v.ll = (u16) px->v.ll;
+            } else if (px->qual == 0) {
+                px->v.ll = (u32) px->v.ll;
+            }
+
+            if (px->flags & FLAGS_HASH) {
+                ac[px->n0++] = '0';
+                if (code == 'x' || code == 'X') {
+
+                    ac[px->n0++] = code;
+                }
+            }
+            px->s = (char *) &ac[px->n0];
+            _Litob(px, code);
+            break;
+
+        case 'e':
+        case 'f':
+        case 'g':
+        case 'E':
+        case 'G':
+            px->v.ld = px->qual == 'L' ? va_arg(*pap, f64) : va_arg(*pap, f64);
+
+            if (*(u16*)&px->v.ll & 0x8000) {
+                ac[px->n0++] = '-';
+            } else {
+                if (px->flags & FLAGS_PLUS) {
+                    ac[px->n0++] = '+';
+                } else if (px->flags & FLAGS_SPACE) {
+                    ac[px->n0++] = ' ';
+                }
+            }
+
+            px->s = (char *) &ac[px->n0];
+            _Ldtob(px, code);
+            break;
+
+        case 'n':
+            if (px->qual == 'h') {
+                *(va_arg(*pap, u16 *)) = px->nchar;
+            } else if (px->qual == 'l') {
+                *va_arg(*pap, u32 *) = px->nchar;
+            } else if (px->qual == 'L') {
+                *va_arg(*pap, u64 *) = px->nchar;
+            } else {
+                *va_arg(*pap, u32 *) = px->nchar;
+            }
+            break;
+
+        case 'p':
+            px->v.ll = (long) va_arg(*pap, void *);
+            px->s = (char *) &ac[px->n0];
+            _Litob(px, 'x');
+            break;
+
+        case 's':
+            px->s = va_arg(*pap, char *);
+            px->n1 = strlen(px->s);
+            if (px->prec >= 0 && px->n1 > px->prec) {
+                px->n1 = px->prec;
+            }
+            break;
+
+        case '%':
+            ac[px->n0++] = '%';
+            break;
+
+        default:
+            ac[px->n0++] = code;
+            break;
+    }
+}