diff --git a/src/backend/Core.cpp b/src/backend/Core.cpp index bf143e67..1882f977 100644 --- a/src/backend/Core.cpp +++ b/src/backend/Core.cpp @@ -58,7 +58,6 @@ void Core::Run(float volumeL, float volumeR) { MMIO& mmio = mem.mmio; Registers& regs = cpu->regs; - Event event; for (int field = 0; field < mmio.vi.numFields; field++) { u32 frameCycles = 0; for (int i = 0; i < mmio.vi.numHalflines; i++) { diff --git a/src/backend/core/Mem.cpp b/src/backend/core/Mem.cpp index 5324859b..c9bd48dc 100644 --- a/src/backend/core/Mem.cpp +++ b/src/backend/core/Mem.cpp @@ -5,6 +5,7 @@ #include #include #include +#include namespace n64 { Mem::Mem() : flash(saveData) { @@ -527,18 +528,14 @@ void Mem::Write64(Registers& regs, u32 paddr, u64 val) { } } -u32 Mem::BackupRead32(u32 addr) { +u32 Mem::BackupRead32() const { switch(saveType) { case SAVE_NONE: return 0; case SAVE_EEPROM_4k: case SAVE_EEPROM_16k: Util::warn("Accessing cartridge backup type SAVE_EEPROM, returning 0 for word read"); return 0; case SAVE_FLASH_1m: - if(flash.flash.is_mapped()) { - return flash.Read32(addr); - } else { - Util::panic("Invalid backup Read32 if save data is not initialized"); - } + return flash.Read32(); case SAVE_SRAM_256k: return 0xFFFFFFFF; default: @@ -553,11 +550,7 @@ void Mem::BackupWrite32(u32 addr, u32 val) { case SAVE_EEPROM_4k: case SAVE_EEPROM_16k: Util::panic("Accessing cartridge with save type SAVE_EEPROM in write word"); case SAVE_FLASH_1m: - if(flash.flash.is_mapped()) { - flash.Write32(addr, val); - } else { - Util::panic("Invalid backup Write32 if save data is not initialized"); - } + flash.Write32(addr, val); break; case SAVE_SRAM_256k: break; @@ -573,11 +566,7 @@ u8 Mem::BackupRead8(u32 addr) { Util::warn("Accessing cartridge backup type SAVE_EEPROM, returning 0 for word read"); return 0; case SAVE_FLASH_1m: - if(flash.flash.is_mapped()) { - return flash.Read8(addr); - } else { - Util::panic("Invalid backup Read8 if save data is not initialized"); - } + return flash.Read8(addr); case SAVE_SRAM_256k: if(saveData.is_mapped()) { assert(addr < saveData.size()); @@ -597,11 +586,7 @@ void Mem::BackupWrite8(u32 addr, u8 val) { case SAVE_EEPROM_4k: case SAVE_EEPROM_16k: Util::panic("Accessing cartridge with save type SAVE_EEPROM in write word"); case SAVE_FLASH_1m: - if(flash.flash.is_mapped()) { - flash.Write8(addr, val); - } else { - Util::panic("Invalid backup Write8 if save data is not initialized"); - } + flash.Write8(addr, val); break; case SAVE_SRAM_256k: if(saveData.is_mapped()) { diff --git a/src/backend/core/Mem.hpp b/src/backend/core/Mem.hpp index 0d7af78f..d97461a4 100644 --- a/src/backend/core/Mem.hpp +++ b/src/backend/core/Mem.hpp @@ -71,100 +71,12 @@ struct Flash { void CommandSetWriteOffs(u32); void CommandWrite(); void CommandRead(); - - FORCE_INLINE std::vector Serialize() { - std::vector res{}; - - res.resize( - sizeof(state) + - sizeof(status) + - sizeof(eraseOffs) + - sizeof(writeOffs) + - 128); - - u32 index = 0; - memcpy(res.data() + index, &state, sizeof(state)); - index += sizeof(state); - memcpy(res.data() + index, &status, sizeof(status)); - index += sizeof(status); - memcpy(res.data() + index, &eraseOffs, sizeof(eraseOffs)); - index += sizeof(eraseOffs); - memcpy(res.data() + index, &writeOffs, sizeof(writeOffs)); - index += sizeof(writeOffs); - memcpy(res.data() + index, writeBuf, 128); - - res.insert(res.begin(), flash.begin(), flash.end()); - - return res; - } - - FORCE_INLINE void Deserialize(const std::vector& data) { - u32 index = 0; - memcpy(&state, data.data() + index, sizeof(state)); - index += sizeof(state); - memcpy(&status, data.data() + index, sizeof(status)); - index += sizeof(status); - memcpy(&eraseOffs, data.data() + index, sizeof(eraseOffs)); - index += sizeof(eraseOffs); - memcpy(&writeOffs, data.data() + index, sizeof(writeOffs)); - index += sizeof(writeOffs); - memcpy(writeBuf, data.data() + index, 128); - } - - FORCE_INLINE void Write32(u32 index, u32 val) { - if(index > 0) { - u8 cmd = val >> 24; - switch(cmd) { - case FLASH_COMMAND_EXECUTE: CommandExecute(); break; - case FLASH_COMMAND_STATUS: CommandStatus(); break; - case FLASH_COMMAND_SET_ERASE_OFFSET: CommandSetEraseOffs(val); break; - case FLASH_COMMAND_ERASE: CommandErase(); break; - case FLASH_COMMAND_SET_WRITE_OFFSET: CommandSetWriteOffs(val); break; - case FLASH_COMMAND_WRITE: CommandWrite(); break; - case FLASH_COMMAND_READ: CommandRead(); break; - default: Util::warn("Invalid flash command: {:02X}", cmd); - } - } else { - status = val; - Util::warn("Write of {:08X} to flash status register", val); - } - } - - FORCE_INLINE void Write8(u32 index, u8 val) { - switch(state) { - case FlashState::Idle: Util::panic("Invalid FlashState::Idle with Write8"); - case FlashState::Status: Util::panic("Invalid FlashState::Status with Write8"); - case FlashState::Erase: Util::panic("Invalid FlashState::Erase with Write8"); - case FlashState::Write: - writeBuf[index] = val; - break; - case FlashState::Read: Util::panic("Invalid FlashState::Read with Write8"); - default: Util::warn("Invalid flash state on Write8: {:02X}", static_cast(state)); - } - } - - FORCE_INLINE u32 Read8(u32 index) const { - switch (state) { - case Idle: Util::panic("Flash read byte while in state FLASH_STATE_IDLE"); - case Write: Util::panic("Flash read byte while in state FLASH_STATE_WRITE"); - case Read: { - u8 value = flash[index]; - Util::debug("Flash read byte in state read: index {:08X} = {:02X}", index, value); - return value; - } - case Status: { - u32 offset = (7 - (index % 8)) * 8; - u8 value = (status >> offset) & 0xFF; - Util::debug("Flash read byte in state status: index {:08X} = {:02X}", index, value); - return value; - } - default: Util::panic("Flash read byte while in unknown state"); - } - } - - FORCE_INLINE u32 Read32(u32 index) const { - return status >> 32; - } + std::vector Serialize(); + void Deserialize(const std::vector& data); + void Write32(u32 index, u32 val); + void Write8(u32 index, u8 val); + u32 Read8(u32 index) const; + u32 Read32() const; }; struct Mem { @@ -191,7 +103,7 @@ struct Mem { void Write32(Registers&, u32, u32); void Write64(Registers&, u32, u64); - u32 BackupRead32(u32); + u32 BackupRead32() const; void BackupWrite32(u32, u32); u8 BackupRead8(u32); void BackupWrite8(u32, u8); diff --git a/src/backend/core/mem/Flash.cpp b/src/backend/core/mem/Flash.cpp index a95028ab..6d46804f 100644 --- a/src/backend/core/mem/Flash.cpp +++ b/src/backend/core/mem/Flash.cpp @@ -98,4 +98,99 @@ void Flash::CommandRead() { state = FlashState::Read; status = 0x11118004F0000000; } + +std::vector Flash::Serialize() { + std::vector res{}; + + res.resize( + sizeof(state) + + sizeof(status) + + sizeof(eraseOffs) + + sizeof(writeOffs) + + 128); + + u32 index = 0; + memcpy(res.data() + index, &state, sizeof(state)); + index += sizeof(state); + memcpy(res.data() + index, &status, sizeof(status)); + index += sizeof(status); + memcpy(res.data() + index, &eraseOffs, sizeof(eraseOffs)); + index += sizeof(eraseOffs); + memcpy(res.data() + index, &writeOffs, sizeof(writeOffs)); + index += sizeof(writeOffs); + memcpy(res.data() + index, writeBuf, 128); + + return res; +} + +void Flash::Deserialize(const std::vector& data) { + u32 index = 0; + memcpy(&state, data.data() + index, sizeof(state)); + index += sizeof(state); + memcpy(&status, data.data() + index, sizeof(status)); + index += sizeof(status); + memcpy(&eraseOffs, data.data() + index, sizeof(eraseOffs)); + index += sizeof(eraseOffs); + memcpy(&writeOffs, data.data() + index, sizeof(writeOffs)); + index += sizeof(writeOffs); + memcpy(writeBuf, data.data() + index, 128); +} + +void Flash::Write32(u32 index, u32 val) { + if(index > 0) { + u8 cmd = val >> 24; + switch(cmd) { + case FLASH_COMMAND_EXECUTE: CommandExecute(); break; + case FLASH_COMMAND_STATUS: CommandStatus(); break; + case FLASH_COMMAND_SET_ERASE_OFFSET: CommandSetEraseOffs(val); break; + case FLASH_COMMAND_ERASE: CommandErase(); break; + case FLASH_COMMAND_SET_WRITE_OFFSET: CommandSetWriteOffs(val); break; + case FLASH_COMMAND_WRITE: CommandWrite(); break; + case FLASH_COMMAND_READ: CommandRead(); break; + default: Util::warn("Invalid flash command: {:02X}", cmd); + } + } else { + Util::warn("Flash Write of {:08X} @ {:08X}", val, index); + } +} + +void Flash::Write8(u32 index, u8 val) { + switch(state) { + case FlashState::Idle: Util::panic("Invalid FlashState::Idle with Write8"); + case FlashState::Status: Util::panic("Invalid FlashState::Status with Write8"); + case FlashState::Erase: Util::panic("Invalid FlashState::Erase with Write8"); + case FlashState::Write: + writeBuf[index] = val; + break; + case FlashState::Read: Util::panic("Invalid FlashState::Read with Write8"); + default: Util::warn("Invalid flash state on Write8: {:02X}", static_cast(state)); + } +} + +u32 Flash::Read8(u32 index) const { + switch (state) { + case Idle: Util::panic("Flash read byte while in state FLASH_STATE_IDLE"); + case Write: Util::panic("Flash read byte while in state FLASH_STATE_WRITE"); + case Read: { + if(saveData.is_mapped()) { + u8 value = saveData[index]; + Util::debug("Flash read byte in state read: index {:08X} = {:02X}", index, value); + return value; + } else { + Util::panic("Accessing flash when not mapped!"); + } + } + case Status: { + u32 offset = (7 - (index % 8)) * 8; + u8 value = (status >> offset) & 0xFF; + Util::debug("Flash read byte in state status: index {:08X} = {:02X}", index, value); + return value; + } + default: Util::panic("Flash read byte while in unknown state"); + } +} + +u32 Flash::Read32() const { + return status >> 32; +} } \ No newline at end of file