From 26318e2c51d48eeac113b3c44c4bb8a7834684cd Mon Sep 17 00:00:00 2001 From: "Admiral H. Curtiss" Date: Thu, 6 Oct 2022 01:10:46 +0200 Subject: [PATCH] HW: Move ExpansionInterface variables to Core::System. --- Source/Core/Core/HW/EXI/EXI.cpp | 88 +++++++++++++++++++++------------ Source/Core/Core/HW/EXI/EXI.h | 18 +++++++ Source/Core/Core/System.cpp | 7 +++ Source/Core/Core/System.h | 5 ++ 4 files changed, 87 insertions(+), 31 deletions(-) diff --git a/Source/Core/Core/HW/EXI/EXI.cpp b/Source/Core/Core/HW/EXI/EXI.cpp index 76d5356db1..461524a689 100644 --- a/Source/Core/Core/HW/EXI/EXI.cpp +++ b/Source/Core/Core/HW/EXI/EXI.cpp @@ -25,14 +25,23 @@ #include "DiscIO/Enums.h" -bool s_using_overridden_sram = false; - namespace ExpansionInterface { -static CoreTiming::EventType* changeDevice; -static CoreTiming::EventType* updateInterrupts; +struct ExpansionInterfaceState::Data +{ + CoreTiming::EventType* event_type_change_device; + CoreTiming::EventType* event_type_update_interrupts; -static std::array, MAX_EXI_CHANNELS> g_Channels; + std::array, MAX_EXI_CHANNELS> channels; + + bool using_overridden_sram = false; +}; + +ExpansionInterfaceState::ExpansionInterfaceState() : m_data(std::make_unique()) +{ +} + +ExpansionInterfaceState::~ExpansionInterfaceState() = default; static void ChangeDeviceCallback(u64 userdata, s64 cyclesLate); static void UpdateInterruptsCallback(u64 userdata, s64 cycles_late); @@ -67,7 +76,8 @@ void AddMemoryCard(Slot slot) memorycard_device = Config::Get(Config::GetInfoForEXIDevice(slot)); } - g_Channels[SlotToEXIChannel(slot)]->AddDevice(memorycard_device, SlotToEXIDevice(slot)); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + state.channels[SlotToEXIChannel(slot)]->AddDevice(memorycard_device, SlotToEXIDevice(slot)); } } // namespace @@ -105,16 +115,18 @@ u8 SlotToEXIDevice(Slot slot) void Init(const Sram* override_sram) { - auto& sram = Core::System::GetInstance().GetSRAM(); + auto& system = Core::System::GetInstance(); + auto& state = system.GetExpansionInterfaceState().GetData(); + auto& sram = system.GetSRAM(); if (override_sram) { sram = *override_sram; - s_using_overridden_sram = true; + state.using_overridden_sram = true; } else { InitSRAM(&sram, SConfig::GetInstance().m_strSRAM); - s_using_overridden_sram = false; + state.using_overridden_sram = false; } CEXIMemoryCard::Init(); @@ -137,60 +149,68 @@ void Init(const Sram* override_sram) Memcard::HeaderData header_data; Memcard::InitializeHeaderData(&header_data, flash_id, size_mbits, shift_jis, rtc_bias, sram_language, format_time + i); - g_Channels[i] = std::make_unique(i, header_data); + state.channels[i] = std::make_unique(i, header_data); } } for (Slot slot : MEMCARD_SLOTS) AddMemoryCard(slot); - g_Channels[0]->AddDevice(EXIDeviceType::MaskROM, 1); - g_Channels[SlotToEXIChannel(Slot::SP1)]->AddDevice(Config::Get(Config::MAIN_SERIAL_PORT_1), - SlotToEXIDevice(Slot::SP1)); - g_Channels[2]->AddDevice(EXIDeviceType::AD16, 0); + state.channels[0]->AddDevice(EXIDeviceType::MaskROM, 1); + state.channels[SlotToEXIChannel(Slot::SP1)]->AddDevice(Config::Get(Config::MAIN_SERIAL_PORT_1), + SlotToEXIDevice(Slot::SP1)); + state.channels[2]->AddDevice(EXIDeviceType::AD16, 0); - changeDevice = CoreTiming::RegisterEvent("ChangeEXIDevice", ChangeDeviceCallback); - updateInterrupts = CoreTiming::RegisterEvent("EXIUpdateInterrupts", UpdateInterruptsCallback); + state.event_type_change_device = + CoreTiming::RegisterEvent("ChangeEXIDevice", ChangeDeviceCallback); + state.event_type_update_interrupts = + CoreTiming::RegisterEvent("EXIUpdateInterrupts", UpdateInterruptsCallback); } void Shutdown() { - for (auto& channel : g_Channels) + auto& system = Core::System::GetInstance(); + auto& state = system.GetExpansionInterfaceState().GetData(); + + for (auto& channel : state.channels) channel.reset(); CEXIMemoryCard::Shutdown(); - if (!s_using_overridden_sram) + if (!state.using_overridden_sram) { File::IOFile file(SConfig::GetInstance().m_strSRAM, "wb"); - auto& sram = Core::System::GetInstance().GetSRAM(); + auto& sram = system.GetSRAM(); file.WriteArray(&sram, 1); } } void DoState(PointerWrap& p) { - for (auto& channel : g_Channels) + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + for (auto& channel : state.channels) channel->DoState(p); } void PauseAndLock(bool doLock, bool unpauseOnUnlock) { - for (auto& channel : g_Channels) + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + for (auto& channel : state.channels) channel->PauseAndLock(doLock, unpauseOnUnlock); } void RegisterMMIO(MMIO::Mapping* mmio, u32 base) { + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); for (int i = 0; i < MAX_EXI_CHANNELS; ++i) { - DEBUG_ASSERT(g_Channels[i] != nullptr); + DEBUG_ASSERT(state.channels[i] != nullptr); // Each channel has 5 32 bit registers assigned to it. We offset the // base that we give to each channel for registration. // // Be careful: this means the base is no longer aligned on a page // boundary and using "base | FOO" is not valid! - g_Channels[i]->RegisterMMIO(mmio, base + 5 * 4 * i); + state.channels[i]->RegisterMMIO(mmio, base + 5 * 4 * i); } } @@ -200,7 +220,8 @@ static void ChangeDeviceCallback(u64 userdata, s64 cyclesLate) u8 type = (u8)(userdata >> 16); u8 num = (u8)userdata; - g_Channels.at(channel)->AddDevice(static_cast(type), num); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + state.channels.at(channel)->AddDevice(static_cast(type), num); } void ChangeDevice(Slot slot, EXIDeviceType device_type, CoreTiming::FromThread from_thread) @@ -212,22 +233,25 @@ void ChangeDevice(u8 channel, u8 device_num, EXIDeviceType device_type, CoreTiming::FromThread from_thread) { // Let the hardware see no device for 1 second - CoreTiming::ScheduleEvent(0, changeDevice, + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + CoreTiming::ScheduleEvent(0, state.event_type_change_device, ((u64)channel << 32) | ((u64)EXIDeviceType::None << 16) | device_num, from_thread); - CoreTiming::ScheduleEvent(SystemTimers::GetTicksPerSecond(), changeDevice, + CoreTiming::ScheduleEvent(SystemTimers::GetTicksPerSecond(), state.event_type_change_device, ((u64)channel << 32) | ((u64)device_type << 16) | device_num, from_thread); } CEXIChannel* GetChannel(u32 index) { - return g_Channels.at(index).get(); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + return state.channels.at(index).get(); } IEXIDevice* GetDevice(Slot slot) { - return g_Channels.at(SlotToEXIChannel(slot))->GetDevice(1 << SlotToEXIDevice(slot)); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + return state.channels.at(SlotToEXIChannel(slot))->GetDevice(1 << SlotToEXIDevice(slot)); } void UpdateInterrupts() @@ -236,10 +260,11 @@ void UpdateInterrupts() // Channel 0 Device 0 generates interrupt on channel 0 // Channel 0 Device 2 generates interrupt on channel 2 // Channel 1 Device 0 generates interrupt on channel 1 - g_Channels[2]->SetEXIINT(g_Channels[0]->GetDevice(4)->IsInterruptSet()); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + state.channels[2]->SetEXIINT(state.channels[0]->GetDevice(4)->IsInterruptSet()); bool causeInt = false; - for (auto& channel : g_Channels) + for (auto& channel : state.channels) causeInt |= channel->IsCausingInterrupt(); ProcessorInterface::SetInterrupt(ProcessorInterface::INT_CAUSE_EXI, causeInt); @@ -252,7 +277,8 @@ static void UpdateInterruptsCallback(u64 userdata, s64 cycles_late) void ScheduleUpdateInterrupts(CoreTiming::FromThread from, int cycles_late) { - CoreTiming::ScheduleEvent(cycles_late, updateInterrupts, 0, from); + auto& state = Core::System::GetInstance().GetExpansionInterfaceState().GetData(); + CoreTiming::ScheduleEvent(cycles_late, state.event_type_update_interrupts, 0, from); } } // namespace ExpansionInterface diff --git a/Source/Core/Core/HW/EXI/EXI.h b/Source/Core/Core/HW/EXI/EXI.h index c18070f514..815029d796 100644 --- a/Source/Core/Core/HW/EXI/EXI.h +++ b/Source/Core/Core/HW/EXI/EXI.h @@ -4,6 +4,7 @@ #pragma once #include +#include #include "Common/CommonTypes.h" #include "Common/EnumFormatter.h" @@ -23,6 +24,23 @@ class Mapping; namespace ExpansionInterface { +class ExpansionInterfaceState +{ +public: + ExpansionInterfaceState(); + ExpansionInterfaceState(const ExpansionInterfaceState&) = delete; + ExpansionInterfaceState(ExpansionInterfaceState&&) = delete; + ExpansionInterfaceState& operator=(const ExpansionInterfaceState&) = delete; + ExpansionInterfaceState& operator=(ExpansionInterfaceState&&) = delete; + ~ExpansionInterfaceState(); + + struct Data; + Data& GetData() { return *m_data; } + +private: + std::unique_ptr m_data; +}; + class CEXIChannel; class IEXIDevice; enum class EXIDeviceType : int; diff --git a/Source/Core/Core/System.cpp b/Source/Core/Core/System.cpp index 313fa81b10..e88386b025 100644 --- a/Source/Core/Core/System.cpp +++ b/Source/Core/Core/System.cpp @@ -11,6 +11,7 @@ #include "Core/HW/DSP.h" #include "Core/HW/DVD/DVDInterface.h" #include "Core/HW/DVD/DVDThread.h" +#include "Core/HW/EXI/EXI.h" #include "Core/HW/Sram.h" #include "Core/HW/VideoInterface.h" @@ -26,6 +27,7 @@ struct System::Impl DSP::DSPState m_dsp_state; DVDInterface::DVDInterfaceState m_dvd_interface_state; DVDThread::DVDThreadState m_dvd_thread_state; + ExpansionInterface::ExpansionInterfaceState m_expansion_interface_state; Sram m_sram; VideoInterface::VideoInterfaceState m_video_interface_state; }; @@ -93,6 +95,11 @@ DVDThread::DVDThreadState& System::GetDVDThreadState() const return m_impl->m_dvd_thread_state; } +ExpansionInterface::ExpansionInterfaceState& System::GetExpansionInterfaceState() const +{ + return m_impl->m_expansion_interface_state; +} + Sram& System::GetSRAM() const { return m_impl->m_sram; diff --git a/Source/Core/Core/System.h b/Source/Core/Core/System.h index a4e313a8bd..f8b2f1ef5e 100644 --- a/Source/Core/Core/System.h +++ b/Source/Core/Core/System.h @@ -24,6 +24,10 @@ namespace DVDThread { class DVDThreadState; } +namespace ExpansionInterface +{ +class ExpansionInterfaceState; +}; namespace VideoInterface { class VideoInterfaceState; @@ -67,6 +71,7 @@ public: DSP::DSPState& GetDSPState() const; DVDInterface::DVDInterfaceState& GetDVDInterfaceState() const; DVDThread::DVDThreadState& GetDVDThreadState() const; + ExpansionInterface::ExpansionInterfaceState& GetExpansionInterfaceState() const; Sram& GetSRAM() const; VideoInterface::VideoInterfaceState& GetVideoInterfaceState() const;