HW/EXI: Pass System to IEXIDevice.

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -44,10 +44,10 @@
 
 namespace
 {
-void PresetTimeBaseTicks(const Core::CPUThreadGuard& guard)
+void PresetTimeBaseTicks(Core::System& system, const Core::CPUThreadGuard& guard)
 {
   const u64 emulated_time =
-      ExpansionInterface::CEXIIPL::GetEmulatedTime(ExpansionInterface::CEXIIPL::GC_EPOCH);
+      ExpansionInterface::CEXIIPL::GetEmulatedTime(system, ExpansionInterface::CEXIIPL::GC_EPOCH);
 
   const u64 time_base_ticks = emulated_time * 40500000ULL;
 
@@ -248,7 +248,7 @@ void CBoot::SetupGCMemory(Core::System& system, const Core::CPUThreadGuard& guar
   PowerPC::HostWrite_U32(guard, 0x4c000064, 0x80000800);  // Write default FPU Handler:     rfi
   PowerPC::HostWrite_U32(guard, 0x4c000064, 0x80000C00);  // Write default Syscall Handler: rfi
 
-  PresetTimeBaseTicks(guard);
+  PresetTimeBaseTicks(system, guard);
 
   // HIO checks this
   // PowerPC::HostWrite_U16(0x8200, 0x000030e6);   // Console type

Source/Core/Core/HW/EXI/EXI.cpp

@@ -149,7 +149,7 @@ 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);
-      state.channels[i] = std::make_unique<CEXIChannel>(i, header_data);
+      state.channels[i] = std::make_unique<CEXIChannel>(system, i, header_data);
     }
   }
 

Source/Core/Core/HW/EXI/EXI_Channel.cpp

@@ -25,8 +25,9 @@ enum
   EXI_READWRITE
 };
 
-CEXIChannel::CEXIChannel(u32 channel_id, const Memcard::HeaderData& memcard_header_data)
+CEXIChannel::CEXIChannel(Core::System& system, u32 channel_id,
-    : m_channel_id(channel_id), m_memcard_header_data(memcard_header_data)
+                         const Memcard::HeaderData& memcard_header_data)
+    : m_system(system), m_channel_id(channel_id), m_memcard_header_data(memcard_header_data)
 {
   if (m_channel_id == 0 || m_channel_id == 1)
     m_status.EXTINT = 1;
@@ -34,7 +35,7 @@ CEXIChannel::CEXIChannel(u32 channel_id, const Memcard::HeaderData& memcard_head
     m_status.CHIP_SELECT = 1;
 
   for (auto& device : m_devices)
-    device = EXIDevice_Create(EXIDeviceType::None, m_channel_id, m_memcard_header_data);
+    device = EXIDevice_Create(system, EXIDeviceType::None, m_channel_id, m_memcard_header_data);
 }
 
 CEXIChannel::~CEXIChannel()
@@ -170,7 +171,8 @@ void CEXIChannel::RemoveDevices()
 
 void CEXIChannel::AddDevice(const EXIDeviceType device_type, const int device_num)
 {
-  AddDevice(EXIDevice_Create(device_type, m_channel_id, m_memcard_header_data), device_num);
+  AddDevice(EXIDevice_Create(m_system, device_type, m_channel_id, m_memcard_header_data),
+            device_num);
 }
 
 void CEXIChannel::AddDevice(std::unique_ptr<IEXIDevice> device, const int device_num,
@@ -255,7 +257,7 @@ void CEXIChannel::DoState(PointerWrap& p)
     else
     {
       std::unique_ptr<IEXIDevice> save_device =
-          EXIDevice_Create(type, m_channel_id, m_memcard_header_data);
+          EXIDevice_Create(m_system, type, m_channel_id, m_memcard_header_data);
       save_device->DoState(p);
       AddDevice(std::move(save_device), device_index, false);
     }

Source/Core/Core/HW/EXI/EXI_Channel.h

@@ -25,7 +25,8 @@ enum class EXIDeviceType : int;
 class CEXIChannel
 {
 public:
-  explicit CEXIChannel(u32 channel_id, const Memcard::HeaderData& memcard_header_data);
+  explicit CEXIChannel(Core::System& system, u32 channel_id,
+                       const Memcard::HeaderData& memcard_header_data);
   ~CEXIChannel();
 
   // get device
@@ -100,6 +101,8 @@ private:
     };
   };
 
+  Core::System& m_system;
+
   // STATE_TO_SAVE
   UEXI_STATUS m_status;
   u32 m_dma_memory_address = 0;

Source/Core/Core/HW/EXI/EXI_Device.cpp

@@ -19,6 +19,10 @@
 
 namespace ExpansionInterface
 {
+IEXIDevice::IEXIDevice(Core::System& system) : m_system(system)
+{
+}
+
 void IEXIDevice::ImmWrite(u32 data, u32 size)
 {
   while (size--)
@@ -48,8 +52,7 @@ void IEXIDevice::ImmReadWrite(u32& data, u32 size)
 
 void IEXIDevice::DMAWrite(u32 address, u32 size)
 {
-  auto& system = Core::System::GetInstance();
+  auto& memory = m_system.GetMemory();
-  auto& memory = system.GetMemory();
   while (size--)
   {
     u8 byte = memory.Read_U8(address++);
@@ -59,8 +62,7 @@ void IEXIDevice::DMAWrite(u32 address, u32 size)
 
 void IEXIDevice::DMARead(u32 address, u32 size)
 {
-  auto& system = Core::System::GetInstance();
+  auto& memory = m_system.GetMemory();
-  auto& memory = system.GetMemory();
   while (size--)
   {
     u8 byte = 0;
@@ -101,7 +103,8 @@ void IEXIDevice::TransferByte(u8& byte)
 }
 
 // F A C T O R Y
-std::unique_ptr<IEXIDevice> EXIDevice_Create(const EXIDeviceType device_type, const int channel_num,
+std::unique_ptr<IEXIDevice> EXIDevice_Create(Core::System& system, const EXIDeviceType device_type,
+                                             const int channel_num,
                                              const Memcard::HeaderData& memcard_header_data)
 {
   std::unique_ptr<IEXIDevice> result;
@@ -112,58 +115,58 @@ std::unique_ptr<IEXIDevice> EXIDevice_Create(const EXIDeviceType device_type, co
   switch (device_type)
   {
   case EXIDeviceType::Dummy:
-    result = std::make_unique<CEXIDummy>("Dummy");
+    result = std::make_unique<CEXIDummy>(system, "Dummy");
     break;
 
   case EXIDeviceType::MemoryCard:
   case EXIDeviceType::MemoryCardFolder:
   {
     bool gci_folder = (device_type == EXIDeviceType::MemoryCardFolder);
-    result = std::make_unique<CEXIMemoryCard>(slot, gci_folder, memcard_header_data);
+    result = std::make_unique<CEXIMemoryCard>(system, slot, gci_folder, memcard_header_data);
     break;
   }
   case EXIDeviceType::MaskROM:
-    result = std::make_unique<CEXIIPL>();
+    result = std::make_unique<CEXIIPL>(system);
     break;
 
   case EXIDeviceType::AD16:
-    result = std::make_unique<CEXIAD16>();
+    result = std::make_unique<CEXIAD16>(system);
     break;
 
   case EXIDeviceType::Microphone:
-    result = std::make_unique<CEXIMic>(channel_num);
+    result = std::make_unique<CEXIMic>(system, channel_num);
     break;
 
   case EXIDeviceType::Ethernet:
-    result = std::make_unique<CEXIETHERNET>(BBADeviceType::TAP);
+    result = std::make_unique<CEXIETHERNET>(system, BBADeviceType::TAP);
     break;
 
 #if defined(__APPLE__)
   case EXIDeviceType::EthernetTapServer:
-    result = std::make_unique<CEXIETHERNET>(BBADeviceType::TAPSERVER);
+    result = std::make_unique<CEXIETHERNET>(system, BBADeviceType::TAPSERVER);
     break;
 #endif
 
   case EXIDeviceType::EthernetXLink:
-    result = std::make_unique<CEXIETHERNET>(BBADeviceType::XLINK);
+    result = std::make_unique<CEXIETHERNET>(system, BBADeviceType::XLINK);
     break;
 
   case EXIDeviceType::EthernetBuiltIn:
-    result = std::make_unique<CEXIETHERNET>(BBADeviceType::BuiltIn);
+    result = std::make_unique<CEXIETHERNET>(system, BBADeviceType::BuiltIn);
     break;
 
   case EXIDeviceType::Gecko:
-    result = std::make_unique<CEXIGecko>();
+    result = std::make_unique<CEXIGecko>(system);
     break;
 
   case EXIDeviceType::AGP:
-    result = std::make_unique<CEXIAgp>(slot);
+    result = std::make_unique<CEXIAgp>(system, slot);
     break;
 
   case EXIDeviceType::AMBaseboard:
   case EXIDeviceType::None:
   default:
-    result = std::make_unique<IEXIDevice>();
+    result = std::make_unique<IEXIDevice>(system);
     break;
   }
 

Source/Core/Core/HW/EXI/EXI_Device.h

@@ -11,6 +11,10 @@
 
 class PointerWrap;
 
+namespace Core
+{
+class System;
+}
 namespace Memcard
 {
 struct HeaderData;
@@ -44,6 +48,7 @@ enum class EXIDeviceType : int
 class IEXIDevice
 {
 public:
+  explicit IEXIDevice(Core::System& system);
   virtual ~IEXIDevice() = default;
 
   // Immediate copy functions
@@ -69,12 +74,16 @@ public:
   // such.
   EXIDeviceType m_device_type = EXIDeviceType::None;
 
+protected:
+  Core::System& m_system;
+
 private:
   // Byte transfer function for this device
   virtual void TransferByte(u8& byte);
 };
 
-std::unique_ptr<IEXIDevice> EXIDevice_Create(EXIDeviceType device_type, int channel_num,
+std::unique_ptr<IEXIDevice> EXIDevice_Create(Core::System& system, EXIDeviceType device_type,
+                                             int channel_num,
                                              const Memcard::HeaderData& memcard_header_data);
 }  // namespace ExpansionInterface
 

Source/Core/Core/HW/EXI/EXI_DeviceAD16.cpp

@@ -9,7 +9,9 @@
 
 namespace ExpansionInterface
 {
-CEXIAD16::CEXIAD16() = default;
+CEXIAD16::CEXIAD16(Core::System& system) : IEXIDevice(system)
+{
+}
 
 void CEXIAD16::SetCS(int cs)
 {

Source/Core/Core/HW/EXI/EXI_DeviceAD16.h

@@ -12,7 +12,7 @@ namespace ExpansionInterface
 class CEXIAD16 : public IEXIDevice
 {
 public:
-  CEXIAD16();
+  explicit CEXIAD16(Core::System& system);
   void SetCS(int cs) override;
   bool IsPresent() const override;
   void DoState(PointerWrap& p) override;

Source/Core/Core/HW/EXI/EXI_DeviceAGP.cpp

@@ -19,7 +19,7 @@
 
 namespace ExpansionInterface
 {
-CEXIAgp::CEXIAgp(Slot slot)
+CEXIAgp::CEXIAgp(Core::System& system, Slot slot) : IEXIDevice(system)
 {
   ASSERT(IsMemcardSlot(slot));
   m_slot = slot;

Source/Core/Core/HW/EXI/EXI_DeviceAGP.h

@@ -17,7 +17,7 @@ enum class Slot : int;
 class CEXIAgp : public IEXIDevice
 {
 public:
-  CEXIAgp(const Slot slot);
+  CEXIAgp(Core::System& system, const Slot slot);
   virtual ~CEXIAgp() override;
   bool IsPresent() const override { return true; }
   void ImmWrite(u32 _uData, u32 _uSize) override;

Source/Core/Core/HW/EXI/EXI_DeviceDummy.cpp

@@ -10,7 +10,8 @@
 
 namespace ExpansionInterface
 {
-CEXIDummy::CEXIDummy(const std::string& name) : m_name{name}
+CEXIDummy::CEXIDummy(Core::System& system, const std::string& name)
+    : IEXIDevice(system), m_name{name}
 {
 }
 

Source/Core/Core/HW/EXI/EXI_DeviceDummy.h

@@ -16,7 +16,7 @@ namespace ExpansionInterface
 class CEXIDummy final : public IEXIDevice
 {
 public:
-  explicit CEXIDummy(const std::string& name);
+  CEXIDummy(Core::System& system, const std::string& name);
 
   void ImmWrite(u32 data, u32 size) override;
   u32 ImmRead(u32 size) override;

Source/Core/Core/HW/EXI/EXI_DeviceEthernet.cpp

@@ -27,7 +27,7 @@ namespace ExpansionInterface
 // Multiple parts of this implementation depend on Dolphin
 // being compiled for a little endian host.
 
-CEXIETHERNET::CEXIETHERNET(BBADeviceType type)
+CEXIETHERNET::CEXIETHERNET(Core::System& system, BBADeviceType type) : IEXIDevice(system)
 {
   // Parse MAC address from config, and generate a new one if it doesn't
   // exist or can't be parsed.
@@ -233,8 +233,7 @@ void CEXIETHERNET::DMAWrite(u32 addr, u32 size)
   if (transfer.region == transfer.MX && transfer.direction == transfer.WRITE &&
       transfer.address == BBA_WRTXFIFOD)
   {
-    auto& system = Core::System::GetInstance();
+    auto& memory = m_system.GetMemory();
-    auto& memory = system.GetMemory();
     DirectFIFOWrite(memory.GetPointer(addr), size);
   }
   else
@@ -248,8 +247,7 @@ void CEXIETHERNET::DMAWrite(u32 addr, u32 size)
 void CEXIETHERNET::DMARead(u32 addr, u32 size)
 {
   DEBUG_LOG_FMT(SP1, "DMA read: {:08x} {:x}", addr, size);
-  auto& system = Core::System::GetInstance();
+  auto& memory = m_system.GetMemory();
-  auto& memory = system.GetMemory();
   memory.CopyToEmu(addr, &mBbaMem[transfer.address], size);
   transfer.address += size;
 }

Source/Core/Core/HW/EXI/EXI_DeviceEthernet.h

@@ -214,7 +214,7 @@ enum class BBADeviceType
 class CEXIETHERNET : public IEXIDevice
 {
 public:
-  explicit CEXIETHERNET(BBADeviceType type);
+  CEXIETHERNET(Core::System& system, BBADeviceType type);
   virtual ~CEXIETHERNET();
   void SetCS(int cs) override;
   bool IsPresent() const override;

Source/Core/Core/HW/EXI/EXI_DeviceGecko.cpp

@@ -159,6 +159,10 @@ void GeckoSockServer::ClientThread()
   client->disconnect();
 }
 
+CEXIGecko::CEXIGecko(Core::System& system) : IEXIDevice(system)
+{
+}
+
 void CEXIGecko::ImmReadWrite(u32& _uData, u32 _uSize)
 {
   // We don't really care about _uSize

Source/Core/Core/HW/EXI/EXI_DeviceGecko.h

@@ -49,7 +49,7 @@ private:
 class CEXIGecko : public IEXIDevice, private GeckoSockServer
 {
 public:
-  CEXIGecko() {}
+  explicit CEXIGecko(Core::System& system);
   bool IsPresent() const override { return true; }
   void ImmReadWrite(u32& _uData, u32 _uSize) override;
 

Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp

@@ -99,7 +99,7 @@ void CEXIIPL::Descrambler(u8* data, u32 size)
   }
 }
 
-CEXIIPL::CEXIIPL()
+CEXIIPL::CEXIIPL(Core::System& system) : IEXIDevice(system)
 {
   // Fill the ROM
   m_rom = std::make_unique<u8[]>(ROM_SIZE);
@@ -130,7 +130,7 @@ CEXIIPL::CEXIIPL()
     LoadFontFile((File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + FONT_WINDOWS_1252), 0x1fcf00);
   }
 
-  auto& sram = Core::System::GetInstance().GetSRAM();
+  auto& sram = system.GetSRAM();
 
   // Clear RTC
   sram.rtc = 0;
@@ -146,7 +146,7 @@ CEXIIPL::~CEXIIPL() = default;
 
 void CEXIIPL::DoState(PointerWrap& p)
 {
-  auto& sram = Core::System::GetInstance().GetSRAM();
+  auto& sram = m_system.GetSRAM();
 
   p.Do(sram);
   p.Do(g_rtc_flags);
@@ -251,8 +251,8 @@ void CEXIIPL::SetCS(int cs)
 
 void CEXIIPL::UpdateRTC()
 {
-  auto& sram = Core::System::GetInstance().GetSRAM();
+  auto& sram = m_system.GetSRAM();
-  sram.rtc = GetEmulatedTime(GC_EPOCH);
+  sram.rtc = GetEmulatedTime(m_system, GC_EPOCH);
 }
 
 bool CEXIIPL::IsPresent() const
@@ -342,7 +342,7 @@ void CEXIIPL::TransferByte(u8& data)
     }
     else if (IN_RANGE(SRAM))
     {
-      auto& sram = Core::System::GetInstance().GetSRAM();
+      auto& sram = m_system.GetSRAM();
       u32 dev_addr = DEV_ADDR_CURSOR(SRAM);
       if (m_command.is_write())
         sram[dev_addr] = data;
@@ -396,7 +396,7 @@ void CEXIIPL::TransferByte(u8& data)
   }
 }
 
-u32 CEXIIPL::GetEmulatedTime(u32 epoch)
+u32 CEXIIPL::GetEmulatedTime(Core::System& system, u32 epoch)
 {
   u64 ltime = 0;
 
@@ -405,16 +405,14 @@ u32 CEXIIPL::GetEmulatedTime(u32 epoch)
     ltime = Movie::GetRecordingStartTime();
 
     // let's keep time moving forward, regardless of what it starts at
-    ltime +=
+    ltime += system.GetCoreTiming().GetTicks() / SystemTimers::GetTicksPerSecond();
-        Core::System::GetInstance().GetCoreTiming().GetTicks() / SystemTimers::GetTicksPerSecond();
   }
   else if (NetPlay::IsNetPlayRunning())
   {
     ltime = NetPlay_GetEmulatedTime();
 
     // let's keep time moving forward, regardless of what it starts at
-    ltime +=
+    ltime += system.GetCoreTiming().GetTicks() / SystemTimers::GetTicksPerSecond();
-        Core::System::GetInstance().GetCoreTiming().GetTicks() / SystemTimers::GetTicksPerSecond();
   }
   else
   {

Source/Core/Core/HW/EXI/EXI_DeviceIPL.h

@@ -16,7 +16,7 @@ namespace ExpansionInterface
 class CEXIIPL : public IEXIDevice
 {
 public:
-  CEXIIPL();
+  explicit CEXIIPL(Core::System& system);
   ~CEXIIPL() override;
 
   void SetCS(int cs) override;
@@ -26,7 +26,7 @@ public:
   static constexpr u32 UNIX_EPOCH = 0;         // 1970-01-01 00:00:00
   static constexpr u32 GC_EPOCH = 0x386D4380;  // 2000-01-01 00:00:00
 
-  static u32 GetEmulatedTime(u32 epoch);
+  static u32 GetEmulatedTime(Core::System& system, u32 epoch);
   static u64 NetPlay_GetEmulatedTime();
 
   static void Descrambler(u8* data, u32 size);

Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.cpp

@@ -104,9 +104,9 @@ void CEXIMemoryCard::Shutdown()
   s_et_transfer_complete.fill(nullptr);
 }
 
-CEXIMemoryCard::CEXIMemoryCard(const Slot slot, bool gci_folder,
+CEXIMemoryCard::CEXIMemoryCard(Core::System& system, const Slot slot, bool gci_folder,
                                const Memcard::HeaderData& header_data)
-    : m_card_slot(slot)
+    : IEXIDevice(system), m_card_slot(slot)
 {
   ASSERT_MSG(EXPANSIONINTERFACE, IsMemcardSlot(slot), "Trying to create invalid memory card in {}.",
              slot);
@@ -144,7 +144,7 @@ CEXIMemoryCard::CEXIMemoryCard(const Slot slot, bool gci_folder,
   m_memory_card_size = m_memory_card->GetCardId() * SIZE_TO_Mb;
   std::array<u8, 20> header{};
   m_memory_card->Read(0, static_cast<s32>(header.size()), header.data());
-  auto& sram = Core::System::GetInstance().GetSRAM();
+  auto& sram = system.GetSRAM();
   SetCardFlashID(&sram, header.data(), m_card_slot);
 }
 
@@ -235,8 +235,7 @@ void CEXIMemoryCard::SetupRawMemcard(u16 size_mb)
 
 CEXIMemoryCard::~CEXIMemoryCard()
 {
-  auto& system = Core::System::GetInstance();
+  auto& core_timing = m_system.GetCoreTiming();
-  auto& core_timing = system.GetCoreTiming();
   core_timing.RemoveEvent(s_et_cmd_done[m_card_slot]);
   core_timing.RemoveEvent(s_et_transfer_complete[m_card_slot]);
 }
@@ -269,8 +268,7 @@ void CEXIMemoryCard::TransferComplete()
 
 void CEXIMemoryCard::CmdDoneLater(u64 cycles)
 {
-  auto& system = Core::System::GetInstance();
+  auto& core_timing = m_system.GetCoreTiming();
-  auto& core_timing = system.GetCoreTiming();
   core_timing.RemoveEvent(s_et_cmd_done[m_card_slot]);
   core_timing.ScheduleEvent(cycles, s_et_cmd_done[m_card_slot], static_cast<u64>(m_card_slot));
 }
@@ -523,8 +521,7 @@ void CEXIMemoryCard::DoState(PointerWrap& p)
 // read all at once instead of single byte at a time as done by IEXIDevice::DMARead
 void CEXIMemoryCard::DMARead(u32 addr, u32 size)
 {
-  auto& system = Core::System::GetInstance();
+  auto& memory = m_system.GetMemory();
-  auto& memory = system.GetMemory();
   m_memory_card->Read(m_address, size, memory.GetPointer(addr));
 
   if ((m_address + size) % Memcard::BLOCK_SIZE == 0)
@@ -533,7 +530,7 @@ void CEXIMemoryCard::DMARead(u32 addr, u32 size)
   }
 
   // Schedule transfer complete later based on read speed
-  system.GetCoreTiming().ScheduleEvent(
+  m_system.GetCoreTiming().ScheduleEvent(
       size * (SystemTimers::GetTicksPerSecond() / MC_TRANSFER_RATE_READ),
       s_et_transfer_complete[m_card_slot], static_cast<u64>(m_card_slot));
 }
@@ -542,8 +539,7 @@ void CEXIMemoryCard::DMARead(u32 addr, u32 size)
 // write all at once instead of single byte at a time as done by IEXIDevice::DMAWrite
 void CEXIMemoryCard::DMAWrite(u32 addr, u32 size)
 {
-  auto& system = Core::System::GetInstance();
+  auto& memory = m_system.GetMemory();
-  auto& memory = system.GetMemory();
   m_memory_card->Write(m_address, size, memory.GetPointer(addr));
 
   if (((m_address + size) % Memcard::BLOCK_SIZE) == 0)
@@ -552,7 +548,7 @@ void CEXIMemoryCard::DMAWrite(u32 addr, u32 size)
   }
 
   // Schedule transfer complete later based on write speed
-  system.GetCoreTiming().ScheduleEvent(
+  m_system.GetCoreTiming().ScheduleEvent(
       size * (SystemTimers::GetTicksPerSecond() / MC_TRANSFER_RATE_WRITE),
       s_et_transfer_complete[m_card_slot], static_cast<u64>(m_card_slot));
 }

Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.h

@@ -36,7 +36,8 @@ enum class AllowMovieFolder
 class CEXIMemoryCard : public IEXIDevice
 {
 public:
-  CEXIMemoryCard(Slot slot, bool gci_folder, const Memcard::HeaderData& header_data);
+  CEXIMemoryCard(Core::System& system, Slot slot, bool gci_folder,
+                 const Memcard::HeaderData& header_data);
   ~CEXIMemoryCard() override;
   void SetCS(int cs) override;
   bool IsInterruptSet() override;

Source/Core/Core/HW/EXI/EXI_DeviceMic.cpp

@@ -196,8 +196,8 @@ void CEXIMic::StreamReadOne()
 
 u8 const CEXIMic::exi_id[] = {0, 0x0a, 0, 0, 0};
 
-CEXIMic::CEXIMic(int index)
+CEXIMic::CEXIMic(Core::System& system, int index)
-    : slot(index)
+    : IEXIDevice(system), slot(index)
 #ifdef _WIN32
       ,
       m_work_queue("Mic Worker", [](const std::function<void()>& func) { func(); })
@@ -265,13 +265,13 @@ void CEXIMic::SetCS(int cs)
 void CEXIMic::UpdateNextInterruptTicks()
 {
   int diff = (SystemTimers::GetTicksPerSecond() / sample_rate) * buff_size_samples;
-  next_int_ticks = Core::System::GetInstance().GetCoreTiming().GetTicks() + diff;
+  next_int_ticks = m_system.GetCoreTiming().GetTicks() + diff;
   ExpansionInterface::ScheduleUpdateInterrupts(CoreTiming::FromThread::CPU, diff);
 }
 
 bool CEXIMic::IsInterruptSet()
 {
-  if (next_int_ticks && Core::System::GetInstance().GetCoreTiming().GetTicks() >= next_int_ticks)
+  if (next_int_ticks && m_system.GetCoreTiming().GetTicks() >= next_int_ticks)
   {
     if (status.is_active)
       UpdateNextInterruptTicks();

Source/Core/Core/HW/EXI/EXI_DeviceMic.h

@@ -17,7 +17,7 @@ namespace ExpansionInterface
 class CEXIMic : public IEXIDevice
 {
 public:
-  CEXIMic(const int index);
+  CEXIMic(Core::System& system, const int index);
   virtual ~CEXIMic();
   void SetCS(int cs) override;
   bool IsInterruptSet() override;

Source/Core/Core/HW/SystemTimers.cpp

@@ -284,7 +284,7 @@ void Init()
 
   core_timing.SetFakeTBStartValue(static_cast<u64>(s_cpu_core_clock / TIMER_RATIO) *
                                   static_cast<u64>(ExpansionInterface::CEXIIPL::GetEmulatedTime(
-                                      ExpansionInterface::CEXIIPL::GC_EPOCH)));
+                                      system, ExpansionInterface::CEXIIPL::GC_EPOCH)));
 
   core_timing.SetFakeTBStartTicks(core_timing.GetTicks());
 

Source/Core/Core/IOS/Network/KD/NetKDTime.cpp

@@ -91,7 +91,8 @@ u64 NetKDTimeDevice::GetAdjustedUTC() const
 {
   using namespace ExpansionInterface;
 
-  const time_t current_time = CEXIIPL::GetEmulatedTime(CEXIIPL::UNIX_EPOCH);
+  const time_t current_time =
+      CEXIIPL::GetEmulatedTime(Core::System::GetInstance(), CEXIIPL::UNIX_EPOCH);
   tm* const gm_time = gmtime(&current_time);
   const u32 emulated_time = mktime(gm_time);
   return u64(s64(emulated_time) + utcdiff);
@@ -101,7 +102,8 @@ void NetKDTimeDevice::SetAdjustedUTC(u64 wii_utc)
 {
   using namespace ExpansionInterface;
 
-  const time_t current_time = CEXIIPL::GetEmulatedTime(CEXIIPL::UNIX_EPOCH);
+  const time_t current_time =
+      CEXIIPL::GetEmulatedTime(Core::System::GetInstance(), CEXIIPL::UNIX_EPOCH);
   tm* const gm_time = gmtime(&current_time);
   const u32 emulated_time = mktime(gm_time);
   utcdiff = s64(emulated_time - wii_utc);

Source/Core/Core/Movie.cpp

@@ -201,7 +201,8 @@ std::string GetRTCDisplay()
 {
   using ExpansionInterface::CEXIIPL;
 
-  const time_t current_time = CEXIIPL::GetEmulatedTime(CEXIIPL::UNIX_EPOCH);
+  const time_t current_time =
+      CEXIIPL::GetEmulatedTime(Core::System::GetInstance(), CEXIIPL::UNIX_EPOCH);
   const tm* const gm_time = gmtime(&current_time);
 
   std::ostringstream format_time;