396 lines
9 KiB
C
396 lines
9 KiB
C
#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;
|
|
}
|