diff options
Diffstat (limited to 'gearboy/src/Memory.cpp')
| -rw-r--r-- | gearboy/src/Memory.cpp | 736 |
1 files changed, 736 insertions, 0 deletions
diff --git a/gearboy/src/Memory.cpp b/gearboy/src/Memory.cpp new file mode 100644 index 00000000..88eb9975 --- /dev/null +++ b/gearboy/src/Memory.cpp @@ -0,0 +1,736 @@ +/* + * Gearboy - Nintendo Game Boy Emulator + * Copyright (C) 2012 Ignacio Sanchez + + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://www.gnu.org/licenses/ + * + */ + +#include <iostream> +#include <fstream> +#include "Memory.h" +#include "Processor.h" +#include "Video.h" + +Memory::Memory() +{ + InitPointer(m_pProcessor); + InitPointer(m_pVideo); + InitPointer(m_pMap); + InitPointer(m_pDisassembledMap); + InitPointer(m_pDisassembledROMMap); + InitPointer(m_pWRAMBanks); + InitPointer(m_pLCDRAMBank1); + InitPointer(m_pCommonMemoryRule); + InitPointer(m_pIORegistersMemoryRule); + InitPointer(m_pCurrentMemoryRule); + InitPointer(m_pBootromDMG); + InitPointer(m_pBootromGBC); + m_bCGB = false; + m_iCurrentWRAMBank = 1; + m_iCurrentLCDRAMBank = 0; + m_bHDMAEnabled = false; + m_iHDMABytes = 0; + for (int i = 0; i < 5; i++) + m_HDMA[i] = 0; + m_HDMASource = 0; + m_HDMADestination = 0; + m_bBootromDMGEnabled = false; + m_bBootromGBCEnabled = false; + m_bBootromRegistryDisabled = false; + m_bBootromDMGLoaded = false; + m_bBootromGBCLoaded = false; +} + +Memory::~Memory() +{ + InitPointer(m_pProcessor); + InitPointer(m_pVideo); + SafeDeleteArray(m_pMap); + SafeDeleteArray(m_pWRAMBanks); + SafeDeleteArray(m_pLCDRAMBank1); + InitPointer(m_pCommonMemoryRule); + InitPointer(m_pIORegistersMemoryRule); + InitPointer(m_pCurrentMemoryRule); + SafeDeleteArray(m_pBootromDMG); + SafeDeleteArray(m_pBootromGBC); + + if (IsValidPointer(m_pDisassembledROMMap)) + { + for (int i = 0; i < MAX_ROM_SIZE; i++) + { + SafeDelete(m_pDisassembledROMMap[i]); + } + SafeDeleteArray(m_pDisassembledROMMap); + } + + if (IsValidPointer(m_pDisassembledMap)) + { + for (int i = 0; i < 65536; i++) + { + SafeDelete(m_pDisassembledMap[i]); + } + SafeDeleteArray(m_pDisassembledMap); + } +} + +void Memory::SetProcessor(Processor* pProcessor) +{ + m_pProcessor = pProcessor; +} + +void Memory::SetVideo(Video* pVideo) +{ + m_pVideo = pVideo; +} + +void Memory::Init() +{ + m_pMap = new u8[65536]; + m_pWRAMBanks = new u8[0x8000]; + m_pLCDRAMBank1 = new u8[0x2000]; + m_pBootromDMG = new u8[0x100]; + m_pBootromGBC = new u8[0x900]; +#ifndef GEARBOY_DISABLE_DISASSEMBLER + m_pDisassembledMap = new stDisassembleRecord*[65536]; + for (int i = 0; i < 65536; i++) + { + InitPointer(m_pDisassembledMap[i]); + } + + m_pDisassembledROMMap = new stDisassembleRecord*[MAX_ROM_SIZE]; + for (int i = 0; i < MAX_ROM_SIZE; i++) + { + InitPointer(m_pDisassembledROMMap[i]); + } +#endif + m_BreakpointsCPU.clear(); + m_BreakpointsMem.clear(); + InitPointer(m_pRunToBreakpoint); + Reset(false); +} + +void Memory::Reset(bool bCGB) +{ + m_bCGB = bCGB; + InitPointer(m_pCommonMemoryRule); + InitPointer(m_pIORegistersMemoryRule); + InitPointer(m_pCurrentMemoryRule); + m_iCurrentWRAMBank = 1; + m_iCurrentLCDRAMBank = 0; + m_bHDMAEnabled = false; + m_iHDMABytes = 0; + m_bBootromRegistryDisabled = false; + + if (IsBootromEnabled()) + ResetBootromDisassembledMemory(); + + for (int i = 0; i < 65536; i++) + { + m_pMap[i] = 0x00; + + if ((i >= 0x8000) && (i < 0xA000)) + { + m_pMap[i] = 0x00; + m_pLCDRAMBank1[i - 0x8000] = 0x00; + } + else if ((i >= 0xC000) && (i < 0xE000)) + { + if ((i & 0x8) ^((i & 0x800) >> 8)) + { + if (m_bCGB) + { + m_pMap[i] = 0x00; + if (i >= 0xD000) + { + for (int a = 0; a < 8; a++) + { + if (a != 2) + m_pWRAMBanks[(i - 0xD000) + (0x1000 * a)] = m_pMap[i - 0x1000]; + else + m_pWRAMBanks[(i - 0xD000) + (0x1000 * a)] = 0x00; + } + } + } + else + m_pMap[i] = 0x0f; + } + else + { + m_pMap[i] = 0xff; + if (i >= 0xD000) + { + for (int a = 0; a < 8; a++) + { + if (a != 2) + m_pWRAMBanks[(i - 0xD000) + (0x1000 * a)] = m_pMap[i - 0x1000]; + else + m_pWRAMBanks[(i - 0xD000) + (0x1000 * a)] = 0x00; + } + } + } + } + else if (i >= 0xFF00) + { + if (m_bCGB) + m_pMap[i] = kInitialValuesForColorFFXX[i - 0xFF00]; + else + m_pMap[i] = kInitialValuesForFFXX[i - 0xFF00]; + } + else + { + m_pMap[i] = 0xFF; + } + } + + if (m_bCGB) + { + for (int i = 0; i < 5; i++) + { + m_HDMA[i] = m_pMap[0xFF51 + i]; + } + + u8 hdma1 = m_HDMA[0]; + u8 hdma2 = m_HDMA[1]; + u8 hdma3 = m_HDMA[2]; + u8 hdma4 = m_HDMA[3]; + + if (hdma1 > 0x7f && hdma1 < 0xa0) + hdma1 = 0; + + m_HDMASource = (hdma1 << 8) | (hdma2 & 0xF0); + m_HDMADestination = ((hdma3 & 0x1F) << 8) | (hdma4 & 0xF0); + m_HDMADestination |= 0x8000; + } +} + +void Memory::SetCurrentRule(MemoryRule* pRule) +{ + m_pCurrentMemoryRule = pRule; +} + +void Memory::SetCommonRule(CommonMemoryRule* pRule) +{ + m_pCommonMemoryRule = pRule; +} + +void Memory::SetIORule(IORegistersMemoryRule* pRule) +{ + m_pIORegistersMemoryRule = pRule; +} + +MemoryRule* Memory::GetCurrentRule() +{ + return m_pCurrentMemoryRule; +} + +u8* Memory::GetMemoryMap() +{ + return m_pMap; +} + +void Memory::LoadBank0and1FromROM(u8* pTheROM) +{ + // loads the first 32KB only (bank 0 and 1) + for (int i = 0; i < 0x8000; i++) + { + m_pMap[i] = pTheROM[i]; + } +} + +void Memory::MemoryDump(const char* szFilePath) +{ + if (!IsValidPointer(m_pDisassembledMap)) + return; + + using namespace std; + + ofstream myfile(szFilePath, ios::out | ios::trunc); + + if (myfile.is_open()) + { + for (int i = 0; i < 65536; i++) + { + if (IsValidPointer(m_pDisassembledMap[i]) && (m_pDisassembledMap[i]->name[0] != 0)) + { + myfile << "0x" << hex << i << "\t " << m_pDisassembledMap[i]->name << "\n"; + i += (m_pDisassembledMap[i]->size - 1); + } + else + { + myfile << "0x" << hex << i << "\t [0x" << hex << (int) m_pMap[i] << "]\n"; + } + } + + myfile.close(); + } +} + +void Memory::PerformDMA(u8 value) +{ + if (m_bCGB) + { + u16 address = value << 8; + if (address < 0xE000) + { + if (address >= 0x8000 && address < 0xA000) + { + for (int i = 0; i < 0xA0; i++) + Load(0xFE00 + i, ReadCGBLCDRAM(address + i, false)); + } + else if (address >= 0xD000 && address < 0xE000) + { + for (int i = 0; i < 0xA0; i++) + Load(0xFE00 + i, ReadCGBWRAM(address + i)); + } + else + { + for (int i = 0; i < 0xA0; i++) + Load(0xFE00 + i, Read(address + i)); + } + } + } + else + { + u16 address = value << 8; + if (address >= 0x8000 && address < 0xE000) + { + for (int i = 0; i < 0xA0; i++) + Load(0xFE00 + i, Read(address + i)); + } + } +} + +void Memory::SwitchCGBDMA(u8 value) +{ + m_iHDMABytes = 16 + ((value & 0x7f) * 16); + + if (m_bHDMAEnabled) + { + if (IsSetBit(value, 7)) + { + m_HDMA[4] = value & 0x7F; + } + else + { + m_HDMA[4] = 0xFF; + m_bHDMAEnabled = false; + } + } + else + { + if (IsSetBit(value, 7)) + { + m_bHDMAEnabled = true; + m_HDMA[4] = value & 0x7F; + if (m_pVideo->GetCurrentStatusMode() == 0) + { + m_pProcessor->AddCycles(PerformHDMA()); + } + } + else + { + PerformGDMA(value); + } + } +} + +unsigned int Memory::PerformHDMA() +{ + u16 source = m_HDMASource & 0xFFF0; + u16 destination = (m_HDMADestination & 0x1FF0) | 0x8000; + + if (source >= 0xD000 && source < 0xE000) + { + for (int i = 0; i < 0x10; i++) + WriteCGBLCDRAM(destination + i, ReadCGBWRAM(source + i)); + } + else + { + for (int i = 0; i < 0x10; i++) + WriteCGBLCDRAM(destination + i, Read(source + i)); + } + + m_HDMADestination += 0x10; + if (m_HDMADestination == 0xA000) + m_HDMADestination = 0x8000; + + m_HDMASource += 0x10; + if (m_HDMASource == 0x8000) + m_HDMASource = 0xA000; + + m_HDMA[1] = m_HDMASource & 0xFF; + m_HDMA[0] = m_HDMASource >> 8; + + m_HDMA[3] = m_HDMADestination & 0xFF; + m_HDMA[2] = m_HDMADestination >> 8; + + m_iHDMABytes -= 0x10; + m_HDMA[4]--; + + if (m_HDMA[4] == 0xFF) + m_bHDMAEnabled = false; + + // return clock cycles used + return (m_pProcessor->CGBSpeed() ? 17 : 9) * 4; +} + +void Memory::PerformGDMA(u8 value) +{ + u16 source = m_HDMASource & 0xFFF0; + u16 destination = (m_HDMADestination & 0x1FF0) | 0x8000; + + if (source >= 0xD000 && source < 0xE000) + { + for (int i = 0; i < m_iHDMABytes; i++) + WriteCGBLCDRAM(destination + i, ReadCGBWRAM(source + i)); + } + else + { + for (int i = 0; i < m_iHDMABytes; i++) + WriteCGBLCDRAM(destination + i, Read(source + i)); + } + + m_HDMADestination += m_iHDMABytes; + m_HDMASource += m_iHDMABytes; + + for (int i = 0; i < 5; i++) + m_HDMA[i] = 0xFF; + + int clock_cycles = 0; + + if (m_pProcessor->CGBSpeed()) + clock_cycles = 2 + 16 * ((value & 0x7f) + 1); + else + clock_cycles = 1 + 8 * ((value & 0x7f) + 1); + + m_pProcessor->AddCycles(clock_cycles * 4); +} + +bool Memory::IsHDMAEnabled() const +{ + return m_bHDMAEnabled; +} + +void Memory::SetHDMARegister(int reg, u8 value) +{ + switch (reg) + { + case 1: + { + // HDMA1 + if (value > 0x7f && value < 0xa0) + value = 0; + m_HDMASource = (value << 8) | (m_HDMASource & 0xF0); + break; + } + case 2: + { + // HDMA2 + value &= 0xF0; + m_HDMASource = (m_HDMASource & 0xFF00) | value; + break; + } + case 3: + { + // HDMA3 + value &= 0x1F; + m_HDMADestination = (value << 8) | (m_HDMADestination & 0xF0); + m_HDMADestination |= 0x8000; + break; + } + case 4: + { + // HDMA4 + value &= 0xF0; + m_HDMADestination = (m_HDMADestination & 0x1F00) | value; + m_HDMADestination |= 0x8000; + break; + } + } + + m_HDMA[reg - 1] = value; +} + +u8 Memory::GetHDMARegister(int reg) const +{ + return m_HDMA[reg - 1]; +} + +u8* Memory::GetCGBRAM() +{ + return m_pWRAMBanks; +} + +int Memory::GetCurrentCGBRAMBank() +{ + return m_iCurrentWRAMBank; +} + +int Memory::GetCurrentLCDRAMBank() +{ + return m_iCurrentLCDRAMBank; +} + +void Memory::SaveState(std::ostream& stream) +{ + using namespace std; + + stream.write(reinterpret_cast<const char*> (m_pMap), 65536); + stream.write(reinterpret_cast<const char*> (&m_iCurrentWRAMBank), sizeof(m_iCurrentWRAMBank)); + stream.write(reinterpret_cast<const char*> (&m_iCurrentLCDRAMBank), sizeof(m_iCurrentLCDRAMBank)); + stream.write(reinterpret_cast<const char*> (m_pWRAMBanks), 0x8000); + stream.write(reinterpret_cast<const char*> (m_pLCDRAMBank1), 0x2000); + stream.write(reinterpret_cast<const char*> (&m_bHDMAEnabled), sizeof(m_bHDMAEnabled)); + stream.write(reinterpret_cast<const char*> (&m_iHDMABytes), sizeof(m_iHDMABytes)); + stream.write(reinterpret_cast<const char*> (m_HDMA), sizeof(m_HDMA)); + stream.write(reinterpret_cast<const char*> (&m_HDMASource), sizeof(m_HDMASource)); + stream.write(reinterpret_cast<const char*> (&m_HDMADestination), sizeof(m_HDMADestination)); +} + +void Memory::LoadState(std::istream& stream) +{ + using namespace std; + + stream.read(reinterpret_cast<char*> (m_pMap), 65536); + stream.read(reinterpret_cast<char*> (&m_iCurrentWRAMBank), sizeof(m_iCurrentWRAMBank)); + stream.read(reinterpret_cast<char*> (&m_iCurrentLCDRAMBank), sizeof(m_iCurrentLCDRAMBank)); + stream.read(reinterpret_cast<char*> (m_pWRAMBanks), 0x8000); + stream.read(reinterpret_cast<char*> (m_pLCDRAMBank1), 0x2000); + stream.read(reinterpret_cast<char*> (&m_bHDMAEnabled), sizeof(m_bHDMAEnabled)); + stream.read(reinterpret_cast<char*> (&m_iHDMABytes), sizeof(m_iHDMABytes)); + stream.read(reinterpret_cast<char*> (m_HDMA), sizeof(m_HDMA)); + stream.read(reinterpret_cast<char*> (&m_HDMASource), sizeof(m_HDMASource)); + stream.read(reinterpret_cast<char*> (&m_HDMADestination), sizeof(m_HDMADestination)); +} + +u8* Memory::GetROM0() +{ + return m_pCurrentMemoryRule->GetRomBank0(); +} + +u8* Memory::GetROM1() +{ + return m_pCurrentMemoryRule->GetCurrentRomBank1(); +} + +u8* Memory::GetVRAM() +{ + if (m_bCGB) + return (m_iCurrentLCDRAMBank == 1) ? m_pLCDRAMBank1 : m_pMap + 0x8000; + else + return m_pMap + 0x8000; +} + +u8* Memory::GetRAM() +{ + return m_pCurrentMemoryRule->GetCurrentRamBank(); +} + +u8* Memory::GetWRAM0() +{ + return m_bCGB ? m_pWRAMBanks : m_pMap + 0xC000; +} + +u8* Memory::GetWRAM1() +{ + return m_bCGB ? m_pWRAMBanks + (0x1000 * m_iCurrentWRAMBank) : m_pMap + 0xD000; +} + +std::vector<Memory::stDisassembleRecord*>* Memory::GetBreakpointsCPU() +{ + return &m_BreakpointsCPU; +} + +std::vector<Memory::stMemoryBreakpoint>* Memory::GetBreakpointsMem() +{ + return &m_BreakpointsMem; +} + +Memory::stDisassembleRecord* Memory::GetRunToBreakpoint() +{ + return m_pRunToBreakpoint; +} + +void Memory::SetRunToBreakpoint(Memory::stDisassembleRecord* pBreakpoint) +{ + m_pRunToBreakpoint = pBreakpoint; +} + +void Memory::EnableBootromDMG(bool enable) +{ + m_bBootromDMGEnabled = enable; + + if (m_bBootromDMGEnabled) + { + Log("DMG Bootrom enabled"); + } + else + { + Log("DMG Bootrom disabled"); + } +} + +void Memory::EnableBootromGBC(bool enable) +{ + m_bBootromGBCEnabled = enable; + + if (m_bBootromGBCEnabled) + { + Log("GBC Bootrom enabled"); + } + else + { + Log("GBC Bootrom disabled"); + } +} + +void Memory::LoadBootromDMG(const char* szFilePath) +{ + Log("Loading DMG Bootrom %s...", szFilePath); + + LoadBootroom(szFilePath, false); +} + +void Memory::LoadBootromGBC(const char* szFilePath) +{ + Log("Loading GBC Bootrom %s...", szFilePath); + + LoadBootroom(szFilePath, true); +} + +bool Memory::IsBootromEnabled() +{ + return (m_bBootromDMGEnabled && m_bBootromDMGLoaded && !m_bCGB) || (m_bBootromGBCEnabled && m_bBootromGBCLoaded && m_bCGB); +} + +void Memory::DisableBootromRegistry() +{ + if (!m_bBootromRegistryDisabled && IsBootromEnabled()) + { + ResetBootromDisassembledMemory(); + } + + m_bBootromRegistryDisabled = true; +} + +bool Memory::IsBootromRegistryEnabled() +{ + return !m_bBootromRegistryDisabled; +} + +void Memory::ResetDisassembledMemory() +{ + #ifndef GEARBOY_DISABLE_DISASSEMBLER + + if (IsValidPointer(m_pDisassembledROMMap)) + { + for (int i = 0; i < MAX_ROM_SIZE; i++) + { + SafeDelete(m_pDisassembledROMMap[i]); + } + } + if (IsValidPointer(m_pDisassembledMap)) + { + for (int i = 0; i < 65536; i++) + { + SafeDelete(m_pDisassembledMap[i]); + } + } + + #endif +} + +void Memory::ResetBootromDisassembledMemory() +{ + #ifndef GEARBOY_DISABLE_DISASSEMBLER + + m_BreakpointsCPU.clear(); + + if (IsValidPointer(m_pDisassembledROMMap)) + { + for (int i = 0; i < 0x0100; i++) + { + SafeDelete(m_pDisassembledROMMap[i]); + } + } + if (IsValidPointer(m_pDisassembledMap)) + { + for (int i = 0; i < 0x0100; i++) + { + SafeDelete(m_pDisassembledMap[i]); + } + } + + if (m_bCGB) + { + if (IsValidPointer(m_pDisassembledROMMap)) + { + for (int i = 0x0200; i < 0x0900; i++) + { + SafeDelete(m_pDisassembledROMMap[i]); + } + } + if (IsValidPointer(m_pDisassembledMap)) + { + for (int i = 0x0200; i < 0x0900; i++) + { + SafeDelete(m_pDisassembledMap[i]); + } + } + } + + #endif +} + +void Memory::LoadBootroom(const char* szFilePath, bool gbc) +{ + using namespace std; + + int expectedSize = gbc ? 0x900 : 0x100; + u8* bootrom = gbc ? m_pBootromGBC : m_pBootromDMG; + + ifstream file(szFilePath, ios::in | ios::binary | ios::ate); + + bool ret = false; + + if (file.is_open()) + { + int size = static_cast<int> (file.tellg()); + + if (size == expectedSize) + { + file.seekg(0, ios::beg); + file.read(reinterpret_cast<char*>(bootrom), size); + file.close(); + + ret = true; + + Log("Bootrom %s loaded", szFilePath); + } + else + { + Log("Incompatible bootrom size (expected 0x%X): 0x%X", expectedSize, size); + } + } + else + { + Log("There was a problem opening the file %s", szFilePath); + } + + if (gbc) + m_bBootromGBCLoaded = ret; + else + m_bBootromDMGLoaded = ret; +} |