Merge branch 'master' of https://github.com/martmists/pokediamond into overlay69

4 files changed, 463 insertions, 35 deletions

diff --git a/arm9/src/FUN_02000DF4.c b/arm9/src/FUN_02000DF4.c
deleted file mode 100644
index 80e80b30..00000000
--- a/arm9/src/FUN_02000DF4.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "global.h"
-#include "main.h"
-
-extern struct Unk2106FA0 gBacklightTop;
-
-THUMB_FUNC void FUN_02000DF4(void)
-{
-    gBacklightTop.unk8 = -1;
-    gBacklightTop.unkC = 0;
-    gBacklightTop.unk10 = -1;
-    gBacklightTop.unk14 = 0;
-}
diff --git a/arm9/src/main.c b/arm9/src/main.c
index 73b63332..8c80d686 100644
--- a/arm9/src/main.c
+++ b/arm9/src/main.c
@@ -1,26 +1,73 @@
 #include "global.h"
 #include "main.h"
+#include "PAD_pad.h"
+#include "CARD_pullOut.h"
+#include "CARD_backup.h"
+#include "CTRDG_common.h"
+#include "poke_overlay.h"
+
+FS_EXTERN_OVERLAY(MODULE_52);
+FS_EXTERN_OVERLAY(MODULE_63);
+
+#define SOFT_RESET_KEY (PAD_BUTTON_L | PAD_BUTTON_R | PAD_BUTTON_START | PAD_BUTTON_SELECT)
 
-extern struct Unk2106FA0 gBacklightTop;
-extern struct Unk2106FA0 gBacklightTop_2; // same as the first one, it's referenced twice in the constant pool...
 extern struct Unk21C48B8 gUnknown21C48B8;
 
-extern s32 gUnk027FFC20;
 extern struct { 
     s32 unk0;
-    s32 unk4;
+    u8 unk4;
+    u8 unk5;
+    u8 unk6;
+    u8 unk7;
     u8 unk8;
 } gUnk021C4918;
 
-extern void PM_GetBackLight();
 extern void OS_WaitIrq();
 extern void FUN_02016438(s32);
+extern void InitSystemForTheGame(void);
+extern void InitGraphicMemory(void);
+extern void FUN_020163BC(void);
+extern void FUN_02022294(void);
+extern void FUN_0201259C(void);
+extern void FUN_02000DF4(void);
+extern void FUN_02002C14(void);
+extern void FUN_02002C50(int, int);
+extern int FUN_0202254C(void);
+extern void FUN_02003B98(int, int);
+extern int FUN_02029EF8(int);
+extern int LoadPlayerDataAddress(int);
+extern void FUN_02020AFC(void);
+extern int FUN_020337E8(int);
+extern void FUN_02034188(int, int);
+extern int FUN_020227FC(int);
+extern void FUN_02089D90(int);
+extern void FUN_02000E7C(FSOverlayID, struct Unk21DBE18 *);
+extern void ErrorHandling(void);
+extern void FUN_02000FA4(void);
+extern void FUN_0200A2AC(void);
+extern void FUN_02015E30(void);
+extern void FUN_02000EE8(void);
+extern void FUN_02000FE8(void);
+extern void FUN_02016464(void);
+void DoSoftReset(u32 parameter);
+extern BOOL FUN_0202FB80(void);
+extern void FUN_02000E0C(void);
+extern void FUN_0201B5CC(int);
+extern void FUN_020125D4(void);
+extern void FUN_02015E60(void);
+extern void FUN_020222C4(void);
+extern void FUN_0200A318(void);
+extern void FUN_0200E2D8(void);
+extern void FUN_02003C10(void);
+void FUN_02000F4C(int arg0, int arg1);
+extern BOOL FUN_02006234(struct Unk21DBE18 *, s32 *, int);
+extern BOOL FUN_02006290(int);
+extern void FUN_02006260(int);
+extern BOOL FUN_02033678(void);
+extern int FUN_020335B8(void);
 
-extern const s32 CONST_3F; // 0x0000003F
-extern const s32 CONST_34; // 0x00000034
-
-extern struct Unk21DBE18 gUnk021DBE18; 
-extern struct Unk21DBE18 gUnk021D76C8;
+extern struct Unk21DBE18 MOD63_UNK_021DBE18; 
+extern struct Unk21DBE18 MOD52_UNK_021D76C8;
 
 
 THUMB_FUNC void NitroMain(void)
@@ -30,7 +77,7 @@ THUMB_FUNC void NitroMain(void)
     FUN_020163BC();
     FUN_02016438(0);
 
-    PM_GetBackLight(&gBacklightTop_2, 0); 
+    PM_GetBackLight(&gBacklightTop_2.unk0, NULL);
 
     FUN_02022294();
     FUN_0201259C();
@@ -51,15 +98,15 @@ THUMB_FUNC void NitroMain(void)
     }
     else
     {
-        switch (gUnk027FFC20)
+        switch (*((s32 *)HW_RESET_PARAMETER_BUF))
         {
         case 0:
             gBacklightTop.unk1C = 0;
-            FUN_02000E7C(&CONST_3F, &gUnk021DBE18);
+            FUN_02000E7C(FS_OVERLAY_ID(MODULE_63), &MOD63_UNK_021DBE18);
             break;
         case 1:
             gBacklightTop.unk1C = 1;
-            FUN_02000E7C(&CONST_34, &gUnk021D76C8);
+            FUN_02000E7C(FS_OVERLAY_ID(MODULE_52), &MOD52_UNK_021D76C8);
             break;
         default:
             ErrorHandling();
@@ -77,9 +124,9 @@ THUMB_FUNC void NitroMain(void)
         FUN_02000EE8();
         FUN_02000FE8();
         FUN_02016464();
-        if ((gUnknown21C48B8.unk38 & 0x30C) == 0x30C && !gUnk021C4918.unk8) // soft reset?
+        if ((gUnknown21C48B8.unk38 & SOFT_RESET_KEY) == SOFT_RESET_KEY && !gUnk021C4918.unk8) // soft reset?
         {
-            FUN_02000F18(0); // soft reset?
+            DoSoftReset(0); // soft reset?
         }
         if (FUN_0202FB80())
         {
@@ -106,4 +153,199 @@ THUMB_FUNC void NitroMain(void)
         FUN_02003C10();
         FUN_0201B5CC(gUnknown21C48B8.unk20);
     }
-}
\ No newline at end of file
+}
+
+THUMB_FUNC void FUN_02000DF4(void)
+{
+    gBacklightTop.unk8 = -1;
+    gBacklightTop.unkC = 0;
+    gBacklightTop.unk10 = -1; // overlay invalid
+    gBacklightTop.unk14 = NULL;
+}
+
+THUMB_FUNC void FUN_02000E0C(void)
+{
+    if (!gBacklightTop.unkC)
+    {
+        if (gBacklightTop.unk14 == NULL)
+            return;
+        if (gBacklightTop.unk10 != -1u)
+            HandleLoadOverlay(gBacklightTop.unk10, 0);
+        gBacklightTop.unk8 = gBacklightTop.unk10;
+        gBacklightTop.unkC = FUN_02006234(gBacklightTop.unk14, &gBacklightTop.unk18, 0);
+        gBacklightTop.unk10 = -1u;
+        gBacklightTop.unk14 = NULL;
+    }
+    if (FUN_02006290(gBacklightTop.unkC))
+    {
+        FUN_02006260(gBacklightTop.unkC);
+        gBacklightTop.unkC = 0;
+        if (gBacklightTop.unk8 != -1u)
+            UnloadOverlayByID(gBacklightTop.unk8);
+    }
+}
+
+THUMB_FUNC void FUN_02000E7C(FSOverlayID id, struct Unk21DBE18 * arg1)
+{
+    if (gBacklightTop.unk14 != NULL)
+        ErrorHandling();
+    gBacklightTop.unk10 = id;
+    gBacklightTop.unk14 = arg1;
+}
+
+THUMB_FUNC void FUN_02000E9C(void)
+{
+    FUN_0202FB80();
+    OS_WaitIrq(1, 1);
+    gUnknown21C48B8.unk2C++;
+    gUnknown21C48B8.unk30 = 0;
+    if (gUnknown21C48B8.unk0 != NULL)
+        gUnknown21C48B8.unk0(gUnknown21C48B8.unk4);
+}
+
+THUMB_FUNC void FUN_02000EC8(u32 parameter)
+{
+    if (FUN_02033678() && CARD_TryWaitBackupAsync() == TRUE)
+    {
+        OS_ResetSystem(parameter);
+    }
+    FUN_02000E9C();
+}
+
+THUMB_FUNC void FUN_02000EE8(void)
+{
+    int r1 = FUN_020335B8();
+    switch (r1)
+    {
+    case 1:
+        FUN_02000F4C(1, r1);
+        break;
+    case 2:
+        FUN_02000F4C(0, r1);
+        break;
+    case 3:
+        FUN_02000F4C(1, r1);
+        break;
+    }
+}
+
+extern void FUN_0200E3A0(int, int);
+extern BOOL FUN_02032DAC(void);
+extern void FUN_020225F8(void);
+extern void FUN_0202287C(void);
+
+// No Return
+THUMB_FUNC void DoSoftReset(u32 parameter)
+{
+    FUN_0200E3A0(0, 0x7FFF);
+    FUN_0200E3A0(1, 0x7FFF);
+    if (FUN_02032DAC())
+    {
+        FUN_020225F8();
+        FUN_0202287C();
+    }
+    do
+    {
+        FUN_02000FE8();
+        FUN_02000EC8(parameter);
+    } while (1);
+}
+
+extern void FUN_02033F70(int, int, int);
+
+THUMB_FUNC void FUN_02000F4C(int arg0, int arg1)
+{
+    if (arg1 == 3)
+    {
+        FUN_02033F70(0, 3, 0);
+    }
+    else if (arg0 == 0)
+    {
+        FUN_02033F70(0, 2, 0);
+    }
+    else
+    {
+        FUN_02033F70(0, 0, 0);
+    }
+    FUN_02032DAC();
+    while (1)
+    {
+        FUN_02000FE8();
+        FUN_02016464();
+        if (gUnknown21C48B8.unk48 & 1)
+            break;
+        FUN_02000E9C();
+    }
+    DoSoftReset(arg0);
+}
+
+extern void FUN_0201265C(struct Unk21C4818 *, struct Unk21C4828 *);
+extern void FUN_0201BA1C(int);
+extern void FUN_0201B9E0(int);
+
+void FUN_02000FA4(void)
+{
+    struct Unk21C4818 spC;
+    struct Unk21C4828 sp0;
+    FUN_0201265C(&spC, &sp0);
+    {
+        int r4 = gUnknown21C48B8.unk2C;
+        int r5 = ((sp0.unk4 + sp0.unk8) << 24) + (spC.unk0 + ((256 * spC.unk4 * spC.unk8) << 16) + (sp0.unk0 << 16));
+        FUN_0201BA1C(r4 + r5);
+        FUN_0201B9E0(r4 + r5);
+    }
+}
+
+extern void FUN_0201CE04(void);
+extern void FUN_0201CDD0(void);
+
+void FUN_02000FE8(void)
+{
+    PMBackLightSwitch top, bottom;
+    if (PAD_DetectFold())
+    {
+        if (!gUnk021C4918.unk7)
+        {
+            FUN_0201CE04();
+            if (CTRDG_IsPulledOut() == TRUE)
+            {
+                gBacklightTop.unk4 = 1;
+            }
+            {
+                int r1 = gBacklightTop.unk4;
+                while (1)
+                {
+                    PMWakeUpTrigger trigger = PM_TRIGGER_COVER_OPEN | PM_TRIGGER_CARD;
+                    if (gUnk021C4918.unk6 && !r1)
+                        trigger |= PM_TRIGGER_CARTRIDGE;
+                    PM_GoSleepMode(trigger, PM_PAD_LOGIC_OR, 0);
+                    if (CARD_IsPulledOut())
+                    {
+                        PM_ForceToPowerOff();
+                        break;
+                    }
+                    else if (PAD_DetectFold())
+                    {
+                        r1 = gBacklightTop.unk4 = 1;
+                    }
+                    else
+                        break;
+                }
+                FUN_0201CDD0();
+                return;
+            }
+        }
+        else
+        {
+            PM_GetBackLight(&top, &bottom);
+            if (top == PM_BACKLIGHT_ON)
+                PM_SetBackLight(PM_LCD_ALL, PM_BACKLIGHT_OFF);
+        }
+    }
+    else
+    {
+        PM_GetBackLight(&top, &bottom);
+        if (top == PM_BACKLIGHT_OFF)
+            PM_SetBackLight(PM_LCD_ALL, gBacklightTop.unk0);
+    }
+}
diff --git a/arm9/src/poke_overlay.c b/arm9/src/poke_overlay.c
new file mode 100644
index 00000000..4cf1ea67
--- /dev/null
+++ b/arm9/src/poke_overlay.c
@@ -0,0 +1,199 @@
+#include "global.h"
+#include "nitro.h"
+#include "FS_file.h"
+#include "poke_overlay.h"
+
+extern void ErrorHandling(void);
+
+struct LoadedOverlay {
+    FSOverlayID id;
+    BOOL active;
+};
+
+extern struct LoadedOverlay gLoadedOverlays[3][8];
+
+struct LoadedOverlay* GetLoadedOverlaysInRegion(int);
+BOOL GetOverlayRamBounds(FSOverlayID, void**, void**);
+BOOL CanOverlayBeLoaded(FSOverlayID);
+int GetOverlayLoadDestination(FSOverlayID);
+BOOL LoadOverlayNormal(MIProcessor, FSOverlayID);
+BOOL LoadOverlayNoInit(MIProcessor, FSOverlayID);
+BOOL LoadOverlayNoInitAsync(MIProcessor, FSOverlayID);
+
+THUMB_FUNC void FreeOverlayAllocation(struct LoadedOverlay * loaded)
+{
+    if (loaded->active != TRUE)
+        ErrorHandling();
+    if (FS_UnloadOverlay(MI_PROCESSOR_ARM9, loaded->id) != TRUE)
+        ErrorHandling();
+    loaded->active = FALSE;
+}
+
+THUMB_FUNC void UnloadOverlayByID(FSOverlayID id)
+{
+    struct LoadedOverlay * loaded = GetLoadedOverlaysInRegion(GetOverlayLoadDestination(id));
+    int i;
+    for (i = 0; i < 8; i++)
+    {
+        if (loaded[i].active == TRUE && loaded[i].id == id)
+        {
+            FreeOverlayAllocation(&loaded[i]);
+            break;
+        }
+    }
+}
+
+THUMB_FUNC int GetOverlayLoadDestination(FSOverlayID id)
+{
+    FSOverlayInfo info;
+    u8 *end;
+    u8 *start;
+    if (FS_LoadOverlayInfo(&info, MI_PROCESSOR_ARM9, id) != TRUE)
+        ErrorHandling();
+    start = (u8 *)HW_ITCM_IMAGE;
+    end = (u8 *)HW_ITCM_END;
+    if (info.header.ram_address <= end && info.header.ram_address >= start)
+        return OVERLAY_LOAD_ITCM;
+    start = (u8 *)SDK_AUTOLOAD_DTCM_START;
+    end = start + HW_DTCM_SIZE;
+    if (info.header.ram_address <= end && info.header.ram_address >= start)
+        return OVERLAY_LOAD_DTCM;
+    return OVERLAY_LOAD_WRAM;
+}
+
+THUMB_FUNC BOOL HandleLoadOverlay(FSOverlayID id, int a1)
+{
+    u32 sp0 = FS_DMA_NOT_USE;
+    struct LoadedOverlay *r3;
+    int r7;
+    int r6;
+    BOOL result;
+
+    if (!CanOverlayBeLoaded(id))
+        return FALSE;
+    r7 = GetOverlayLoadDestination(id);
+    r3 = GetLoadedOverlaysInRegion(r7);
+    for (r6 = 0; r6 < 8; r6++)
+    {
+        if (!r3[r6].active)
+        {
+            struct LoadedOverlay * ovly;
+            ovly = &r3[r6];
+            ovly->active = TRUE;
+            ovly->id = id;
+            break;
+        }
+    }
+    if (r6 >= 8)
+    {
+        ErrorHandling();
+        return FALSE;
+    }
+    if (r7 == OVERLAY_LOAD_ITCM || r7 == OVERLAY_LOAD_DTCM)
+    {
+        sp0 = FS_SetDefaultDMA(FS_DMA_NOT_USE);
+    }
+    switch (a1)
+    {
+    case 0:
+        result = LoadOverlayNormal(MI_PROCESSOR_ARM9, id);
+        break;
+    case 1:
+        result = LoadOverlayNoInit(MI_PROCESSOR_ARM9, id);
+        break;
+    case 2:
+        result = LoadOverlayNoInitAsync(MI_PROCESSOR_ARM9, id);
+        break;
+    default:
+        ErrorHandling();
+        return FALSE;
+    }
+    if (r7 == OVERLAY_LOAD_ITCM || r7 == OVERLAY_LOAD_DTCM)
+    {
+        FS_SetDefaultDMA(sp0);
+    }
+    if (result == 0)
+    {
+        ErrorHandling();
+        return FALSE;
+    }
+    return TRUE;
+}
+
+THUMB_FUNC BOOL CanOverlayBeLoaded(FSOverlayID id)
+{
+    void *start, *end, *start2, *end2;
+    struct LoadedOverlay *r5;
+    int i;
+    if (!GetOverlayRamBounds(id, &start, &end))
+        return FALSE;
+    r5 = GetLoadedOverlaysInRegion(GetOverlayLoadDestination(id));
+    for (i = 0; i < 8; i++)
+    {
+        if (r5[i].active == TRUE && GetOverlayRamBounds(r5[i].id, &start2, &end2) == TRUE)
+        {
+            if ((start >= start2 && start < end2) || (end > start2 && end <= end2) || (start <= start2 && end >= end2))
+            {
+                ErrorHandling();
+                return FALSE;
+            }
+        }
+    }
+    return TRUE;
+}
+
+THUMB_FUNC struct LoadedOverlay* GetLoadedOverlaysInRegion(int a0)
+{
+    switch (a0)
+    {
+    case OVERLAY_LOAD_WRAM:
+    default:
+        return gLoadedOverlays[0];
+    case OVERLAY_LOAD_ITCM:
+        return gLoadedOverlays[1];
+    case OVERLAY_LOAD_DTCM:
+        return gLoadedOverlays[2];
+    }
+}
+
+THUMB_FUNC BOOL GetOverlayRamBounds(FSOverlayID id, void ** start, void ** end)
+{
+    FSOverlayInfo info;
+    if (!FS_LoadOverlayInfo(&info, MI_PROCESSOR_ARM9, id)) {
+        ErrorHandling();
+        return FALSE;
+    }
+    *start = (void *)info.header.ram_address;
+    *end = (char *)*start + (info.header.ram_size + info.header.bss_size);
+    return TRUE;
+}
+
+THUMB_FUNC BOOL LoadOverlayNormal(MIProcessor target, FSOverlayID id)
+{
+    return FS_LoadOverlay(target, id);
+}
+
+THUMB_FUNC BOOL LoadOverlayNoInit(MIProcessor target, FSOverlayID id)
+{
+    FSOverlayInfo info;
+    if (!FS_LoadOverlayInfo(&info, target, id))
+        return FALSE;
+    if (!FS_LoadOverlayImage(&info))
+        return FALSE;
+    FS_StartOverlay(&info);
+    return TRUE;
+}
+
+THUMB_FUNC BOOL LoadOverlayNoInitAsync(MIProcessor target, FSOverlayID id)
+{
+    FSOverlayInfo info;
+    FSFile file;
+    if (!FS_LoadOverlayInfo(&info, target, id))
+        return FALSE;
+    FS_InitFile(&file);
+    FS_LoadOverlayImageAsync(&info, &file);
+    FS_WaitAsync(&file);
+    FS_CloseFile(&file);
+    FS_StartOverlay(&info);
+    return TRUE;
+}
diff --git a/arm9/src/string_util.c b/arm9/src/string_util.c
index 6c949e88..e6ea85de 100644
--- a/arm9/src/string_util.c
+++ b/arm9/src/string_util.c
@@ -1,6 +1,9 @@
 #include "global.h"

 

-u16 gDigitTable[] = {

+#define EOS 0xFFFF

+#define NON_DIGIT 0xE2

+

+const u16 gDigitTable[] = {

     0xA2,

     0xA3,

     0xA4,

@@ -19,7 +22,7 @@ u16 gDigitTable[] = {
     0xB1

 };

 

-s32 gPowersOfTen[] = {

+const s32 gPowersOfTen[] = {

              1,

             10,

            100,

@@ -32,8 +35,6 @@ s32 gPowersOfTen[] = {
     1000000000,

 };

 

-static const u16 EOS = 0xFFFF;

-

 THUMB_FUNC void StringCopy(u16 *dest, const u16 *src)

 {

     u16 c = *src;

@@ -129,8 +130,6 @@ enum PrintingMode {
     PAD_ZEROES

 };

 

-const u16 NON_DIGIT = 0xE2;

-

 THUMB_FUNC u16 *ConvertUIntToDecimalString(u16 *dest, u32 value, enum PrintingMode mode, u32 n)

 {

     for (u32 x = gPowersOfTen[n - 1]; x != 0; x = x / 10) {