ShuriZma
/
mgba
mirror of https://github.com/mgba-emu/mgba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GBA Savedata: Prefix SavedataType constants and type name

This commit is contained in:
Vicki Pfau 2024-03-24 22:57:51 -07:00
parent 6940b424df
commit ea5339304a
13 changed files with 270 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/mgba/internal/gba/overrides.h
View File

@ -16,7 +16,7 @@ CXX_GUARD_START
struct GBACartridgeOverride {
char id[4];
enum SavedataType savetype;
enum GBASavedataType savetype;
int hardware;
uint32_t idleLoop;
bool mirroring;

22
include/mgba/internal/gba/savedata.h
View File

@ -17,15 +17,15 @@ mLOG_DECLARE_CATEGORY(GBA_SAVE);
struct VFile;
enum SavedataType {
SAVEDATA_AUTODETECT = -1,
SAVEDATA_FORCE_NONE = 0,
SAVEDATA_SRAM = 1,
SAVEDATA_FLASH512 = 2,
SAVEDATA_FLASH1M = 3,
SAVEDATA_EEPROM = 4,
SAVEDATA_EEPROM512 = 5,
SAVEDATA_SRAM512 = 6,
enum GBASavedataType {
GBA_SAVEDATA_AUTODETECT = -1,
GBA_SAVEDATA_FORCE_NONE = 0,
GBA_SAVEDATA_SRAM = 1,
GBA_SAVEDATA_FLASH512 = 2,
GBA_SAVEDATA_FLASH1M = 3,
GBA_SAVEDATA_EEPROM = 4,
GBA_SAVEDATA_EEPROM512 = 5,
GBA_SAVEDATA_SRAM512 = 6,
};
enum SavedataCommand {
@ -68,7 +68,7 @@ enum {
};
struct GBASavedata {
enum SavedataType type;
enum GBASavedataType type;
uint8_t* data;
enum SavedataCommand command;
struct VFile* vf;
@ -108,7 +108,7 @@ void GBASavedataUnmask(struct GBASavedata* savedata);
size_t GBASavedataSize(const struct GBASavedata* savedata);
bool GBASavedataClone(struct GBASavedata* savedata, struct VFile* out);
bool GBASavedataLoad(struct GBASavedata* savedata, struct VFile* in);
void GBASavedataForceType(struct GBASavedata* savedata, enum SavedataType type);
void GBASavedataForceType(struct GBASavedata* savedata, enum GBASavedataType type);
void GBASavedataInitFlash(struct GBASavedata* savedata);
void GBASavedataInitEEPROM(struct GBASavedata* savedata);

14
src/gba/core.c
View File

@ -1004,27 +1004,27 @@ size_t _GBACoreListMemoryBlocks(const struct mCore* core, const struct mCoreMemo
if (gbacore->memoryBlockType != gba->memory.savedata.type) {
switch (gba->memory.savedata.type) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksSRAM, sizeof(_GBAMemoryBlocksSRAM));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksSRAM) / sizeof(*_GBAMemoryBlocksSRAM);
break;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksSRAM512, sizeof(_GBAMemoryBlocksSRAM512));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksSRAM512) / sizeof(*_GBAMemoryBlocksSRAM512);
break;
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksFlash512, sizeof(_GBAMemoryBlocksFlash512));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksFlash512) / sizeof(*_GBAMemoryBlocksFlash512);
break;
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH1M:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksFlash1M, sizeof(_GBAMemoryBlocksFlash1M));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksFlash1M) / sizeof(*_GBAMemoryBlocksFlash1M);
break;
case SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksEEPROM, sizeof(_GBAMemoryBlocksEEPROM));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksEEPROM) / sizeof(*_GBAMemoryBlocksEEPROM);
break;
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM512:
memcpy(gbacore->memoryBlocks, _GBAMemoryBlocksEEPROM512, sizeof(_GBAMemoryBlocksEEPROM512));
gbacore->nMemoryBlocks = sizeof(_GBAMemoryBlocksEEPROM512) / sizeof(*_GBAMemoryBlocksEEPROM512);
break;
@ -1076,7 +1076,7 @@ void* _GBACoreGetMemoryBlock(struct mCore* core, size_t id, size_t* sizeOut) {
*sizeOut = gba->memory.romSize;
return gba->memory.rom;
case GBA_REGION_SRAM:
if (gba->memory.savedata.type == SAVEDATA_FLASH1M) {
if (gba->memory.savedata.type == GBA_SAVEDATA_FLASH1M) {
*sizeOut = GBA_SIZE_FLASH1M;
return gba->memory.savedata.currentBank;
}

6
src/gba/dma.c
View File

@ -274,7 +274,7 @@ void GBADMAService(struct GBA* gba, int number, struct GBADMA* info) {
}
cpu->memory.store32(cpu, dest, memory->dmaTransferRegister, 0);
} else {
if (sourceRegion == GBA_REGION_ROM2_EX && (memory->savedata.type == SAVEDATA_EEPROM || memory->savedata.type == SAVEDATA_EEPROM512)) {
if (sourceRegion == GBA_REGION_ROM2_EX && (memory->savedata.type == GBA_SAVEDATA_EEPROM || memory->savedata.type == GBA_SAVEDATA_EEPROM512)) {
memory->dmaTransferRegister = GBASavedataReadEEPROM(&memory->savedata);
memory->dmaTransferRegister |= memory->dmaTransferRegister << 16;
} else if (source) {
@ -282,11 +282,11 @@ void GBADMAService(struct GBA* gba, int number, struct GBADMA* info) {
memory->dmaTransferRegister |= memory->dmaTransferRegister << 16;
}
if (destRegion == GBA_REGION_ROM2_EX) {
if (memory->savedata.type == SAVEDATA_AUTODETECT) {
if (memory->savedata.type == GBA_SAVEDATA_AUTODETECT) {
mLOG(GBA_MEM, INFO, "Detected EEPROM savegame");
GBASavedataInitEEPROM(&memory->savedata);
}
if (memory->savedata.type == SAVEDATA_EEPROM512 || memory->savedata.type == SAVEDATA_EEPROM) {
if (memory->savedata.type == GBA_SAVEDATA_EEPROM512 || memory->savedata.type == GBA_SAVEDATA_EEPROM) {
GBASavedataWriteEEPROM(&memory->savedata, memory->dmaTransferRegister, info->nextCount);
}
} else {

4
src/gba/gba.c
View File

@ -469,10 +469,10 @@ bool GBALoadROM(struct GBA* gba, struct VFile* vf) {
}
bool GBALoadSave(struct GBA* gba, struct VFile* sav) {
enum SavedataType type = gba->memory.savedata.type;
enum GBASavedataType type = gba->memory.savedata.type;
GBASavedataDeinit(&gba->memory.savedata);
GBASavedataInit(&gba->memory.savedata, sav);
if (type != SAVEDATA_AUTODETECT) {
if (type != GBA_SAVEDATA_AUTODETECT) {
GBASavedataForceType(&gba->memory.savedata, type);
}
return sav;

28
src/gba/memory.c
View File

@ -595,7 +595,7 @@ uint32_t GBALoad16(struct ARMCore* cpu, uint32_t address, int* cycleCounter) {
break;
case GBA_REGION_ROM2_EX:
wait = memory->waitstatesNonseq16[address >> BASE_OFFSET];
if (memory->savedata.type == SAVEDATA_EEPROM || memory->savedata.type == SAVEDATA_EEPROM512) {
if (memory->savedata.type == GBA_SAVEDATA_EEPROM || memory->savedata.type == GBA_SAVEDATA_EEPROM512) {
value = GBASavedataReadEEPROM(&memory->savedata);
} else if ((address & 0x0DFC0000) >= 0x0DF80000 && memory->hw.devices & HW_EREADER) {
value = GBACartEReaderRead(&memory->ereader, address);
@ -702,7 +702,7 @@ uint32_t GBALoad8(struct ARMCore* cpu, uint32_t address, int* cycleCounter) {
case GBA_REGION_SRAM:
case GBA_REGION_SRAM_MIRROR:
wait = memory->waitstatesNonseq16[address >> BASE_OFFSET];
if (memory->savedata.type == SAVEDATA_AUTODETECT) {
if (memory->savedata.type == GBA_SAVEDATA_AUTODETECT) {
mLOG(GBA_MEM, INFO, "Detected SRAM savegame");
GBASavedataInitSRAM(&memory->savedata);
}
@ -711,13 +711,13 @@ uint32_t GBALoad8(struct ARMCore* cpu, uint32_t address, int* cycleCounter) {
}
if (memory->hw.devices & HW_EREADER && (address & 0xE00FF80) >= 0xE00FF80) {
value = GBACartEReaderReadFlash(&memory->ereader, address);
} else if (memory->savedata.type == SAVEDATA_SRAM) {
} else if (memory->savedata.type == GBA_SAVEDATA_SRAM) {
value = memory->savedata.data[address & (GBA_SIZE_SRAM - 1)];
} else if (memory->savedata.type == SAVEDATA_FLASH512 || memory->savedata.type == SAVEDATA_FLASH1M) {
} else if (memory->savedata.type == GBA_SAVEDATA_FLASH512 || memory->savedata.type == GBA_SAVEDATA_FLASH1M) {
value = GBASavedataReadFlash(&memory->savedata, address);
} else if (memory->hw.devices & HW_TILT) {
value = GBAHardwareTiltRead(&memory->hw, address & OFFSET_MASK);
} else if (memory->savedata.type == SAVEDATA_SRAM512) {
} else if (memory->savedata.type == GBA_SAVEDATA_SRAM512) {
value = memory->savedata.data[address & (GBA_SIZE_SRAM512 - 1)];
} else {
mLOG(GBA_MEM, GAME_ERROR, "Reading from non-existent SRAM: 0x%08X", address);
@ -975,11 +975,11 @@ void GBAStore16(struct ARMCore* cpu, uint32_t address, int16_t value, int* cycle
if ((address & 0x0DFC0000) >= 0x0DF80000 && memory->hw.devices & HW_EREADER) {
GBACartEReaderWrite(&memory->ereader, address, value);
break;
} else if (memory->savedata.type == SAVEDATA_AUTODETECT) {
} else if (memory->savedata.type == GBA_SAVEDATA_AUTODETECT) {
mLOG(GBA_MEM, INFO, "Detected EEPROM savegame");
GBASavedataInitEEPROM(&memory->savedata);
}
if (memory->savedata.type == SAVEDATA_EEPROM512 || memory->savedata.type == SAVEDATA_EEPROM) {
if (memory->savedata.type == GBA_SAVEDATA_EEPROM512 || memory->savedata.type == GBA_SAVEDATA_EEPROM) {
GBASavedataWriteEEPROM(&memory->savedata, value, 1);
break;
}
@ -1050,7 +1050,7 @@ void GBAStore8(struct ARMCore* cpu, uint32_t address, int8_t value, int* cycleCo
break;
case GBA_REGION_SRAM:
case GBA_REGION_SRAM_MIRROR:
if (memory->savedata.type == SAVEDATA_AUTODETECT) {
if (memory->savedata.type == GBA_SAVEDATA_AUTODETECT) {
if (address == SAVEDATA_FLASH_BASE) {
mLOG(GBA_MEM, INFO, "Detected Flash savegame");
GBASavedataInitFlash(&memory->savedata);
@ -1061,9 +1061,9 @@ void GBAStore8(struct ARMCore* cpu, uint32_t address, int8_t value, int* cycleCo
}
if (memory->hw.devices & HW_EREADER && (address & 0xE00FF80) >= 0xE00FF80) {
GBACartEReaderWriteFlash(&memory->ereader, address, value);
} else if (memory->savedata.type == SAVEDATA_FLASH512 || memory->savedata.type == SAVEDATA_FLASH1M) {
} else if (memory->savedata.type == GBA_SAVEDATA_FLASH512 || memory->savedata.type == GBA_SAVEDATA_FLASH1M) {
GBASavedataWriteFlash(&memory->savedata, address, value);
} else if (memory->savedata.type == SAVEDATA_SRAM) {
} else if (memory->savedata.type == GBA_SAVEDATA_SRAM) {
if (memory->vfame.cartType) {
GBAVFameSramWrite(&memory->vfame, address, value, memory->savedata.data);
} else {
@ -1072,7 +1072,7 @@ void GBAStore8(struct ARMCore* cpu, uint32_t address, int8_t value, int* cycleCo
memory->savedata.dirty |= mSAVEDATA_DIRT_NEW;
} else if (memory->hw.devices & HW_TILT) {
GBAHardwareTiltWrite(&memory->hw, address & OFFSET_MASK, value);
} else if (memory->savedata.type == SAVEDATA_SRAM512) {
} else if (memory->savedata.type == GBA_SAVEDATA_SRAM512) {
memory->savedata.data[address & (GBA_SIZE_SRAM512 - 1)] = value;
memory->savedata.dirty |= mSAVEDATA_DIRT_NEW;
} else {
@ -1263,7 +1263,7 @@ void GBAPatch32(struct ARMCore* cpu, uint32_t address, int32_t value, int32_t* o
break;
case GBA_REGION_SRAM:
case GBA_REGION_SRAM_MIRROR:
if (memory->savedata.type == SAVEDATA_SRAM) {
if (memory->savedata.type == GBA_SAVEDATA_SRAM) {
LOAD_32(oldValue, address & (GBA_SIZE_SRAM - 4), memory->savedata.data);
STORE_32(value, address & (GBA_SIZE_SRAM - 4), memory->savedata.data);
} else {
@ -1333,7 +1333,7 @@ void GBAPatch16(struct ARMCore* cpu, uint32_t address, int16_t value, int16_t* o
break;
case GBA_REGION_SRAM:
case GBA_REGION_SRAM_MIRROR:
if (memory->savedata.type == SAVEDATA_SRAM) {
if (memory->savedata.type == GBA_SAVEDATA_SRAM) {
LOAD_16(oldValue, address & (GBA_SIZE_SRAM - 2), memory->savedata.data);
STORE_16(value, address & (GBA_SIZE_SRAM - 2), memory->savedata.data);
} else {
@ -1391,7 +1391,7 @@ void GBAPatch8(struct ARMCore* cpu, uint32_t address, int8_t value, int8_t* old)
break;
case GBA_REGION_SRAM:
case GBA_REGION_SRAM_MIRROR:
if (memory->savedata.type == SAVEDATA_SRAM) {
if (memory->savedata.type == GBA_SAVEDATA_SRAM) {
oldValue = ((int8_t*) memory->savedata.data)[address & (GBA_SIZE_SRAM - 1)];
((int8_t*) memory->savedata.data)[address & (GBA_SIZE_SRAM - 1)] = value;
} else {

260
src/gba/overrides.c
View File

@ -13,210 +13,210 @@
static const struct GBACartridgeOverride _overrides[] = {
// Advance Wars
{ "AWRE", SAVEDATA_FLASH512, HW_NONE, 0x8038810, false },
{ "AWRP", SAVEDATA_FLASH512, HW_NONE, 0x8038810, false },
{ "AWRE", GBA_SAVEDATA_FLASH512, HW_NONE, 0x8038810, false },
{ "AWRP", GBA_SAVEDATA_FLASH512, HW_NONE, 0x8038810, false },
// Advance Wars 2: Black Hole Rising
{ "AW2E", SAVEDATA_FLASH512, HW_NONE, 0x8036E08, false },
{ "AW2P", SAVEDATA_FLASH512, HW_NONE, 0x803719C, false },
{ "AW2E", GBA_SAVEDATA_FLASH512, HW_NONE, 0x8036E08, false },
{ "AW2P", GBA_SAVEDATA_FLASH512, HW_NONE, 0x803719C, false },
// Boktai: The Sun is in Your Hand
{ "U3IJ", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U3IE", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U3IP", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U3IJ", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U3IE", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U3IP", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
// Boktai 2: Solar Boy Django
{ "U32J", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U32E", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U32P", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U32J", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U32E", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U32P", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
// Crash Bandicoot 2 - N-Tranced
{ "AC8J", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AC8E", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AC8P", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AC8J", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AC8E", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AC8P", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// DigiCommunication Nyo - Datou! Black Gemagema Dan
{ "BDKJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "BDKJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Dragon Ball Z - The Legacy of Goku
{ "ALGP", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALGP", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Dragon Ball Z - The Legacy of Goku II
{ "ALFJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALFE", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALFP", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALFJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALFE", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALFP", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Dragon Ball Z - Taiketsu
{ "BDBE", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "BDBP", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "BDBE", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "BDBP", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Drill Dozer
{ "V49J", SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "V49E", SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "V49P", SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "V49J", GBA_SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "V49E", GBA_SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "V49P", GBA_SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
// e-Reader
{ "PEAJ", SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
{ "PSAJ", SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
{ "PSAE", SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
{ "PEAJ", GBA_SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
{ "PSAJ", GBA_SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
{ "PSAE", GBA_SAVEDATA_FLASH1M, HW_EREADER, IDLE_LOOP_NONE },
// Final Fantasy Tactics Advance
{ "AFXE", SAVEDATA_FLASH512, HW_NONE, 0x8000428, false },
{ "AFXE", GBA_SAVEDATA_FLASH512, HW_NONE, 0x8000428, false },
// F-Zero - Climax
{ "BFTJ", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BFTJ", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
// Goodboy Galaxy
{ "2GBP", SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
{ "2GBP", GBA_SAVEDATA_SRAM, HW_RUMBLE, IDLE_LOOP_NONE, false },
// Iridion II
{ "AI2E", SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "AI2P", SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "AI2E", GBA_SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "AI2P", GBA_SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
// Game Boy Wars Advance 1+2
{ "BGWJ", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BGWJ", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
// Golden Sun: The Lost Age
{ "AGFE", SAVEDATA_FLASH512, HW_NONE, 0x801353A, false },
{ "AGFE", GBA_SAVEDATA_FLASH512, HW_NONE, 0x801353A, false },
// Koro Koro Puzzle - Happy Panechu!
{ "KHPJ", SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KHPJ", GBA_SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
// Legendz - Yomigaeru Shiren no Shima
{ "BLJJ", SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
{ "BLJK", SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
{ "BLJJ", GBA_SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
{ "BLJK", GBA_SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
// Legendz - Sign of Nekuromu
{ "BLVJ", SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
{ "BLVJ", GBA_SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
// Mega Man Battle Network
{ "AREE", SAVEDATA_SRAM, HW_NONE, 0x800032E, false },
{ "AREE", GBA_SAVEDATA_SRAM, HW_NONE, 0x800032E, false },
// Mega Man Zero
{ "AZCE", SAVEDATA_SRAM, HW_NONE, 0x80004E8, false },
{ "AZCE", GBA_SAVEDATA_SRAM, HW_NONE, 0x80004E8, false },
// Metal Slug Advance
{ "BSME", SAVEDATA_EEPROM, HW_NONE, 0x8000290, false },
{ "BSME", GBA_SAVEDATA_EEPROM, HW_NONE, 0x8000290, false },
// Pokemon Ruby
{ "AXVJ", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVE", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVP", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVI", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVS", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVD", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVF", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVJ", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVE", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVP", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVI", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVS", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVD", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXVF", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
// Pokemon Sapphire
{ "AXPJ", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPE", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPP", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPI", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPS", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPD", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPF", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPJ", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPE", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPP", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPI", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPS", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPD", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "AXPF", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
// Pokemon Emerald
{ "BPEJ", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEE", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEP", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEI", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPES", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPED", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEF", SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEJ", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEE", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEP", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEI", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPES", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPED", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
{ "BPEF", GBA_SAVEDATA_FLASH1M, HW_RTC, 0x80008C6, false },
// Pokemon Mystery Dungeon
{ "B24E", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "B24P", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "B24E", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "B24P", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
// Pokemon FireRed
{ "BPRJ", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRE", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRP", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRI", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRS", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRD", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRF", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRJ", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRE", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRP", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRI", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRS", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRD", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPRF", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
// Pokemon LeafGreen
{ "BPGJ", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGE", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGP", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGI", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGS", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGD", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGF", SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGJ", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGE", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGP", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGI", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGS", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGD", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
{ "BPGF", GBA_SAVEDATA_FLASH1M, HW_NONE, IDLE_LOOP_NONE, false },
// RockMan EXE 4.5 - Real Operation
{ "BR4J", SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
{ "BR4J", GBA_SAVEDATA_FLASH512, HW_RTC, IDLE_LOOP_NONE, false },
// Rocky
{ "AR8E", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AROP", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AR8E", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "AROP", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Sennen Kazoku
{ "BKAJ", SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
{ "BKAJ", GBA_SAVEDATA_FLASH1M, HW_RTC, IDLE_LOOP_NONE, false },
// Shin Bokura no Taiyou: Gyakushuu no Sabata
{ "U33J", SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
{ "U33J", GBA_SAVEDATA_EEPROM, HW_RTC | HW_LIGHT_SENSOR, IDLE_LOOP_NONE, false },
// Stuart Little 2
{ "ASLE", SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "ASLF", SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "ASLE", GBA_SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "ASLF", GBA_SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
// Super Mario Advance 2
{ "AA2J", SAVEDATA_EEPROM, HW_NONE, 0x800052E, false },
{ "AA2E", SAVEDATA_EEPROM, HW_NONE, 0x800052E, false },
{ "AA2P", SAVEDATA_AUTODETECT, HW_NONE, 0x800052E, false },
{ "AA2J", GBA_SAVEDATA_EEPROM, HW_NONE, 0x800052E, false },
{ "AA2E", GBA_SAVEDATA_EEPROM, HW_NONE, 0x800052E, false },
{ "AA2P", GBA_SAVEDATA_AUTODETECT, HW_NONE, 0x800052E, false },
// Super Mario Advance 3
{ "A3AJ", SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
{ "A3AE", SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
{ "A3AP", SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
{ "A3AJ", GBA_SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
{ "A3AE", GBA_SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
{ "A3AP", GBA_SAVEDATA_EEPROM, HW_NONE, 0x8002B9C, false },
// Super Mario Advance 4
{ "AX4J", SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
{ "AX4E", SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
{ "AX4P", SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
{ "AX4J", GBA_SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
{ "AX4E", GBA_SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
{ "AX4P", GBA_SAVEDATA_FLASH1M, HW_NONE, 0x800072A, false },
// Super Monkey Ball Jr.
{ "ALUE", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALUP", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALUE", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "ALUP", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Top Gun - Combat Zones
{ "A2YE", SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
{ "A2YE", GBA_SAVEDATA_FORCE_NONE, HW_NONE, IDLE_LOOP_NONE, false },
// Ueki no Housoku - Jingi Sakuretsu! Nouryokusha Battle
{ "BUHJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "BUHJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Wario Ware Twisted
{ "RZWJ", SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
{ "RZWE", SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
{ "RZWP", SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
{ "RZWJ", GBA_SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
{ "RZWE", GBA_SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
{ "RZWP", GBA_SAVEDATA_SRAM, HW_RUMBLE | HW_GYRO, IDLE_LOOP_NONE, false },
// Yoshi's Universal Gravitation
{ "KYGJ", SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KYGE", SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KYGP", SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KYGJ", GBA_SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KYGE", GBA_SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
{ "KYGP", GBA_SAVEDATA_EEPROM, HW_TILT, IDLE_LOOP_NONE, false },
// Aging cartridge
{ "TCHK", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "TCHK", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
// Famicom Mini series 3 (FDS), some aren't mirrored (22 - 28)
// See https://forum.no-intro.org/viewtopic.php?f=2&t=4221 for discussion
{ "FNMJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FMRJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FPTJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FLBJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FFMJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FTKJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FTUJ", SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FNMJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FMRJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FPTJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FLBJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FFMJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FTKJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ "FTUJ", GBA_SAVEDATA_EEPROM, HW_NONE, IDLE_LOOP_NONE, false },
{ { 0, 0, 0, 0 }, 0, 0, IDLE_LOOP_NONE, false }
};
bool GBAOverrideFind(const struct Configuration* config, struct GBACartridgeOverride* override) {
override->savetype = SAVEDATA_AUTODETECT;
override->savetype = GBA_SAVEDATA_AUTODETECT;
override->hardware = HW_NONE;
override->idleLoop = IDLE_LOOP_NONE;
override->mirroring = false;
@ -233,7 +233,7 @@ bool GBAOverrideFind(const struct Configuration* config, struct GBACartridgeOver
}
if (!found && override->id[0] == 'F') {
// Classic NES Series
override->savetype = SAVEDATA_EEPROM;
override->savetype = GBA_SAVEDATA_EEPROM;
found = true;
}
@ -247,25 +247,25 @@ bool GBAOverrideFind(const struct Configuration* config, struct GBACartridgeOver
if (savetype) {
if (strcasecmp(savetype, "SRAM") == 0) {
found = true;
override->savetype = SAVEDATA_SRAM;
override->savetype = GBA_SAVEDATA_SRAM;
} else if (strcasecmp(savetype, "SRAM512") == 0) {
found = true;
override->savetype = SAVEDATA_SRAM512;
override->savetype = GBA_SAVEDATA_SRAM512;
} else if (strcasecmp(savetype, "EEPROM") == 0) {
found = true;
override->savetype = SAVEDATA_EEPROM;
override->savetype = GBA_SAVEDATA_EEPROM;
} else if (strcasecmp(savetype, "EEPROM512") == 0) {
found = true;
override->savetype = SAVEDATA_EEPROM512;
override->savetype = GBA_SAVEDATA_EEPROM512;
} else if (strcasecmp(savetype, "FLASH512") == 0) {
found = true;
override->savetype = SAVEDATA_FLASH512;
override->savetype = GBA_SAVEDATA_FLASH512;
} else if (strcasecmp(savetype, "FLASH1M") == 0) {
found = true;
override->savetype = SAVEDATA_FLASH1M;
override->savetype = GBA_SAVEDATA_FLASH1M;
} else if (strcasecmp(savetype, "NONE") == 0) {
found = true;
override->savetype = SAVEDATA_FORCE_NONE;
override->savetype = GBA_SAVEDATA_FORCE_NONE;
}
}
@ -295,28 +295,28 @@ void GBAOverrideSave(struct Configuration* config, const struct GBACartridgeOver
snprintf(sectionName, sizeof(sectionName), "override.%c%c%c%c", override->id[0], override->id[1], override->id[2], override->id[3]);
const char* savetype = 0;
switch (override->savetype) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
savetype = "SRAM";
break;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
savetype = "SRAM512";
break;
case SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM:
savetype = "EEPROM";
break;
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM512:
savetype = "EEPROM512";
break;
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
savetype = "FLASH512";
break;
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH1M:
savetype = "FLASH1M";
break;
case SAVEDATA_FORCE_NONE:
case GBA_SAVEDATA_FORCE_NONE:
savetype = "NONE";
break;
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_AUTODETECT:
break;
}
ConfigurationSetValue(config, sectionName, "savetype", savetype);
@ -335,7 +335,7 @@ void GBAOverrideSave(struct Configuration* config, const struct GBACartridgeOver
}
void GBAOverrideApply(struct GBA* gba, const struct GBACartridgeOverride* override) {
if (override->savetype != SAVEDATA_AUTODETECT) {
if (override->savetype != GBA_SAVEDATA_AUTODETECT) {
GBASavedataForceType(&gba->memory.savedata, override->savetype);
}
@ -429,7 +429,7 @@ void GBAOverrideApplyDefaults(struct GBA* gba, const struct Configuration* overr
if (isPokemon && !isKnownPokemon) {
// Enable FLASH1M and RTC on Pokémon ROM hacks
override.savetype = SAVEDATA_FLASH1M;
override.savetype = GBA_SAVEDATA_FLASH1M;
override.hardware = HW_RTC;
override.vbaBugCompat = true;
GBAOverrideApply(gba, &override);

128
src/gba/savedata.c
View File

@ -44,7 +44,7 @@ static void _ashesToAshes(struct mTiming* timing, void* user, uint32_t cyclesLat
}
void GBASavedataInit(struct GBASavedata* savedata, struct VFile* vf) {
savedata->type = SAVEDATA_AUTODETECT;
savedata->type = GBA_SAVEDATA_AUTODETECT;
savedata->data = 0;
savedata->command = EEPROM_COMMAND_NULL;
savedata->flashState = FLASH_STATE_RAW;
@ -72,35 +72,35 @@ void GBASavedataDeinit(struct GBASavedata* savedata) {
savedata->vf = NULL;
} else {
switch (savedata->type) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
mappedMemoryFree(savedata->data, GBA_SIZE_SRAM);
break;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
mappedMemoryFree(savedata->data, GBA_SIZE_SRAM512);
break;
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
mappedMemoryFree(savedata->data, GBA_SIZE_FLASH512);
break;
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH1M:
mappedMemoryFree(savedata->data, GBA_SIZE_FLASH1M);
break;
case SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM:
mappedMemoryFree(savedata->data, GBA_SIZE_EEPROM);
break;
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM512:
mappedMemoryFree(savedata->data, GBA_SIZE_EEPROM512);
break;
case SAVEDATA_FORCE_NONE:
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_FORCE_NONE:
case GBA_SAVEDATA_AUTODETECT:
break;
}
}
savedata->data = 0;
savedata->type = SAVEDATA_AUTODETECT;
savedata->type = GBA_SAVEDATA_AUTODETECT;
}
void GBASavedataMask(struct GBASavedata* savedata, struct VFile* vf, bool writeback) {
enum SavedataType type = savedata->type;
enum GBASavedataType type = savedata->type;
struct VFile* oldVf = savedata->vf;
GBASavedataDeinit(savedata);
if (oldVf && oldVf != savedata->realVf) {
@ -116,7 +116,7 @@ void GBASavedataUnmask(struct GBASavedata* savedata) {
if (!savedata->realVf || savedata->vf == savedata->realVf) {
return;
}
enum SavedataType type = savedata->type;
enum GBASavedataType type = savedata->type;
struct VFile* vf = savedata->vf;
GBASavedataDeinit(savedata);
savedata->vf = savedata->realVf;
@ -132,20 +132,20 @@ void GBASavedataUnmask(struct GBASavedata* savedata) {
bool GBASavedataClone(struct GBASavedata* savedata, struct VFile* out) {
if (savedata->data) {
switch (savedata->type) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
return out->write(out, savedata->data, GBA_SIZE_SRAM) == GBA_SIZE_SRAM;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
return out->write(out, savedata->data, GBA_SIZE_SRAM512) == GBA_SIZE_SRAM512;
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
return out->write(out, savedata->data, GBA_SIZE_FLASH512) == GBA_SIZE_FLASH512;
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH1M:
return out->write(out, savedata->data, GBA_SIZE_FLASH1M) == GBA_SIZE_FLASH1M;
case SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM:
return out->write(out, savedata->data, GBA_SIZE_EEPROM) == GBA_SIZE_EEPROM;
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM512:
return out->write(out, savedata->data, GBA_SIZE_EEPROM512) == GBA_SIZE_EEPROM512;
case SAVEDATA_AUTODETECT:
case SAVEDATA_FORCE_NONE:
case GBA_SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_FORCE_NONE:
return true;
}
} else if (savedata->vf) {
@ -163,21 +163,21 @@ bool GBASavedataClone(struct GBASavedata* savedata, struct VFile* out) {
size_t GBASavedataSize(const struct GBASavedata* savedata) {
switch (savedata->type) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
return GBA_SIZE_SRAM;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
return GBA_SIZE_SRAM512;
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
return GBA_SIZE_FLASH512;
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH1M:
return GBA_SIZE_FLASH1M;
case SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM:
return GBA_SIZE_EEPROM;
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM512:
return GBA_SIZE_EEPROM512;
case SAVEDATA_FORCE_NONE:
case GBA_SAVEDATA_FORCE_NONE:
return 0;
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_AUTODETECT:
default:
if (savedata->vf) {
return savedata->vf->size(savedata->vf);
@ -188,7 +188,7 @@ size_t GBASavedataSize(const struct GBASavedata* savedata) {
bool GBASavedataLoad(struct GBASavedata* savedata, struct VFile* in) {
if (savedata->data) {
if (!in || savedata->type == SAVEDATA_FORCE_NONE) {
if (!in || savedata->type == GBA_SAVEDATA_FORCE_NONE) {
return false;
}
ssize_t size = GBASavedataSize(savedata);
@ -220,11 +220,11 @@ bool GBASavedataLoad(struct GBASavedata* savedata, struct VFile* in) {
return true;
}
void GBASavedataForceType(struct GBASavedata* savedata, enum SavedataType type) {
void GBASavedataForceType(struct GBASavedata* savedata, enum GBASavedataType type) {
if (savedata->type == type) {
return;
}
if (savedata->type != SAVEDATA_AUTODETECT) {
if (savedata->type != GBA_SAVEDATA_AUTODETECT) {
struct VFile* vf = savedata->vf;
int mapMode = savedata->mapMode;
bool maskWriteback = savedata->maskWriteback;
@ -234,40 +234,40 @@ void GBASavedataForceType(struct GBASavedata* savedata, enum SavedataType type)
savedata->maskWriteback = maskWriteback;
}
switch (type) {
case SAVEDATA_FLASH512:
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH1M:
savedata->type = type;
GBASavedataInitFlash(savedata);
break;
case SAVEDATA_EEPROM:
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM512:
savedata->type = type;
GBASavedataInitEEPROM(savedata);
break;
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
GBASavedataInitSRAM(savedata);
break;
case SAVEDATA_SRAM512:
case GBA_SAVEDATA_SRAM512:
GBASavedataInitSRAM512(savedata);
break;
case SAVEDATA_FORCE_NONE:
savedata->type = SAVEDATA_FORCE_NONE;
case GBA_SAVEDATA_FORCE_NONE:
savedata->type = GBA_SAVEDATA_FORCE_NONE;
break;
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_AUTODETECT:
break;
}
}
void GBASavedataInitFlash(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_FLASH512;
if (savedata->type == GBA_SAVEDATA_AUTODETECT) {
savedata->type = GBA_SAVEDATA_FLASH512;
}
if (savedata->type != SAVEDATA_FLASH512 && savedata->type != SAVEDATA_FLASH1M) {
if (savedata->type != GBA_SAVEDATA_FLASH512 && savedata->type != GBA_SAVEDATA_FLASH1M) {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
int32_t flashSize = GBA_SIZE_FLASH512;
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
flashSize = GBA_SIZE_FLASH1M;
}
off_t end;
@ -289,14 +289,14 @@ void GBASavedataInitFlash(struct GBASavedata* savedata) {
}
void GBASavedataInitEEPROM(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_EEPROM512;
} else if (savedata->type != SAVEDATA_EEPROM512 && savedata->type != SAVEDATA_EEPROM) {
if (savedata->type == GBA_SAVEDATA_AUTODETECT) {
savedata->type = GBA_SAVEDATA_EEPROM512;
} else if (savedata->type != GBA_SAVEDATA_EEPROM512 && savedata->type != GBA_SAVEDATA_EEPROM) {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
int32_t eepromSize = GBA_SIZE_EEPROM512;
if (savedata->type == SAVEDATA_EEPROM) {
if (savedata->type == GBA_SAVEDATA_EEPROM) {
eepromSize = GBA_SIZE_EEPROM;
}
off_t end;
@ -316,8 +316,8 @@ void GBASavedataInitEEPROM(struct GBASavedata* savedata) {
}
void GBASavedataInitSRAM(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_SRAM;
if (savedata->type == GBA_SAVEDATA_AUTODETECT) {
savedata->type = GBA_SAVEDATA_SRAM;
} else {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
@ -340,8 +340,8 @@ void GBASavedataInitSRAM(struct GBASavedata* savedata) {
}
void GBASavedataInitSRAM512(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_SRAM512;
if (savedata->type == GBA_SAVEDATA_AUTODETECT) {
savedata->type = GBA_SAVEDATA_SRAM512;
} else {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
@ -365,11 +365,11 @@ void GBASavedataInitSRAM512(struct GBASavedata* savedata) {
uint8_t GBASavedataReadFlash(struct GBASavedata* savedata, uint16_t address) {
if (savedata->command == FLASH_COMMAND_ID) {
if (savedata->type == SAVEDATA_FLASH512) {
if (savedata->type == GBA_SAVEDATA_FLASH512) {
if (address < 2) {
return FLASH_MFG_PANASONIC >> (address * 8);
}
} else if (savedata->type == SAVEDATA_FLASH1M) {
} else if (savedata->type == GBA_SAVEDATA_FLASH1M) {
if (address < 2) {
return FLASH_MFG_SANYO >> (address * 8);
}
@ -472,10 +472,10 @@ static void _ensureEeprom(struct GBASavedata* savedata, uint32_t size) {
if (size < GBA_SIZE_EEPROM512) {
return;
}
if (savedata->type == SAVEDATA_EEPROM) {
if (savedata->type == GBA_SAVEDATA_EEPROM) {
return;
}
savedata->type = SAVEDATA_EEPROM;
savedata->type = GBA_SAVEDATA_EEPROM;
if (!savedata->vf) {
return;
}
@ -605,7 +605,7 @@ void GBASavedataRTCWrite(struct GBASavedata* savedata) {
int bank = 0;
if ((savedata->vf->size(savedata->vf) & 0xFF) != sizeof(buffer)) {
// Writing past the end of the file can invalidate the file mapping
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
bank = savedata->currentBank == &savedata->data[0x10000];
}
savedata->vf->unmap(savedata->vf, savedata->data, size);
@ -614,9 +614,9 @@ void GBASavedataRTCWrite(struct GBASavedata* savedata) {
savedata->vf->write(savedata->vf, &buffer, sizeof(buffer));
if (!savedata->data) {
savedata->data = savedata->vf->map(savedata->vf, size, MAP_WRITE);
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
savedata->currentBank = &savedata->data[bank << 16];
} else if (savedata->type == SAVEDATA_FLASH512) {
} else if (savedata->type == GBA_SAVEDATA_FLASH512) {
savedata->currentBank = savedata->data;
}
}
@ -730,7 +730,7 @@ void GBASavedataDeserialize(struct GBASavedata* savedata, const struct GBASerial
LOAD_32(savedata->writeAddress, 0, &state->savedata.writeAddress);
LOAD_16(savedata->settling, 0, &state->savedata.settlingSector);
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
_flashSwitchBank(savedata, GBASerializedSavedataFlagsGetFlashBank(flags));
}
@ -743,9 +743,9 @@ void GBASavedataDeserialize(struct GBASavedata* savedata, const struct GBASerial
void _flashSwitchBank(struct GBASavedata* savedata, int bank) {
mLOG(GBA_SAVE, DEBUG, "Performing flash bank switch to bank %i", bank);
if (bank > 0 && savedata->type == SAVEDATA_FLASH512) {
if (bank > 0 && savedata->type == GBA_SAVEDATA_FLASH512) {
mLOG(GBA_SAVE, INFO, "Updating flash chip from 512kb to 1Mb");
savedata->type = SAVEDATA_FLASH1M;
savedata->type = GBA_SAVEDATA_FLASH1M;
if (savedata->vf) {
savedata->vf->unmap(savedata->vf, savedata->data, GBA_SIZE_FLASH512);
if (savedata->vf->size(savedata->vf) < GBA_SIZE_FLASH1M) {
@ -764,7 +764,7 @@ void _flashErase(struct GBASavedata* savedata) {
mLOG(GBA_SAVE, DEBUG, "Performing flash chip erase");
savedata->dirty |= mSAVEDATA_DIRT_NEW;
size_t size = GBA_SIZE_FLASH512;
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
size = GBA_SIZE_FLASH1M;
}
memset(savedata->data, 0xFF, size);
@ -774,7 +774,7 @@ void _flashEraseSector(struct GBASavedata* savedata, uint16_t sectorStart) {
mLOG(GBA_SAVE, DEBUG, "Performing flash sector erase at 0x%04x", sectorStart);
savedata->dirty |= mSAVEDATA_DIRT_NEW;
size_t size = 0x1000;
if (savedata->type == SAVEDATA_FLASH1M) {
if (savedata->type == GBA_SAVEDATA_FLASH1M) {
mLOG(GBA_SAVE, DEBUG, "Performing unknown sector-size erase at 0x%04x", sectorStart);
}
savedata->settling = sectorStart >> 12;

10
src/gba/sharkport.c
View File

@ -18,9 +18,9 @@ static const int GSV_PAYLOAD_OFFSET = 0x430;
static bool _importSavedata(struct GBA* gba, void* payload, size_t size) {
bool success = false;
switch (gba->memory.savedata.type) {
case SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH512:
if (size > GBA_SIZE_FLASH512) {
GBASavedataForceType(&gba->memory.savedata, SAVEDATA_FLASH1M);
GBASavedataForceType(&gba->memory.savedata, GBA_SAVEDATA_FLASH1M);
}
// Fall through
default:
@ -28,8 +28,8 @@ static bool _importSavedata(struct GBA* gba, void* payload, size_t size) {
size = GBASavedataSize(&gba->memory.savedata);
}
break;
case SAVEDATA_FORCE_NONE:
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_FORCE_NONE:
case GBA_SAVEDATA_AUTODETECT:
goto cleanup;
}
@ -276,7 +276,7 @@ bool GBASavedataExportSharkPort(const struct GBA* gba, struct VFile* vf) {
checksum += buffer.c[i] << (checksum % 24);
}
if (gba->memory.savedata.type == SAVEDATA_EEPROM) {
if (gba->memory.savedata.type == GBA_SAVEDATA_EEPROM) {
for (i = 0; i < size; ++i) {
char byte = gba->memory.savedata.data[i ^ 7];
checksum += byte << (checksum % 24);

2
src/platform/libretro/libretro.c
View File

@ -1156,7 +1156,7 @@ size_t retro_get_memory_size(unsigned id) {
#ifdef M_CORE_GBA
case mPLATFORM_GBA:
switch (((struct GBA*) core->board)->memory.savedata.type) {
case SAVEDATA_AUTODETECT:
case GBA_SAVEDATA_AUTODETECT:
return GBA_SIZE_FLASH1M;
default:
return GBASavedataSize(&((struct GBA*) core->board)->memory.savedata);

4
src/platform/qt/OverrideView.cpp
View File

@ -153,14 +153,14 @@ void OverrideView::updateOverrides() {
if (m_ui.tabWidget->currentWidget() == m_ui.tabGBA) {
auto gba = std::make_unique<GBAOverride>();
memset(gba->override.id, 0, 4);
gba->override.savetype = static_cast<SavedataType>(m_ui.savetype->currentIndex() - 1);
gba->override.savetype = static_cast<GBASavedataType>(m_ui.savetype->currentIndex() - 1);
gba->override.hardware = HW_NO_OVERRIDE;
gba->override.idleLoop = IDLE_LOOP_NONE;
gba->override.mirroring = false;
gba->override.vbaBugCompat = false;
gba->vbaBugCompatSet = false;
if (gba->override.savetype != SAVEDATA_AUTODETECT) {
if (gba->override.savetype != GBA_SAVEDATA_AUTODETECT) {
hasOverride = true;
}
if (!m_ui.hwAutodetect->isChecked()) {

56
src/platform/qt/SaveConverter.cpp
View File

@ -170,8 +170,8 @@ void SaveConverter::detectFromSavestate(VFile* vf) {
switch (platform) {
#ifdef M_CORE_GBA
case mPLATFORM_GBA:
save.gba.type = static_cast<SavedataType>(state.at(offsetof(GBASerializedState, savedata.type)));
if (save.gba.type == SAVEDATA_EEPROM || save.gba.type == SAVEDATA_EEPROM512) {
save.gba.type = static_cast<GBASavedataType>(state.at(offsetof(GBASerializedState, savedata.type)));
if (save.gba.type == GBA_SAVEDATA_EEPROM || save.gba.type == GBA_SAVEDATA_EEPROM512) {
save.endianness = Endian::LITTLE;
}
break;
@ -198,25 +198,25 @@ void SaveConverter::detectFromSize(std::shared_ptr<VFileDevice> vf) {
switch (vf->size()) {
case GBA_SIZE_SRAM:
case GBA_SIZE_SRAM + 16:
m_validSaves.append(AnnotatedSave{SAVEDATA_SRAM, vf});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_SRAM, vf});
break;
case GBA_SIZE_FLASH512:
case GBA_SIZE_FLASH512 + 16:
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH512, vf});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH512, vf});
break;
case GBA_SIZE_FLASH1M:
case GBA_SIZE_FLASH1M + 16:
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH1M, vf});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH1M, vf});
break;
case GBA_SIZE_EEPROM:
case GBA_SIZE_EEPROM + 16:
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM, vf, Endian::LITTLE});
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM, vf, Endian::BIG});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM, vf, Endian::LITTLE});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM, vf, Endian::BIG});
break;
case GBA_SIZE_EEPROM512:
case GBA_SIZE_EEPROM512 + 16:
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM512, vf, Endian::LITTLE});
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM512, vf, Endian::BIG});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM512, vf, Endian::LITTLE});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM512, vf, Endian::BIG});
break;
}
#endif
@ -272,12 +272,12 @@ void SaveConverter::detectFromHeaders(std::shared_ptr<VFileDevice> vf) {
QByteArray bytes = QByteArray::fromRawData(static_cast<const char*>(data), size);
bytes.data(); // Trigger a deep copy before we delete the backing
if (size == GBA_SIZE_FLASH1M) {
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::SHARKPORT});
} else {
m_validSaves.append(AnnotatedSave{SAVEDATA_SRAM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_SRAM)), Endian::NONE, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_FLASH512)), Endian::NONE, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM)), Endian::BIG, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM512)), Endian::BIG, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_SRAM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_SRAM)), Endian::NONE, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_FLASH512)), Endian::NONE, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM)), Endian::BIG, Container::SHARKPORT});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM512)), Endian::BIG, Container::SHARKPORT});
}
free(data);
}
@ -289,20 +289,20 @@ void SaveConverter::detectFromHeaders(std::shared_ptr<VFileDevice> vf) {
bytes.data(); // Trigger a deep copy before we delete the backing
switch (size) {
case GBA_SIZE_FLASH1M:
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
break;
case GBA_SIZE_FLASH512:
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH512, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
m_validSaves.append(AnnotatedSave{SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH512, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_FLASH1M, std::make_shared<VFileDevice>(bytes), Endian::NONE, Container::GSV});
break;
case GBA_SIZE_SRAM:
m_validSaves.append(AnnotatedSave{SAVEDATA_SRAM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_SRAM)), Endian::NONE, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_SRAM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_SRAM)), Endian::NONE, Container::GSV});
break;
case GBA_SIZE_EEPROM:
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM)), Endian::BIG, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM)), Endian::BIG, Container::GSV});
break;
case GBA_SIZE_EEPROM512:
m_validSaves.append(AnnotatedSave{SAVEDATA_EEPROM512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM512)), Endian::BIG, Container::GSV});
m_validSaves.append(AnnotatedSave{GBA_SAVEDATA_EEPROM512, std::make_shared<VFileDevice>(bytes.left(GBA_SIZE_EEPROM512)), Endian::BIG, Container::GSV});
break;
}
free(data);
@ -401,7 +401,7 @@ SaveConverter::AnnotatedSave::AnnotatedSave(mPlatform platform, std::shared_ptr<
}
#ifdef M_CORE_GBA
SaveConverter::AnnotatedSave::AnnotatedSave(SavedataType type, std::shared_ptr<VFileDevice> vf, Endian endianness, Container container)
SaveConverter::AnnotatedSave::AnnotatedSave(GBASavedataType type, std::shared_ptr<VFileDevice> vf, Endian endianness, Container container)
: container(container)
, platform(mPLATFORM_GBA)
, size(vf->size())
@ -468,15 +468,15 @@ SaveConverter::AnnotatedSave::operator QString() const {
#ifdef M_CORE_GBA
case mPLATFORM_GBA:
switch (gba.type) {
case SAVEDATA_SRAM:
case GBA_SAVEDATA_SRAM:
typeFormat = QCoreApplication::translate("QGBA::SaveConverter", "SRAM");
break;
case SAVEDATA_FLASH512:
case SAVEDATA_FLASH1M:
case GBA_SAVEDATA_FLASH512:
case GBA_SAVEDATA_FLASH1M:
typeFormat = QCoreApplication::translate("QGBA::SaveConverter", "%1 flash");
break;
case SAVEDATA_EEPROM:
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM512:
typeFormat = QCoreApplication::translate("QGBA::SaveConverter", "%1 EEPROM");
break;
default:
@ -664,8 +664,8 @@ QByteArray SaveConverter::AnnotatedSave::convertTo(const SaveConverter::Annotate
#ifdef M_CORE_GBA
case mPLATFORM_GBA:
switch (gba.type) {
case SAVEDATA_EEPROM:
case SAVEDATA_EEPROM512:
case GBA_SAVEDATA_EEPROM:
case GBA_SAVEDATA_EEPROM512:
if (endianness == target.endianness) {
break;
}

4
src/platform/qt/SaveConverter.h
View File

@ -48,7 +48,7 @@ private slots:
private:
#ifdef M_CORE_GBA
struct GBASave {
SavedataType type;
GBASavedataType type;
};
#endif
#ifdef M_CORE_GB
@ -66,7 +66,7 @@ private:
AnnotatedSave();
AnnotatedSave(mPlatform, std::shared_ptr<VFileDevice>, Endian = Endian::NONE, Container = Container::NONE);
#ifdef M_CORE_GBA
AnnotatedSave(SavedataType, std::shared_ptr<VFileDevice>, Endian = Endian::NONE, Container = Container::NONE);
AnnotatedSave(GBASavedataType, std::shared_ptr<VFileDevice>, Endian = Endian::NONE, Container = Container::NONE);
#endif
#ifdef M_CORE_GB
AnnotatedSave(GBMemoryBankControllerType, std::shared_ptr<VFileDevice>, Endian = Endian::NONE, Container = Container::NONE);