iris/kaizen
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

general clean-up

Browse Source
This commit is contained in:
SimoneN64
2023-11-07 22:53:56 +01:00
parent 7cceefd7fc
commit 2a77c1ab25
4 changed files with 108 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/backend/Core.cpp
View File

@@ -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++) {

27
src/backend/core/Mem.cpp
View File

@@ -5,6 +5,7 @@
#include <backend/RomHelpers.hpp>
#include <File.hpp>
#include <unarr.h>
#include <cassert>
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()) {

102
src/backend/core/Mem.hpp
View File

@@ -71,100 +71,12 @@ struct Flash {
void CommandSetWriteOffs(u32);
void CommandWrite();
void CommandRead();
FORCE_INLINE std::vector<u8> Serialize() {
std::vector<u8> 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<u8>& 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<u8>(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<u8> Serialize();
void Deserialize(const std::vector<u8>& 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);

95
src/backend/core/mem/Flash.cpp
View File

@@ -98,4 +98,99 @@ void Flash::CommandRead() {
state = FlashState::Read;
status = 0x11118004F0000000;
}
std::vector<u8> Flash::Serialize() {
std::vector<u8> 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<u8>& 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<u8>(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;
}
}