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

remove old cruft

This commit is contained in:
Arisotura 2021-04-24 21:17:19 +02:00
parent ca524f000e
commit 3942b61c4b
3 changed files with 3 additions and 625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

581
src/GBACart.cpp
View File

@ -23,468 +23,6 @@
#include "Platform.h"
/*namespace GBACart_SRAM
{
enum SaveType {
S_NULL,
S_EEPROM4K,
S_EEPROM64K,
S_SRAM256K,
S_FLASH512K,
S_FLASH1M
};
// from DeSmuME
struct FlashProperties
{
u8 state;
u8 cmd;
u8 device;
u8 manufacturer;
u8 bank;
};
u8* SRAM;
FILE* SRAMFile;
u32 SRAMLength;
SaveType SRAMType;
FlashProperties SRAMFlashState;
char SRAMPath[1024];
void (*WriteFunc)(u32 addr, u8 val);
void Write_Null(u32 addr, u8 val);
void Write_EEPROM(u32 addr, u8 val);
void Write_SRAM(u32 addr, u8 val);
void Write_Flash(u32 addr, u8 val);
bool Init()
{
SRAM = NULL;
SRAMFile = NULL;
return true;
}
void DeInit()
{
if (SRAMFile) fclose(SRAMFile);
if (SRAM) delete[] SRAM;
}
void Reset()
{
// do nothing, we don't want to clear GBA SRAM on reset
}
void Eject()
{
if (SRAMFile) fclose(SRAMFile);
if (SRAM) delete[] SRAM;
SRAM = NULL;
SRAMFile = NULL;
SRAMLength = 0;
SRAMType = S_NULL;
SRAMFlashState = {};
}
void DoSavestate(Savestate* file)
{
file->Section("GBCS"); // Game Boy [Advance] Cart Save
// logic mostly copied from NDSCart_SRAM
u32 oldlen = SRAMLength;
file->Var32(&SRAMLength);
if (SRAMLength != oldlen)
{
// reallocate save memory
if (oldlen) delete[] SRAM;
if (SRAMLength) SRAM = new u8[SRAMLength];
}
if (SRAMLength)
{
// fill save memory if data is present
file->VarArray(SRAM, SRAMLength);
}
else
{
// no save data, clear the current state
SRAMType = SaveType::S_NULL;
if (SRAMFile) fclose(SRAMFile);
SRAM = NULL;
SRAMFile = NULL;
return;
}
// persist some extra state info
file->Var8(&SRAMFlashState.bank);
file->Var8(&SRAMFlashState.cmd);
file->Var8(&SRAMFlashState.device);
file->Var8(&SRAMFlashState.manufacturer);
file->Var8(&SRAMFlashState.state);
file->Var8((u8*)&SRAMType);
}
void LoadSave(const char* path)
{
if (SRAM) delete[] SRAM;
strncpy(SRAMPath, path, 1023);
SRAMPath[1023] = '\0';
SRAMLength = 0;
FILE* f = Platform::OpenFile(SRAMPath, "r+b");
if (f)
{
fseek(f, 0, SEEK_END);
SRAMLength = (u32)ftell(f);
SRAM = new u8[SRAMLength];
fseek(f, 0, SEEK_SET);
fread(SRAM, SRAMLength, 1, f);
SRAMFile = f;
}
switch (SRAMLength)
{
case 512:
SRAMType = S_EEPROM4K;
WriteFunc = Write_EEPROM;
break;
case 8192:
SRAMType = S_EEPROM64K;
WriteFunc = Write_EEPROM;
break;
case 32768:
SRAMType = S_SRAM256K;
WriteFunc = Write_SRAM;
break;
case 65536:
SRAMType = S_FLASH512K;
WriteFunc = Write_Flash;
break;
case 128*1024:
SRAMType = S_FLASH1M;
WriteFunc = Write_Flash;
break;
default:
printf("!! BAD SAVE LENGTH %d\n", SRAMLength);
case 0:
SRAMType = S_NULL;
WriteFunc = Write_Null;
break;
}
if (SRAMType == S_FLASH512K)
{
// Panasonic 64K chip
SRAMFlashState.device = 0x1B;
SRAMFlashState.manufacturer = 0x32;
}
else if (SRAMType == S_FLASH1M)
{
// Sanyo 128K chip
SRAMFlashState.device = 0x13;
SRAMFlashState.manufacturer = 0x62;
}
}
void RelocateSave(const char* path, bool write)
{
if (!write)
{
LoadSave(path); // lazy
return;
}
strncpy(SRAMPath, path, 1023);
SRAMPath[1023] = '\0';
FILE *f = Platform::OpenFile(path, "r+b");
if (!f)
{
printf("GBACart_SRAM::RelocateSave: failed to create new file. fuck\n");
return;
}
SRAMFile = f;
fwrite(SRAM, SRAMLength, 1, SRAMFile);
}
// mostly ported from DeSmuME
u8 Read_Flash(u32 addr)
{
if (SRAMFlashState.cmd == 0) // no cmd
{
return *(u8*)&SRAM[addr + 0x10000 * SRAMFlashState.bank];
}
switch (SRAMFlashState.cmd)
{
case 0x90: // chip ID
if (addr == 0x0000) return SRAMFlashState.manufacturer;
if (addr == 0x0001) return SRAMFlashState.device;
break;
case 0xF0: // terminate command (TODO: break if non-Macronix chip and not at the end of an ID call?)
SRAMFlashState.state = 0;
SRAMFlashState.cmd = 0;
break;
case 0xA0: // write command
break; // ignore here, handled in Write_Flash()
case 0xB0: // bank switching (128K only)
break; // ignore here, handled in Write_Flash()
default:
printf("GBACart_SRAM::Read_Flash: unknown command 0x%02X @ 0x%04X\n", SRAMFlashState.cmd, addr);
break;
}
return 0xFF;
}
void Write_Null(u32 addr, u8 val) {}
void Write_EEPROM(u32 addr, u8 val)
{
// TODO: could be used in homebrew?
}
// mostly ported from DeSmuME
void Write_Flash(u32 addr, u8 val)
{
switch (SRAMFlashState.state)
{
case 0x00:
if (addr == 0x5555)
{
if (val == 0xF0)
{
// reset
SRAMFlashState.state = 0;
SRAMFlashState.cmd = 0;
return;
}
else if (val == 0xAA)
{
SRAMFlashState.state = 1;
return;
}
}
if (addr == 0x0000)
{
if (SRAMFlashState.cmd == 0xB0)
{
// bank switching
SRAMFlashState.bank = val;
SRAMFlashState.cmd = 0;
return;
}
}
break;
case 0x01:
if (addr == 0x2AAA && val == 0x55)
{
SRAMFlashState.state = 2;
return;
}
SRAMFlashState.state = 0;
break;
case 0x02:
if (addr == 0x5555)
{
// send command
switch (val)
{
case 0x80: // erase
SRAMFlashState.state = 0x80;
break;
case 0x90: // chip ID
SRAMFlashState.state = 0x90;
break;
case 0xA0: // write
SRAMFlashState.state = 0;
break;
default:
SRAMFlashState.state = 0;
break;
}
SRAMFlashState.cmd = val;
return;
}
SRAMFlashState.state = 0;
break;
// erase
case 0x80:
if (addr == 0x5555 && val == 0xAA)
{
SRAMFlashState.state = 0x81;
return;
}
SRAMFlashState.state = 0;
break;
case 0x81:
if (addr == 0x2AAA && val == 0x55)
{
SRAMFlashState.state = 0x82;
return;
}
SRAMFlashState.state = 0;
break;
case 0x82:
if (val == 0x30)
{
u32 start_addr = addr + 0x10000 * SRAMFlashState.bank;
memset((u8*)&SRAM[start_addr], 0xFF, 0x1000);
if (SRAMFile)
{
fseek(SRAMFile, start_addr, SEEK_SET);
fwrite((u8*)&SRAM[start_addr], 1, 0x1000, SRAMFile);
}
}
SRAMFlashState.state = 0;
SRAMFlashState.cmd = 0;
return;
// chip ID
case 0x90:
if (addr == 0x5555 && val == 0xAA)
{
SRAMFlashState.state = 0x91;
return;
}
SRAMFlashState.state = 0;
break;
case 0x91:
if (addr == 0x2AAA && val == 0x55)
{
SRAMFlashState.state = 0x92;
return;
}
SRAMFlashState.state = 0;
break;
case 0x92:
SRAMFlashState.state = 0;
SRAMFlashState.cmd = 0;
return;
default:
break;
}
if (SRAMFlashState.cmd == 0xA0) // write
{
Write_SRAM(addr + 0x10000 * SRAMFlashState.bank, val);
SRAMFlashState.state = 0;
SRAMFlashState.cmd = 0;
return;
}
printf("GBACart_SRAM::Write_Flash: unknown write 0x%02X @ 0x%04X (state: 0x%02X)\n",
val, addr, SRAMFlashState.state);
}
void Write_SRAM(u32 addr, u8 val)
{
u8 prev = *(u8*)&SRAM[addr];
if (prev != val)
{
*(u8*)&SRAM[addr] = val;
if (SRAMFile)
{
fseek(SRAMFile, addr, SEEK_SET);
fwrite((u8*)&SRAM[addr], 1, 1, SRAMFile);
}
}
}
u8 Read8(u32 addr)
{
if (SRAMType == S_NULL)
{
return 0xFF;
}
if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
{
return Read_Flash(addr);
}
return *(u8*)&SRAM[addr];
}
u16 Read16(u32 addr)
{
if (SRAMType == S_NULL)
{
return 0xFFFF;
}
if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
{
u16 val = Read_Flash(addr + 0) |
(Read_Flash(addr + 1) << 8);
return val;
}
return *(u16*)&SRAM[addr];
}
u32 Read32(u32 addr)
{
if (SRAMType == S_NULL)
{
return 0xFFFFFFFF;
}
if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
{
u32 val = Read_Flash(addr + 0) |
(Read_Flash(addr + 1) << 8) |
(Read_Flash(addr + 2) << 16) |
(Read_Flash(addr + 3) << 24);
return val;
}
return *(u32*)&SRAM[addr];
}
void Write8(u32 addr, u8 val)
{
u8 prev = *(u8*)&SRAM[addr];
WriteFunc(addr, val);
}
void Write16(u32 addr, u16 val)
{
u16 prev = *(u16*)&SRAM[addr];
WriteFunc(addr + 0, val & 0xFF);
WriteFunc(addr + 1, val >> 8 & 0xFF);
}
void Write32(u32 addr, u32 val)
{
u32 prev = *(u32*)&SRAM[addr];
WriteFunc(addr + 0, val & 0xFF);
WriteFunc(addr + 1, val >> 8 & 0xFF);
WriteFunc(addr + 2, val >> 16 & 0xFF);
WriteFunc(addr + 3, val >> 24 & 0xFF);
}
}*/
namespace GBACart
{
@ -1068,8 +606,6 @@ void CartGameSolarSensor::ProcessGPIO()
bool Init()
{
//if (!GBACart_SRAM::Init()) return false;
CartROM = nullptr;
Cart = nullptr;
@ -1082,8 +618,6 @@ void DeInit()
if (CartROM) delete[] CartROM;
if (Cart) delete Cart;
//GBACart_SRAM::DeInit();
}
void Reset()
@ -1093,9 +627,6 @@ void Reset()
// This allows resetting a DS game without losing GBA state,
// and resetting to firmware without the slot being emptied.
// The Stop function will clear the cartridge state via Eject().
//GBACart_SRAM::Reset();
//GBACart_SolarSensor::Reset();
}
void Eject()
@ -1103,17 +634,14 @@ void Eject()
if (CartROM) delete[] CartROM;
CartInserted = false;
//HasSolarSensor = false;
CartROM = NULL;
CartROMSize = 0;
CartCRC = 0;
CartID = 0;
//CartGPIO = {};
if (Cart) delete Cart;
Cart = nullptr;
//GBACart_SRAM::Eject();
Reset();
}
@ -1142,13 +670,6 @@ void DoSavestate(Savestate* file)
// delete and reallocate ROM so that it is zero-padded to its full length
if (CartROM) delete[] CartROM;
CartROM = new u8[CartROMSize];
// clear the SRAM file handle; writes will not be committed
/*if (GBACart_SRAM::SRAMFile)
{
fclose(GBACart_SRAM::SRAMFile);
GBACart_SRAM::SRAMFile = NULL;
}*/
}
// only save/load the cartridge header
@ -1171,16 +692,8 @@ void DoSavestate(Savestate* file)
file->Var32(&CartCRC);
file->Var32(&CartID);
/*file->Var8((u8*)&HasSolarSensor);
file->Var16(&CartGPIO.control);
file->Var16(&CartGPIO.data);
file->Var16(&CartGPIO.direction);*/
// now do the rest
//GBACart_SRAM::DoSavestate(file);
//if (HasSolarSensor) GBACart_SolarSensor::DoSavestate(file);
if (Cart) Cart->DoSavestate(file);
}
@ -1214,7 +727,6 @@ void LoadROMCommon(const char *sram)
// save
printf("GBA save file: %s\n", sram);
//GBACart_SRAM::LoadSave(sram);
// TODO: have a list of sorts like in NDSCart? to determine the savemem type
if (Cart) Cart->LoadSave(sram, 0);
@ -1267,8 +779,6 @@ bool LoadROM(const u8* romdata, u32 filelength, const char *sram)
void RelocateSave(const char* path, bool write)
{
// derp herp
//GBACart_SRAM::RelocateSave(path, write);
if (Cart) Cart->RelocateSave(path, write);
}
@ -1305,95 +815,4 @@ void SRAMWrite(u32 addr, u8 val)
if (Cart) Cart->SRAMWrite(addr, val);
}
// referenced from mGBA
/*void WriteGPIO(u32 addr, u16 val)
{
switch (addr)
{
case 0xC4:
CartGPIO.data &= ~CartGPIO.direction;
CartGPIO.data |= val & CartGPIO.direction;
if (HasSolarSensor) GBACart_SolarSensor::Process(&CartGPIO);
break;
case 0xC6:
CartGPIO.direction = val;
break;
case 0xC8:
CartGPIO.control = val;
break;
default:
printf("Unknown GBA GPIO write 0x%02X @ 0x%04X\n", val, addr);
}
// write the GPIO values in the ROM (if writable)
if (CartGPIO.control & 1)
{
*(u16*)&CartROM[0xC4] = CartGPIO.data;
*(u16*)&CartROM[0xC6] = CartGPIO.direction;
*(u16*)&CartROM[0xC8] = CartGPIO.control;
}
else
{
// GBATEK: "in write-only mode, reads return 00h (or [possibly] other data (...))"
// ambiguous, but mGBA sets ROM to 00h when switching to write-only, so do the same
*(u16*)&CartROM[0xC4] = 0;
*(u16*)&CartROM[0xC6] = 0;
*(u16*)&CartROM[0xC8] = 0;
}
}*/
}
/*namespace GBACart_SolarSensor
{
bool LightEdge;
u8 LightCounter;
u8 LightSample;
u8 LightLevel; // 0-10 range
// levels from mGBA
const int GBA_LUX_LEVELS[11] = { 0, 5, 11, 18, 27, 42, 62, 84, 109, 139, 183 };
#define LIGHT_VALUE (0xFF - (0x16 + GBA_LUX_LEVELS[LightLevel]))
void Reset()
{
LightEdge = false;
LightCounter = 0;
LightSample = 0xFF;
LightLevel = 0;
}
void DoSavestate(Savestate* file)
{
file->Var8((u8*)&LightEdge);
file->Var8(&LightCounter);
file->Var8(&LightSample);
file->Var8(&LightLevel);
}
void Process(GBACart::GPIO* gpio)
{
if (gpio->data & 4) return; // Boktai chip select
if (gpio->data & 2) // Reset
{
u8 prev = LightSample;
LightCounter = 0;
LightSample = LIGHT_VALUE;
printf("Solar sensor reset (sample: 0x%02X -> 0x%02X)\n", prev, LightSample);
}
if (gpio->data & 1 && LightEdge) LightCounter++;
LightEdge = !(gpio->data & 1);
bool sendBit = LightCounter >= LightSample;
if (gpio->control & 1)
{
gpio->data = (gpio->data & gpio->direction) | ((sendBit << 3) & ~gpio->direction & 0xF);
}
}
}*/

44
src/GBACart.h
View File

@ -22,27 +22,6 @@
#include "types.h"
#include "Savestate.h"
/*namespace GBACart_SRAM
{
extern u8* SRAM;
extern u32 SRAMLength;
void Reset();
void DoSavestate(Savestate* file);
u8 Read8(u32 addr);
u16 Read16(u32 addr);
u32 Read32(u32 addr);
void Write8(u32 addr, u8 val);
void Write16(u32 addr, u16 val);
void Write32(u32 addr, u32 val);
}*/
namespace GBACart
{
@ -157,13 +136,6 @@ private:
u8 LightLevel;
};
/*struct GPIO
{
u16 data;
u16 direction;
u16 control;
};*/
// possible inputs for GBA carts that might accept user input
enum
{
@ -172,7 +144,6 @@ enum
};
extern bool CartInserted;
//extern bool HasSolarSensor;
extern u8* CartROM;
extern u32 CartROMSize;
extern u32 CartCRC;
@ -187,6 +158,7 @@ bool LoadROM(const char* path, const char* sram);
bool LoadROM(const u8* romdata, u32 filelength, const char *sram);
void RelocateSave(const char* path, bool write);
// TODO: make more flexible, support nonbinary inputs
int SetInput(int num, bool pressed);
u16 ROMRead(u32 addr);
@ -195,20 +167,6 @@ void ROMWrite(u32 addr, u16 val);
u8 SRAMRead(u32 addr);
void SRAMWrite(u32 addr, u8 val);
//void WriteGPIO(u32 addr, u16 val);
}
/*namespace GBACart_SolarSensor
{
extern u8 LightLevel;
void Reset();
void DoSavestate(Savestate* file);
void Process(GBACart::GPIO* gpio);
}*/
#endif // GBACART_H

3
src/NDSCart.cpp
View File

@ -29,11 +29,12 @@
#include "melonDLDI.h"
#include "NDSCart_SRAMManager.h"
// SRAM TODO: emulate write delays???
namespace NDSCart
{
// SRAM TODO: emulate write delays???
u16 SPICnt;
u32 ROMCnt;