From aca784eb582c0ff2465320a97807ee889591f190 Mon Sep 17 00:00:00 2001 From: SimoneN64 Date: Sat, 25 Nov 2023 22:00:54 +0100 Subject: [PATCH] minor refactor --- src/backend/core/Mem.cpp | 8 +- src/backend/core/mem/Flash.cpp | 8 +- src/backend/core/mmio/PI.cpp | 223 ++++++--------------------------- src/backend/core/mmio/PI.hpp | 2 +- 4 files changed, 46 insertions(+), 195 deletions(-) diff --git a/src/backend/core/Mem.cpp b/src/backend/core/Mem.cpp index 2abf1993..f6c4e191 100644 --- a/src/backend/core/Mem.cpp +++ b/src/backend/core/Mem.cpp @@ -528,7 +528,7 @@ void Mem::Write(Registers& regs, u32 paddr, u64 val) { } } -template <> u32 Mem::BackupRead(u32 addr) { +template <> u32 Mem::BackupRead(u32 addr) { switch(saveType) { case SAVE_NONE: return 0; case SAVE_EEPROM_4k: case SAVE_EEPROM_16k: @@ -543,7 +543,7 @@ template <> u32 Mem::BackupRead(u32 addr) { } } -template <> u8 Mem::BackupRead(u32 addr) { +template <> u8 Mem::BackupRead(u32 addr) { switch (saveType) { case SAVE_NONE: return 0; case SAVE_EEPROM_4k: case SAVE_EEPROM_16k: @@ -564,7 +564,7 @@ template <> u8 Mem::BackupRead(u32 addr) { } } -template <> void Mem::BackupWrite(u32 addr, u32 val) { +template <> void Mem::BackupWrite(u32 addr, u32 val) { switch(saveType) { case SAVE_NONE: Util::panic("Accessing cartridge with save type SAVE_NONE in write word"); @@ -580,7 +580,7 @@ template <> void Mem::BackupWrite(u32 addr, u32 val) { } } -template <> void Mem::BackupWrite(u32 addr, u8 val) { +template <> void Mem::BackupWrite(u32 addr, u8 val) { switch(saveType) { case SAVE_NONE: Util::panic("Accessing cartridge with save type SAVE_NONE in write word"); diff --git a/src/backend/core/mem/Flash.cpp b/src/backend/core/mem/Flash.cpp index 577057f6..8bc81f0c 100644 --- a/src/backend/core/mem/Flash.cpp +++ b/src/backend/core/mem/Flash.cpp @@ -136,7 +136,7 @@ void Flash::Deserialize(const std::vector& data) { memcpy(writeBuf, data.data() + index, 128); } -template <> void Flash::Write(u32 index, u32 val) { +template <> void Flash::Write(u32 index, u32 val) { if(index > 0) { u8 cmd = val >> 24; switch(cmd) { @@ -154,7 +154,7 @@ template <> void Flash::Write(u32 index, u32 val) { } } -template <> void Flash::Write(u32 index, u8 val) { +template <> void Flash::Write(u32 index, u8 val) { switch(state) { case FlashState::Idle: Util::panic("Invalid FlashState::Idle with Write"); case FlashState::Status: Util::panic("Invalid FlashState::Status with Write"); @@ -167,7 +167,7 @@ template <> void Flash::Write(u32 index, u8 val) { } } -template <> u8 Flash::Read(u32 index) const { +template <> u8 Flash::Read(u32 index) const { switch (state) { case FlashState::Idle: Util::panic("Flash read byte while in state FLASH_STATE_IDLE"); case FlashState::Write: Util::panic("Flash read byte while in state FLASH_STATE_WRITE"); @@ -190,7 +190,7 @@ template <> u8 Flash::Read(u32 index) const { } } -template <> u32 Flash::Read(u32 index) const { +template <> u32 Flash::Read(u32) const { return status >> 32; } } \ No newline at end of file diff --git a/src/backend/core/mmio/PI.cpp b/src/backend/core/mmio/PI.cpp index c4abc038..acf5077d 100644 --- a/src/backend/core/mmio/PI.cpp +++ b/src/backend/core/mmio/PI.cpp @@ -78,56 +78,26 @@ template<> auto PI::BusRead(Mem& mem, u32 addr) -> u8 { return latch >> 24; } - switch (addr) { - case REGION_PI_UNKNOWN: - Util::panic("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN - This is the N64DD, returning FF because it is not emulated", addr); - case REGION_PI_64DD_REG: - Util::panic("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_64DD_REG - This is the N64DD, returning FF because it is not emulated", addr); - case REGION_PI_64DD_ROM: - Util::warn("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM - This is the N64DD, returning FF because it is not emulated", addr); - return 0xFF; - case REGION_PI_SRAM: - return mem.BackupRead(addr - SREGION_PI_SRAM); - case REGION_PI_ROM: { - addr = (addr + 2) & ~2; - // round to nearest 4 byte boundary, keeping old LSB - u32 index = BYTE_ADDRESS(addr) - SREGION_PI_ROM; - if (index > mem.rom.size) { - Util::warn("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM! ({}/0x{:016X})", addr, index, index, mem.rom.size, mem.rom.size); - return 0xFF; - } - return mem.rom.cart[index]; - } - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } -} - -template<> void PI::BusWrite(Mem& mem, u32 addr, u8 val) { - int latch_shift = 24 - (addr & 1) * 8; - - if (!WriteLatch(val << latch_shift) && addr != 0x05000020) [[unlikely]] { - return; - } - switch (addr) { case REGION_PI_UNKNOWN: - Util::panic("Writing byte 0x{:02X} to address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN", val, addr); + Util::panic("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN - This is the N64DD, returning FF because it is not emulated", addr); case REGION_PI_64DD_REG: - if (addr == 0x05000020) { - fprintf(stderr, "%c", val); - } else { - Util::panic("Writing byte 0x{:02X} to address 0x{:08X} in region: REGION_PI_64DD_ROM, this is the 64DD, ignoring!", val, addr); - } - return; + Util::panic("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_64DD_REG - This is the N64DD, returning FF because it is not emulated", addr); case REGION_PI_64DD_ROM: - Util::panic("Writing byte 0x{:02X} to address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM", val, addr); + Util::warn("Reading byte from address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM - This is the N64DD, returning FF because it is not emulated", addr); + return 0xFF; case REGION_PI_SRAM: - mem.BackupWrite(addr - SREGION_PI_SRAM, val); - return; - case REGION_PI_ROM: - Util::warn("Writing byte 0x{:02X} to address 0x{:08X} in unsupported region: REGION_PI_ROM", val, addr); - return; + return mem.BackupRead(addr - SREGION_PI_SRAM); + case REGION_PI_ROM: { + addr = (addr + 2) & ~2; + // round to nearest 4 byte boundary, keeping old LSB + u32 index = BYTE_ADDRESS(addr) - SREGION_PI_ROM; + if (index > mem.rom.size) { + Util::warn("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM! ({}/0x{:016X})", addr, index, index, mem.rom.size, mem.rom.size); + return 0xFF; + } + return mem.rom.cart[index]; + } default: Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); } @@ -142,7 +112,7 @@ template<> void PI::BusWrite(Mem& mem, u32 addr, u8 val) { fprintf(stderr, "%c", val); } else { - Util::panic("Writing byte 0x{:02X} to address 0x{:08X} in region: REGION_PI_64DD_ROM, this is the 64DD, ignoring!", val, addr); + Util::warn("Writing byte 0x{:02X} to address 0x{:08X} in region: REGION_PI_64DD_ROM, this is the 64DD, ignoring!", val, addr); } return; case REGION_PI_64DD_ROM: @@ -158,6 +128,16 @@ template<> void PI::BusWrite(Mem& mem, u32 addr, u8 val) { } } +template<> void PI::BusWrite(Mem& mem, u32 addr, u8 val) { + int latch_shift = 24 - (addr & 1) * 8; + + if (!WriteLatch(val << latch_shift) && addr != 0x05000020) [[unlikely]] { + return; + } + + BusWrite(mem, addr, val); +} + template <> auto PI::BusRead(Mem& mem, u32 addr) -> u16 { if (!ReadLatch()) [[unlikely]] { return latch >> 16; @@ -186,25 +166,7 @@ template <> auto PI::BusRead(Mem& mem, u32 addr) -> u16 { } template <> auto PI::BusRead(Mem& mem, u32 addr) -> u16 { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::panic("Reading half from address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN - This is the N64DD, returning FF because it is not emulated", addr); - case REGION_PI_64DD_REG: - Util::panic("Reading half from address 0x{:08X} in unsupported region: REGION_PI_64DD_REG - This is the N64DD, returning FF because it is not emulated", addr); - case REGION_PI_64DD_ROM: - Util::panic("Reading half from address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM - This is the N64DD, returning FF because it is not emulated", addr); - case REGION_PI_SRAM: - Util::panic("Reading half from address 0x{:08X} in unsupported region: REGION_PI_SRAM", addr); - case REGION_PI_ROM: { - u32 index = HALF_ADDRESS(addr) - SREGION_PI_ROM; - if (index > mem.rom.size - 1) { - Util::panic("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM!", addr, index, index); - } - return Util::ReadAccess(mem.rom.cart, index); - } - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } + return BusRead(mem, addr); } template <> void PI::BusWrite(Mem&, u32 addr, u16 val) { @@ -229,22 +191,8 @@ template <> void PI::BusWrite(Mem&, u32 addr, u16 val) { } } -template <> void PI::BusWrite(Mem&, u32 addr, u16 val) { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::panic("Writing half 0x{:04X} to address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN", val, addr); - case REGION_PI_64DD_REG: - Util::panic("Writing half 0x{:04X} to address 0x{:08X} in region: REGION_PI_64DD_ROM, this is the 64DD, ignoring!", val, addr); - case REGION_PI_64DD_ROM: - Util::panic("Writing half 0x{:04X} to address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM", val, addr); - case REGION_PI_SRAM: - Util::panic("Writing half 0x{:04X} to address 0x{:08X} in unsupported region: REGION_PI_SRAM", val, addr); - case REGION_PI_ROM: - Util::warn("Writing half 0x{:04X} to address 0x{:08X} in unsupported region: REGION_PI_ROM", val, addr); - break; - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } +template <> void PI::BusWrite(Mem& mem, u32 addr, u16 val) { + BusWrite(mem, addr, val); } template <> auto PI::BusRead(Mem& mem, u32 addr) -> u32 { @@ -272,6 +220,8 @@ template <> auto PI::BusRead(Mem& mem, u32 addr) -> u32 { return htobe32(Util::ReadAccess(mem.isviewer, addr - SREGION_CART_ISVIEWER_BUFFER)); case CART_ISVIEWER_FLUSH: Util::panic("Read from ISViewer flush!"); + default: + Util::panic("Read from unknown address {:08X} in REGION_PI_ROM!", addr); } Util::warn("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM!", addr, index, index); return 0; @@ -285,37 +235,7 @@ template <> auto PI::BusRead(Mem& mem, u32 addr) -> u32 { } template <> auto PI::BusRead(Mem& mem, u32 addr) -> u32 { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::warn("Reading word from address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN - This is the N64DD, returning FF because it is not emulated", addr); - return 0xFF; - case REGION_PI_64DD_REG: - Util::warn("Reading word from address 0x{:08X} in unsupported region: REGION_PI_64DD_REG - This is the N64DD, returning FF because it is not emulated", addr); - return 0xFF; - case REGION_PI_64DD_ROM: - Util::warn("Reading word from address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM - This is the N64DD, returning FF because it is not emulated", addr); - return 0xFF; - case REGION_PI_SRAM: - return mem.BackupRead(addr); - case REGION_PI_ROM: { - u32 index = addr - SREGION_PI_ROM; - if (index > mem.rom.size - 3) { // -3 because we're reading an entire word - switch (addr) { - case REGION_CART_ISVIEWER_BUFFER: - return htobe32(Util::ReadAccess(mem.isviewer, addr - SREGION_CART_ISVIEWER_BUFFER)); - case CART_ISVIEWER_FLUSH: - Util::panic("Read from ISViewer flush!"); - } - Util::warn("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM!", addr, index, index); - return 0; - } - else { - return Util::ReadAccess(mem.rom.cart, index); - } - } - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } + return BusRead(mem, addr); } template <> void PI::BusWrite(Mem& mem, u32 addr, u32 val) { @@ -374,44 +294,7 @@ template <> void PI::BusWrite(Mem& mem, u32 addr, u32 val) { } template <> void PI::BusWrite(Mem& mem, u32 addr, u32 val) { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::warn("Writing word 0x{:08X} to address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN", val, addr); - return; - case REGION_PI_64DD_REG: - Util::warn("Writing word 0x{:08X} to address 0x{:08X} in region: REGION_PI_64DD_ROM, this is the 64DD, ignoring!", val, addr); - return; - case REGION_PI_64DD_ROM: - Util::warn("Writing word 0x{:08X} to address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM", val, addr); - return; - case REGION_PI_SRAM: - mem.BackupWrite(addr - SREGION_PI_SRAM, val); - return; - case REGION_PI_ROM: - switch (addr) { - case REGION_CART_ISVIEWER_BUFFER: - Util::WriteAccess(mem.isviewer, addr - SREGION_CART_ISVIEWER_BUFFER, be32toh(val)); - break; - case CART_ISVIEWER_FLUSH: { - if (val < CART_ISVIEWER_SIZE) { - char* message = (char*)malloc(val + 1); - memcpy(message, mem.isviewer, val); - message[val] = '\0'; - printf("%s", message); - free(message); - } - else { - Util::panic("ISViewer buffer size is emulated at {} bytes, but received a flush command for {} bytes!", CART_ISVIEWER_SIZE, val); - } - break; - } - default: - Util::warn("Writing word 0x{:08X} to address 0x{:08X} in unsupported region: REGION_PI_ROM", val, addr); - } - return; - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } + BusWrite(mem, addr, val); } template <> auto PI::BusRead(Mem& mem, u32 addr) -> u64 { @@ -441,28 +324,10 @@ template <> auto PI::BusRead(Mem& mem, u32 addr) -> u64 { } template <> auto PI::BusRead(Mem& mem, u32 addr) -> u64 { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::panic("Reading dword from address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN", addr); - case REGION_PI_64DD_REG: - Util::panic("Reading dword from address 0x{:08X} in unsupported region: REGION_PI_64DD_REG", addr); - case REGION_PI_64DD_ROM: - Util::panic("Reading dword from address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM", addr); - case REGION_PI_SRAM: - Util::panic("Reading dword from address 0x{:08X} in unsupported region: REGION_PI_SRAM", addr); - case REGION_PI_ROM: { - u32 index = addr - SREGION_PI_ROM; - if (index > mem.rom.size - 7) { // -7 because we're reading an entire dword - Util::panic("Address 0x{:08X} accessed an index {}/0x{:X} outside the bounds of the ROM!", addr, index, index); - } - return Util::ReadAccess(mem.rom.cart, index); - } - default: - Util::panic("Should never end up here! Access to address {:08X} which did not match any PI bus regions!", addr); - } + return BusRead(mem, addr); } -template <> void PI::BusWrite(Mem& mem, u32 addr, u64 val) { +template <> void PI::BusWrite(Mem&, u32 addr, u64 val) { if (!WriteLatch(val >> 32)) [[unlikely]] { return; } @@ -485,21 +350,7 @@ template <> void PI::BusWrite(Mem& mem, u32 addr, u64 val) { } template <> void PI::BusWrite(Mem& mem, u32 addr, u64 val) { - switch (addr) { - case REGION_PI_UNKNOWN: - Util::panic("Writing dword 0x{:016X} to address 0x{:08X} in unsupported region: REGION_PI_UNKNOWN", val, addr); - case REGION_PI_64DD_REG: - Util::panic("Writing dword 0x{:016X} to address 0x{:08X} in unsupported region: REGION_PI_64DD_REG", val, addr); - case REGION_PI_64DD_ROM: - Util::panic("Writing dword 0x{:016X} to address 0x{:08X} in unsupported region: REGION_PI_64DD_ROM", val, addr); - case REGION_PI_SRAM: - Util::panic("Writing dword 0x{:016X} to address 0x{:08X} in unsupported region: REGION_PI_SRAM", val, addr); - case REGION_PI_ROM: - Util::warn("Writing dword 0x{:016X} to address 0x{:08X} in unsupported region: REGION_PI_ROM", val, addr); - break; - default: - Util::panic("Should never end up here! Access to address %08X which did not match any PI bus regions!", addr); - } + BusWrite(mem, addr, val); } auto PI::Read(MI& mi, u32 addr) const -> u32 { @@ -543,7 +394,7 @@ u8 PI::GetDomain(u32 address) { } } -u32 PI::AccessTiming(u8 domain, u32 length) { +u32 PI::AccessTiming(u8 domain, u32 length) const { uint32_t cycles = 0; uint32_t latency = 0; uint32_t pulse_width = 0; diff --git a/src/backend/core/mmio/PI.hpp b/src/backend/core/mmio/PI.hpp index 4baa32b0..8440a4fe 100644 --- a/src/backend/core/mmio/PI.hpp +++ b/src/backend/core/mmio/PI.hpp @@ -20,7 +20,7 @@ struct PI { bool WriteLatch(u32 val); static u8 GetDomain(u32 address); - u32 AccessTiming(u8 domain, u32 length); + u32 AccessTiming(u8 domain, u32 length) const; bool dmaBusy{}, ioBusy{}, toCart{}; u32 latch; u32 dramAddr{}, cartAddr{}, dramAddrInternal{}, cartAddrInternal{};