Dump current status

src/boot/boot_0x80080060.c

@@ -0,0 +1,128 @@
+#include <ultra64.h>
+#include <global.h>
+
+UNK_RET func_80080060(void) {
+	func_80085320(&D_80099500, &D_80099AF0, &D_80099EF0, 0, -1, &D_80098190);
+	D_80000318 = func_8008D350();
+	func_800818F4();
+	func_8008A6FC();
+	func_8008EDE0();
+	D_80096B40 = func_80092920();
+	func_80085320(&D_80099AD0, &D_800996D0, &D_80099AD0_, 0, 256, &D_80098198);
+	osCreateThread(&D_80099520, 1, (void(*)(void*))func_80080514, 0, &D_80099AD0, 12);
+	func_800957B0(&D_80099520);
+}
+
+void func_80080150(UNK_PTR a0, UNK_PTR a1) {
+	if (a0 < a1) {
+		func_80089630(a0, (u32)a1 - (u32)a0);
+	}
+}
+
+void func_80080180(UNK_TYPE* a0, UNK_TYPE a1, UNK_TYPE a2) {
+	for (; a1 != 0; a1 -= 4) {
+		*a0++ = a2;
+	}
+}
+
+UNK_RET func_8008019C(void) {
+	func_80080180(&D_80000500, 0x25800, 0x00010001);
+	func_800805E0(0);
+	func_8008FE60(&D_80000500);
+	func_8008AE70(0);
+}
+
+UNK_RET func_800801EC(void) {
+	func_80080150((void*)0x80000400, &D_80000500);
+	func_80080150(&D_80025D00, (int*)func_80080060);
+	func_80080150(&D_80208EA0, (UNK_PTR)(0x80000000 + D_80000318));
+}
+
+UNK_RET func_80080250(void) {
+	UNK_PTR v0;
+	UNK_PTR v1;
+	UNK_PTR t7;
+	UNK_TYPE sp88;
+	UNK_TYPE sp84;
+	UNK_TYPE sp80;
+	UNK_TYPE sp76;
+	UNK_TYPE sp72;
+	UNK_TYPE sp68;
+	UNK_TYPE sp64;
+	UNK_TYPE sp60;
+	UNK_TYPE sp56;
+	UNK_TYPE sp52;
+	UNK_TYPE sp48;
+	UNK_TYPE sp44;
+	UNK_PTR sp40;
+	
+	func_8008F240(&sp48, &sp44, 1);
+	
+	v1 = &D_00B3C000;
+	t7 = &D_00C7A4E0;
+	sp40 = D_80096B50;
+	*(int*)sp40 = 0;
+	
+	func_80080C04(&sp72, (UNK_FUN_ARG)func_800A5AC0, v1, (u32)t7 - (u32)v1, 0, &sp48, 0);
+	func_8008019C();
+	func_800801EC();
+	func_80087ED0(&sp48, 0, 1);
+	
+	D_80096B50 = sp40;
+	
+	func_80080150(&D_801E3FA0, &D_80208EA0);
+}
+
+UNK_RET func_80080300(UNK_TYPE a0) {
+	func_80085320(&D_8009A670, &D_8009A170, &D_8009A670_, 0, 256, &D_800981A0);
+	func_80081754(&D_80099EF0, &D_8009A670, 18, 1);
+	func_80080D0C();
+	func_80080250();
+	func_80174BF0(a0);
+	func_80080E00();
+}
+
+void func_8008038C(void) {
+	u32 i;
+	func_800952A0(254);
+	
+	D_80096B2C = 66;
+	D_80096B30 = 1.0;
+	D_80096B34 = 1.0;
+	
+	switch (osTvType) {
+		case 1:
+		D_8009B290 = 2;
+		for (i = 0; i < 20; i++) {
+			D_800980E0[i] = D_8009B240[i];
+		}
+		D_80096B34 = D_800981B0;
+		break;
+		case 2:
+		D_8009B290 = 30;
+		for (i = 0; i < 20; i++) {
+			D_80098010[i] = D_8009B240[i];
+		}
+		D_80096B34 = D_800981B0;
+		break;
+		case 0:
+		D_8009B290 = 44;
+		for (i = 0; i < 20; i++) {
+			D_80097FC0[i] = D_8009B240[i];
+		}
+		break;
+	}
+	
+	D_80096B20 = 1;
+}
+
+void func_80080514(UNK_TYPE a0) {
+	func_8008038C();
+	func_8008C020(150, &D_8009B228, &D_8009B160, 50);
+	func_80085320(&D_8009B140, &D_8009A840, &D_8009B140_, 0, 1024, &D_800981A8);
+	func_80089E40(&D_8009A690, 3, func_80080300, a0, &D_8009B140, 12);
+	func_800957B0(&D_8009A690);
+	func_8008FC00(0, 0);
+	
+	while(1);
+}

src/boot/boot_0x800805E0.c

@@ -0,0 +1,55 @@
+#include <ultra64.h>
+#include <global.h>
+
+UNK_RET func_800805E0(UNK_TYPE a0) {
+	if (a0 != 0) {
+		switch (osTvType) {
+		case 2:
+			func_8008B650(&D_80098010);
+			break;
+		case 0:
+			func_8008B650(&D_80097590);
+			break;
+		case 1:
+			default:
+			func_8008B650(&D_80097FC0);
+			break;
+		}
+		
+		if (D_80096B2C != 0) {
+			func_80092100(D_80096B2C);
+		}
+		
+		if (D_80096B34 != 1) {
+			func_80095900(1);
+		}
+	} else {
+		func_8008B650(&D_8009B240);
+		
+		if (D_80096B28 != 0) {
+			func_80087E00(D_80096B28);
+		}
+		
+		if (D_80096B2C != 0) {
+			func_80092100(D_80096B2C);
+		}
+		
+		if (D_80096B30 != 1) {
+			func_80095950(D_80096B30);
+		}
+		
+		if (D_80096B34 != 1) {
+			func_80095900(D_80096B34);
+		}
+	}
+	
+	*D_80096B24 = a0;
+}
+
+UNK_RET func_80080748(void) {
+	if (*D_80096B24 != 0) {
+		func_8008AE70(1);
+	} else {
+		func_8008AE70(0);
+	}
+}

src/boot/boot_0x80081820.c

@@ -0,0 +1,25 @@
+#include <ultra64.h>
+#include <global.h>
+
+void func_80081820(void) {}
+
+void func_80081828(void) {}
+
+void func_80081830(void) {
+	func_8008481C(80, 200, &D_80098280, (UNK_PTR)(*(u32*)0xA4040010));
+	func_8008481C(40, 184, &D_80098290, &D_800994D0);
+	func_8008481C(56, 192, &D_800982A4, &D_800994DC);
+}
+
+void func_8008189C(void) {
+	func_800819F0(&D_8009BE38, (void(*)(UNK_TYPE, UNK_TYPE))func_80081830, 0, 0);
+}
+
+void func_800818D0(void) {
+	func_80081AD4(&D_8009BE38);
+}
+
+void func_800818F4(void) {
+	D_8009BE30 = *(u32*)0xA02FB1F4;
+	D_8009BE34 = *(u32*)0xA02FE1C0;
+}

src/boot/boot_0x80085320.c

@@ -0,0 +1,104 @@
+#include <ultra64.h>
+#include <global.h>
+
+void func_80085320(struct s80085320* a0, UNK_PTR a1, UNK_PTR a2, UNK_TYPE a3, UNK_TYPE sp16, UNK_PTR sp20) {
+	UNK_TYPE* i;
+	struct s80085320* v0;
+	
+	if (a0 == NULL) {
+		g_s80085320_ListHead = NULL;
+		return;
+	}
+	
+	a0->unk8 = a1;
+	a0->unk12 = a2;
+	a0->unk16 = a3;
+	a0->unk20 = sp16;
+	a0->unk24 = sp20;
+	
+	v0 = g_s80085320_ListHead;
+	while (v0 != NULL) {
+		if (v0 == a0) return;
+		v0 = v0->next;
+	}
+	
+	a0->prev = g_s80085320_ListTail;
+	a0->next = NULL;
+	
+	if (g_s80085320_ListTail != NULL) {
+		g_s80085320_ListTail->next = a0;
+	}
+	
+	g_s80085320_ListTail = a0;
+	
+	if (g_s80085320_ListHead == NULL) {
+		g_s80085320_ListHead = a0;
+	}
+	
+	if (a0->unk20 != -1) {
+		for (i = a0->unk8; i < a0->unk12; i++) {
+			*i = a0->unk16;
+		}
+	}
+}
+
+UNK_RET func_800853F8(struct s80085320* a0) {
+	if (a0->prev == NULL) {
+		if (g_s80085320_ListHead == a0) {
+			g_s80085320_ListHead = a0->next;
+		}
+	} else {
+		a0->prev->next = a0->next;
+	}
+	
+	if (a0->next == NULL) {
+		if (g_s80085320_ListTail == a0) {
+			g_s80085320_ListTail = a0->prev;
+		}
+	}
+}
+
+UNK_TYPE func_80085468(struct s80085320* a0) {
+	UNK_TYPE* v1 = a0->unk8;
+	UNK_TYPE* a1 = a0->unk12;
+	UNK_TYPE* v0 = v1;
+	u32 x; // ptr_diff
+	
+	while (v0 < a1) {
+		if (*v0++ != a0->unk16) break;
+		a1 = (UNK_TYPE*)((u32)v0 - (u32)v1);
+	}
+	
+	x = v0 - v1;
+	
+	if (x == 0) {
+		return 2;
+	}
+	
+	if ((x < a0->unk20) && (a0->unk20 != -1)) {
+		return 1;
+	}
+	
+	return 0;
+}
+
+UNK_TYPE func_800854E0(UNK_ARGS) {
+	struct s80085320* s0 = g_s80085320_ListHead;
+	UNK_TYPE ret = 0;
+	while (s0 != NULL) {
+		if (func_80085468(s0) != 0) {
+			ret = 1;
+		}
+		s0 = s0->next;
+	}
+	
+	return ret;
+}
+
+UNK_RET func_80085538(struct s80085320* a0) {
+	if (a0 == NULL) {
+		func_800854E0();
+	} else {
+		func_80085468(a0);
+	}
+}

src/boot/boot_0x80087830.c

@@ -0,0 +1,26 @@
+#include <ultra64.h>
+#include <global.h>
+
+UNK_TYPE func_80087830(UNK_TYPE a0, UNK_TYPE a1, UNK_TYPE a2) {
+	return func_8008F208(a0, a1) + a2;
+}
+
+UNK_TYPE func_80087854(u8* a0, UNK_TYPE a1, UNK_PTR a2) {
+	UNK_TYPE v0 = func_8008E050(func_80087830, a0, a1, a2);
+	
+	if (v0 >= 0) {
+		a0[v0] = 0;
+	}
+	
+	return v0;
+}
+
+UNK_TYPE func_800878A4(u8* a0, UNK_TYPE a1, UNK_TYPE a2, UNK_TYPE a3) {
+	UNK_TYPE v0 = func_8008E050(func_80087830, a0, a1, &a2);
+	
+	if (v0 >= 0) {
+		a0[v0] = 0;
+	}
+	
+	return v0;
+}

src/boot/boot_0x80087900.c

@@ -0,0 +1,30 @@
+#include <ultra64.h>
+#include <global.h>
+
+UNK_RET func_80087900(UNK_PTR a0, UNK_TYPE a1, UNK_PTR a2) {
+	func_8008E050((UNK_TYPE(*)(UNK_TYPE, UNK_TYPE, UNK_TYPE))(*(u32*)a0), a0, a1, a2);
+}
+
+UNK_RET func_80087934(UNK_PTR a0, UNK_TYPE a1, UNK_PTR a2, UNK_TYPE a3) {
+	func_80087900(a0, a1, &a2);
+}
+
+UNK_RET func_80087960(u64 a0) {
+	
+}
+
+UNK_RET func_800879CC(u32 a0) {
+	func_80087960(func_800888A8(func_800889A8(a0, 3), 64));
+}
+
+UNK_RET func_80087A1C(u32 a0) {
+	func_80087960(func_800888A8(func_800889A8(a0, 3000), 64));
+}
+
+UNK_RET func_80087A6C(u32 a0) {
+	func_80087960(func_800888A8(func_800889A8(a0, 0x02CB4178), 1000));
+}
+
+UNK_RET func_80087AC0(u32 a0) {
+	func_80087960(func_800889A8(a0, 0x02CB4178));
+}

src/boot/boot_0x80087E00.c

@@ -0,0 +1,6 @@
+#include <ultra64.h>
+#include <global.h>
+
+void func_80087E00(u32 a0) {
+	D_8009817C = a0;
+}

src/boot/boot_0x8008A660.c.ignore

@@ -0,0 +1,64 @@
+#include <ultra64.h>
+#include <global.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;
+}
+
+u64 D_80097E50; // this has to be defined in this file for func_8008A6FC to match
+
+void func_8008A6FC(void) {
+	UNK_TYPE sp44;
+	
+	D_8009CF70 = 1;
+	
+	func_8008A5D0(func_8008A5C0() | 0x20000000);
+	func_80092CE0(0x20000800);
+	func_80096820(0x04900000);
+	
+	while (func_8008AEE0(0x1FC007FC, &sp44) != 0);
+	while (func_80095220(0x1FC007FC, sp44 | 8) != 0);
+	
+	*(struct s8008A6FC*)0x80000000 = *((struct s8008A6FC*)__osExceptionPreamble);
+	*(struct s8008A6FC*)0x80000080 = *((struct s8008A6FC*)__osExceptionPreamble);
+	*(struct s8008A6FC*)0x80000100 = *((struct s8008A6FC*)__osExceptionPreamble);
+	*(struct s8008A6FC*)0x80000180 = *((struct s8008A6FC*)__osExceptionPreamble);
+	
+	func_8008A5E0(0x80000000, 400);
+	func_8008F270(0x80000000, 400);
+	func_8008A660();
+	func_8008EDE0();
+	func_80093C00();
+	D_80097E50 = func_800888A8(func_800889A8(D_80097E50, 3), 4);
+	
+	if (D_8000030C == 0) {
+		func_80089630(&D_8000031C, 64);
+	}
+	
+	if (osTvType == 0) {
+		D_80097E58 = 0x02F5B2D2;
+	} else if (osTvType == 2) {
+		D_80097E58 = 0x02E6025C;
+	} else {
+		D_80097E58 = 0x02E6D354;
+	}
+	
+	if((func_80093D90() & 0x1000) != 0) {
+		while(1);
+	}
+	
+	*(u32*)0xA4500008 = 1;
+	*(u32*)0xA4500010 = 16383;
+	*(u32*)0xA4500014 = 15;
+}
+
+void func_8008A9A8(void) {}

src/boot/boot_0x8008ACE0.c

@@ -0,0 +1,19 @@
+#include <ultra64.h>
+#include <global.h>
+
+s32 __osSpRawStartDma(s32 direction, u32 devAddr , void* dramAddr, u32 size) {
+	if (__osSpDeviceBusy() != 0) {
+		return -1;
+	}
+	
+	*(vu32*)0xA4040000 = devAddr;
+	*(vu32*)0xA4040004 = osVirtualToPhysical(dramAddr);
+	
+	if (direction == 0) {
+		*(vu32*)0xA404000C = size - 1;
+	} else {
+		*(vu32*)0xA4040008 = size - 1;
+	}
+	
+	return 0;
+}

src/boot/boot_0x8008D350.c.ignore

@@ -0,0 +1,30 @@
+#include <ultra64.h>
+#include <global.h>
+
+UNK_TYPE func_8008D350(void) {
+	u32* sp12;
+	u32 sp8;
+	u32 sp4;
+	u32 sp0;
+	
+	sp8 = 0x400000;
+	
+	do {
+	    sp12 = (u32*)(sp8 + 0xA0000000);
+	    sp4 = *(u32*)(0xA0000000 + sp8);
+	    sp0 = *(u32*)(0xA00FFFFC + sp8);
+		*(u32*)(0xA0000000 + sp8) = *(u32*)(0xA0000000 + sp8) ^ 0xFFFFFFFF;
+		sp12[0x000FFFFC/4] = sp12[0x000FFFFC/4] ^ 0xFFFFFFFF;
+		
+		if ((sp12[0] != (sp4 ^ 0xFFFFFFFF)) ||
+		    (sp12[0x000FFFFC/4] != (sp0 ^ 0xFFFFFFFF))) {
+			return sp8;
+		}
+		
+		*sp12 = sp4;
+		sp12[0x000FFFFC/4] = sp0;
+		sp8 = sp8 + 0x100000;
+	} while(sp8 < 0x800000);
+	
+	return sp8;
+}

src/boot/boot_0x80092920.c

@@ -0,0 +1,61 @@
+#include <ultra64.h>
+#include <global.h>
+
+struct s80092920* func_80092920(void) {
+	u32 v0;
+	u32 temp;
+	u32 temp2;
+	u32 temp3;
+	u32 temp4;
+	UNK_TYPE func_ret;
+	
+	func_8008C1E0();
+	
+	if (D_800980D0 == 0) {
+		func_8008C224();
+		return &D_8009E610;
+	}
+	
+	D_800980D0_ = 0;
+	
+	D_8009E610.unk4 = 0;
+	D_8009E610.unk12 = 0xB0000000;
+	D_8009E610.unk9 = 0;
+	D_8009E610.unk16 = 0;
+	
+	func_80089630(&D_8009E624, 96);
+	
+	while ((*(vu32*)0xA4600010) & 0x3);
+	
+	temp = *(vu32*)0xA4600014;
+	temp2 = *(vu32*)0xA460001C;
+	temp3 = *(vu32*)0xA4600020;
+	temp4 = *(vu32*)0xA4600018;
+	
+	*(vu32*)0xA4600014 = 255;
+	*(vu32*)0xA460001C = 0;
+	*(vu32*)0xA4600020 = 3;
+	*(vu32*)0xA4600018 = 255;
+	
+	v0 = *(u32*)(D_8009E610.unk12 | 0xA0000000);
+	D_8009E610.unk6 = (v0 >> 16) & 0xF;
+	D_8009E610.unk7 = (v0 >> 20) & 0xF;
+	D_8009E610.unk8 = v0 >> 8;
+	D_8009E610.unk5 = v0;
+	
+	*(vu32*)0xA4600014 = temp;
+	*(vu32*)0xA460001C = temp2;
+	*(vu32*)0xA4600020 = temp3;
+	*(vu32*)0xA4600018 = temp4;
+	
+	func_ret = func_80091A60();
+	
+	D_8009E610.unk0 = D_80097E8C;
+	D_80097E8C = &D_8009E610;
+	
+	func_80091AD0(func_ret);
+	
+	func_8008C224();
+	
+	return &D_8009E610;
+}

src/boot/boot_0x80095900.c

@@ -0,0 +1,14 @@
+#include <ultra64.h>
+#include <global.h>
+
+void func_80095900(f32 f12) {
+	u32 oldInt;
+	
+	oldInt = __osDisableInt();
+	
+	*((f32*)__osViNext + 36 / 4) = f12;
+	
+	*(u16*)__osViNext |= 0x4;
+	
+	__osRestoreInt(oldInt);
+}

src/boot/boot_0x800968B0.c

@@ -0,0 +1,15 @@
+#include <ultra64.h>
+#include <global.h>
+
+u32 func_800968B0(const u8* a0, const u8* a1) {
+	u8 v0;
+	u8 v1;
+	do {
+		v0 = *a0++;
+		v1 = *a1++;
+		if (v0 != v1) {
+			return v0 - v1;
+		}
+	} while (v0 != 0);
+	return 0;
+}