mirror of
https://github.com/melonDS-emu/melonDS.git
synced 2024-11-14 13:27:41 -07:00
Cart refactor (#1073)
complete cart-interface refactor, will make this code a lot easier to deal with
This commit is contained in:
Arisotura
GitHub
parent
ede6e832d8
commit
1846a71265
@ -79,14 +79,15 @@ void Start()
|
||||
|
||||
u8 Read(bool last)
|
||||
{
|
||||
//printf("BPTWL: read %02X -> %02X @ %08X\n", CurPos, Registers[CurPos], NDS::GetPC(1));
|
||||
u8 ret = Registers[CurPos++];
|
||||
|
||||
if (last)
|
||||
{
|
||||
CurPos = -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//printf("BPTWL: read %02X -> %02X\n", CurPos, Registers[CurPos]);
|
||||
return Registers[CurPos++];
|
||||
return ret;
|
||||
}
|
||||
|
||||
void Write(u8 val, bool last)
|
||||
|
||||
@ -464,6 +464,10 @@ u16 DSi_SDHost::Read(u32 addr)
|
||||
case 0x102: return 0;
|
||||
case 0x104: return BlockLen32;
|
||||
case 0x108: return BlockCount32;
|
||||
|
||||
// dunno
|
||||
case 0x106: return 0;
|
||||
case 0x10A: return 0;
|
||||
}
|
||||
|
||||
printf("unknown %s read %08X @ %08X\n", SD_DESC, addr, NDS::GetPC(1));
|
||||
@ -626,6 +630,10 @@ void DSi_SDHost::Write(u32 addr, u16 val)
|
||||
case 0x102: return;
|
||||
case 0x104: BlockLen32 = val & 0x03FF; return;
|
||||
case 0x108: BlockCount32 = val; return;
|
||||
|
||||
// dunno
|
||||
case 0x106: return;
|
||||
case 0x10A: return;
|
||||
}
|
||||
|
||||
printf("unknown %s write %08X %04X\n", SD_DESC, addr, val);
|
||||
@ -847,8 +855,7 @@ void DSi_MMCStorage::SendCMD(u8 cmd, u32 param)
|
||||
}
|
||||
RWCommand = 18;
|
||||
Host->SendResponse(CSR, true);
|
||||
ReadBlock(RWAddress);
|
||||
RWAddress += BlockSize;
|
||||
RWAddress += ReadBlock(RWAddress);
|
||||
SetState(0x05);
|
||||
return;
|
||||
|
||||
@ -862,8 +869,7 @@ void DSi_MMCStorage::SendCMD(u8 cmd, u32 param)
|
||||
}
|
||||
RWCommand = 25;
|
||||
Host->SendResponse(CSR, true);
|
||||
WriteBlock(RWAddress);
|
||||
RWAddress += BlockSize;
|
||||
RWAddress += WriteBlock(RWAddress);
|
||||
SetState(0x04);
|
||||
return;
|
||||
|
||||
|
||||
570
src/GBACart.cpp
570
src/GBACart.cpp
@ -23,77 +23,105 @@
|
||||
#include "Platform.h"
|
||||
|
||||
|
||||
namespace GBACart_SRAM
|
||||
namespace GBACart
|
||||
{
|
||||
|
||||
enum SaveType {
|
||||
S_NULL,
|
||||
S_EEPROM4K,
|
||||
S_EEPROM64K,
|
||||
S_SRAM256K,
|
||||
S_FLASH512K,
|
||||
S_FLASH1M
|
||||
const char SOLAR_SENSOR_GAMECODES[10][5] =
|
||||
{
|
||||
"U3IJ", // Bokura no Taiyou - Taiyou Action RPG (Japan)
|
||||
"U3IE", // Boktai - The Sun Is in Your Hand (USA)
|
||||
"U3IP", // Boktai - The Sun Is in Your Hand (Europe)
|
||||
"U32J", // Zoku Bokura no Taiyou - Taiyou Shounen Django (Japan)
|
||||
"U32E", // Boktai 2 - Solar Boy Django (USA)
|
||||
"U32P", // Boktai 2 - Solar Boy Django (Europe)
|
||||
"U33J", // Shin Bokura no Taiyou - Gyakushuu no Sabata (Japan)
|
||||
"A3IJ" // Boktai - The Sun Is in Your Hand (USA) (Sample)
|
||||
};
|
||||
|
||||
// from DeSmuME
|
||||
struct FlashProperties
|
||||
|
||||
bool CartInserted;
|
||||
//bool HasSolarSensor;
|
||||
u8* CartROM;
|
||||
u32 CartROMSize;
|
||||
u32 CartCRC;
|
||||
u32 CartID;
|
||||
//GPIO CartGPIO; // overridden GPIO parameters
|
||||
|
||||
CartCommon* Cart;
|
||||
|
||||
|
||||
CartCommon::CartCommon()
|
||||
{
|
||||
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()
|
||||
CartCommon::~CartCommon()
|
||||
{
|
||||
if (SRAMFile) fclose(SRAMFile);
|
||||
if (SRAM) delete[] SRAM;
|
||||
}
|
||||
|
||||
void Reset()
|
||||
void CartCommon::DoSavestate(Savestate* file)
|
||||
{
|
||||
// do nothing, we don't want to clear GBA SRAM on reset
|
||||
file->Section("GBCS");
|
||||
}
|
||||
|
||||
void Eject()
|
||||
void CartCommon::LoadSave(const char* path, u32 type)
|
||||
{
|
||||
if (SRAMFile) fclose(SRAMFile);
|
||||
if (SRAM) delete[] SRAM;
|
||||
SRAM = NULL;
|
||||
SRAMFile = NULL;
|
||||
}
|
||||
|
||||
void CartCommon::RelocateSave(const char* path, bool write)
|
||||
{
|
||||
}
|
||||
|
||||
int CartCommon::SetInput(int num, bool pressed)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
u16 CartCommon::ROMRead(u32 addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CartCommon::ROMWrite(u32 addr, u16 val)
|
||||
{
|
||||
}
|
||||
|
||||
u8 CartCommon::SRAMRead(u32 addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CartCommon::SRAMWrite(u32 addr, u8 val)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
CartGame::CartGame(u8* rom, u32 len) : CartCommon()
|
||||
{
|
||||
ROM = rom;
|
||||
ROMLength = len;
|
||||
|
||||
memset(&GPIO, 0, sizeof(GPIO));
|
||||
|
||||
SRAM = nullptr;
|
||||
SRAMFile = nullptr;
|
||||
SRAMLength = 0;
|
||||
SRAMType = S_NULL;
|
||||
SRAMFlashState = {};
|
||||
}
|
||||
|
||||
void DoSavestate(Savestate* file)
|
||||
CartGame::~CartGame()
|
||||
{
|
||||
file->Section("GBCS"); // Game Boy [Advance] Cart Save
|
||||
if (SRAMFile) fclose(SRAMFile);
|
||||
if (SRAM) delete[] SRAM;
|
||||
}
|
||||
|
||||
void CartGame::DoSavestate(Savestate* file)
|
||||
{
|
||||
CartCommon::DoSavestate(file);
|
||||
|
||||
file->Var16(&GPIO.control);
|
||||
file->Var16(&GPIO.data);
|
||||
file->Var16(&GPIO.direction);
|
||||
|
||||
// logic mostly copied from NDSCart_SRAM
|
||||
|
||||
@ -117,8 +145,8 @@ void DoSavestate(Savestate* file)
|
||||
// no save data, clear the current state
|
||||
SRAMType = SaveType::S_NULL;
|
||||
if (SRAMFile) fclose(SRAMFile);
|
||||
SRAM = NULL;
|
||||
SRAMFile = NULL;
|
||||
SRAM = nullptr;
|
||||
SRAMFile = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
@ -132,7 +160,7 @@ void DoSavestate(Savestate* file)
|
||||
file->Var8((u8*)&SRAMType);
|
||||
}
|
||||
|
||||
void LoadSave(const char* path)
|
||||
void CartGame::LoadSave(const char* path, u32 type)
|
||||
{
|
||||
if (SRAM) delete[] SRAM;
|
||||
|
||||
@ -157,29 +185,23 @@ void LoadSave(const char* path)
|
||||
{
|
||||
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);
|
||||
printf("!! BAD GBA SAVE LENGTH %d\n", SRAMLength);
|
||||
case 0:
|
||||
SRAMType = S_NULL;
|
||||
WriteFunc = Write_Null;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -197,11 +219,11 @@ void LoadSave(const char* path)
|
||||
}
|
||||
}
|
||||
|
||||
void RelocateSave(const char* path, bool write)
|
||||
void CartGame::RelocateSave(const char* path, bool write)
|
||||
{
|
||||
if (!write)
|
||||
{
|
||||
LoadSave(path); // lazy
|
||||
LoadSave(path, 0); // lazy
|
||||
return;
|
||||
}
|
||||
|
||||
@ -219,8 +241,114 @@ void RelocateSave(const char* path, bool write)
|
||||
fwrite(SRAM, SRAMLength, 1, SRAMFile);
|
||||
}
|
||||
|
||||
u16 CartGame::ROMRead(u32 addr)
|
||||
{
|
||||
addr &= 0x01FFFFFF;
|
||||
|
||||
if (addr >= 0xC4 && addr < 0xCA)
|
||||
{
|
||||
if (GPIO.control & 0x1)
|
||||
{
|
||||
switch (addr)
|
||||
{
|
||||
case 0xC4: return GPIO.data;
|
||||
case 0xC6: return GPIO.direction;
|
||||
case 0xC8: return GPIO.control;
|
||||
}
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
// CHECKME: does ROM mirror?
|
||||
if (addr < ROMLength)
|
||||
return *(u16*)&ROM[addr];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CartGame::ROMWrite(u32 addr, u16 val)
|
||||
{
|
||||
addr &= 0x01FFFFFF;
|
||||
|
||||
switch (addr)
|
||||
{
|
||||
case 0xC4:
|
||||
GPIO.data &= ~GPIO.direction;
|
||||
GPIO.data |= val & GPIO.direction;
|
||||
ProcessGPIO();
|
||||
break;
|
||||
|
||||
case 0xC6:
|
||||
GPIO.direction = val;
|
||||
break;
|
||||
|
||||
case 0xC8:
|
||||
GPIO.control = val;
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("Unknown GBA GPIO write 0x%02X @ 0x%04X\n", val, addr);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
u8 CartGame::SRAMRead(u32 addr)
|
||||
{
|
||||
addr &= 0xFFFF;
|
||||
|
||||
switch (SRAMType)
|
||||
{
|
||||
case S_EEPROM4K:
|
||||
case S_EEPROM64K:
|
||||
return SRAMRead_EEPROM(addr);
|
||||
|
||||
case S_FLASH512K:
|
||||
case S_FLASH1M:
|
||||
return SRAMRead_FLASH(addr);
|
||||
|
||||
case S_SRAM256K:
|
||||
return SRAMRead_SRAM(addr);
|
||||
}
|
||||
|
||||
return 0xFF;
|
||||
}
|
||||
|
||||
void CartGame::SRAMWrite(u32 addr, u8 val)
|
||||
{
|
||||
addr &= 0xFFFF;
|
||||
|
||||
switch (SRAMType)
|
||||
{
|
||||
case S_EEPROM4K:
|
||||
case S_EEPROM64K:
|
||||
return SRAMWrite_EEPROM(addr, val);
|
||||
|
||||
case S_FLASH512K:
|
||||
case S_FLASH1M:
|
||||
return SRAMWrite_FLASH(addr, val);
|
||||
|
||||
case S_SRAM256K:
|
||||
return SRAMWrite_SRAM(addr, val);
|
||||
}
|
||||
}
|
||||
|
||||
void CartGame::ProcessGPIO()
|
||||
{
|
||||
}
|
||||
|
||||
u8 CartGame::SRAMRead_EEPROM(u32 addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CartGame::SRAMWrite_EEPROM(u32 addr, u8 val)
|
||||
{
|
||||
// TODO: could be used in homebrew?
|
||||
}
|
||||
|
||||
// mostly ported from DeSmuME
|
||||
u8 Read_Flash(u32 addr)
|
||||
u8 CartGame::SRAMRead_FLASH(u32 addr)
|
||||
{
|
||||
if (SRAMFlashState.cmd == 0) // no cmd
|
||||
{
|
||||
@ -249,15 +377,8 @@ u8 Read_Flash(u32 addr)
|
||||
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)
|
||||
void CartGame::SRAMWrite_FLASH(u32 addr, u8 val)
|
||||
{
|
||||
switch (SRAMFlashState.state)
|
||||
{
|
||||
@ -380,7 +501,7 @@ void Write_Flash(u32 addr, u8 val)
|
||||
|
||||
if (SRAMFlashState.cmd == 0xA0) // write
|
||||
{
|
||||
Write_SRAM(addr + 0x10000 * SRAMFlashState.bank, val);
|
||||
SRAMWrite_SRAM(addr + 0x10000 * SRAMFlashState.bank, val);
|
||||
SRAMFlashState.state = 0;
|
||||
SRAMFlashState.cmd = 0;
|
||||
return;
|
||||
@ -390,10 +511,18 @@ void Write_Flash(u32 addr, u8 val)
|
||||
val, addr, SRAMFlashState.state);
|
||||
}
|
||||
|
||||
void Write_SRAM(u32 addr, u8 val)
|
||||
u8 CartGame::SRAMRead_SRAM(u32 addr)
|
||||
{
|
||||
u8 prev = *(u8*)&SRAM[addr];
|
||||
if (addr >= SRAMLength) return 0xFF;
|
||||
|
||||
return SRAM[addr];
|
||||
}
|
||||
|
||||
void CartGame::SRAMWrite_SRAM(u32 addr, u8 val)
|
||||
{
|
||||
if (addr >= SRAMLength) return;
|
||||
|
||||
u8 prev = *(u8*)&SRAM[addr];
|
||||
if (prev != val)
|
||||
{
|
||||
*(u8*)&SRAM[addr] = val;
|
||||
@ -406,115 +535,80 @@ void Write_SRAM(u32 addr, u8 val)
|
||||
}
|
||||
}
|
||||
|
||||
u8 Read8(u32 addr)
|
||||
|
||||
const int CartGameSolarSensor::kLuxLevels[11] = {0, 5, 11, 18, 27, 42, 62, 84, 109, 139, 183};
|
||||
|
||||
CartGameSolarSensor::CartGameSolarSensor(u8* rom, u32 len) : CartGame(rom, len)
|
||||
{
|
||||
if (SRAMType == S_NULL)
|
||||
LightEdge = false;
|
||||
LightCounter = 0;
|
||||
LightSample = 0xFF;
|
||||
LightLevel = 0;
|
||||
}
|
||||
|
||||
CartGameSolarSensor::~CartGameSolarSensor()
|
||||
{
|
||||
}
|
||||
|
||||
void CartGameSolarSensor::DoSavestate(Savestate* file)
|
||||
{
|
||||
CartGame::DoSavestate(file);
|
||||
|
||||
file->Var8((u8*)&LightEdge);
|
||||
file->Var8(&LightCounter);
|
||||
file->Var8(&LightSample);
|
||||
file->Var8(&LightLevel);
|
||||
}
|
||||
|
||||
int CartGameSolarSensor::SetInput(int num, bool pressed)
|
||||
{
|
||||
if (!pressed) return -1;
|
||||
|
||||
if (num == Input_SolarSensorDown)
|
||||
{
|
||||
return 0xFF;
|
||||
if (LightLevel > 0)
|
||||
LightLevel--;
|
||||
|
||||
return LightLevel;
|
||||
}
|
||||
else if (num == Input_SolarSensorUp)
|
||||
{
|
||||
if (LightLevel < 10)
|
||||
LightLevel++;
|
||||
|
||||
return LightLevel;
|
||||
}
|
||||
|
||||
if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
|
||||
return -1;
|
||||
}
|
||||
|
||||
void CartGameSolarSensor::ProcessGPIO()
|
||||
{
|
||||
if (GPIO.data & 4) return; // Boktai chip select
|
||||
if (GPIO.data & 2) // Reset
|
||||
{
|
||||
return Read_Flash(addr);
|
||||
u8 prev = LightSample;
|
||||
LightCounter = 0;
|
||||
LightSample = (0xFF - (0x16 + kLuxLevels[LightLevel]));
|
||||
printf("Solar sensor reset (sample: 0x%02X -> 0x%02X)\n", prev, LightSample);
|
||||
}
|
||||
if (GPIO.data & 1 && LightEdge) LightCounter++;
|
||||
|
||||
return *(u8*)&SRAM[addr];
|
||||
}
|
||||
LightEdge = !(GPIO.data & 1);
|
||||
|
||||
u16 Read16(u32 addr)
|
||||
{
|
||||
if (SRAMType == S_NULL)
|
||||
bool sendBit = LightCounter >= LightSample;
|
||||
if (GPIO.control & 1)
|
||||
{
|
||||
return 0xFFFF;
|
||||
GPIO.data = (GPIO.data & GPIO.direction) | ((sendBit << 3) & ~GPIO.direction & 0xF);
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
|
||||
const char SOLAR_SENSOR_GAMECODES[10][5] =
|
||||
{
|
||||
"U3IJ", // Bokura no Taiyou - Taiyou Action RPG (Japan)
|
||||
"U3IE", // Boktai - The Sun Is in Your Hand (USA)
|
||||
"U3IP", // Boktai - The Sun Is in Your Hand (Europe)
|
||||
"U32J", // Zoku Bokura no Taiyou - Taiyou Shounen Django (Japan)
|
||||
"U32E", // Boktai 2 - Solar Boy Django (USA)
|
||||
"U32P", // Boktai 2 - Solar Boy Django (Europe)
|
||||
"U33J", // Shin Bokura no Taiyou - Gyakushuu no Sabata (Japan)
|
||||
"A3IJ" // Boktai - The Sun Is in Your Hand (USA) (Sample)
|
||||
};
|
||||
|
||||
|
||||
bool CartInserted;
|
||||
bool HasSolarSensor;
|
||||
u8* CartROM;
|
||||
u32 CartROMSize;
|
||||
u32 CartCRC;
|
||||
u32 CartID;
|
||||
GPIO CartGPIO; // overridden GPIO parameters
|
||||
|
||||
|
||||
bool Init()
|
||||
{
|
||||
if (!GBACart_SRAM::Init()) return false;
|
||||
CartROM = nullptr;
|
||||
|
||||
CartROM = NULL;
|
||||
Cart = nullptr;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -523,7 +617,7 @@ void DeInit()
|
||||
{
|
||||
if (CartROM) delete[] CartROM;
|
||||
|
||||
GBACart_SRAM::DeInit();
|
||||
if (Cart) delete Cart;
|
||||
}
|
||||
|
||||
void Reset()
|
||||
@ -533,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()
|
||||
@ -543,14 +634,14 @@ void Eject()
|
||||
if (CartROM) delete[] CartROM;
|
||||
|
||||
CartInserted = false;
|
||||
HasSolarSensor = false;
|
||||
CartROM = NULL;
|
||||
CartROMSize = 0;
|
||||
CartCRC = 0;
|
||||
CartID = 0;
|
||||
CartGPIO = {};
|
||||
|
||||
GBACart_SRAM::Eject();
|
||||
if (Cart) delete Cart;
|
||||
Cart = nullptr;
|
||||
|
||||
Reset();
|
||||
}
|
||||
|
||||
@ -579,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
|
||||
@ -608,42 +692,44 @@ 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);
|
||||
}
|
||||
|
||||
void LoadROMCommon(const char *sram)
|
||||
{
|
||||
char gamecode[5] = { '\0' };
|
||||
memcpy(&gamecode, CartROM + 0xAC, 4);
|
||||
printf("Game code: %s\n", gamecode);
|
||||
printf("GBA game code: %s\n", gamecode);
|
||||
|
||||
bool solarsensor = false;
|
||||
for (int i = 0; i < sizeof(SOLAR_SENSOR_GAMECODES)/sizeof(SOLAR_SENSOR_GAMECODES[0]); i++)
|
||||
{
|
||||
if (strcmp(gamecode, SOLAR_SENSOR_GAMECODES[i]) == 0) HasSolarSensor = true;
|
||||
if (strcmp(gamecode, SOLAR_SENSOR_GAMECODES[i]) == 0)
|
||||
solarsensor = true;
|
||||
}
|
||||
|
||||
if (HasSolarSensor)
|
||||
if (solarsensor)
|
||||
{
|
||||
printf("GBA solar sensor support detected!\n");
|
||||
}
|
||||
|
||||
CartCRC = CRC32(CartROM, CartROMSize);
|
||||
printf("ROM CRC32: %08X\n", CartCRC);
|
||||
printf("GBA ROM CRC32: %08X\n", CartCRC);
|
||||
|
||||
CartInserted = true;
|
||||
|
||||
if (solarsensor)
|
||||
Cart = new CartGameSolarSensor(CartROM, CartROMSize);
|
||||
else
|
||||
Cart = new CartGame(CartROM, CartROMSize);
|
||||
|
||||
// save
|
||||
printf("Save file: %s\n", sram);
|
||||
GBACart_SRAM::LoadSave(sram);
|
||||
printf("GBA save file: %s\n", sram);
|
||||
|
||||
// TODO: have a list of sorts like in NDSCart? to determine the savemem type
|
||||
if (Cart) Cart->LoadSave(sram, 0);
|
||||
}
|
||||
|
||||
bool LoadROM(const char* path, const char* sram)
|
||||
@ -693,98 +779,40 @@ 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);
|
||||
}
|
||||
|
||||
// referenced from mGBA
|
||||
void WriteGPIO(u32 addr, u16 val)
|
||||
|
||||
int SetInput(int num, bool pressed)
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
if (Cart) return Cart->SetInput(num, pressed);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
namespace GBACart_SolarSensor
|
||||
u16 ROMRead(u32 addr)
|
||||
{
|
||||
if (Cart) return Cart->ROMRead(addr);
|
||||
|
||||
bool LightEdge;
|
||||
u8 LightCounter;
|
||||
u8 LightSample;
|
||||
u8 LightLevel; // 0-10 range
|
||||
return (addr >> 1) & 0xFFFF;
|
||||
}
|
||||
|
||||
// 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()
|
||||
void ROMWrite(u32 addr, u16 val)
|
||||
{
|
||||
LightEdge = false;
|
||||
LightCounter = 0;
|
||||
LightSample = 0xFF;
|
||||
LightLevel = 0;
|
||||
if (Cart) Cart->ROMWrite(addr, val);
|
||||
}
|
||||
|
||||
void DoSavestate(Savestate* file)
|
||||
u8 SRAMRead(u32 addr)
|
||||
{
|
||||
file->Var8((u8*)&LightEdge);
|
||||
file->Var8(&LightCounter);
|
||||
file->Var8(&LightSample);
|
||||
file->Var8(&LightLevel);
|
||||
if (Cart) return Cart->SRAMRead(addr);
|
||||
|
||||
return 0xFF;
|
||||
}
|
||||
|
||||
void Process(GBACart::GPIO* gpio)
|
||||
void SRAMWrite(u32 addr, u8 val)
|
||||
{
|
||||
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);
|
||||
}
|
||||
if (Cart) Cart->SRAMWrite(addr, val);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
152
src/GBACart.h
152
src/GBACart.h
@ -22,39 +22,128 @@
|
||||
#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
|
||||
{
|
||||
|
||||
struct GPIO
|
||||
// CartCommon -- base code shared by all cart types
|
||||
class CartCommon
|
||||
{
|
||||
public:
|
||||
CartCommon();
|
||||
virtual ~CartCommon();
|
||||
|
||||
virtual void DoSavestate(Savestate* file);
|
||||
|
||||
virtual void LoadSave(const char* path, u32 type);
|
||||
virtual void RelocateSave(const char* path, bool write);
|
||||
|
||||
virtual int SetInput(int num, bool pressed);
|
||||
|
||||
virtual u16 ROMRead(u32 addr);
|
||||
virtual void ROMWrite(u32 addr, u16 val);
|
||||
|
||||
virtual u8 SRAMRead(u32 addr);
|
||||
virtual void SRAMWrite(u32 addr, u8 val);
|
||||
};
|
||||
|
||||
// CartGame -- regular retail game cart (ROM, SRAM)
|
||||
class CartGame : public CartCommon
|
||||
{
|
||||
public:
|
||||
CartGame(u8* rom, u32 len);
|
||||
virtual ~CartGame() override;
|
||||
|
||||
virtual void DoSavestate(Savestate* file) override;
|
||||
|
||||
virtual void LoadSave(const char* path, u32 type) override;
|
||||
virtual void RelocateSave(const char* path, bool write) override;
|
||||
|
||||
virtual u16 ROMRead(u32 addr) override;
|
||||
virtual void ROMWrite(u32 addr, u16 val) override;
|
||||
|
||||
virtual u8 SRAMRead(u32 addr) override;
|
||||
virtual void SRAMWrite(u32 addr, u8 val) override;
|
||||
|
||||
protected:
|
||||
virtual void ProcessGPIO();
|
||||
|
||||
u8 SRAMRead_EEPROM(u32 addr);
|
||||
void SRAMWrite_EEPROM(u32 addr, u8 val);
|
||||
u8 SRAMRead_FLASH(u32 addr);
|
||||
void SRAMWrite_FLASH(u32 addr, u8 val);
|
||||
u8 SRAMRead_SRAM(u32 addr);
|
||||
void SRAMWrite_SRAM(u32 addr, u8 val);
|
||||
|
||||
u8* ROM;
|
||||
u32 ROMLength;
|
||||
|
||||
struct
|
||||
{
|
||||
u16 data;
|
||||
u16 direction;
|
||||
u16 control;
|
||||
|
||||
} GPIO;
|
||||
|
||||
enum SaveType
|
||||
{
|
||||
S_NULL,
|
||||
S_EEPROM4K,
|
||||
S_EEPROM64K,
|
||||
S_SRAM256K,
|
||||
S_FLASH512K,
|
||||
S_FLASH1M
|
||||
};
|
||||
|
||||
// from DeSmuME
|
||||
struct
|
||||
{
|
||||
u8 state;
|
||||
u8 cmd;
|
||||
u8 device;
|
||||
u8 manufacturer;
|
||||
u8 bank;
|
||||
|
||||
} SRAMFlashState;
|
||||
|
||||
u8* SRAM;
|
||||
FILE* SRAMFile;
|
||||
u32 SRAMLength;
|
||||
SaveType SRAMType;
|
||||
|
||||
char SRAMPath[1024];
|
||||
};
|
||||
|
||||
// CartGameSolarSensor -- Boktai game cart
|
||||
class CartGameSolarSensor : public CartGame
|
||||
{
|
||||
public:
|
||||
CartGameSolarSensor(u8* rom, u32 len);
|
||||
virtual ~CartGameSolarSensor() override;
|
||||
|
||||
virtual void DoSavestate(Savestate* file) override;
|
||||
|
||||
virtual int SetInput(int num, bool pressed) override;
|
||||
|
||||
private:
|
||||
virtual void ProcessGPIO() override;
|
||||
|
||||
static const int kLuxLevels[11];
|
||||
|
||||
bool LightEdge;
|
||||
u8 LightCounter;
|
||||
u8 LightSample;
|
||||
u8 LightLevel;
|
||||
};
|
||||
|
||||
// possible inputs for GBA carts that might accept user input
|
||||
enum
|
||||
{
|
||||
Input_SolarSensorDown = 0,
|
||||
Input_SolarSensorUp,
|
||||
};
|
||||
|
||||
extern bool CartInserted;
|
||||
extern bool HasSolarSensor;
|
||||
extern u8* CartROM;
|
||||
extern u32 CartROMSize;
|
||||
extern u32 CartCRC;
|
||||
@ -69,19 +158,14 @@ 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);
|
||||
|
||||
void WriteGPIO(u32 addr, u16 val);
|
||||
// TODO: make more flexible, support nonbinary inputs
|
||||
int SetInput(int num, bool pressed);
|
||||
|
||||
}
|
||||
u16 ROMRead(u32 addr);
|
||||
void ROMWrite(u32 addr, u16 val);
|
||||
|
||||
|
||||
namespace GBACart_SolarSensor
|
||||
{
|
||||
|
||||
extern u8 LightLevel;
|
||||
|
||||
void Reset();
|
||||
void DoSavestate(Savestate* file);
|
||||
void Process(GBACart::GPIO* gpio);
|
||||
u8 SRAMRead(u32 addr);
|
||||
void SRAMWrite(u32 addr, u8 val);
|
||||
|
||||
}
|
||||
|
||||
|
||||
526
src/NDS.cpp
526
src/NDS.cpp
@ -1943,19 +1943,12 @@ u8 ARM9Read8(u32 addr)
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x00; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u8*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFF; // TODO: proper open bus
|
||||
if (addr & 0x1) return GBACart::ROMRead(addr-1) >> 8;
|
||||
return GBACart::ROMRead(addr) & 0xFF;
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x00; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read8(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr);
|
||||
}
|
||||
|
||||
printf("unknown arm9 read8 %08X\n", addr);
|
||||
@ -2008,22 +2001,15 @@ u16 ARM9Read16(u32 addr)
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x0000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u16*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFFFF; // TODO: proper open bus
|
||||
return GBACart::ROMRead(addr);
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x0000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read16(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFFFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr) |
|
||||
(GBACart::SRAMRead(addr+1) << 8);
|
||||
}
|
||||
|
||||
//printf("unknown arm9 read16 %08X %08X\n", addr, ARM9->R[15]);
|
||||
if (addr) printf("unknown arm9 read16 %08X %08X\n", addr, ARM9->R[15]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2073,19 +2059,15 @@ u32 ARM9Read32(u32 addr)
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x00000000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u32*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFFFFFFFF; // TODO: proper open bus
|
||||
return GBACart::ROMRead(addr) |
|
||||
(GBACart::ROMRead(addr+2) << 16);
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return 0x00000000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read32(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFFFFFFFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr) |
|
||||
(GBACart::SRAMRead(addr+1) << 8) |
|
||||
(GBACart::SRAMRead(addr+2) << 16) |
|
||||
(GBACart::SRAMRead(addr+3) << 24);
|
||||
}
|
||||
|
||||
printf("unknown arm9 read32 %08X | %08X %08X\n", addr, ARM9->R[15], ARM9->R[12]);
|
||||
@ -2120,28 +2102,15 @@ void ARM9Write8(u32 addr, u8 val)
|
||||
case 0x05000000:
|
||||
case 0x06000000:
|
||||
case 0x07000000:
|
||||
// checkme
|
||||
return;
|
||||
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
if ((addr & 0x00FFFFFF) >= 0xC4 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write8(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -2199,28 +2168,17 @@ void ARM9Write16(u32 addr, u16 val)
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
// Note: the lower bound is adjusted such that a write starting
|
||||
// there will hit the first byte of the GPIO region.
|
||||
if ((addr & 0x00FFFFFF) >= 0xC3 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
|
||||
GBACart::ROMWrite(addr, val);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write16(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val & 0xFF);
|
||||
GBACart::SRAMWrite(addr+1, val >> 8);
|
||||
return;
|
||||
}
|
||||
|
||||
//printf("unknown arm9 write16 %08X %04X\n", addr, val);
|
||||
if (addr) printf("unknown arm9 write16 %08X %04X\n", addr, val);
|
||||
}
|
||||
|
||||
void ARM9Write32(u32 addr, u32 val)
|
||||
@ -2274,29 +2232,20 @@ void ARM9Write32(u32 addr, u32 val)
|
||||
case 0x08000000:
|
||||
case 0x09000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
// Note: the lower bound is adjusted such that a write starting
|
||||
// there will hit the first byte of the GPIO region.
|
||||
if ((addr & 0x00FFFFFF) >= 0xC1 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val & 0xFF);
|
||||
GBACart::WriteGPIO((addr + 2) & (GBACart::CartROMSize-1), (val >> 16) & 0xFF);
|
||||
GBACart::ROMWrite(addr, val & 0xFFFF);
|
||||
GBACart::ROMWrite(addr+2, val >> 16);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write32(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val & 0xFF);
|
||||
GBACart::SRAMWrite(addr+1, (val >> 8) & 0xFF);
|
||||
GBACart::SRAMWrite(addr+2, (val >> 16) & 0xFF);
|
||||
GBACart::SRAMWrite(addr+3, val >> 24);
|
||||
return;
|
||||
}
|
||||
|
||||
//printf("unknown arm9 write32 %08X %08X | %08X\n", addr, val, ARM9->R[15]);
|
||||
printf("unknown arm9 write32 %08X %08X | %08X\n", addr, val, ARM9->R[15]);
|
||||
}
|
||||
|
||||
bool ARM9GetMemRegion(u32 addr, bool write, MemRegion* region)
|
||||
@ -2366,26 +2315,30 @@ u8 ARM7Read8(u32 addr)
|
||||
case 0x04000000:
|
||||
return ARM7IORead8(addr);
|
||||
|
||||
case 0x04800000:
|
||||
if (addr < 0x04810000)
|
||||
{
|
||||
if (addr & 0x1) return Wifi::Read(addr-1) >> 8;
|
||||
return Wifi::Read(addr) & 0xFF;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x06000000:
|
||||
case 0x06800000:
|
||||
return GPU::ReadVRAM_ARM7<u8>(addr);
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
case 0x09800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x00; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u8*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFF; // TODO: proper open bus
|
||||
if (addr & 0x1) return GBACart::ROMRead(addr-1) >> 8;
|
||||
return GBACart::ROMRead(addr) & 0xFF;
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x00; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read8(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr);
|
||||
}
|
||||
|
||||
printf("unknown arm7 read8 %08X %08X %08X/%08X\n", addr, ARM7->R[15], ARM7->R[0], ARM7->R[1]);
|
||||
@ -2438,21 +2391,17 @@ u16 ARM7Read16(u32 addr)
|
||||
return GPU::ReadVRAM_ARM7<u16>(addr);
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
case 0x09800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x0000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u16*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFFFF; // TODO: proper open bus
|
||||
return GBACart::ROMRead(addr);
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x0000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read16(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFFFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr) |
|
||||
(GBACart::SRAMRead(addr+1) << 8);
|
||||
}
|
||||
|
||||
printf("unknown arm7 read16 %08X %08X\n", addr, ARM7->R[15]);
|
||||
@ -2505,21 +2454,20 @@ u32 ARM7Read32(u32 addr)
|
||||
return GPU::ReadVRAM_ARM7<u32>(addr);
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
case 0x09800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x00000000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return *(u32*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
|
||||
}
|
||||
return 0xFFFFFFFF; // TODO: proper open bus
|
||||
return GBACart::ROMRead(addr) |
|
||||
(GBACart::ROMRead(addr+2) << 16);
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return 0x00000000; // deselected CPU is 00h-filled
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
return GBACart_SRAM::Read32(addr & (GBACart_SRAM::SRAMLength-1));
|
||||
}
|
||||
return 0xFFFFFFFF; // TODO: proper open bus
|
||||
return GBACart::SRAMRead(addr) |
|
||||
(GBACart::SRAMRead(addr+1) << 8) |
|
||||
(GBACart::SRAMRead(addr+2) << 16) |
|
||||
(GBACart::SRAMRead(addr+3) << 24);
|
||||
}
|
||||
|
||||
printf("unknown arm7 read32 %08X | %08X\n", addr, ARM7->R[15]);
|
||||
@ -2576,24 +2524,15 @@ void ARM7Write8(u32 addr, u8 val)
|
||||
return;
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
if ((addr & 0x00FFFFFF) >= 0xC4 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
|
||||
case 0x09800000:
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write8(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -2659,30 +2598,22 @@ void ARM7Write16(u32 addr, u16 val)
|
||||
return;
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
case 0x09800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
// Note: the lower bound is adjusted such that a write starting
|
||||
// there will hit the first byte of the GPIO region.
|
||||
if ((addr & 0x00FFFFFF) >= 0xC3 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
|
||||
GBACart::ROMWrite(addr, val);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write16(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val & 0xFF);
|
||||
GBACart::SRAMWrite(addr+1, val >> 8);
|
||||
return;
|
||||
}
|
||||
|
||||
//printf("unknown arm7 write16 %08X %04X @ %08X\n", addr, val, ARM7->R[15]);
|
||||
printf("unknown arm7 write16 %08X %04X @ %08X\n", addr, val, ARM7->R[15]);
|
||||
}
|
||||
|
||||
void ARM7Write32(u32 addr, u32 val)
|
||||
@ -2744,31 +2675,25 @@ void ARM7Write32(u32 addr, u32 val)
|
||||
return;
|
||||
|
||||
case 0x08000000:
|
||||
case 0x08800000:
|
||||
case 0x09000000:
|
||||
case 0x09800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
// Note: the lower bound is adjusted such that a write starting
|
||||
// there will hit the first byte of the GPIO region.
|
||||
if ((addr & 0x00FFFFFF) >= 0xC1 && (addr & 0x00FFFFFF) <= 0xC9)
|
||||
{
|
||||
GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val & 0xFF);
|
||||
GBACart::WriteGPIO((addr + 2) & (GBACart::CartROMSize-1), (val >> 16) & 0xFF);
|
||||
GBACart::ROMWrite(addr, val & 0xFFFF);
|
||||
GBACart::ROMWrite(addr+2, val >> 16);
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0A000000:
|
||||
case 0x0A800000:
|
||||
if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
|
||||
if (GBACart::CartInserted)
|
||||
{
|
||||
GBACart_SRAM::Write32(addr & (GBACart_SRAM::SRAMLength-1), val);
|
||||
}
|
||||
GBACart::SRAMWrite(addr, val & 0xFF);
|
||||
GBACart::SRAMWrite(addr+1, (val >> 8) & 0xFF);
|
||||
GBACart::SRAMWrite(addr+2, (val >> 16) & 0xFF);
|
||||
GBACart::SRAMWrite(addr+3, val >> 24);
|
||||
return;
|
||||
}
|
||||
|
||||
//printf("unknown arm7 write32 %08X %08X @ %08X\n", addr, val, ARM7->R[15]);
|
||||
printf("unknown arm7 write32 %08X %08X @ %08X\n", addr, val, ARM7->R[15]);
|
||||
}
|
||||
|
||||
bool ARM7GetMemRegion(u32 addr, bool write, MemRegion* region)
|
||||
@ -2838,16 +2763,43 @@ u8 ARM9IORead8(u32 addr)
|
||||
case 0x04000132: return KeyCnt & 0xFF;
|
||||
case 0x04000133: return KeyCnt >> 8;
|
||||
|
||||
case 0x040001A2: return NDSCart::ReadSPIData();
|
||||
case 0x040001A2:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ReadSPIData();
|
||||
return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0];
|
||||
case 0x040001A9: return NDSCart::ROMCommand[1];
|
||||
case 0x040001AA: return NDSCart::ROMCommand[2];
|
||||
case 0x040001AB: return NDSCart::ROMCommand[3];
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4];
|
||||
case 0x040001AD: return NDSCart::ROMCommand[5];
|
||||
case 0x040001AE: return NDSCart::ROMCommand[6];
|
||||
case 0x040001AF: return NDSCart::ROMCommand[7];
|
||||
case 0x040001A8:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[0];
|
||||
return 0;
|
||||
case 0x040001A9:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[1];
|
||||
return 0;
|
||||
case 0x040001AA:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[2];
|
||||
return 0;
|
||||
case 0x040001AB:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[3];
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[4];
|
||||
return 0;
|
||||
case 0x040001AD:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[5];
|
||||
return 0;
|
||||
case 0x040001AE:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[6];
|
||||
return 0;
|
||||
case 0x040001AF:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[7];
|
||||
return 0;
|
||||
|
||||
case 0x04000208: return IME[0];
|
||||
|
||||
@ -2949,17 +2901,35 @@ u16 ARM9IORead16(u32 addr)
|
||||
return val;
|
||||
}
|
||||
|
||||
case 0x040001A0: return NDSCart::SPICnt;
|
||||
case 0x040001A2: return NDSCart::ReadSPIData();
|
||||
case 0x040001A0:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::SPICnt;
|
||||
return 0;
|
||||
case 0x040001A2:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ReadSPIData();
|
||||
return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0] |
|
||||
case 0x040001A8:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[0] |
|
||||
(NDSCart::ROMCommand[1] << 8);
|
||||
case 0x040001AA: return NDSCart::ROMCommand[2] |
|
||||
return 0;
|
||||
case 0x040001AA:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[2] |
|
||||
(NDSCart::ROMCommand[3] << 8);
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4] |
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[4] |
|
||||
(NDSCart::ROMCommand[5] << 8);
|
||||
case 0x040001AE: return NDSCart::ROMCommand[6] |
|
||||
return 0;
|
||||
case 0x040001AE:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[6] |
|
||||
(NDSCart::ROMCommand[7] << 8);
|
||||
return 0;
|
||||
|
||||
case 0x04000204: return ExMemCnt[0];
|
||||
case 0x04000208: return IME[0];
|
||||
@ -3058,17 +3028,29 @@ u32 ARM9IORead32(u32 addr)
|
||||
case 0x04000180: return IPCSync9;
|
||||
case 0x04000184: return ARM9IORead16(addr);
|
||||
|
||||
case 0x040001A0: return NDSCart::SPICnt | (NDSCart::ReadSPIData() << 16);
|
||||
case 0x040001A4: return NDSCart::ROMCnt;
|
||||
case 0x040001A0:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::SPICnt | (NDSCart::ReadSPIData() << 16);
|
||||
return 0;
|
||||
case 0x040001A4:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCnt;
|
||||
return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0] |
|
||||
case 0x040001A8:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[0] |
|
||||
(NDSCart::ROMCommand[1] << 8) |
|
||||
(NDSCart::ROMCommand[2] << 16) |
|
||||
(NDSCart::ROMCommand[3] << 24);
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4] |
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
return NDSCart::ROMCommand[4] |
|
||||
(NDSCart::ROMCommand[5] << 8) |
|
||||
(NDSCart::ROMCommand[6] << 16) |
|
||||
(NDSCart::ROMCommand[7] << 24);
|
||||
return 0;
|
||||
|
||||
case 0x04000208: return IME[0];
|
||||
case 0x04000210: return IE[0];
|
||||
@ -3155,34 +3137,31 @@ void ARM9IOWrite8(u32 addr, u8 val)
|
||||
KeyCnt = (KeyCnt & 0x00FF) | (val << 8);
|
||||
return;
|
||||
|
||||
case 0x040001A0:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::WriteSPICnt((NDSCart::SPICnt & 0xFF00) | val);
|
||||
}
|
||||
return;
|
||||
case 0x040001A1:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::WriteSPICnt((NDSCart::SPICnt & 0x00FF) | (val << 8));
|
||||
}
|
||||
return;
|
||||
case 0x040001A2:
|
||||
NDSCart::WriteSPIData(val);
|
||||
return;
|
||||
|
||||
case 0x04000188:
|
||||
ARM9IOWrite32(addr, val | (val << 8) | (val << 16) | (val << 24));
|
||||
return;
|
||||
|
||||
case 0x040001A8: NDSCart::ROMCommand[0] = val; return;
|
||||
case 0x040001A9: NDSCart::ROMCommand[1] = val; return;
|
||||
case 0x040001AA: NDSCart::ROMCommand[2] = val; return;
|
||||
case 0x040001AB: NDSCart::ROMCommand[3] = val; return;
|
||||
case 0x040001AC: NDSCart::ROMCommand[4] = val; return;
|
||||
case 0x040001AD: NDSCart::ROMCommand[5] = val; return;
|
||||
case 0x040001AE: NDSCart::ROMCommand[6] = val; return;
|
||||
case 0x040001AF: NDSCart::ROMCommand[7] = val; return;
|
||||
case 0x040001A0:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteSPICnt((NDSCart::SPICnt & 0xFF00) | val);
|
||||
return;
|
||||
case 0x040001A1:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteSPICnt((NDSCart::SPICnt & 0x00FF) | (val << 8));
|
||||
return;
|
||||
case 0x040001A2:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteSPIData(val);
|
||||
return;
|
||||
|
||||
case 0x040001A8: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[0] = val; return;
|
||||
case 0x040001A9: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[1] = val; return;
|
||||
case 0x040001AA: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[2] = val; return;
|
||||
case 0x040001AB: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[3] = val; return;
|
||||
case 0x040001AC: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[4] = val; return;
|
||||
case 0x040001AD: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[5] = val; return;
|
||||
case 0x040001AE: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[6] = val; return;
|
||||
case 0x040001AF: if (!(ExMemCnt[0] & (1<<11))) NDSCart::ROMCommand[7] = val; return;
|
||||
|
||||
case 0x04000208: IME[0] = val & 0x1; UpdateIRQ(0); return;
|
||||
|
||||
@ -3296,27 +3275,41 @@ void ARM9IOWrite16(u32 addr, u16 val)
|
||||
return;
|
||||
|
||||
case 0x040001A0:
|
||||
if (!(ExMemCnt[0] & (1<<11))) NDSCart::WriteSPICnt(val);
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteSPICnt(val);
|
||||
return;
|
||||
case 0x040001A2:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteSPIData(val & 0xFF);
|
||||
return;
|
||||
|
||||
case 0x040001A8:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[0] = val & 0xFF;
|
||||
NDSCart::ROMCommand[1] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AA:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[2] = val & 0xFF;
|
||||
NDSCart::ROMCommand[3] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AC:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[4] = val & 0xFF;
|
||||
NDSCart::ROMCommand[5] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AE:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[6] = val & 0xFF;
|
||||
NDSCart::ROMCommand[7] = val >> 8;
|
||||
}
|
||||
return;
|
||||
|
||||
case 0x040001B8: ROMSeed0[4] = val & 0x7F; return;
|
||||
@ -3470,20 +3463,27 @@ void ARM9IOWrite32(u32 addr, u32 val)
|
||||
}
|
||||
return;
|
||||
case 0x040001A4:
|
||||
if (!(ExMemCnt[0] & (1<<11))) NDSCart::WriteROMCnt(val);
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
NDSCart::WriteROMCnt(val);
|
||||
return;
|
||||
|
||||
case 0x040001A8:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[0] = val & 0xFF;
|
||||
NDSCart::ROMCommand[1] = (val >> 8) & 0xFF;
|
||||
NDSCart::ROMCommand[2] = (val >> 16) & 0xFF;
|
||||
NDSCart::ROMCommand[3] = val >> 24;
|
||||
}
|
||||
return;
|
||||
case 0x040001AC:
|
||||
if (!(ExMemCnt[0] & (1<<11)))
|
||||
{
|
||||
NDSCart::ROMCommand[4] = val & 0xFF;
|
||||
NDSCart::ROMCommand[5] = (val >> 8) & 0xFF;
|
||||
NDSCart::ROMCommand[6] = (val >> 16) & 0xFF;
|
||||
NDSCart::ROMCommand[7] = val >> 24;
|
||||
}
|
||||
return;
|
||||
|
||||
case 0x040001B0: *(u32*)&ROMSeed0[0] = val; return;
|
||||
@ -3528,7 +3528,7 @@ void ARM9IOWrite32(u32 addr, u32 val)
|
||||
return;
|
||||
|
||||
case 0x04100010:
|
||||
NDSCart::WriteROMData(val);
|
||||
if (!(ExMemCnt[0] & (1<<11))) NDSCart::WriteROMData(val);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -3567,16 +3567,43 @@ u8 ARM7IORead8(u32 addr)
|
||||
|
||||
case 0x04000138: return RTC::Read() & 0xFF;
|
||||
|
||||
case 0x040001A2: return NDSCart::ReadSPIData();
|
||||
case 0x040001A2:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ReadSPIData();
|
||||
return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0];
|
||||
case 0x040001A9: return NDSCart::ROMCommand[1];
|
||||
case 0x040001AA: return NDSCart::ROMCommand[2];
|
||||
case 0x040001AB: return NDSCart::ROMCommand[3];
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4];
|
||||
case 0x040001AD: return NDSCart::ROMCommand[5];
|
||||
case 0x040001AE: return NDSCart::ROMCommand[6];
|
||||
case 0x040001AF: return NDSCart::ROMCommand[7];
|
||||
case 0x040001A8:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[0];
|
||||
return 0;
|
||||
case 0x040001A9:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[1];
|
||||
return 0;
|
||||
case 0x040001AA:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[2];
|
||||
return 0;
|
||||
case 0x040001AB:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[3];
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[4];
|
||||
return 0;
|
||||
case 0x040001AD:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[5];
|
||||
return 0;
|
||||
case 0x040001AE:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[6];
|
||||
return 0;
|
||||
case 0x040001AF:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[7];
|
||||
return 0;
|
||||
|
||||
case 0x040001C2: return SPI::ReadData();
|
||||
|
||||
@ -3640,17 +3667,29 @@ u16 ARM7IORead16(u32 addr)
|
||||
return val;
|
||||
}
|
||||
|
||||
case 0x040001A0: return NDSCart::SPICnt;
|
||||
case 0x040001A2: return NDSCart::ReadSPIData();
|
||||
case 0x040001A0: if (ExMemCnt[0] & (1<<11)) return NDSCart::SPICnt; return 0;
|
||||
case 0x040001A2: if (ExMemCnt[0] & (1<<11)) return NDSCart::ReadSPIData(); return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0] |
|
||||
case 0x040001A8:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[0] |
|
||||
(NDSCart::ROMCommand[1] << 8);
|
||||
case 0x040001AA: return NDSCart::ROMCommand[2] |
|
||||
return 0;
|
||||
case 0x040001AA:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[2] |
|
||||
(NDSCart::ROMCommand[3] << 8);
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4] |
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[4] |
|
||||
(NDSCart::ROMCommand[5] << 8);
|
||||
case 0x040001AE: return NDSCart::ROMCommand[6] |
|
||||
return 0;
|
||||
case 0x040001AE:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[6] |
|
||||
(NDSCart::ROMCommand[7] << 8);
|
||||
return 0;
|
||||
|
||||
case 0x040001C0: return SPI::Cnt;
|
||||
case 0x040001C2: return SPI::ReadData();
|
||||
@ -3707,17 +3746,29 @@ u32 ARM7IORead32(u32 addr)
|
||||
case 0x04000180: return IPCSync7;
|
||||
case 0x04000184: return ARM7IORead16(addr);
|
||||
|
||||
case 0x040001A0: return NDSCart::SPICnt | (NDSCart::ReadSPIData() << 16);
|
||||
case 0x040001A4: return NDSCart::ROMCnt;
|
||||
case 0x040001A0:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::SPICnt | (NDSCart::ReadSPIData() << 16);
|
||||
return 0;
|
||||
case 0x040001A4:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCnt;
|
||||
return 0;
|
||||
|
||||
case 0x040001A8: return NDSCart::ROMCommand[0] |
|
||||
case 0x040001A8:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[0] |
|
||||
(NDSCart::ROMCommand[1] << 8) |
|
||||
(NDSCart::ROMCommand[2] << 16) |
|
||||
(NDSCart::ROMCommand[3] << 24);
|
||||
case 0x040001AC: return NDSCart::ROMCommand[4] |
|
||||
return 0;
|
||||
case 0x040001AC:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
return NDSCart::ROMCommand[4] |
|
||||
(NDSCart::ROMCommand[5] << 8) |
|
||||
(NDSCart::ROMCommand[6] << 16) |
|
||||
(NDSCart::ROMCommand[7] << 24);
|
||||
return 0;
|
||||
|
||||
case 0x040001C0:
|
||||
return SPI::Cnt | (SPI::ReadData() << 16);
|
||||
@ -3794,22 +3845,21 @@ void ARM7IOWrite8(u32 addr, u8 val)
|
||||
return;
|
||||
case 0x040001A1:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::WriteSPICnt((NDSCart::SPICnt & 0x00FF) | (val << 8));
|
||||
}
|
||||
return;
|
||||
case 0x040001A2:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
NDSCart::WriteSPIData(val);
|
||||
return;
|
||||
|
||||
case 0x040001A8: NDSCart::ROMCommand[0] = val; return;
|
||||
case 0x040001A9: NDSCart::ROMCommand[1] = val; return;
|
||||
case 0x040001AA: NDSCart::ROMCommand[2] = val; return;
|
||||
case 0x040001AB: NDSCart::ROMCommand[3] = val; return;
|
||||
case 0x040001AC: NDSCart::ROMCommand[4] = val; return;
|
||||
case 0x040001AD: NDSCart::ROMCommand[5] = val; return;
|
||||
case 0x040001AE: NDSCart::ROMCommand[6] = val; return;
|
||||
case 0x040001AF: NDSCart::ROMCommand[7] = val; return;
|
||||
case 0x040001A8: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[0] = val; return;
|
||||
case 0x040001A9: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[1] = val; return;
|
||||
case 0x040001AA: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[2] = val; return;
|
||||
case 0x040001AB: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[3] = val; return;
|
||||
case 0x040001AC: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[4] = val; return;
|
||||
case 0x040001AD: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[5] = val; return;
|
||||
case 0x040001AE: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[6] = val; return;
|
||||
case 0x040001AF: if (ExMemCnt[0] & (1<<11)) NDSCart::ROMCommand[7] = val; return;
|
||||
|
||||
case 0x040001C2:
|
||||
SPI::WriteData(val);
|
||||
@ -3903,24 +3953,37 @@ void ARM7IOWrite16(u32 addr, u16 val)
|
||||
NDSCart::WriteSPICnt(val);
|
||||
return;
|
||||
case 0x040001A2:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
NDSCart::WriteSPIData(val & 0xFF);
|
||||
return;
|
||||
|
||||
case 0x040001A8:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[0] = val & 0xFF;
|
||||
NDSCart::ROMCommand[1] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AA:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[2] = val & 0xFF;
|
||||
NDSCart::ROMCommand[3] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AC:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[4] = val & 0xFF;
|
||||
NDSCart::ROMCommand[5] = val >> 8;
|
||||
}
|
||||
return;
|
||||
case 0x040001AE:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[6] = val & 0xFF;
|
||||
NDSCart::ROMCommand[7] = val >> 8;
|
||||
}
|
||||
return;
|
||||
|
||||
case 0x040001B8: ROMSeed0[12] = val & 0x7F; return;
|
||||
@ -4040,20 +4103,27 @@ void ARM7IOWrite32(u32 addr, u32 val)
|
||||
}
|
||||
return;
|
||||
case 0x040001A4:
|
||||
if (ExMemCnt[0] & (1<<11)) NDSCart::WriteROMCnt(val);
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
NDSCart::WriteROMCnt(val);
|
||||
return;
|
||||
|
||||
case 0x040001A8:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[0] = val & 0xFF;
|
||||
NDSCart::ROMCommand[1] = (val >> 8) & 0xFF;
|
||||
NDSCart::ROMCommand[2] = (val >> 16) & 0xFF;
|
||||
NDSCart::ROMCommand[3] = val >> 24;
|
||||
}
|
||||
return;
|
||||
case 0x040001AC:
|
||||
if (ExMemCnt[0] & (1<<11))
|
||||
{
|
||||
NDSCart::ROMCommand[4] = val & 0xFF;
|
||||
NDSCart::ROMCommand[5] = (val >> 8) & 0xFF;
|
||||
NDSCart::ROMCommand[6] = (val >> 16) & 0xFF;
|
||||
NDSCart::ROMCommand[7] = val >> 24;
|
||||
}
|
||||
return;
|
||||
|
||||
case 0x040001B0: *(u32*)&ROMSeed0[8] = val; return;
|
||||
@ -4074,6 +4144,10 @@ void ARM7IOWrite32(u32 addr, u32 val)
|
||||
if (ARM7BIOSProt == 0)
|
||||
ARM7BIOSProt = val & 0xFFFE;
|
||||
return;
|
||||
|
||||
case 0x04100010:
|
||||
if (ExMemCnt[0] & (1<<11)) NDSCart::WriteROMData(val);
|
||||
return;
|
||||
}
|
||||
|
||||
if (addr >= 0x04000400 && addr < 0x04000520)
|
||||
|
||||
@ -82,7 +82,7 @@ enum
|
||||
IRQ_IPCSync,
|
||||
IRQ_IPCSendDone,
|
||||
IRQ_IPCRecv,
|
||||
IRQ_CartSendDone, // TODO: less misleading name
|
||||
IRQ_CartXferDone,
|
||||
IRQ_CartIREQMC, // IRQ triggered by game cart (example: Pokémon Typing Adventure, BT controller)
|
||||
IRQ_GXFIFO,
|
||||
IRQ_LidOpen,
|
||||
|
||||
1990
src/NDSCart.cpp
1990
src/NDSCart.cpp
File diff suppressed because it is too large
Load Diff
161
src/NDSCart.h
161
src/NDSCart.h
@ -24,14 +24,167 @@
|
||||
namespace NDSCart
|
||||
{
|
||||
|
||||
// CartCommon -- base code shared by all cart types
|
||||
class CartCommon
|
||||
{
|
||||
public:
|
||||
CartCommon(u8* rom, u32 len, u32 chipid);
|
||||
virtual ~CartCommon();
|
||||
|
||||
virtual void Reset();
|
||||
virtual void SetupDirectBoot();
|
||||
|
||||
virtual void DoSavestate(Savestate* file);
|
||||
|
||||
virtual void LoadSave(const char* path, u32 type);
|
||||
virtual void RelocateSave(const char* path, bool write);
|
||||
virtual int ImportSRAM(const u8* data, u32 length);
|
||||
virtual void FlushSRAMFile();
|
||||
|
||||
virtual int ROMCommandStart(u8* cmd, u8* data, u32 len);
|
||||
virtual void ROMCommandFinish(u8* cmd, u8* data, u32 len);
|
||||
|
||||
virtual u8 SPIWrite(u8 val, u32 pos, bool last);
|
||||
|
||||
protected:
|
||||
void ReadROM(u32 addr, u32 len, u8* data, u32 offset);
|
||||
|
||||
void SetIRQ();
|
||||
|
||||
u8* ROM;
|
||||
u32 ROMLength;
|
||||
u32 ChipID;
|
||||
bool IsDSi;
|
||||
|
||||
u32 CmdEncMode;
|
||||
u32 DataEncMode;
|
||||
};
|
||||
|
||||
// CartRetail -- regular retail cart (ROM, SPI SRAM)
|
||||
class CartRetail : public CartCommon
|
||||
{
|
||||
public:
|
||||
CartRetail(u8* rom, u32 len, u32 chipid);
|
||||
virtual ~CartRetail() override;
|
||||
|
||||
virtual void Reset() override;
|
||||
|
||||
virtual void DoSavestate(Savestate* file) override;
|
||||
|
||||
virtual void LoadSave(const char* path, u32 type) override;
|
||||
virtual void RelocateSave(const char* path, bool write) override;
|
||||
virtual int ImportSRAM(const u8* data, u32 length) override;
|
||||
virtual void FlushSRAMFile() override;
|
||||
|
||||
virtual int ROMCommandStart(u8* cmd, u8* data, u32 len) override;
|
||||
|
||||
virtual u8 SPIWrite(u8 val, u32 pos, bool last) override;
|
||||
|
||||
protected:
|
||||
void ReadROM_B7(u32 addr, u32 len, u8* data, u32 offset);
|
||||
|
||||
u8 SRAMWrite_EEPROMTiny(u8 val, u32 pos, bool last);
|
||||
u8 SRAMWrite_EEPROM(u8 val, u32 pos, bool last);
|
||||
u8 SRAMWrite_FLASH(u8 val, u32 pos, bool last);
|
||||
|
||||
u8* SRAM;
|
||||
u32 SRAMLength;
|
||||
u32 SRAMType;
|
||||
|
||||
char SRAMPath[1024];
|
||||
bool SRAMFileDirty;
|
||||
|
||||
u8 SRAMCmd;
|
||||
u32 SRAMAddr;
|
||||
u8 SRAMStatus;
|
||||
};
|
||||
|
||||
// CartRetailNAND -- retail cart with NAND SRAM (WarioWare DIY, Jam with the Band, ...)
|
||||
class CartRetailNAND : public CartRetail
|
||||
{
|
||||
public:
|
||||
CartRetailNAND(u8* rom, u32 len, u32 chipid);
|
||||
~CartRetailNAND() override;
|
||||
|
||||
void Reset() override;
|
||||
|
||||
void DoSavestate(Savestate* file);
|
||||
|
||||
void LoadSave(const char* path, u32 type) override;
|
||||
int ImportSRAM(const u8* data, u32 length) override;
|
||||
|
||||
int ROMCommandStart(u8* cmd, u8* data, u32 len) override;
|
||||
void ROMCommandFinish(u8* cmd, u8* data, u32 len) override;
|
||||
|
||||
u8 SPIWrite(u8 val, u32 pos, bool last) override;
|
||||
|
||||
private:
|
||||
void BuildSRAMID();
|
||||
|
||||
u32 SRAMBase;
|
||||
u32 SRAMWindow;
|
||||
|
||||
u8 SRAMWriteBuffer[0x800];
|
||||
u32 SRAMWritePos;
|
||||
};
|
||||
|
||||
// CartRetailIR -- SPI IR device and SRAM
|
||||
class CartRetailIR : public CartRetail
|
||||
{
|
||||
public:
|
||||
CartRetailIR(u8* rom, u32 len, u32 chipid, u32 irversion);
|
||||
~CartRetailIR() override;
|
||||
|
||||
void Reset() override;
|
||||
|
||||
void DoSavestate(Savestate* file) override;
|
||||
|
||||
u8 SPIWrite(u8 val, u32 pos, bool last) override;
|
||||
|
||||
private:
|
||||
u32 IRVersion;
|
||||
u8 IRCmd;
|
||||
};
|
||||
|
||||
// CartRetailBT - Pokémon Typing Adventure (SPI BT controller)
|
||||
class CartRetailBT : public CartRetail
|
||||
{
|
||||
public:
|
||||
CartRetailBT(u8* rom, u32 len, u32 chipid);
|
||||
~CartRetailBT() override;
|
||||
|
||||
void Reset() override;
|
||||
|
||||
void DoSavestate(Savestate* file) override;
|
||||
|
||||
u8 SPIWrite(u8 val, u32 pos, bool last) override;
|
||||
};
|
||||
|
||||
// CartHomebrew -- homebrew 'cart' (no SRAM, DLDI)
|
||||
class CartHomebrew : public CartCommon
|
||||
{
|
||||
public:
|
||||
CartHomebrew(u8* rom, u32 len, u32 chipid);
|
||||
~CartHomebrew() override;
|
||||
|
||||
void Reset() override;
|
||||
|
||||
void DoSavestate(Savestate* file) override;
|
||||
|
||||
int ROMCommandStart(u8* cmd, u8* data, u32 len) override;
|
||||
void ROMCommandFinish(u8* cmd, u8* data, u32 len) override;
|
||||
|
||||
private:
|
||||
void ApplyDLDIPatch(const u8* patch, u32 len);
|
||||
void ReadROM_B7(u32 addr, u32 len, u8* data, u32 offset);
|
||||
|
||||
FILE* SDFile;
|
||||
};
|
||||
|
||||
extern u16 SPICnt;
|
||||
extern u32 ROMCnt;
|
||||
|
||||
extern u8 ROMCommand[8];
|
||||
extern u32 ROMDataOut;
|
||||
|
||||
extern u8 EncSeed0[5];
|
||||
extern u8 EncSeed1[5];
|
||||
|
||||
extern u8* CartROM;
|
||||
extern u32 CartROMSize;
|
||||
|
||||
@ -1590,7 +1590,7 @@ ROMListEntry ROMList[] =
|
||||
{0x45524D43, 0x02000000, 0x00000002},
|
||||
{0x45524E42, 0x04000000, 0x00000003},
|
||||
{0x45524E43, 0x04000000, 0x00000002},
|
||||
{0x45524F55, 0x08000000, 0x00000008},
|
||||
{0x45524F55, 0x08000000, 0x00000009},
|
||||
{0x45525041, 0x02000000, 0x00000002},
|
||||
{0x45525042, 0x00800000, 0x00000001},
|
||||
{0x45525043, 0x04000000, 0x00000002},
|
||||
@ -3828,7 +3828,7 @@ ROMListEntry ROMList[] =
|
||||
{0x4A524E54, 0x10000000, 0x00000003},
|
||||
{0x4A524E59, 0x04000000, 0x00000002},
|
||||
{0x4A524F42, 0x01000000, 0x00000003},
|
||||
{0x4A524F55, 0x02000000, 0x00000008},
|
||||
{0x4A524F55, 0x02000000, 0x00000009},
|
||||
{0x4A525041, 0x02000000, 0x00000002},
|
||||
{0x4A525142, 0x02000000, 0x00000002},
|
||||
{0x4A525143, 0x04000000, 0x00000002},
|
||||
@ -5773,7 +5773,7 @@ ROMListEntry ROMList[] =
|
||||
{0x50524E41, 0x04000000, 0x00000001},
|
||||
{0x50524E42, 0x04000000, 0x00000003},
|
||||
{0x50524E43, 0x04000000, 0x00000002},
|
||||
{0x50524F55, 0x08000000, 0x00000008},
|
||||
{0x50524F55, 0x08000000, 0x00000009},
|
||||
{0x50525041, 0x02000000, 0x00000002},
|
||||
{0x50525042, 0x00800000, 0x00000001},
|
||||
{0x50525054, 0x02000000, 0x00000001},
|
||||
|
||||
@ -22,8 +22,8 @@
|
||||
#include <stdio.h>
|
||||
#include "types.h"
|
||||
|
||||
#define SAVESTATE_MAJOR 7
|
||||
#define SAVESTATE_MINOR 1
|
||||
#define SAVESTATE_MAJOR 8
|
||||
#define SAVESTATE_MINOR 0
|
||||
|
||||
class Savestate
|
||||
{
|
||||
|
||||
@ -561,7 +561,7 @@ int Reset()
|
||||
if (ROMPath[ROMSlot_GBA][0] != '\0')
|
||||
{
|
||||
char ext[5] = {0}; int _len = strlen(ROMPath[ROMSlot_GBA]);
|
||||
strncpy(ext, ROMPath[ROMSlot_NDS] + _len - 4, 4);
|
||||
strncpy(ext, ROMPath[ROMSlot_GBA] + _len - 4, 4);
|
||||
|
||||
if(!strncmp(ext, ".gba", 4))
|
||||
{
|
||||
|
||||
@ -382,7 +382,7 @@ void EmuThread::run()
|
||||
|
||||
if (Input::HotkeyPressed(HK_SwapScreens)) emit swapScreensToggle();
|
||||
|
||||
if (GBACart::CartInserted && GBACart::HasSolarSensor)
|
||||
/*if (GBACart::CartInserted && GBACart::HasSolarSensor)
|
||||
{
|
||||
if (Input::HotkeyPressed(HK_SolarSensorDecrease))
|
||||
{
|
||||
@ -398,6 +398,26 @@ void EmuThread::run()
|
||||
sprintf(msg, "Solar sensor level set to %d", GBACart_SolarSensor::LightLevel);
|
||||
OSD::AddMessage(0, msg);
|
||||
}
|
||||
}*/
|
||||
if (Input::HotkeyPressed(HK_SolarSensorDecrease))
|
||||
{
|
||||
int level = GBACart::SetInput(GBACart::Input_SolarSensorDown, true);
|
||||
if (level != -1)
|
||||
{
|
||||
char msg[64];
|
||||
sprintf(msg, "Solar sensor level: %d", level);
|
||||
OSD::AddMessage(0, msg);
|
||||
}
|
||||
}
|
||||
if (Input::HotkeyPressed(HK_SolarSensorIncrease))
|
||||
{
|
||||
int level = GBACart::SetInput(GBACart::Input_SolarSensorUp, true);
|
||||
if (level != -1)
|
||||
{
|
||||
char msg[64];
|
||||
sprintf(msg, "Solar sensor level: %d", level);
|
||||
OSD::AddMessage(0, msg);
|
||||
}
|
||||
}
|
||||
|
||||
if (EmuRunning == 1)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user