r37 changes

Makefile

@@ -20,6 +20,8 @@ else
   $(error Unsupported host/building OS <$(UNAME_S)>)
 endif
 
+DOLPHIN_REVISION ?= 36
+
 BUILD_DIR := build
 TOOLS_DIR := $(BUILD_DIR)/tools
 BASEROM_DIR := baserom
@@ -110,7 +112,7 @@ CC        = $(MWCC)
 
 CHARFLAGS := -char unsigned
 
-CFLAGS = $(CHARFLAGS) -nodefaults -proc gekko -fp hard -Cpp_exceptions off -enum int -warn pragmas -pragma 'cats off'
+CFLAGS = $(CHARFLAGS) -nodefaults -proc gekko -fp hard -Cpp_exceptions off -enum int -warn pragmas -pragma 'cats off' -DDOLPHIN_REVISION=$(DOLPHIN_REVISION)
 INCLUDES := -Iinclude -Iinclude/libc -ir src
 
 ASFLAGS = -mgekko -I src -I include
@@ -253,6 +255,7 @@ os_c_files := \
 	src/os/OSMessage.c \
 	src/os/OSMemory.c \
 	src/os/OSMutex.c \
+	src/os/OSReboot.c \
 	src/os/OSReset.c \
 	src/os/OSResetSW.c \
 	src/os/OSRtc.c \

include/dolphin/card.h

@@ -159,6 +159,7 @@ typedef struct CARDID {
 #define CARD_RESULT_CANCELED     -14
 #define CARD_RESULT_FATAL_ERROR -128
 
+// TODO: This should be private
 #define CARDIsValidBlockNo(card, blockNo) ((blockNo) >= CARD_NUM_SYSTEM_BLOCK && (blockNo) < (card)->cBlock)
 
 #define CARD_READ_SIZE 512

include/dolphin/os.h

@@ -62,6 +62,7 @@ unsigned int __gUnknown800030C0[2] : (OS_BASE_CACHED | 0x30C0);
 #define OSTicksToMicroseconds(ticks) ((ticks)*8 / (OS_TIMER_CLOCK/125000))
 #define OSSecondsToTicks(sec) ((sec) * (OS_TIMER_CLOCK))
 #define OSMillisecondsToTicks(msec) ((msec) * (OS_TIMER_CLOCK / 1000))
+#define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8)
 #define OSNanosecondsToTicks(nsec) (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000)
 #define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8)
 

include/dolphin/pad.h

@@ -57,7 +57,11 @@ typedef struct PADStatus
 int PADReset(unsigned long mask);
 BOOL PADRecalibrate(u32 mask);
 BOOL PADInit();
-void PADRead(struct PADStatus * status);
+#if DOLPHIN_REVISION >= 37
+u32 PADRead(struct PADStatus *status);
+#else
+void PADRead(struct PADStatus *status);
+#endif
 void PADSetSamplingRate(unsigned long msec);
 void __PADTestSamplingRate(unsigned long tvmode);
 void PADControlAllMotors(const u32 *commandArray);

src/card/CARDBios.c

@@ -41,6 +41,9 @@ void __CARDExtHandler(s32 chan, OSContext *context) {
         card->attached = FALSE;
         card->result = CARD_RESULT_NOCARD;
         EXISetExiCallback(chan, 0);
+#if DOLPHIN_REVISION >= 37
+        OSCancelAlarm(&card->alarm);
+#endif
         callback = card->exiCallback;
 
         if (callback)
@@ -113,17 +116,28 @@ void __CARDExiHandler(s32 chan, OSContext *context) {
 void __CARDTxHandler(s32 chan, OSContext *context) {
     CARDControl *card;
     CARDCallback callback;
+#if DOLPHIN_REVISION >= 37
+    BOOL r31;
+#endif
 
     ASSERTLINE(0x12D, 0 <= chan && chan < 2);
 
     card = &__CARDBlock[chan];
+#if DOLPHIN_REVISION >= 37
+    r31 = !EXIDeselect(chan);
+#else
     !EXIDeselect(chan);
+#endif
     !EXIUnlock(chan);
     callback = card->txCallback;
     if (callback)
     {
         card->txCallback = NULL;
+#if DOLPHIN_REVISION >= 37
+        callback(chan, (!r31 && EXIProbe(chan)) ? CARD_RESULT_READY : CARD_RESULT_NOCARD);
+#else
         callback(chan, (EXIProbe(chan)) ? CARD_RESULT_READY : CARD_RESULT_NOCARD);
+#endif
     }
 }
 
@@ -280,6 +294,12 @@ static void TimeoutHandler(OSAlarm *alarm, OSContext *context) {
         }
     }
 
+#if DOLPHIN_REVISION >= 37
+    if (!card->attached) {
+        return;
+    }
+#endif
+
     ASSERTLINE(0x20E, 0 <= chan && chan < 2);
 
     EXISetExiCallback(chan, NULL);
@@ -297,9 +317,13 @@ static void SetupTimeoutAlarm(CARDControl *card) {
     {
     case 0xF3: 
         break;
+    case 0xF2:
+#if DOLPHIN_REVISION >= 37
+        OSSetAlarm(&card->alarm, OSMillisecondsToTicks(100), TimeoutHandler);
+        break;
+#endif
     case 0xF4:
     case 0xF1:
-    case 0xF2: 
         OSSetAlarm(&card->alarm, OSSecondsToTicks((OSTime)2) * (card->sectorSize / 0x2000),
                    TimeoutHandler);
         break;
@@ -709,15 +733,19 @@ s32 CARDFreeBlocks(s32 chan, s32 *byteNotUsed, s32 *filesNotUsed) {
         return __CARDPutControlBlock(card, CARD_RESULT_BROKEN);
     }
 
-    *byteNotUsed = (s32)(card->sectorSize * fat[CARD_FAT_FREEBLOCKS]);
+    if (DOLPHIN_REVISION < 37 || byteNotUsed != NULL) {
+        *byteNotUsed = (s32)(card->sectorSize * fat[CARD_FAT_FREEBLOCKS]);
+    }
 
-    *filesNotUsed = 0;
-    for (fileNo = 0; fileNo < CARD_MAX_FILE; fileNo++)
-    {
-        ent = &dir[fileNo];
-        if (ent->fileName[0] == 0xff)
+    if (DOLPHIN_REVISION < 37 || filesNotUsed != NULL) {
+        *filesNotUsed = 0;
+        for (fileNo = 0; fileNo < CARD_MAX_FILE; fileNo++)
         {
-            ++*filesNotUsed;
+            ent = &dir[fileNo];
+            if (ent->fileName[0] == 0xff)
+            {
+                ++*filesNotUsed;
+            }
         }
     }
 
@@ -753,14 +781,30 @@ long CARDGetMemSize(long chan, unsigned short * size) {
 s32 CARDGetSectorSize(s32 chan, u32 *size) {
     struct CARDControl *card;
     long result;
+#if DOLPHIN_REVISION >= 37
+    BOOL enabled;
+    CARDControl *tmp;
+#endif
 
     result = __CARDGetControlBlock(chan, &card);
     if (result < 0)
     {
         return result;
     }
     *size = card->sectorSize;
+#if DOLPHIN_REVISION >= 37
+    tmp = card;
+    enabled = OSDisableInterrupts();
+    if (tmp->attached) {
+        tmp->result = 0;
+    } else if (tmp->result == -1) {
+        tmp->result = 0;
+    }
+    OSRestoreInterrupts(enabled);
+    return 0;
+#else
     return __CARDPutControlBlock(card, 0);
+#endif
 }
 
 s32 __CARDSync(s32 chan) {

src/card/CARDCheck.c

@@ -189,7 +189,148 @@ s32 __CARDVerify(CARDControl *card) {
     }
 }
 
+#if DOLPHIN_REVISION >= 37
+s32 CARDCheckExAsync(s32 chan, s32 *xferBytes, CARDCallback callback)
+{
+    CARDControl *card;
+    CARDDir *dir[2];
+    u16 *fat[2];
+    u16 *map;
+    s32 result;
+    int errors;
+    int currentFat;
+    int currentDir;
+    s32 fileNo;
+    u16 iBlock;
+    u16 cBlock;
+    u16 cFree;
+    BOOL updateFat = FALSE;
+    BOOL updateDir = FALSE;
+    BOOL updateOrphan = FALSE;
+
+    if (xferBytes)
+        *xferBytes = 0;
+
+    result = __CARDGetControlBlock(chan, &card);
+    if (result < 0)
+        return result;
+
+    result = VerifyID(card);
+    if (result < 0)
+        return __CARDPutControlBlock(card, result);
+
+    errors = VerifyDir(card, &currentDir);
+    errors += VerifyFAT(card, &currentFat);
+    if (1 < errors)
+        return __CARDPutControlBlock(card, CARD_RESULT_BROKEN);
+
+    dir[0] = (CARDDir *)((u8 *)card->workArea + (1 + 0) * CARD_SYSTEM_BLOCK_SIZE);
+    dir[1] = (CARDDir *)((u8 *)card->workArea + (1 + 1) * CARD_SYSTEM_BLOCK_SIZE);
+    fat[0] = (u16 *)((u8 *)card->workArea + (3 + 0) * CARD_SYSTEM_BLOCK_SIZE);
+    fat[1] = (u16 *)((u8 *)card->workArea + (3 + 1) * CARD_SYSTEM_BLOCK_SIZE);
+
+    switch (errors)
+    {
+    case 0: break;
+    case 1:
+        if (!card->currentDir)
+        {
+            card->currentDir = dir[currentDir];
+            memcpy(dir[currentDir], dir[currentDir ^ 1], CARD_SYSTEM_BLOCK_SIZE);
+            updateDir = TRUE;
+        }
+        else
+        {
+            card->currentFat = fat[currentFat];
+            memcpy(fat[currentFat], fat[currentFat ^ 1], CARD_SYSTEM_BLOCK_SIZE);
+            updateFat = TRUE;
+        }
+        break;
+    }
+
+    map = fat[currentFat ^ 1];
+    memset(map, 0, CARD_SYSTEM_BLOCK_SIZE);
+
+    for (fileNo = 0; fileNo < CARD_MAX_FILE; fileNo++)
+    {
+        CARDDir *ent;
+
+        ent = &card->currentDir[fileNo];
+        if (ent->gameName[0] == 0xff)
+            continue;
+
+        for (iBlock = ent->startBlock, cBlock = 0; iBlock != 0xFFFF && cBlock < ent->length;
+             iBlock = card->currentFat[iBlock], ++cBlock)
+        {
+            if (!CARDIsValidBlockNo(card, iBlock) || 1 < ++map[iBlock])
+                return __CARDPutControlBlock(card, CARD_RESULT_BROKEN);
+        }
+        if (cBlock != ent->length || iBlock != 0xFFFF)
+            return __CARDPutControlBlock(card, CARD_RESULT_BROKEN);
+    }
+
+    cFree = 0;
+    for (iBlock = CARD_NUM_SYSTEM_BLOCK; iBlock < card->cBlock; iBlock++)
+    {
+        u16 nextBlock;
+
+        nextBlock = card->currentFat[iBlock];
+        if (map[iBlock] == 0)
+        {
+            if (nextBlock != CARD_FAT_AVAIL)
+            {
+                card->currentFat[iBlock] = CARD_FAT_AVAIL;
+                updateOrphan = TRUE;
+            }
+            cFree++;
+        }
+        else if (!CARDIsValidBlockNo(card, nextBlock) && nextBlock != 0xFFFF)
+            return __CARDPutControlBlock(card, CARD_RESULT_BROKEN);
+    }
+    if (cFree != card->currentFat[CARD_FAT_FREEBLOCKS])
+    {
+        card->currentFat[CARD_FAT_FREEBLOCKS] = cFree;
+        updateOrphan = TRUE;
+    }
+    if (updateOrphan)
+    {
+        __CARDCheckSum(&card->currentFat[CARD_FAT_CHECKCODE], CARD_SYSTEM_BLOCK_SIZE - sizeof(u32),
+                       &card->currentFat[CARD_FAT_CHECKSUM], &card->currentFat[CARD_FAT_CHECKSUMINV]);
+    }
+
+    memcpy(fat[currentFat ^ 1], fat[currentFat], CARD_SYSTEM_BLOCK_SIZE);
+
+    if (updateDir)
+    {
+        if (xferBytes)
+            *xferBytes = CARD_SYSTEM_BLOCK_SIZE;
+        return __CARDUpdateDir(chan, callback);
+    }
+
+    if (updateFat | updateOrphan)
+    {
+        if (xferBytes)
+            *xferBytes = CARD_SYSTEM_BLOCK_SIZE;
+        return __CARDUpdateFatBlock(chan, card->currentFat, callback);
+    }
+
+    __CARDPutControlBlock(card, CARD_RESULT_READY);
+    if (callback)
+    {
+        BOOL enabled = OSDisableInterrupts();
+        callback(chan, CARD_RESULT_READY);
+        OSRestoreInterrupts(enabled);
+    }
+    return CARD_RESULT_READY;
+}
+#endif
+
 s32 CARDCheckAsync(s32 chan, CARDCallback callback) {
+#if DOLPHIN_REVISION >= 37
+    s32 xferBytes;
+
+    return CARDCheckExAsync(chan, &xferBytes, callback);
+#else
     CARDControl *card;
     CARDDir *dir[2];
     u16 *fat[2];
@@ -314,6 +455,7 @@ s32 CARDCheckAsync(s32 chan, CARDCallback callback) {
     }
 
     return __CARDPutControlBlock(card, CARD_RESULT_READY);
+#endif
 }
 
 long CARDCheck(long chan) {

src/card/CARDCreate.c

@@ -29,6 +29,9 @@ static void CreateCallbackFat(long chan, long result) {
         ent->iconFormat = 0;
         ent->iconSpeed = 0;
         ent->commentAddr = -1;
+#if DOLPHIN_REVISION >= 37
+        __CARDSetIconSpeed(ent, 0, CARD_STAT_SPEED_FAST);
+#endif
         card->fileInfo->offset = 0;
         card->fileInfo->iBlock = ent->startBlock;
         ent->time = OSTicksToSeconds(OSGetTime());