m_Do_MemCard/d_file_select wii/debug work (#2976)

* m_Do_MemCard/d_file_select wii/debug work

* fix builds

1 files changed, 393 insertions, 12 deletions

diff --git a/src/m_Do/m_Do_MemCard.cpp b/src/m_Do/m_Do_MemCard.cpp
index 29248e5b69..47c29af4a1 100644
--- a/src/m_Do/m_Do_MemCard.cpp
+++ b/src/m_Do/m_Do_MemCard.cpp
@@ -10,6 +10,11 @@
 #include "m_Do/m_Do_MemCardRWmng.h"
 #include "m_Do/m_Do_Reset.h"
 
+#if PLATFORM_WII || PLATFORM_SHIELD
+#include <revolution/nand.h>
+#include <revolution/sc.h>
+#endif
+
 #define SLOT_A 0
 
 #define CHECKSPACE_RESULT_READY    0
@@ -17,14 +22,60 @@
 #define CHECKSPACE_RESULT_NOENT    2
 #define CHECKSPACE_RESULT_ERROR    3
 
+#if PLATFORM_WII
+s32 my_CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo) {
+    CARDStat stat;
+    DVDDiskID* diskID = DVDGetCurrentDiskID();
+    
+    for (int i = 0; i < CARD_MAX_FILE; i++) {
+        s32 ret = CARDGetStatus(chan, i, &stat);
+        if (ret == CARD_RESULT_READY) {
+            if (memcmp(stat.gameName, "GZ2E", 4) == 0 &&
+                memcmp(stat.company, diskID->company, 2) == 0 &&
+                strncmp(stat.fileName, fileName, 32) == 0)
+            {
+                return CARDFastOpen(chan, i, fileInfo);
+            }
+        } else if (ret != CARD_RESULT_NOFILE) {
+            return ret;
+        }
+    }
+
+    return CARD_RESULT_NOFILE;
+}
+#endif
+
+#if PLATFORM_WII
+#define CARD_OPEN my_CARDOpen
+#else
+#define CARD_OPEN CARDOpen
+#endif
+
+#if PLATFORM_WII
+#define NAND_OPEN  NANDSafeOpen
+#define NAND_CLOSE NANDSafeClose
+#elif PLATFORM_SHIELD
+#define NAND_OPEN  NANDSimpleSafeOpen
+#define NAND_CLOSE NANDSimpleSafeClose
+#endif
+
 mDoMemCd_Ctrl_c::mDoMemCd_Ctrl_c() {}
 
-static u8 MemCardStack[0x1000];
+#if PLATFORM_GCN
+#define STACK_SIZE 0x1000
+#else
+#define STACK_SIZE 0x2000
+#endif
+
+static u8 MemCardStack[STACK_SIZE];
 
 static OSThread MemCardThread;
 
 void mDoMemCd_Ctrl_c::ThdInit() {
+    #if !PLATFORM_SHIELD
     CARDInit();
+    #endif
+
     mCopyToPos = 0;
     mProbeStat = 2;
     mCardState = CARD_STATE_NO_CARD_e;
@@ -33,10 +84,8 @@ void mDoMemCd_Ctrl_c::ThdInit() {
 
     OSInitMutex(&mMutex);
     OSInitCond(&mCond);
-
-    int priority = OSGetThreadPriority(OSGetCurrentThread());
     OSCreateThread(&MemCardThread, (void*(*)(void*))mDoMemCd_main, NULL, MemCardStack + sizeof(MemCardStack),
-                   sizeof(MemCardStack), priority + 1, 1);
+                   sizeof(MemCardStack), OSGetThreadPriority(OSGetCurrentThread()) + 1, 1);
     OSResumeThread(&MemCardThread);
 
     // "Memory Card Thread Init\n"
@@ -52,6 +101,7 @@ void mDoMemCd_Ctrl_c::main() {
         OSUnlockMutex(&mMutex);
 
         switch (mCardCommand) {
+        #if PLATFORM_GCN || PLATFORM_WII
         case COMM_RESTORE_e:
             restore();
             break;
@@ -67,6 +117,26 @@ void mDoMemCd_Ctrl_c::main() {
         case COMM_DETACH_e:
             detach();
             break;
+        #elif PLATFORM_SHIELD
+        case COMM_RESTORE_e:
+        case COMM_STORE_e:
+        case COMM_FORMAT_e:
+        case COMM_ATTACH_e:
+        case COMM_DETACH_e:
+            break;
+        #endif
+
+        #if PLATFORM_WII || PLATFORM_SHIELD
+        case COMM_RESTORE_NAND_e:
+            restoreNAND();
+            break;
+        case COMM_STORE_NAND_e:
+            storeNAND();
+            break;
+        case COMM_STORE_SETUP_NAND_e:
+            storeSetUpNAND();
+            break;
+        #endif
         }
 
         OSLockMutex(&mMutex);
@@ -83,6 +153,7 @@ void mDoMemCd_Ctrl_c::update() {
         OSUnlockMutex(&mMutex);
         OSSignalCond(&mCond);
     } else if (getStatus(0) != 14) {
+        #if PLATFORM_GCN || PLATFORM_WII
         if (CARDProbe(SLOT_A) && getStatus(0) == 0) {
             OSLockMutex(&mMutex);
             mProbeStat = 0;
@@ -98,6 +169,7 @@ void mDoMemCd_Ctrl_c::update() {
             OSUnlockMutex(&mMutex);
             OSSignalCond(&mCond);
         }
+        #endif
     }
 }
 
@@ -110,11 +182,12 @@ void mDoMemCd_Ctrl_c::load() {
     }
 }
 
+#if !PLATFORM_SHIELD
 void mDoMemCd_Ctrl_c::restore() {
     CARDFileInfo file;
     field_0x1fc8 = 0;
 
-    s32 ret = CARDOpen(mChannel, "gczelda2", &file);
+    s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
     OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
     if (ret == CARD_RESULT_READY) {
         s32 ret2 = mDoMemCdRWm_Restore(&file, this, sizeof(mData));
@@ -131,6 +204,7 @@ void mDoMemCd_Ctrl_c::restore() {
 
     field_0x1fc8 = 1;
 }
+#endif
 
 s32 mDoMemCd_Ctrl_c::LoadSync(void* i_buffer, u32 i_size, u32 i_position) {
     int ret = 0;
@@ -164,13 +238,18 @@ void mDoMemCd_Ctrl_c::save(void* i_buffer, u32 i_size, u32 i_position) {
     }
 }
 
+#if !PLATFORM_SHIELD
 void mDoMemCd_Ctrl_c::store() {
     CARDFileInfo file;
     s32 ret;
     field_0x1fc8 = 0;
 
     if (mCardState == CARD_STATE_NO_FILE_e) {
-        ret = CARDCreate(mChannel, "gczelda2", SAVEDATA_FILE_SIZE, &file);
+        #if PLATFORM_GCN
+        ret = CARDCreate(mChannel, "gczelda2", CARD_FILE_SIZE, &file);
+        #else
+        ret = CARDCreate(mChannel, "zeldaTp.dat", CARD_FILE_SIZE, &file);
+        #endif
         if (ret == CARD_RESULT_READY || ret == CARD_RESULT_EXIST) {
             mCardState = CARD_STATE_READY_e;
         } else {
@@ -179,7 +258,7 @@ void mDoMemCd_Ctrl_c::store() {
     }
 
     if (mCardState == CARD_STATE_READY_e) {
-        ret = CARDOpen(mChannel, "gczelda2", &file);
+        ret = CARD_OPEN(mChannel, "gczelda2", &file);
         if (ret == CARD_RESULT_READY) {
             ret = mDoMemCdRWm_Store(&file, this, sizeof(mData));
             if (ret != CARD_RESULT_READY) {
@@ -199,6 +278,7 @@ void mDoMemCd_Ctrl_c::store() {
 
     field_0x1fc8 = 1;
 }
+#endif
 
 s32 mDoMemCd_Ctrl_c::SaveSync() {
     int ret = 0;
@@ -217,7 +297,6 @@ s32 mDoMemCd_Ctrl_c::SaveSync() {
             ret = 2;
         }
 
-        OS_REPORT("CARD Save Sync ret:%d stat:%d\n", ret, mCardState);
         OSUnlockMutex(&mMutex);
     }
 
@@ -287,6 +366,7 @@ void mDoMemCd_Ctrl_c::command_format() {
     }
 }
 
+#if !PLATFORM_SHIELD
 void mDoMemCd_Ctrl_c::format() {
     field_0x1fc8 = 0;
 
@@ -302,6 +382,7 @@ void mDoMemCd_Ctrl_c::format() {
         OSUnlockMutex(&mMutex);
     }
 }
+#endif
 
 s32 mDoMemCd_Ctrl_c::FormatSync() {
     int ret = 0;
@@ -325,6 +406,7 @@ s32 mDoMemCd_Ctrl_c::FormatSync() {
     return ret;
 }
 
+#if !PLATFORM_SHIELD
 void mDoMemCd_Ctrl_c::attach() {
     s32 mem_size;
     s32 sector_size;
@@ -418,7 +500,7 @@ s32 mDoMemCd_Ctrl_c::mount() {
 s32 mDoMemCd_Ctrl_c::loadfile() {
     CARDFileInfo file;
 
-    s32 ret = CARDOpen(mChannel, "gczelda2", &file);
+    s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
     if (ret == CARD_RESULT_READY) {
         CARDClose(&file);
         return TRUE;
@@ -428,7 +510,6 @@ s32 mDoMemCd_Ctrl_c::loadfile() {
     }
 }
 
-// 
 s32 mDoMemCd_Ctrl_c::checkspace() {
     s32 bytesNotUsed, filesNotUsed;
     s32 result = CARDFreeBlocks(mChannel, &bytesNotUsed, &filesNotUsed);
@@ -438,7 +519,7 @@ s32 mDoMemCd_Ctrl_c::checkspace() {
         return CHECKSPACE_RESULT_ERROR;  
     }
 
-    if (bytesNotUsed < SAVEDATA_FILE_SIZE) {
+    if (bytesNotUsed < CARD_FILE_SIZE) {
         return CHECKSPACE_RESULT_INSSPACE;
     }
 
@@ -472,13 +553,313 @@ void mDoMemCd_Ctrl_c::setCardState(s32 i_result) {
         break;
     }
 }
+#endif
+
+#if PLATFORM_WII || PLATFORM_SHIELD
+void mDoMemCd_Ctrl_c::loadNAND() {
+    if (OSTryLockMutex(&mMutex)) {
+        field_0x1fc8 = 0;
+        mCardCommand = COMM_RESTORE_NAND_e;
+        OSUnlockMutex(&mMutex);
+        OSSignalCond(&mCond);
+    }
+}
+
+void mDoMemCd_Ctrl_c::restoreNAND() {
+    NANDFileInfo file;
+    s32 ret, ret2;
+
+    field_0x1fc8 = 0;    
+
+    ret = NANDOpen("zeldaTp.dat", &file, NAND_ACCESS_RW);
+    OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
+    if (ret == NAND_RESULT_OK) {
+        ret2 = mDoMemCdRWm_RestoreNAND(&file, this, sizeof(mData));
+        OS_REPORT("\x1b[43;30mret2=%d\n\x1b[m", ret2);
+        if (ret2 == NAND_RESULT_OK) {
+            mNandState = NAND_STATE_READ_e;
+        } else {
+            setNandState(ret);
+        }
+        NANDClose(&file);
+    } else {
+        setNandState(ret);
+    }
+
+    field_0x1fc8 = 1;
+}
+
+s32 mDoMemCd_Ctrl_c::LoadSyncNAND(void* i_buffer, u32 i_size, u32 i_position) {
+    int ret = 0;
+
+    if (field_0x1fc8 == 0) {
+        return 0;
+    }
+
+    if (OSTryLockMutex(&mMutex)) {
+        if (mNandState == NAND_STATE_READ_e) {
+            memcpy(i_buffer, &mData[i_position], i_size);
+            mNandState = NAND_STATE_READY_e;
+            ret = 1;
+        } else {
+            ret = 2;
+        }
+        OSUnlockMutex(&mMutex);
+    }
+
+    return ret;
+}
+
+void mDoMemCd_Ctrl_c::saveNAND(void* i_buffer, u32 i_size, u32 i_position) {
+    if (OSTryLockMutex(&mMutex)) {
+        memcpy(&mData[i_position], i_buffer, i_size);
+        field_0x1fc8 = 0;
+        mCardCommand = COMM_STORE_NAND_e;
+        OSUnlockMutex(&mMutex);
+        OSSignalCond(&mCond);
+    }
+}
+
+static u8 l_safeCopyBuf[0x4000];
+
+void mDoMemCd_Ctrl_c::storeNAND() {
+    NANDFileInfo file;
+    s32 ret;
+    field_0x1fc8 = 0;
+
+    if (mNandState == NAND_STATE_NO_FILE_e) {
+        ret = NANDCreate("zeldaTp.dat", NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP, 0);
+        if (ret == NAND_RESULT_OK) {
+            mNandState = NAND_STATE_READY_e;
+        } else {
+            setNandState(ret);
+        }
+    }
+
+    if (mNandState == NAND_STATE_READY_e) {
+        u8 sp8 = 1;
+        ret = NANDCreate("banner.bin", NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP, 0);
+        printf("NAND bannerFile Create ret:%d\n", ret);
+        if (ret == NAND_RESULT_OK || ret == NAND_RESULT_EXISTS) {
+            ret = NAND_OPEN("banner.bin", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
+            if (ret == NAND_RESULT_OK) {
+                ret = mDoMemCdRWm_StoreBannerNAND(&file);
+                if (ret == NAND_RESULT_OK) {
+                    printf("NAND bannerFile Write OK ret:%d\n", ret);
+                } else {
+                    setNandState(ret);
+                    printf("NAND bannerFile Write ERR ret:%d\n", ret);
+                }
+                NAND_CLOSE(&file);
+            } else {
+                setNandState(ret);
+            }
+        } else {
+            setNandState(ret);
+        }
+
+        if (ret == NAND_RESULT_OK) {
+            ret = NAND_OPEN("zeldaTp.dat", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
+            if (ret == NAND_RESULT_OK) {
+                ret = mDoMemCdRWm_StoreNAND(&file, this, sizeof(mData));
+                if (ret == NAND_RESULT_OK) {
+                    mNandState = NAND_STATE_WRITE_e;
+                    printf("NAND Write OK ret:%d stat:%d\n", ret, mNandState);
+                } else {
+                    setNandState(ret);
+                    printf("NAND Write ERR ret:%d\n", ret);
+                }
+                NAND_CLOSE(&file);
+            } else {
+                setNandState(ret);
+            }
+        }
+    } else {
+        setNandState(ret);
+    }
+
+    field_0x1fc8 = 1;
+}
+
+s32 mDoMemCd_Ctrl_c::SaveSyncNAND() {
+    int ret = 0;
+
+    if (field_0x1fc8 == 0) {
+        return 0;
+    }
+
+    if (OSTryLockMutex(&mMutex)) {
+        if (mNandState == NAND_STATE_WRITE_e) {
+            mNandState = NAND_STATE_READY_e;
+            ret = 1;
+        } else {
+            ret = 2;
+        }
+
+        printf("NAND Save Sync ret:%d stat:%d\n", ret, mNandState);
+        OSUnlockMutex(&mMutex);
+    }
+
+    return ret;
+}
+
+void mDoMemCd_Ctrl_c::storeSetUpNAND() {
+    field_0x1fc8 = 0;
+    
+    while ((int)SCCheckStatus() != 0) {}
+
+    #if PLATFORM_WII
+    if (!SCFlush()) {
+        mNandState = NAND_STATE_WRITE_e;
+        printf("== 本体設定Write OK ==\n");
+    } else {
+        mNandState = NAND_STATE_FATAL_ERROR_e;
+        printf("== 本体設定Write ERR ==\n");
+    }
+    #else
+    mNandState = NAND_STATE_WRITE_e;
+    #endif
+
+    field_0x1fc8 = 1;
+}
+
+void m_Do_MemCard_cpp__dummyString() {
+    DEAD_STRING("本体設定 Save Sync ret:%d stat:%d\n");
+}
+
+void mDoMemCd_Ctrl_c::setNandState(s32 i_result) {
+    switch (i_result) {
+    case NAND_RESULT_CORRUPT:
+        mNandState = NAND_STATE_BROKEN_e;
+        break;
+    case NAND_RESULT_MAXBLOCKS:
+        mNandState = NAND_STATE_INSSPACE_e;
+        break;
+    case NAND_RESULT_MAXFILES:
+    case NAND_RESULT_MAXFD:
+        mNandState = NAND_STATE_NOENT_e;
+        break;
+    case NAND_RESULT_ECC_CRIT:
+    case NAND_RESULT_AUTHENTICATION:
+        mNandState = NAND_STATE_AUTHENTICATION_e;
+        break;
+    case NAND_RESULT_NOEXISTS:
+        mNandState = NAND_STATE_NO_FILE_e;
+        break;
+    case NAND_RESULT_UNKNOWN:
+    case NAND_RESULT_FATAL_ERROR:
+        mNandState = NAND_STATE_FATAL_ERROR_e;
+        break;
+    case -7:
+    case NAND_RESULT_BUSY:
+    case NAND_RESULT_ALLOC_FAILED:
+    case NAND_RESULT_ACCESS:
+        break;
+    }
+}
+
+u32 mDoMemCd_Ctrl_c::getStatusNAND() {
+    u32 status;
+    if (OSTryLockMutex(&mMutex)) {
+        switch (mNandState) {
+        case NAND_STATE_READY_e:
+            status = 1;
+            break;
+        case NAND_STATE_NO_FILE_e:
+            status = 0;
+            break;
+        case NAND_STATE_READ_e:
+            status = 2;
+            break;
+        case NAND_STATE_WRITE_e:
+            status = 3;
+            break;
+        case NAND_STATE_FORMAT_e:
+            status = 6;
+            break;
+        case NAND_STATE_AUTHENTICATION_e:
+            status = 4;
+            break;
+        case NAND_STATE_BROKEN_e:
+            status = 5;
+            break;
+        case NAND_STATE_INSSPACE_e:
+            status = 7;
+            break;
+        case NAND_STATE_NOENT_e:
+            status = 8;
+            break;
+        case NAND_STATE_FATAL_ERROR_e:
+            status = 9;
+            break;
+        case NAND_STATE_10_e:
+            status = 10;
+            break;
+        }
+
+        OSUnlockMutex(&mMutex);
+        return status;
+    }
+
+    return 10;
+}
+
+s32 mDoMemCd_Ctrl_c::chekNANDFile() {
+    NANDFileInfo file;
+
+    s32 ret = NANDOpen("zeldaTp.dat", &file, NAND_ACCESS_RW);
+    if (ret == NAND_RESULT_OK) {
+        mNandState = NAND_STATE_READY_e;
+        NANDClose(&file);
+        return 1;
+    }
+
+    switch (checkspaceNAND()) {
+    case CHECKSPACE_RESULT_READY:
+        mNandState = NAND_STATE_NO_FILE_e;
+        break;
+    case CHECKSPACE_RESULT_INSSPACE:
+        mNandState = NAND_STATE_INSSPACE_e;
+        break;
+    case CHECKSPACE_RESULT_NOENT:
+        mNandState = NAND_STATE_NOENT_e;
+        break;
+    case CHECKSPACE_RESULT_ERROR:
+        setNandState(ret);
+        break;
+    }
+
+    return 0;
+}
+
+s32 mDoMemCd_Ctrl_c::checkspaceNAND() {
+    u32 answer = -1;
+    s32 ret;
+
+    s32 result = NANDCheck(3, 2, &answer);
+    if (result != NAND_RESULT_OK) {
+        setNandState(result);
+        return CHECKSPACE_RESULT_ERROR;  
+    }
+
+    if (answer == 0) {
+        ret = 0;
+    } else if (answer & 5) {
+        ret = 1;
+    } else if (answer & 10) {
+        ret = 2;
+    }
+    
+    return ret;
+}
+#endif
 
 mDoMemCd_Ctrl_c g_mDoMemCd_control;
 
 static int mDoMemCd_main(void*) {
     { JKRThread thread(OSGetCurrentThread(), 0); }
 
-    mDoExt_getAssertHeap()->becomeCurrentHeap();
+    JKRSetCurrentHeap(mDoExt_getAssertHeap());
 
     g_mDoMemCd_control.main();
     return 0;