From b7b4a265b7ade29b1d53c0ad7f6fec520a7e5155 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Tue, 20 Oct 2026 12:09:00 +0200 Subject: [PATCH] MMIO: Register hardware register blocks as devices The interpreter's MMIO dispatch was a hardcoded chain for GPIO and the syscon serial port. Devices now register an address range in Core/HW/MMIO and get each access with its width and the MIPSState making it, for registers that answer each CPU differently. An access no device handles is logged and reads as poison, as before. GPIO and syscon serial become the first two devices. They're reset at boot, which they never were, and saved in savestates (SaveStart section version 4). ll/sc, lwl/lwr and lwc1/swc1 reach MMIO in the interpreter too, and kernel blocks leave lwc1/swc1 to it like the other loads and stores. swl/swr and lv/sv still treat it as a bad address. TestMMIO runs a kernel-mode access on each core and the registers through a savestate. Co-Authored-By: Claude Opus 5.5 (1M context) --- Core/CMakeLists.txt | 2 + Core/Core.vcxproj | 2 + Core/Core.vcxproj.filters | 6 + Core/HW/GpioMMIO.cpp | 249 ++++++++++++++++++---------- Core/HW/GpioMMIO.h | 16 +- Core/HW/MMIO.cpp | 95 +++++++++++ Core/HW/MMIO.h | 64 +++++++ Core/MIPS/IR/IRCompFPU.cpp | 6 + Core/MIPS/Interpreter.cpp | 115 ++++--------- Core/SaveState.cpp | 8 +- Core/System.cpp | 3 + UWP/CoreUWP/CoreUWP.vcxproj | 2 + UWP/CoreUWP/CoreUWP.vcxproj.filters | 2 + android/jni/Android.mk | 1 + libretro/Makefile.common | 1 + unittest/JitHarness.cpp | 70 ++++++++ unittest/JitHarness.h | 1 + unittest/UnitTest.cpp | 1 + 18 files changed, 457 insertions(+), 187 deletions(-) create mode 100644 Core/HW/MMIO.cpp create mode 100644 Core/HW/MMIO.h diff --git a/Core/CMakeLists.txt b/Core/CMakeLists.txt index 1c9a19417f..a32134aefc 100644 --- a/Core/CMakeLists.txt +++ b/Core/CMakeLists.txt @@ -578,6 +578,8 @@ add_library(Core STATIC HW/Display.h HW/GpioMMIO.cpp HW/GpioMMIO.h + HW/MMIO.cpp + HW/MMIO.h HW/AvcDecoder.cpp HW/AvcDecoder.h HW/MediaEngine.cpp diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj index c413dd7ed7..37493b9955 100644 --- a/Core/Core.vcxproj +++ b/Core/Core.vcxproj @@ -493,6 +493,7 @@ + @@ -864,6 +865,7 @@ + diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters index 1ec7c1115c..468cdc841f 100644 --- a/Core/Core.vcxproj.filters +++ b/Core/Core.vcxproj.filters @@ -1171,6 +1171,9 @@ HW + + HW + HLE\Libraries @@ -2172,6 +2175,9 @@ HW + + HW + HLE\Libraries diff --git a/Core/HW/GpioMMIO.cpp b/Core/HW/GpioMMIO.cpp index 5f4349000d..c2568890c7 100644 --- a/Core/HW/GpioMMIO.cpp +++ b/Core/HW/GpioMMIO.cpp @@ -17,38 +17,73 @@ #include +#include "Common/Common.h" +#include "Common/Serialize/Serializer.h" +#include "Common/Serialize/SerializeFuncs.h" #include "Core/HW/GpioMMIO.h" +#include "Core/HW/MMIO.h" namespace GpioMMIO { namespace { -u32 g_regs[SIZE / 4]; - constexpr u32 REG_INTR_ACK = 0x024; +class GpioDevice : public MMIODevice { +public: + GpioDevice() : MMIODevice("GPIO", BASE_ADDRESS, SIZE) {} + + bool Read(MIPSState *mips, u32 offset, int size, u32 *value) override { + if (size != 4) + return false; + *value = regs_[offset / 4]; + return true; + } + + bool Write(MIPSState *mips, u32 offset, int size, u32 value) override { + if (size != 4) + return false; + if (offset == REG_INTR_ACK) { + // Acknowledging an interrupt clears the corresponding bit(s) in the triggered-status + // register, rather than storing the acknowledge value itself - matches uofw's usage + // (GpioAcquireIntr writes the same bit it's acknowledging) and JPCSP's + // acknowledgeInterrupt(). + regs_[REG_INTR_STATUS / 4] &= ~value; + return true; + } + regs_[offset / 4] = value; + return true; + } + + void Reset() override { + memset(regs_, 0, sizeof(regs_)); + } + + void DoState(PointerWrap &p) override { + auto s = p.Section("GpioMMIO", 1, 1); + if (!s) + return; + DoArray(p, regs_, ARRAY_SIZE(regs_)); + } + + void SetInterruptStatusBits(u32 bits) { + regs_[REG_INTR_STATUS / 4] |= bits; + } + +private: + u32 regs_[SIZE / 4]{}; +}; + +GpioDevice g_device; + } // namespace -u32 Read32(u32 address) { - u32 offset = address - BASE_ADDRESS; - return g_regs[offset / 4]; -} - -void Write32(u32 address, u32 value) { - u32 offset = address - BASE_ADDRESS; - if (offset == REG_INTR_ACK) { - // Acknowledging an interrupt clears the corresponding bit(s) in the triggered-status - // register, rather than storing the acknowledge value itself - matches uofw's usage - // (GpioAcquireIntr writes the same bit it's acknowledging) and JPCSP's - // acknowledgeInterrupt(). - g_regs[REG_INTR_STATUS / 4] &= ~value; - return; - } - g_regs[offset / 4] = value; +MMIODevice *Device() { + return &g_device; } void SetInterruptStatusBits(u32 bits) { - g_regs[REG_INTR_STATUS / 4] |= bits; + g_device.SetInterruptStatusBits(bits); } } // namespace GpioMMIO @@ -72,23 +107,103 @@ enum SysconCmd : u8 { // (including these first two), bytes 2.. = payload, byte [length] = checksum // (~sum(bytes[0..length-1]) & 0xFF). constexpr int DATA_SIZE = 16; -u8 g_data[DATA_SIZE]; -int g_dataIndex = 0; -int g_responseLen = 0; -bool g_dataExhausted = true; // AC_SUPPLY | WLAN_POWER | POWER_SWITCH - matches JPCSP's MMIOHandlerSyscon.getBaryonStatus(), // used as the RX status byte for every response (real hardware would report genuine baryon // status bits here; this is just a plausible constant since PPSSPP doesn't model those). constexpr u8 kBaryonStatus = 0x13; -// Persistent alarm value across sceSysconReadAlarm/WriteAlarm calls - mirrors JPCSP's -// sceSyscon.java readAlarm()/writeAlarm(), which are just as simple (a stored int, no real -// hardware backing). -u32 g_alarm = 0; +class SysconSerialDevice : public MMIODevice { +public: + SysconSerialDevice() : MMIODevice("syscon serial", BASE_ADDRESS, SIZE) {} -void ProcessCommand() { - u8 cmd = g_data[0]; + bool Read(MIPSState *mips, u32 offset, int size, u32 *value) override { + if (size != 4) + return false; + switch (offset) { + case 0x008: + { + *value = (data_[dataIndex_] << 8) | data_[dataIndex_ + 1]; + dataIndex_ += 2; + if (dataIndex_ > responseLen_) { + dataIndex_ = 0; + dataExhausted_ = true; + } + return true; + } + case 0x00C: + { + u32 flags = 1; // bit 0: no error. + if (!dataExhausted_) + flags |= 4; // bit 2: more response data available. + *value = flags; + return true; + } + default: + *value = 0; + return true; + } + } + + bool Write(MIPSState *mips, u32 offset, int size, u32 value) override { + if (size != 4) + return false; + switch (offset) { + case 0x004: + if (value & 4) { + dataIndex_ = 0; + } + if (value & 2) { + ProcessCommand(); + } + break; + case 0x008: + if (dataIndex_ + 1 < DATA_SIZE) { + data_[dataIndex_] = (value >> 8) & 0xFF; + data_[dataIndex_ + 1] = value & 0xFF; + } + dataIndex_ += 2; + break; + default: + break; + } + return true; + } + + void Reset() override { + memset(data_, 0, sizeof(data_)); + dataIndex_ = 0; + responseLen_ = 0; + dataExhausted_ = true; + alarm_ = 0; + } + + void DoState(PointerWrap &p) override { + auto s = p.Section("SysconSerialMMIO", 1, 1); + if (!s) + return; + DoArray(p, data_, DATA_SIZE); + Do(p, dataIndex_); + Do(p, responseLen_); + Do(p, dataExhausted_); + Do(p, alarm_); + } + +private: + void ProcessCommand(); + + u8 data_[DATA_SIZE]{}; + int dataIndex_ = 0; + int responseLen_ = 0; + bool dataExhausted_ = true; + // Persistent alarm value across sceSysconReadAlarm/WriteAlarm calls - mirrors JPCSP's + // sceSyscon.java readAlarm()/writeAlarm(), which are just as simple (a stored int, no real + // hardware backing). + u32 alarm_ = 0; +}; + +void SysconSerialDevice::ProcessCommand() { + u8 cmd = data_[0]; // Sub-status byte: must not be 0x80 or 0x81 (uofw's Syscon_cmd() treats those as // SYSCON_RES_80/81 and retries the whole command) - 0x82 is what JPCSP's own fallback @@ -103,89 +218,43 @@ void ProcessCommand() { payloadLen += 4; break; case CMD_READ_ALARM: - memcpy(&payload[payloadLen], &g_alarm, 4); + memcpy(&payload[payloadLen], &alarm_, 4); payloadLen += 4; break; case CMD_WRITE_CLOCK: // Not modeled - accept and ignore, same as JPCSP's writeClock(). break; case CMD_WRITE_ALARM: - memcpy(&g_alarm, &g_data[2], 4); + memcpy(&alarm_, &data_[2], 4); break; case CMD_NOP: default: break; } - g_data[0] = kBaryonStatus; - g_data[1] = (u8)(payloadLen + 2); - memcpy(&g_data[2], payload, payloadLen); + data_[0] = kBaryonStatus; + data_[1] = (u8)(payloadLen + 2); + memcpy(&data_[2], payload, payloadLen); u8 sum = 0; - for (int i = 0; i < g_data[1]; i++) - sum += g_data[i]; - g_data[g_data[1]] = (u8)~sum; + for (int i = 0; i < data_[1]; i++) + sum += data_[i]; + data_[data_[1]] = (u8)~sum; - g_dataIndex = 0; - g_responseLen = g_data[1]; - g_dataExhausted = false; + dataIndex_ = 0; + responseLen_ = data_[1]; + dataExhausted_ = false; // Signals "response ready" the way real hardware raising GPIO4 would - see // uofw's Syscon_cmd(), which polls exactly this bit after triggering a command. GpioMMIO::SetInterruptStatusBits(0x10); } +SysconSerialDevice g_device; + } // namespace -u32 Read32(u32 address) { - u32 offset = address - BASE_ADDRESS; - switch (offset) { - case 0x004: - return 0; - case 0x008: - { - u32 value = (g_data[g_dataIndex] << 8) | g_data[g_dataIndex + 1]; - g_dataIndex += 2; - if (g_dataIndex > g_responseLen) { - g_dataIndex = 0; - g_dataExhausted = true; - } - return value; - } - case 0x00C: - { - u32 flags = 1; // bit 0: no error. - if (!g_dataExhausted) - flags |= 4; // bit 2: more response data available. - return flags; - } - case 0x018: - return 0; - default: - return 0; - } -} - -void Write32(u32 address, u32 value) { - u32 offset = address - BASE_ADDRESS; - switch (offset) { - case 0x004: - if (value & 4) { - g_dataIndex = 0; - } - if (value & 2) { - ProcessCommand(); - } - break; - case 0x008: - if (g_dataIndex + 1 < DATA_SIZE) { - g_data[g_dataIndex] = (value >> 8) & 0xFF; - g_data[g_dataIndex + 1] = value & 0xFF; - } - g_dataIndex += 2; - break; - default: - break; - } +MMIODevice *Device() { + return &g_device; } } // namespace SysconSerialMMIO diff --git a/Core/HW/GpioMMIO.h b/Core/HW/GpioMMIO.h index 1b145b7da2..89a7c2ea75 100644 --- a/Core/HW/GpioMMIO.h +++ b/Core/HW/GpioMMIO.h @@ -48,6 +48,8 @@ #include "Common/CommonTypes.h" +class MMIODevice; + namespace GpioMMIO { constexpr u32 BASE_ADDRESS = 0xBE240000; @@ -58,12 +60,7 @@ constexpr u32 SIZE = 0x100; // line, is ever actually driven here since that's the only one this MMIO model needs). constexpr u32 REG_INTR_STATUS = 0x020; -inline bool IsGpioAddress(u32 address) { - return address >= BASE_ADDRESS && address < BASE_ADDRESS + SIZE; -} - -u32 Read32(u32 address); -void Write32(u32 address, u32 value); +MMIODevice *Device(); // Sets bits in the interrupt-triggered status register (offset 0x020) - used by // SysconSerialMMIO to signal "response ready" on GPIO pin 4 the same way real Syscon @@ -77,11 +74,6 @@ namespace SysconSerialMMIO { constexpr u32 BASE_ADDRESS = 0xBE580000; constexpr u32 SIZE = 0x100; -inline bool IsSysconSerialAddress(u32 address) { - return address >= BASE_ADDRESS && address < BASE_ADDRESS + SIZE; -} - -u32 Read32(u32 address); -void Write32(u32 address, u32 value); +MMIODevice *Device(); } // namespace SysconSerialMMIO diff --git a/Core/HW/MMIO.cpp b/Core/HW/MMIO.cpp new file mode 100644 index 0000000000..ffc3ba85f3 --- /dev/null +++ b/Core/HW/MMIO.cpp @@ -0,0 +1,95 @@ +// Copyright (c) 2012- PPSSPP Project. + +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include + +#include "Common/Log.h" +#include "Common/Serialize/Serializer.h" +#include "Core/Core.h" +#include "Core/HW/GpioMMIO.h" +#include "Core/HW/MMIO.h" +#include "Core/MemMap.h" +#include "Core/MIPS/MIPS.h" + +namespace MMIO { + +// Unhandled reads return a distinctive poison value (not 0) so it's obvious in a live trace when +// some later computation's input traces back to an unimplemented register, rather than looking +// like an ordinary, legitimate zero. +constexpr u32 UNKNOWN_MMIO_POISON = 0x1337BEEF; + +static std::vector g_devices; + +void Init() { + g_devices = { + GpioMMIO::Device(), + SysconSerialMMIO::Device(), + }; + for (MMIODevice *device : g_devices) { + device->Reset(); + } +} + +void Shutdown() { + g_devices.clear(); +} + +void DoState(PointerWrap &p) { + auto s = p.Section("MMIO", 1, 1); + if (!s) + return; + // Every device, whether or not this boot registered it, so the layout doesn't depend on that. + GpioMMIO::Device()->DoState(p); + SysconSerialMMIO::Device()->DoState(p); +} + +static MMIODevice *FindDevice(u32 address) { + for (MMIODevice *device : g_devices) { + if (device->Contains(address)) + return device; + } + return nullptr; +} + +static bool CheckKernelMode(MIPSState *mips, u32 address, int size, MemoryExceptionType type) { + if (Memory::IsKernelCodeAddress(mips->pc)) + return true; + Core_MemoryException(address, size, mips->pc, type, "Kernel mode only"); + return false; +} + +u32 Read(MIPSState *mips, u32 address, int size) { + if (!CheckKernelMode(mips, address, size, MemoryExceptionType::READ_WORD)) + return UNKNOWN_MMIO_POISON; + MMIODevice *device = FindDevice(address); + u32 value; + if (device && device->Read(mips, address - device->Base(), size, &value)) + return value; + WARN_LOG(Log::CPU, "Unhandled MMIO Read%d at %08x%s%s", size * 8, address, device ? " in " : "", device ? device->Name() : ""); + return UNKNOWN_MMIO_POISON; +} + +void Write(MIPSState *mips, u32 address, int size, u32 value) { + if (!CheckKernelMode(mips, address, size, MemoryExceptionType::WRITE_WORD)) + return; + MMIODevice *device = FindDevice(address); + if (device && device->Write(mips, address - device->Base(), size, value)) + return; + WARN_LOG(Log::CPU, "Unhandled MMIO Write%d at %08x = %08x%s%s", size * 8, address, value, device ? " in " : "", device ? device->Name() : ""); +} + +} // namespace MMIO diff --git a/Core/HW/MMIO.h b/Core/HW/MMIO.h new file mode 100644 index 0000000000..fba78d7275 --- /dev/null +++ b/Core/HW/MMIO.h @@ -0,0 +1,64 @@ +// Copyright (c) 2012- PPSSPP Project. + +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +// Memory-mapped hardware registers, for kernel code that pokes the hardware directly (the firmware +// modules the VSH boot runs). Each block of registers is a device covering an address range; the +// interpreter sends an access there (Memory::IsMMIOAccess) to the device, or logs it as unhandled. + +#pragma once + +#include "Common/CommonTypes.h" + +class MIPSState; +class PointerWrap; + +class MMIODevice { +public: + MMIODevice(const char *name, u32 base, u32 size) : name_(name), base_(base), size_(size) {} + virtual ~MMIODevice() {} + + // offset is from the base. size is 1, 2 or 4. The CPU doing the access is passed for registers + // that answer each CPU differently. Returns false for an access the device doesn't handle. + virtual bool Read(MIPSState *mips, u32 offset, int size, u32 *value) = 0; + virtual bool Write(MIPSState *mips, u32 offset, int size, u32 value) = 0; + // To the power-on state. + virtual void Reset() = 0; + virtual void DoState(PointerWrap &p) = 0; + + const char *Name() const { return name_; } + bool Contains(u32 address) const { return address - base_ < size_; } + u32 Base() const { return base_; } + +private: + const char *name_; + u32 base_; + u32 size_; +}; + +namespace MMIO { + +// Registers the devices, in their power-on state. +void Init(); +void Shutdown(); +void DoState(PointerWrap &p); + +// For an address Memory::IsMMIOAccess() accepts. size is 1, 2 or 4. An access no device handles is +// logged, and reads as poison. +u32 Read(MIPSState *mips, u32 address, int size); +void Write(MIPSState *mips, u32 address, int size, u32 value); + +} // namespace MMIO diff --git a/Core/MIPS/IR/IRCompFPU.cpp b/Core/MIPS/IR/IRCompFPU.cpp index df91c8fcdb..990ce8efb2 100644 --- a/Core/MIPS/IR/IRCompFPU.cpp +++ b/Core/MIPS/IR/IRCompFPU.cpp @@ -80,6 +80,12 @@ void IRFrontend::Comp_FPULS(MIPSOpcode op) { CheckMemoryBreakpoint(rs, offset); + if (js.kernelMode) { + // Kernel code may reach hardware registers (MMIO), which only the interpreter handles. + DISABLE; + return; + } + switch (op >> 26) { case 49: // lwc1 ir.Write(IROp::LoadFloat, ft, rs, 0, offset); diff --git a/Core/MIPS/Interpreter.cpp b/Core/MIPS/Interpreter.cpp index 3ae1232190..4779cc0de2 100644 --- a/Core/MIPS/Interpreter.cpp +++ b/Core/MIPS/Interpreter.cpp @@ -36,7 +36,7 @@ #include "Core/HLE/HLETables.h" #include "Core/HLE/ReplaceTables.h" #include "Core/HLE/sceKernelInterrupt.h" -#include "Core/HW/GpioMMIO.h" +#include "Core/HW/MMIO.h" #define R(i) (mips->r[i]) #define F(i) (mips->f[i]) @@ -99,78 +99,6 @@ int MIPS_InterpretSingleStep(MIPSState *mips) { return 1; } -// MMIO handling, for limited LLE, just enough for VSH. -// -// Unregistered reads return a distinctive poison value (not 0) so it's obvious in a live trace -// when some later computation's input traces back to an unimplemented MMIO register, rather -// than looking like an ordinary, legitimate zero. -constexpr u32 UNKNOWN_MMIO_POISON = 0x1337BEEF; - -static u8 ReadMMIO_U8(MIPSState *mips, u32 addr) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 1, mips->pc, MemoryExceptionType::READ_WORD, "Kernel mode only"); - return (u8)UNKNOWN_MMIO_POISON; - } - WARN_LOG(Log::CPU, "Unhandled MMIO Read8 at %08x", addr); - return (u8)UNKNOWN_MMIO_POISON; -} - -static u16 ReadMMIO_U16(MIPSState *mips, u32 addr) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 2, mips->pc, MemoryExceptionType::READ_WORD, "Kernel mode only"); - return (u16)UNKNOWN_MMIO_POISON; - } - WARN_LOG(Log::CPU, "Unhandled MMIO Read16 at %08x", addr); - return (u16)UNKNOWN_MMIO_POISON; -} - -static u32 ReadMMIO_U32(MIPSState *mips, u32 addr) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 4, mips->pc, MemoryExceptionType::READ_WORD, "Kernel mode only"); - return UNKNOWN_MMIO_POISON; - } - if (GpioMMIO::IsGpioAddress(addr)) { - return GpioMMIO::Read32(addr); - } - if (SysconSerialMMIO::IsSysconSerialAddress(addr)) { - return SysconSerialMMIO::Read32(addr); - } - WARN_LOG(Log::CPU, "Unhandled MMIO Read32 at %08x", addr); - return UNKNOWN_MMIO_POISON; -} - -void WriteMMIO_U8(MIPSState *mips, u32 addr, u8 value) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 1, mips->pc, MemoryExceptionType::WRITE_WORD, "Kernel mode only"); - return; - } - WARN_LOG(Log::CPU, "Unhandled MMIO Write8 at %08x = %02x", addr, value); -} - -void WriteMMIO_U16(MIPSState *mips, u32 addr, u16 value) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 2, mips->pc, MemoryExceptionType::WRITE_WORD, "Kernel mode only"); - return; - } - WARN_LOG(Log::CPU, "Unhandled MMIO Write16 at %08x = %04x", addr, value); -} - -void WriteMMIO_U32(MIPSState *mips, u32 addr, u32 value) { - if (!Memory::IsKernelCodeAddress(mips->pc)) { - Core_MemoryException(addr, 4, mips->pc, MemoryExceptionType::WRITE_WORD, "Kernel mode only"); - return; - } - if (GpioMMIO::IsGpioAddress(addr)) { - GpioMMIO::Write32(addr, value); - return; - } - if (SysconSerialMMIO::IsSysconSerialAddress(addr)) { - SysconSerialMMIO::Write32(addr, value); - return; - } - WARN_LOG(Log::CPU, "Unhandled MMIO Write32 at %08x = %08x", addr, value); -} - namespace MIPSInt { void Int_Cache(MIPSState *mips, MIPSOpcode op) { int imm = SignExtend16ToS32(op); @@ -427,8 +355,12 @@ namespace MIPSInt { case 48: // ll if (rt != 0) { if (!Memory::IsValid4AlignedAddress(addr)) { - Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "ll"); - R(rt) = 0; + if (Memory::IsMMIOAccess(addr)) { + R(rt) = MMIO::Read(mips, addr, 4); + } else { + Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "ll"); + R(rt) = 0; + } } else { R(rt) = Memory::ReadUnchecked_U32(addr); } @@ -438,7 +370,10 @@ namespace MIPSInt { case 56: // sc if (mips->llBit) { if (!Memory::IsValid4AlignedAddress(addr)) { - Core_MemoryException(addr, 4, PC, MemoryExceptionType::WRITE_WORD, "sc"); + if (Memory::IsMMIOAccess(addr)) + MMIO::Write(mips, addr, 4, R(rt)); + else + Core_MemoryException(addr, 4, PC, MemoryExceptionType::WRITE_WORD, "sc"); } else { Memory::WriteUnchecked_U32(R(rt), addr); } @@ -513,7 +448,7 @@ namespace MIPSInt { if (!Memory::IsValidAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a read from MMIO, so we can handle it. - R(rt) = SignExtend8ToU32(ReadMMIO_U8(mips, addr)); + R(rt) = SignExtend8ToU32(MMIO::Read(mips, addr, 1)); break; } Core_MemoryException(addr, 1, PC, MemoryExceptionType::READ_WORD, "lb"); @@ -526,7 +461,7 @@ namespace MIPSInt { if (!Memory::IsValid2AlignedAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a read from MMIO, so we can handle it. - R(rt) = SignExtend16ToU32(ReadMMIO_U16(mips, addr)); + R(rt) = SignExtend16ToU32(MMIO::Read(mips, addr, 2)); break; } Core_MemoryException(addr, 2, PC, MemoryExceptionType::READ_WORD, "lh"); @@ -539,7 +474,7 @@ namespace MIPSInt { if (!Memory::IsValid4AlignedAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a read from MMIO, so we can handle it. - R(rt) = ReadMMIO_U32(mips, addr); + R(rt) = MMIO::Read(mips, addr, 4); break; } Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "lw"); @@ -552,7 +487,7 @@ namespace MIPSInt { if (!Memory::IsValidAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a read from MMIO, so we can handle it. - R(rt) = ReadMMIO_U8(mips, addr); + R(rt) = MMIO::Read(mips, addr, 1); break; } Core_MemoryException(addr, 1, PC, MemoryExceptionType::READ_WORD, "lbu"); @@ -565,7 +500,7 @@ namespace MIPSInt { if (!Memory::IsValid2AlignedAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a read from MMIO, so we can handle it. - R(rt) = ReadMMIO_U16(mips, addr); + R(rt) = MMIO::Read(mips, addr, 2); break; } Core_MemoryException(addr, 2, PC, MemoryExceptionType::READ_WORD, "lhu"); @@ -578,7 +513,7 @@ namespace MIPSInt { if (!Memory::IsValidAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a write to MMIO, so we can handle it. - WriteMMIO_U8(mips, addr, (u8)(R(rt))); + MMIO::Write(mips, addr, 1, (u8)R(rt)); break; } Core_MemoryException(addr, 1, PC, MemoryExceptionType::WRITE_WORD, "sb"); @@ -590,7 +525,7 @@ namespace MIPSInt { if (!Memory::IsValid2AlignedAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a write to MMIO, so we can handle it. - WriteMMIO_U16(mips, addr, (u16)(R(rt))); + MMIO::Write(mips, addr, 2, (u16)R(rt)); break; } Core_MemoryException(addr, 2, PC, MemoryExceptionType::WRITE_WORD, "sh"); @@ -602,7 +537,7 @@ namespace MIPSInt { if (!Memory::IsValid4AlignedAddress(addr)) { if (Memory::IsMMIOAccess(addr)) { // This is a write to MMIO, so we can handle it. - WriteMMIO_U32(mips, addr, R(rt)); + MMIO::Write(mips, addr, 4, R(rt)); break; } Core_MemoryException(addr, 4, PC, MemoryExceptionType::WRITE_WORD, "sw"); @@ -619,6 +554,8 @@ namespace MIPSInt { u32 mem = 0; if (Memory::IsValidAddress(addr)) { mem = Memory::ReadUnchecked_U32(addr & 0xfffffffc); + } else if (Memory::IsMMIOAccess(addr)) { + mem = MMIO::Read(mips, addr & 0xfffffffc, 4); } else { Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "lwl"); } @@ -634,6 +571,8 @@ namespace MIPSInt { u32 mem = 0; if (Memory::IsValidAddress(addr)) { mem = Memory::ReadUnchecked_U32(addr & 0xfffffffc); + } else if (Memory::IsMMIOAccess(addr)) { + mem = MMIO::Read(mips, addr & 0xfffffffc, 4); } else { Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "lwr"); } @@ -688,6 +627,10 @@ namespace MIPSInt { switch (op >> 26) { case 49: if (!Memory::IsValid4AlignedAddress(addr)) { + if (Memory::IsMMIOAccess(addr)) { + FI(ft) = MMIO::Read(mips, addr, 4); + break; + } Core_MemoryException(addr, 4, PC, MemoryExceptionType::READ_WORD, "lwc1"); FI(ft) = 0; break; @@ -696,6 +639,10 @@ namespace MIPSInt { break; //lwc1 case 57: if (!Memory::IsValid4AlignedAddress(addr)) { + if (Memory::IsMMIOAccess(addr)) { + MMIO::Write(mips, addr, 4, FI(ft)); + break; + } Core_MemoryException(addr, 4, PC, MemoryExceptionType::WRITE_WORD, "swc1"); break; } diff --git a/Core/SaveState.cpp b/Core/SaveState.cpp index b19b7ccd99..57662ed013 100644 --- a/Core/SaveState.cpp +++ b/Core/SaveState.cpp @@ -64,6 +64,7 @@ #include "Core/MIPS/JitCommon/JitCommon.h" #include "Core/RetroAchievements.h" #include "HW/MemoryStick.h" +#include "Core/HW/MMIO.h" #ifndef MOBILE_DEVICE #include "Core/AVIDump.h" @@ -210,7 +211,7 @@ int g_screenshotFailures; if (gpu) gpu->FlushPendingDrawing(); - auto s = p.Section("SaveStart", 1, 3); + auto s = p.Section("SaveStart", 1, 4); if (!s) return; @@ -268,6 +269,11 @@ int g_screenshotFailures; Achievements::DoState(p); // Kernel object destructors might close open files, so do the filesystem last. pspFileSystem.DoState(p); + if (s >= 4) { + MMIO::DoState(p); + } else if (p.mode == p.MODE_READ) { + MMIO::Init(); + } if (p.mode == p.MODE_READ && p.error == PointerWrap::ERROR_FAILURE) { // RAM may be loaded and the JIT not told, or the other way round. Keep nothing. diff --git a/Core/System.cpp b/Core/System.cpp index c1f90a635b..1590da74b5 100644 --- a/Core/System.cpp +++ b/Core/System.cpp @@ -60,6 +60,7 @@ #include "Core/HLE/sceKernel.h" #include "Core/HLE/sceUtility.h" #include "Core/HW/Display.h" +#include "Core/HW/MMIO.h" #include "Core/Config.h" #include "Core/Core.h" #include "Core/Util/PathUtil.h" @@ -552,6 +553,7 @@ static bool CPU_Init(FileLoader *fileLoader, IdentifiedFileType type, std::strin mipsr4k.Reset(); CoreTiming::Init(&mipsr4k); + MMIO::Init(); DisplayHWInit(); @@ -676,6 +678,7 @@ void CPU_Shutdown(bool success) { Replacement_Shutdown(); CoreTiming::Shutdown(); + MMIO::Shutdown(); __KernelShutdown(); HLEShutdown(); diff --git a/UWP/CoreUWP/CoreUWP.vcxproj b/UWP/CoreUWP/CoreUWP.vcxproj index 4fafc73aac..cc57a3adcf 100644 --- a/UWP/CoreUWP/CoreUWP.vcxproj +++ b/UWP/CoreUWP/CoreUWP.vcxproj @@ -261,6 +261,7 @@ + @@ -556,6 +557,7 @@ + diff --git a/UWP/CoreUWP/CoreUWP.vcxproj.filters b/UWP/CoreUWP/CoreUWP.vcxproj.filters index bef5fe63c4..382b5f7d77 100644 --- a/UWP/CoreUWP/CoreUWP.vcxproj.filters +++ b/UWP/CoreUWP/CoreUWP.vcxproj.filters @@ -168,6 +168,7 @@ + @@ -584,6 +585,7 @@ + diff --git a/android/jni/Android.mk b/android/jni/Android.mk index c0dd81c0b8..d843963663 100644 --- a/android/jni/Android.mk +++ b/android/jni/Android.mk @@ -655,6 +655,7 @@ EXEC_AND_LIB_FILES := \ $(SRC)/Core/HW/Camera.cpp \ $(SRC)/Core/HW/Display.cpp \ $(SRC)/Core/HW/GpioMMIO.cpp \ + $(SRC)/Core/HW/MMIO.cpp \ $(SRC)/Core/HW/MemoryStick.cpp \ $(SRC)/Core/HW/MpegDemux.cpp.arm \ $(SRC)/Core/HW/AvcDecoder.cpp.arm \ diff --git a/libretro/Makefile.common b/libretro/Makefile.common index 8d58d198cd..ab5fc9171d 100644 --- a/libretro/Makefile.common +++ b/libretro/Makefile.common @@ -848,6 +848,7 @@ SOURCES_CXX += \ $(COREDIR)/HW/Camera.cpp \ $(COREDIR)/HW/Display.cpp \ $(COREDIR)/HW/GpioMMIO.cpp \ + $(COREDIR)/HW/MMIO.cpp \ $(COREDIR)/HW/SimpleAudioDec.cpp \ $(COREDIR)/HW/Atrac3Standalone.cpp \ $(COREDIR)/HW/AsyncIOManager.cpp \ diff --git a/unittest/JitHarness.cpp b/unittest/JitHarness.cpp index 4aa0d7af14..277bf0a0eb 100644 --- a/unittest/JitHarness.cpp +++ b/unittest/JitHarness.cpp @@ -44,8 +44,10 @@ #include "Core/Config.h" #include "Core/HLE/HLE.h" #include "Core/HLE/ReplaceTables.h" +#include "Core/HW/MMIO.h" #include "Core/MIPS/MIPSAnalyst.h" #include "Core/MIPS/JitCommon/JitState.h" +#include "Common/Serialize/Serializer.h" #if PPSSPP_ARCH(RISCV64) #include "Core/MIPS/RiscV/RiscVVfpuDot.h" #elif PPSSPP_ARCH(LOONGARCH64) @@ -510,6 +512,74 @@ bool TestCPUEret() { return success; } +// Kernel code reaching the GPIO block's registers on every core: a write, an acknowledge clearing a +// status bit, reads back through lw and lwc1, and poison from a register nothing handles. Then the +// registers through a savestate. +bool TestMMIO() { + SetupJitHarness(); + MMIO::Init(); + + // Kernel code, which may touch hardware registers. + const u32 base = 0x88000100; + auto sw = [](int rt, int rs, int imm) { return (0x2Bu << 26) | (rs << 21) | (rt << 16) | (imm & 0xFFFF); }; + auto lwc1 = [](int ft, int rs, int imm) { return (0x31u << 26) | (rs << 21) | (ft << 16) | (imm & 0xFFFF); }; + const u32 code[] = { + MIPS_MAKE_LUI(MIPS_REG_T0, 0xBE24), // GPIO + MIPS_MAKE_ORI(MIPS_REG_T1, MIPS_REG_ZERO, 0x30), + sw(MIPS_REG_T1, MIPS_REG_T0, 0x20), // Interrupt status. + MIPS_MAKE_ORI(MIPS_REG_T1, MIPS_REG_ZERO, 0x10), + sw(MIPS_REG_T1, MIPS_REG_T0, 0x24), // Acknowledge, clears the bit. + MIPS_MAKE_LW(MIPS_REG_V0, MIPS_REG_T0, 0x20), + lwc1(0, MIPS_REG_T0, 0x20), + MIPS_MAKE_LUI(MIPS_REG_T2, 0xBC10), + MIPS_MAKE_LW(MIPS_REG_V1, MIPS_REG_T2, 0), + MIPS_MAKE_SYSCALL("UnitTestFakeSyscalls", "UnitTestTerminator"), + MIPS_MAKE_BREAK(1), + }; + for (size_t i = 0; i < ARRAY_SIZE(code); ++i) + Memory::WriteUnchecked_U32(code[i], base + (u32)i * 4); + + static const CPUCore cores[] = { + CPUCore::INTERPRETER, + CPUCore::IR_INTERPRETER, + CPUCore::JIT, + }; + bool success = true; + for (CPUCore core : cores) { + mipsr4k.UpdateCore(core); + MMIO::Init(); + currentMIPS->r[MIPS_REG_V0] = 0; + currentMIPS->r[MIPS_REG_V1] = 0; + currentMIPS->fi[0] = 0; + currentMIPS->pc = base; + coreState = CORE_RUNNING_CPU; + while (coreState == CORE_RUNNING_CPU) + mipsr4k.RunLoopUntil(CoreTiming::GetTicks(currentMIPS) + 1000000); + + if (currentMIPS->r[MIPS_REG_V0] != 0x20 || currentMIPS->fi[0] != 0x20 || currentMIPS->r[MIPS_REG_V1] != 0x1337BEEF) { + printf("MMIO on core %d: v0=%08x f0=%08x v1=%08x, expected 00000020, 00000020, 1337beef\n", (int)core, + currentMIPS->r[MIPS_REG_V0], currentMIPS->fi[0], currentMIPS->r[MIPS_REG_V1]); + success = false; + } + } + mipsr4k.UpdateCore(CPUCore::INTERPRETER); + + struct MMIOState { + void DoState(PointerWrap &p) { MMIO::DoState(p); } + } state; + std::vector saved; + EXPECT_EQ_INT(CChunkFileReader::MeasureAndSavePtr(state, &saved), CChunkFileReader::ERROR_NONE); + MMIO::Init(); + std::string error; + EXPECT_EQ_INT(CChunkFileReader::LoadPtr(saved.data(), saved.size(), state, &error), CChunkFileReader::ERROR_NONE); + currentMIPS->pc = base; + EXPECT_EQ_HEX(MMIO::Read(currentMIPS, 0xBE240020, 4), 0x20); + + MMIO::Shutdown(); + DestroyJitHarness(); + return success; +} + // Differential fuzzing of the CPU cores. Random straight-line code (ALU, FPU, VFPU, loads and // stores) runs from a random register state on each core, and every core has to end up with the // interpreter's state, NaN payloads aside. diff --git a/unittest/JitHarness.h b/unittest/JitHarness.h index f17427396b..15df5a9b22 100644 --- a/unittest/JitHarness.h +++ b/unittest/JitHarness.h @@ -21,6 +21,7 @@ bool TestJit(); bool TestJitDotBench(); bool TestJitReplacementHooks(); bool TestCPUEret(); +bool TestMMIO(); bool TestCPUEquivalence(); bool TestCPURoundingMode(); bool TestVFPUDotJit(); diff --git a/unittest/UnitTest.cpp b/unittest/UnitTest.cpp index 050858e7ef..99fa1d92c3 100644 --- a/unittest/UnitTest.cpp +++ b/unittest/UnitTest.cpp @@ -3734,6 +3734,7 @@ TestItem availableTests[] = { TEST_ITEM(JitDotBench), TEST_ITEM(JitReplacementHooks), TEST_ITEM(CPUEret), + TEST_ITEM(MMIO), TEST_ITEM(CPUEquivalence), TEST_ITEM(CPURoundingMode), TEST_ITEM(VFPUDotJit),