mirror of
https://github.com/SourMesen/Mesen2.git
synced 2025-04-02 10:21:44 -04:00
483 lines
12 KiB
C++
483 lines
12 KiB
C++
#include "pch.h"
|
|
#include "SNES/SnesMemoryManager.h"
|
|
#include "SNES/SnesConsole.h"
|
|
#include "SNES/BaseCartridge.h"
|
|
#include "SNES/SnesCpu.h"
|
|
#include "SNES/SnesPpu.h"
|
|
#include "SNES/SnesDmaController.h"
|
|
#include "SNES/RegisterHandlerA.h"
|
|
#include "SNES/RegisterHandlerB.h"
|
|
#include "SNES/RamHandler.h"
|
|
#include "Debugger/DebugTypes.h"
|
|
#include "Shared/MessageManager.h"
|
|
#include "Shared/Emulator.h"
|
|
#include "Shared/EmuSettings.h"
|
|
#include "Shared/CheatManager.h"
|
|
#include "Utilities/Serializer.h"
|
|
#include "Utilities/HexUtilities.h"
|
|
#include "Shared/MemoryOperationType.h"
|
|
|
|
void SnesMemoryManager::Initialize(SnesConsole *console)
|
|
{
|
|
_masterClock = 0;
|
|
_openBus = 0;
|
|
|
|
_cpuSpeed = 8;
|
|
UpdateExecCallbacks();
|
|
|
|
_console = console;
|
|
_emu = console->GetEmulator();
|
|
_regs = console->GetInternalRegisters();
|
|
_cpu = console->GetCpu();
|
|
_ppu = console->GetPpu();
|
|
_cart = console->GetCartridge();
|
|
_cheatManager = _emu->GetCheatManager();
|
|
|
|
_workRam = new uint8_t[SnesMemoryManager::WorkRamSize];
|
|
_emu->RegisterMemory(MemoryType::SnesWorkRam, _workRam, SnesMemoryManager::WorkRamSize);
|
|
_console->InitializeRam(_workRam, SnesMemoryManager::WorkRamSize);
|
|
|
|
_registerHandlerA.reset(new RegisterHandlerA(
|
|
console->GetDmaController(),
|
|
console->GetInternalRegisters(),
|
|
(SnesControlManager*)console->GetControlManager()
|
|
));
|
|
|
|
_registerHandlerB.reset(new RegisterHandlerB(
|
|
_console,
|
|
_ppu,
|
|
console->GetSpc(),
|
|
_workRam
|
|
));
|
|
|
|
for(uint32_t i = 0; i < 128 * 1024; i += 0x1000) {
|
|
_workRamHandlers.push_back(unique_ptr<RamHandler>(new RamHandler(_workRam, i, SnesMemoryManager::WorkRamSize, MemoryType::SnesWorkRam)));
|
|
}
|
|
|
|
_mappings.RegisterHandler(0x7E, 0x7F, 0x0000, 0xFFFF, _workRamHandlers);
|
|
|
|
_mappings.RegisterHandler(0x00, 0x3F, 0x2000, 0x2FFF, _registerHandlerB.get());
|
|
_mappings.RegisterHandler(0x80, 0xBF, 0x2000, 0x2FFF, _registerHandlerB.get());
|
|
|
|
_mappings.RegisterHandler(0x00, 0x3F, 0x4000, 0x4FFF, _registerHandlerA.get());
|
|
_mappings.RegisterHandler(0x80, 0xBF, 0x4000, 0x4FFF, _registerHandlerA.get());
|
|
|
|
_mappings.RegisterHandler(0x00, 0x3F, 0x0000, 0x0FFF, _workRamHandlers[0].get());
|
|
_mappings.RegisterHandler(0x80, 0xBF, 0x0000, 0x0FFF, _workRamHandlers[0].get());
|
|
_mappings.RegisterHandler(0x00, 0x3F, 0x1000, 0x1FFF, _workRamHandlers[1].get());
|
|
_mappings.RegisterHandler(0x80, 0xBF, 0x1000, 0x1FFF, _workRamHandlers[1].get());
|
|
|
|
_cart->Init(_mappings);
|
|
|
|
GenerateMasterClockTable();
|
|
Reset();
|
|
}
|
|
|
|
SnesMemoryManager::~SnesMemoryManager()
|
|
{
|
|
delete[] _workRam;
|
|
}
|
|
|
|
void SnesMemoryManager::Reset()
|
|
{
|
|
_masterClock = 0;
|
|
_hClock = 0;
|
|
_dramRefreshPosition = 538 - (_masterClock & 0x07);
|
|
_nextEventClock = _dramRefreshPosition;
|
|
_nextEvent = SnesEventType::DramRefresh;
|
|
}
|
|
|
|
void SnesMemoryManager::GenerateMasterClockTable()
|
|
{
|
|
for(int i = 0; i < 0x800; i++) {
|
|
uint8_t bank = (i & 0x300) >> 8;
|
|
if(bank == 1) {
|
|
//Banks $40-$7F - Slow
|
|
_masterClockTable[i] = 8;
|
|
} else if(bank == 3) {
|
|
//Banks $C0-$FF
|
|
//Slow or fast (depending on register)
|
|
_masterClockTable[i] = (i >= 0x400) ? 6 : 8;
|
|
} else {
|
|
//Banks $00-$3F and $80-$BF
|
|
uint8_t page = (i & 0xFF);
|
|
if(page <= 0x1F) {
|
|
//Slow
|
|
_masterClockTable[i] = 8;
|
|
} else if(page >= 0x20 && page <= 0x3F) {
|
|
//Fast
|
|
_masterClockTable[i] = 6;
|
|
} else if(page == 0x40 || page == 0x41) {
|
|
//Extra slow
|
|
_masterClockTable[i] = 12;
|
|
} else if(page >= 0x42 && page <= 0x5F) {
|
|
//Fast
|
|
_masterClockTable[i] = 6;
|
|
} else if(page >= 0x60 && page <= 0x7F) {
|
|
//Slow
|
|
_masterClockTable[i] = 8;
|
|
} else if(bank == 0) {
|
|
//Slow
|
|
_masterClockTable[i] = 8;
|
|
} else {
|
|
//page >= $80
|
|
//Slow or fast (depending on register)
|
|
_masterClockTable[i] = (i >= 0x400) ? 6 : 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template<uint8_t clocks>
|
|
void SnesMemoryManager::IncMasterClock()
|
|
{
|
|
if constexpr(clocks == 2) {
|
|
Exec();
|
|
} else if constexpr(clocks == 4) {
|
|
Exec();
|
|
Exec();
|
|
} else if constexpr(clocks == 6) {
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
} else if constexpr(clocks == 8) {
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
} else if constexpr(clocks == 12) {
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
}
|
|
}
|
|
|
|
void SnesMemoryManager::IncMasterClock4()
|
|
{
|
|
Exec();
|
|
Exec();
|
|
}
|
|
|
|
void SnesMemoryManager::IncMasterClock6()
|
|
{
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
}
|
|
|
|
void SnesMemoryManager::IncMasterClock8()
|
|
{
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
Exec();
|
|
}
|
|
|
|
void SnesMemoryManager::IncMasterClock40()
|
|
{
|
|
Exec(); Exec(); Exec(); Exec(); Exec();
|
|
Exec(); Exec(); Exec(); Exec(); Exec();
|
|
Exec(); Exec(); Exec(); Exec(); Exec();
|
|
Exec(); Exec(); Exec(); Exec(); Exec();
|
|
}
|
|
|
|
void SnesMemoryManager::IncMasterClockStartup()
|
|
{
|
|
for(int i = 0; i < 186 / 2; i++) {
|
|
Exec();
|
|
}
|
|
}
|
|
|
|
void SnesMemoryManager::IncrementMasterClockValue(uint16_t cyclesToRun)
|
|
{
|
|
switch(cyclesToRun) {
|
|
case 12: Exec(); [[fallthrough]];
|
|
case 10: Exec(); [[fallthrough]];
|
|
case 8: Exec(); [[fallthrough]];
|
|
case 6: Exec(); [[fallthrough]];
|
|
case 4: Exec(); [[fallthrough]];
|
|
case 2: Exec(); break;
|
|
}
|
|
}
|
|
|
|
void SnesMemoryManager::Exec()
|
|
{
|
|
_masterClock += 2;
|
|
_hClock += 2;
|
|
|
|
if(_hClock == _nextEventClock) {
|
|
ProcessEvent();
|
|
}
|
|
|
|
if((_hClock & 0x03) == 0) {
|
|
_emu->ProcessPpuCycle<CpuType::Snes>();
|
|
} else if(_hClock & 0x02) {
|
|
_regs->ProcessIrqCounters();
|
|
}
|
|
|
|
_cart->SyncCoprocessors();
|
|
}
|
|
|
|
void SnesMemoryManager::ProcessEvent()
|
|
{
|
|
switch(_nextEvent) {
|
|
case SnesEventType::HdmaInit:
|
|
_console->GetDmaController()->BeginHdmaInit();
|
|
_nextEvent = SnesEventType::DramRefresh;
|
|
_nextEventClock = _dramRefreshPosition;
|
|
break;
|
|
|
|
case SnesEventType::DramRefresh:
|
|
IncMasterClock40();
|
|
if(_ppu->GetScanline() < _ppu->GetVblankStart()) {
|
|
_nextEvent = SnesEventType::HdmaStart;
|
|
_nextEventClock = 276 * 4;
|
|
} else {
|
|
_nextEvent = SnesEventType::EndOfScanline;
|
|
_nextEventClock = 1360;
|
|
}
|
|
break;
|
|
|
|
case SnesEventType::HdmaStart:
|
|
_console->GetDmaController()->BeginHdmaTransfer();
|
|
_nextEvent = SnesEventType::EndOfScanline;
|
|
_nextEventClock = 1360;
|
|
break;
|
|
|
|
case SnesEventType::EndOfScanline:
|
|
if(_ppu->ProcessEndOfScanline(_hClock)) {
|
|
_dramRefreshPosition = 538 - (_masterClock & 0x07);
|
|
if(_ppu->GetScanline() == 0) {
|
|
_nextEvent = SnesEventType::HdmaInit;
|
|
_nextEventClock = 12 + (_masterClock & 0x07);
|
|
} else {
|
|
_nextEvent = SnesEventType::DramRefresh;
|
|
_nextEventClock = _dramRefreshPosition;
|
|
}
|
|
} else {
|
|
_nextEventClock += 2;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::Read(uint32_t addr, MemoryOperationType type)
|
|
{
|
|
(this->*_execRead)();
|
|
|
|
uint8_t value;
|
|
IMemoryHandler *handler = _mappings.GetHandler(addr);
|
|
if(handler) {
|
|
value = handler->Read(addr);
|
|
_memTypeBusA = handler->GetMemoryType();
|
|
if(handler != _registerHandlerA.get()) {
|
|
//Reading from the internal CPU bus does not update the external bus
|
|
_openBus = value;
|
|
}
|
|
} else {
|
|
//open bus
|
|
value = _openBus;
|
|
LogDebug("[Debug] Read - missing handler: $" + HexUtilities::ToHex(addr));
|
|
}
|
|
if(_cheatManager->HasCheats<CpuType::Snes>()) {
|
|
_cheatManager->ApplyCheat<CpuType::Snes>(addr, value);
|
|
}
|
|
IncMasterClock4();
|
|
_emu->ProcessMemoryRead<CpuType::Snes>(addr, value, type);
|
|
return value;
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::ReadDma(uint32_t addr, bool forBusA)
|
|
{
|
|
IncMasterClock4();
|
|
|
|
uint8_t value;
|
|
IMemoryHandler* handler = _mappings.GetHandler(addr);
|
|
if(handler) {
|
|
if(forBusA && handler == _registerHandlerB.get() && (addr & 0xFF00) == 0x2100) {
|
|
//Trying to read from bus B using bus A returns open bus
|
|
value = _openBus;
|
|
} else if(handler == _registerHandlerA.get()) {
|
|
uint16_t regAddr = addr & 0xFFFF;
|
|
if(regAddr == 0x420B || regAddr == 0x420C || (regAddr >= 0x4300 && regAddr <= 0x437F)) {
|
|
//Trying to read the DMA controller with DMA returns open bus
|
|
value = _openBus;
|
|
} else {
|
|
value = handler->Read(addr);
|
|
}
|
|
} else {
|
|
value = handler->Read(addr);
|
|
if(handler != _registerHandlerB.get()) {
|
|
_memTypeBusA = handler->GetMemoryType();
|
|
}
|
|
}
|
|
_openBus = value;
|
|
} else {
|
|
//open bus
|
|
value = _openBus;
|
|
LogDebug("[Debug] Read - missing handler: $" + HexUtilities::ToHex(addr));
|
|
}
|
|
if(_cheatManager->HasCheats<CpuType::Snes>()) {
|
|
_cheatManager->ApplyCheat<CpuType::Snes>(addr, value);
|
|
}
|
|
_emu->ProcessMemoryRead<CpuType::Snes>(addr, value, MemoryOperationType::DmaRead);
|
|
return value;
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::Peek(uint32_t addr)
|
|
{
|
|
return _mappings.Peek(addr);
|
|
}
|
|
|
|
uint16_t SnesMemoryManager::PeekWord(uint32_t addr)
|
|
{
|
|
return _mappings.PeekWord(addr);
|
|
}
|
|
|
|
void SnesMemoryManager::PeekBlock(uint32_t addr, uint8_t *dest)
|
|
{
|
|
_mappings.PeekBlock(addr, dest);
|
|
}
|
|
|
|
void SnesMemoryManager::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
|
|
{
|
|
(this->*_execWrite)();
|
|
|
|
if(_emu->ProcessMemoryWrite<CpuType::Snes>(addr, value, type)) {
|
|
IMemoryHandler* handler = _mappings.GetHandler(addr);
|
|
if(handler) {
|
|
handler->Write(addr, value);
|
|
_memTypeBusA = handler->GetMemoryType();
|
|
} else {
|
|
LogDebug("[Debug] Write - missing handler: $" + HexUtilities::ToHex(addr) + " = " + HexUtilities::ToHex(value));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SnesMemoryManager::WriteDma(uint32_t addr, uint8_t value, bool forBusA)
|
|
{
|
|
IncMasterClock4();
|
|
if(_emu->ProcessMemoryWrite<CpuType::Snes>(addr, value, MemoryOperationType::DmaWrite)) {
|
|
IMemoryHandler* handler = _mappings.GetHandler(addr);
|
|
if(handler) {
|
|
if(forBusA && handler == _registerHandlerB.get() && (addr & 0xFF00) == 0x2100) {
|
|
//Trying to write to bus B using bus A does nothing
|
|
} else if(handler == _registerHandlerA.get()) {
|
|
uint16_t regAddr = addr & 0xFFFF;
|
|
if(regAddr == 0x420B || regAddr == 0x420C || (regAddr >= 0x4300 && regAddr <= 0x437F)) {
|
|
//Trying to write to the DMA controller with DMA does nothing
|
|
} else {
|
|
handler->Write(addr, value);
|
|
}
|
|
} else {
|
|
handler->Write(addr, value);
|
|
if(handler != _registerHandlerB.get()) {
|
|
_memTypeBusA = handler->GetMemoryType();
|
|
}
|
|
}
|
|
} else {
|
|
LogDebug("[Debug] Write - missing handler: $" + HexUtilities::ToHex(addr) + " = " + HexUtilities::ToHex(value));
|
|
}
|
|
_openBus = value;
|
|
}
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::GetOpenBus()
|
|
{
|
|
return _openBus;
|
|
}
|
|
|
|
uint64_t SnesMemoryManager::GetMasterClock()
|
|
{
|
|
return _masterClock;
|
|
}
|
|
|
|
uint16_t SnesMemoryManager::GetHClock()
|
|
{
|
|
return _hClock;
|
|
}
|
|
|
|
uint8_t * SnesMemoryManager::DebugGetWorkRam()
|
|
{
|
|
return _workRam;
|
|
}
|
|
|
|
MemoryMappings* SnesMemoryManager::GetMemoryMappings()
|
|
{
|
|
return &_mappings;
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::GetCpuSpeed(uint32_t addr)
|
|
{
|
|
return _masterClockTable[(_regs->IsFastRomEnabled() << 10) | ((addr & 0xC00000) >> 14) | ((addr & 0xFF00) >> 8)];
|
|
}
|
|
|
|
uint8_t SnesMemoryManager::GetCpuSpeed()
|
|
{
|
|
return _cpuSpeed;
|
|
}
|
|
|
|
void SnesMemoryManager::SetCpuSpeed(uint8_t speed)
|
|
{
|
|
if(_cpuSpeed != speed) {
|
|
_cpuSpeed = speed;
|
|
UpdateExecCallbacks();
|
|
}
|
|
}
|
|
|
|
void SnesMemoryManager::UpdateExecCallbacks()
|
|
{
|
|
switch(_cpuSpeed) {
|
|
case 6:
|
|
_execRead = &SnesMemoryManager::IncMasterClock<2>;
|
|
_execWrite = &SnesMemoryManager::IncMasterClock<6>;
|
|
break;
|
|
|
|
case 8:
|
|
_execRead = &SnesMemoryManager::IncMasterClock<4>;
|
|
_execWrite = &SnesMemoryManager::IncMasterClock<8>;
|
|
break;
|
|
|
|
case 12:
|
|
_execRead = &SnesMemoryManager::IncMasterClock<8>;
|
|
_execWrite = &SnesMemoryManager::IncMasterClock<12>;
|
|
break;
|
|
}
|
|
}
|
|
|
|
MemoryType SnesMemoryManager::GetMemoryTypeBusA()
|
|
{
|
|
return _memTypeBusA;
|
|
}
|
|
|
|
bool SnesMemoryManager::IsRegister(uint32_t cpuAddress)
|
|
{
|
|
IMemoryHandler* handler = _mappings.GetHandler(cpuAddress);
|
|
return handler == _registerHandlerA.get() || handler == _registerHandlerB.get();
|
|
}
|
|
|
|
bool SnesMemoryManager::IsWorkRam(uint32_t cpuAddress)
|
|
{
|
|
IMemoryHandler* handler = _mappings.GetHandler(cpuAddress);
|
|
return handler && handler->GetMemoryType() == MemoryType::SnesWorkRam;
|
|
}
|
|
|
|
uint32_t SnesMemoryManager::GetWramPosition()
|
|
{
|
|
return _registerHandlerB->GetWramPosition();
|
|
}
|
|
|
|
void SnesMemoryManager::Serialize(Serializer &s)
|
|
{
|
|
SV(_masterClock); SV(_openBus); SV(_cpuSpeed); SV(_hClock); SV(_dramRefreshPosition);
|
|
SV(_memTypeBusA); SV(_nextEvent); SV(_nextEventClock);
|
|
SVArray(_workRam, SnesMemoryManager::WorkRamSize);
|
|
SV(_registerHandlerB);
|
|
|
|
if(!s.IsSaving()) {
|
|
UpdateExecCallbacks();
|
|
}
|
|
}
|