Imported dolphin/card

src/dolphin/card/CARDMount.c

@@ -0,0 +1,396 @@
+#include <dolphin/card.h>
+#include <dolphin/dsp.h>
+#include <dolphin/dvd.h>
+#include <dolphin/exi.h>
+#include <dolphin/os.h>
+
+#include <dolphin/CARDPriv.h>
+#include <dolphin/OSRtcPriv.h>
+
+u8 GameChoice : (OS_BASE_CACHED | 0x000030E3);
+
+static u32 SectorSizeTable[8] = {
+    8 * 1024,
+    16 * 1024,
+    32 * 1024,
+    64 * 1024,
+    128 * 1024,
+    256 * 1024,
+    0,
+    0,
+};
+
+static u32 LatencyTable[8] = {
+    4,
+    8,
+    16,
+    32,
+    64,
+    128,
+    256,
+    512,
+};
+
+void __CARDMountCallback(s32 chan, s32 result);
+static void DoUnmount(s32 chan, s32 result);
+
+static BOOL IsCard(u32 id)
+{
+    u32 size;
+    s32 sectorSize;
+    if (id & (0xFFFF0000) && (id != 0x80000004 || __CARDVendorID == 0xFFFF)) {
+        return FALSE;
+    }
+
+    if ((id & 3) != 0) {
+        return FALSE;
+    }
+
+    size = id & 0xfc;
+    switch (size) {
+        case 4:
+        case 8:
+        case 16:
+        case 32:
+        case 64:
+        case 128:
+            break;
+        default:
+            return FALSE;
+            break;
+    }
+
+    sectorSize = SectorSizeTable[(id & 0x00003800) >> 11];
+    if (sectorSize == 0) {
+        return FALSE;
+    }
+
+    if ((size * 1024 * 1024 / 8) / sectorSize < 8) {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+s32 CARDProbeEx(s32 chan, s32 *memSize, s32 *sectorSize)
+{
+    u32 id;
+    CARDControl *card;
+    BOOL enabled;
+    s32 result;
+    int probe;
+
+    if (chan < 0 || 2 <= chan) {
+        return CARD_RESULT_FATAL_ERROR;
+    }
+
+    if (GameChoice & 0x80) {
+        return CARD_RESULT_NOCARD;
+    }
+
+    card = &__CARDBlock[chan];
+    enabled = OSDisableInterrupts();
+
+    probe = EXIProbeEx(chan);
+    if (probe == -1) {
+        result = CARD_RESULT_NOCARD;
+    }
+    else if (probe == 0) {
+        result = CARD_RESULT_BUSY;
+    }
+    else if (card->attached) {
+        if (card->mountStep < 1) {
+            result = CARD_RESULT_BUSY;
+        }
+        else {
+            if (memSize) {
+                *memSize = card->size;
+            }
+            if (sectorSize) {
+                *sectorSize = card->sectorSize;
+            }
+            result = CARD_RESULT_READY;
+        }
+    }
+    else if ((EXIGetState(chan) & 8)) {
+        result = CARD_RESULT_WRONGDEVICE;
+    }
+    else if (!EXIGetID(chan, 0, &id)) {
+        result = CARD_RESULT_BUSY;
+    }
+    else if (IsCard(id)) {
+        if (memSize) {
+            *memSize = (s32)(id & 0xfc);
+        }
+        if (sectorSize) {
+            *sectorSize = SectorSizeTable[(id & 0x00003800) >> 11];
+        }
+        result = CARD_RESULT_READY;
+    }
+    else {
+        result = CARD_RESULT_WRONGDEVICE;
+    }
+
+    OSRestoreInterrupts(enabled);
+    return result;
+}
+
+static s32 DoMount(s32 chan)
+{
+    CARDControl *card;
+    u32 id;
+    u8 status;
+    s32 result;
+    OSSramEx *sram;
+    int i;
+    u8 checkSum;
+    int step;
+
+    card = &__CARDBlock[chan];
+
+    if (card->mountStep == 0) {
+        if (EXIGetID(chan, 0, &id) == 0) {
+            result = CARD_RESULT_NOCARD;
+        }
+        else if (IsCard(id)) {
+            result = CARD_RESULT_READY;
+        }
+        else {
+            result = CARD_RESULT_WRONGDEVICE;
+        }
+        if (result < 0) {
+            goto error;
+        }
+
+        card->cid = id;
+
+        card->size = (u16)(id & 0xFC);
+        card->sectorSize = SectorSizeTable[(id & 0x00003800) >> 11];
+        card->cBlock = (u16)((card->size * 1024 * 1024 / 8) / card->sectorSize);
+        card->latency = LatencyTable[(id & 0x00000700) >> 8];
+
+        result = __CARDClearStatus(chan);
+        if (result < 0) {
+            goto error;
+        }
+        result = __CARDReadStatus(chan, &status);
+        if (result < 0) {
+            goto error;
+        }
+
+        if (!EXIProbe(chan)) {
+            result = CARD_RESULT_NOCARD;
+            goto error;
+        }
+
+        if (!(status & 0x40)) {
+            result = __CARDUnlock(chan, card->id);
+            if (result < 0) {
+                goto error;
+            }
+
+            checkSum = 0;
+            sram = __OSLockSramEx();
+            for (i = 0; i < 12; i++) {
+                sram->flashID[chan][i] = card->id[i];
+                checkSum += card->id[i];
+            }
+            sram->flashIDCheckSum[chan] = (u8)~checkSum;
+            __OSUnlockSramEx(TRUE);
+
+            return result;
+        }
+        else {
+            card->mountStep = 1;
+
+            checkSum = 0;
+            sram = __OSLockSramEx();
+            for (i = 0; i < 12; i++) {
+                checkSum += sram->flashID[chan][i];
+            }
+            __OSUnlockSramEx(FALSE);
+            if (sram->flashIDCheckSum[chan] != (u8)~checkSum) {
+                result = CARD_RESULT_IOERROR;
+                goto error;
+            }
+        }
+    }
+
+    if (card->mountStep == 1) {
+        if (card->cid == 0x80000004) {
+            u16 vendorID;
+
+            sram = __OSLockSramEx();
+            vendorID = *(u16 *)sram->flashID[chan];
+            __OSUnlockSramEx(FALSE);
+
+            if (__CARDVendorID == 0xffff || vendorID != __CARDVendorID) {
+                result = CARD_RESULT_WRONGDEVICE;
+                goto error;
+            }
+        }
+
+        card->mountStep = 2;
+
+        result = __CARDEnableInterrupt(chan, TRUE);
+        if (result < 0) {
+            goto error;
+        }
+
+        EXISetExiCallback(chan, __CARDExiHandler);
+        EXIUnlock(chan);
+        DCInvalidateRange(card->workArea, CARD_WORKAREA_SIZE);
+    }
+
+    step = card->mountStep - 2;
+    result = __CARDRead(
+        chan, (u32)card->sectorSize * step, CARD_SYSTEM_BLOCK_SIZE, (u8 *)card->workArea + (CARD_SYSTEM_BLOCK_SIZE * step), __CARDMountCallback);
+    if (result < 0) {
+        __CARDPutControlBlock(card, result);
+    }
+    return result;
+
+error:
+    EXIUnlock(chan);
+    DoUnmount(chan, result);
+    return result;
+}
+
+void __CARDMountCallback(s32 chan, s32 result)
+{
+    CARDControl *card;
+    CARDCallback callback;
+
+    card = &__CARDBlock[chan];
+
+    switch (result) {
+        case CARD_RESULT_READY:
+            if (++card->mountStep < CARD_MAX_MOUNT_STEP) {
+                result = DoMount(chan);
+                if (0 <= result) {
+                    return;
+                }
+            }
+            else {
+                result = __CARDVerify(card);
+            }
+            break;
+        case CARD_RESULT_UNLOCKED:
+            card->unlockCallback = __CARDMountCallback;
+            if (!EXILock(chan, 0, __CARDUnlockedHandler)) {
+                return;
+            }
+            card->unlockCallback = 0;
+
+            result = DoMount(chan);
+            if (0 <= result) {
+                return;
+            }
+            break;
+        case CARD_RESULT_IOERROR:
+        case CARD_RESULT_NOCARD:
+            DoUnmount(chan, result);
+            break;
+    }
+
+    callback = card->apiCallback;
+    card->apiCallback = 0;
+    __CARDPutControlBlock(card, result);
+    callback(chan, result);
+}
+
+s32 CARDMountAsync(s32 chan, void *workArea, CARDCallback detachCallback, CARDCallback attachCallback)
+{
+    CARDControl *card;
+    BOOL enabled;
+
+    if (chan < 0 || 2 <= chan) {
+        return CARD_RESULT_FATAL_ERROR;
+    }
+    if (GameChoice & 0x80) {
+        return CARD_RESULT_NOCARD;
+    }
+    card = &__CARDBlock[chan];
+
+    enabled = OSDisableInterrupts();
+    if (card->result == CARD_RESULT_BUSY) {
+        OSRestoreInterrupts(enabled);
+        return CARD_RESULT_BUSY;
+    }
+
+    if (!card->attached && (EXIGetState(chan) & 0x08)) {
+        OSRestoreInterrupts(enabled);
+        return CARD_RESULT_WRONGDEVICE;
+    }
+
+    card->result = CARD_RESULT_BUSY;
+    card->workArea = workArea;
+    card->extCallback = detachCallback;
+    card->apiCallback = attachCallback ? attachCallback : __CARDDefaultApiCallback;
+    card->exiCallback = 0;
+
+    if (!card->attached && !EXIAttach(chan, __CARDExtHandler)) {
+        card->result = CARD_RESULT_NOCARD;
+        OSRestoreInterrupts(enabled);
+        return CARD_RESULT_NOCARD;
+    }
+
+    card->mountStep = 0;
+    card->attached = TRUE;
+    EXISetExiCallback(chan, 0);
+    OSCancelAlarm(&card->alarm);
+
+    card->currentDir = 0;
+    card->currentFat = 0;
+
+    OSRestoreInterrupts(enabled);
+
+    card->unlockCallback = __CARDMountCallback;
+    if (!EXILock(chan, 0, __CARDUnlockedHandler)) {
+        return CARD_RESULT_READY;
+    }
+    card->unlockCallback = 0;
+
+    return DoMount(chan);
+}
+
+s32 CARDMount(s32 chan, void *workArea, CARDCallback attachCb)
+{
+    s32 result = CARDMountAsync(chan, workArea, attachCb, __CARDSyncCallback);
+    if (result < 0) {
+        return result;
+    }
+
+    return __CARDSync(chan);
+}
+
+static void DoUnmount(s32 chan, s32 result)
+{
+    CARDControl *card;
+    BOOL enabled;
+
+    card = &__CARDBlock[chan];
+    enabled = OSDisableInterrupts();
+    if (card->attached) {
+        EXISetExiCallback(chan, 0);
+        EXIDetach(chan);
+        OSCancelAlarm(&card->alarm);
+        card->attached = FALSE;
+        card->result = result;
+        card->mountStep = 0;
+    }
+    OSRestoreInterrupts(enabled);
+}
+
+s32 CARDUnmount(s32 chan)
+{
+    CARDControl *card;
+    s32 result;
+
+    result = __CARDGetControlBlock(chan, &card);
+    if (result < 0) {
+        return result;
+    }
+    DoUnmount(chan, CARD_RESULT_NOCARD);
+    return CARD_RESULT_READY;
+}