HW/SerialInterface: Refactor to class.

2026-06-19 01:16:48 -07:00 · 2023-03-12 16:08:56 +01:00
parent d371b17f37
commit bf2f901a99
11 changed files with 463 additions and 455 deletions
@@ -42,7 +42,7 @@ void Init(const Sram* override_sram)
  // Init the whole Hardware
  system.GetAudioInterface().Init();
  system.GetVideoInterface().Init();
-  SerialInterface::Init();
+  system.GetSerialInterface().Init();
  system.GetProcessorInterface().Init();
  system.GetExpansionInterface().Init(override_sram);  // Needs to be initialized before Memory
  system.GetHSP().Init();
@@ -79,7 +79,7 @@ void Shutdown()
  system.GetMemory().Shutdown();
  system.GetHSP().Shutdown();
  system.GetExpansionInterface().Shutdown();
-  SerialInterface::Shutdown();
+  system.GetSerialInterface().Shutdown();
  system.GetAudioInterface().Shutdown();

  State::Shutdown();
@@ -95,7 +95,7 @@ void DoState(PointerWrap& p)
  p.DoMarker("MemoryInterface");
  system.GetVideoInterface().DoState(p);
  p.DoMarker("VideoInterface");
-  SerialInterface::DoState(p);
+  system.GetSerialInterface().DoState(p);
  p.DoMarker("SerialInterface");
  system.GetProcessorInterface().DoState(p);
  p.DoMarker("ProcessorInterface");
@@ -56,14 +56,14 @@ void MemoryManager::InitMMIO(bool is_wii)
  system.GetMemoryInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C004000);
  system.GetDSP().RegisterMMIO(m_mmio_mapping.get(), 0x0C005000);
  system.GetDVDInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006000, false);
-  SerialInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0C006400);
+  system.GetSerialInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006400);
  system.GetExpansionInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006800);
  system.GetAudioInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0C006C00);
  if (is_wii)
  {
    IOS::RegisterMMIO(m_mmio_mapping.get(), 0x0D000000);
    system.GetDVDInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006000, true);
-    SerialInterface::RegisterMMIO(m_mmio_mapping.get(), 0x0D006400);
+    system.GetSerialInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006400);
    system.GetExpansionInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006800);
    system.GetAudioInterface().RegisterMMIO(m_mmio_mapping.get(), 0x0D006C00);
  }
@@ -3,11 +3,23 @@

 #pragma once

+#include <array>
+#include <atomic>
 #include <memory>
+
+#include "Common/BitField.h"
 #include "Common/CommonTypes.h"

 class PointerWrap;

+namespace Core
+{
+class System;
+}
+namespace CoreTiming
+{
+struct EventType;
+}
 namespace MMIO
 {
 class Mapping;
@@ -15,23 +27,6 @@ class Mapping;

 namespace SerialInterface
 {
-class SerialInterfaceState
-{
-public:
-  SerialInterfaceState();
-  SerialInterfaceState(const SerialInterfaceState&) = delete;
-  SerialInterfaceState(SerialInterfaceState&&) = delete;
-  SerialInterfaceState& operator=(const SerialInterfaceState&) = delete;
-  SerialInterfaceState& operator=(SerialInterfaceState&&) = delete;
-  ~SerialInterfaceState();
-
-  struct Data;
-  Data& GetData() { return *m_data; }
-
-private:
-  std::unique_ptr<Data> m_data;
-};
-
 class ISIDevice;
 enum SIDevices : int;

@@ -41,25 +36,212 @@ enum
  MAX_SI_CHANNELS = 0x04
 };

-void Init();
-void Shutdown();
-void DoState(PointerWrap& p);
+class SerialInterfaceManager
+{
+public:
+  explicit SerialInterfaceManager(Core::System& system);
+  SerialInterfaceManager(const SerialInterfaceManager&) = delete;
+  SerialInterfaceManager(SerialInterfaceManager&&) = delete;
+  SerialInterfaceManager& operator=(const SerialInterfaceManager&) = delete;
+  SerialInterfaceManager& operator=(SerialInterfaceManager&&) = delete;
+  ~SerialInterfaceManager();

-void RegisterMMIO(MMIO::Mapping* mmio, u32 base);
+  void Init();
+  void Shutdown();
+  void DoState(PointerWrap& p);

-void ScheduleEvent(int device_number, s64 cycles_into_future, u64 userdata = 0);
-void RemoveEvent(int device_number);
+  void RegisterMMIO(MMIO::Mapping* mmio, u32 base);

-void UpdateDevices();
+  void ScheduleEvent(int device_number, s64 cycles_into_future, u64 userdata = 0);
+  void RemoveEvent(int device_number);

-void RemoveDevice(int device_number);
-void AddDevice(SIDevices device, int device_number);
-void AddDevice(std::unique_ptr<ISIDevice> device);
+  void UpdateDevices();

-void ChangeDevice(SIDevices device, int channel);
+  void RemoveDevice(int device_number);
+  void AddDevice(SIDevices device, int device_number);
+  void AddDevice(std::unique_ptr<ISIDevice> device);

-SIDevices GetDeviceType(int channel);
+  void ChangeDevice(SIDevices device, int channel);

-u32 GetPollXLines();
+  SIDevices GetDeviceType(int channel);

+  u32 GetPollXLines();
+
+private:
+  // SI Interrupt Types
+  enum SIInterruptType
+  {
+    INT_RDSTINT = 0,
+    INT_TCINT = 1,
+  };
+
+  void SetNoResponse(u32 channel);
+  void UpdateInterrupts();
+  void GenerateSIInterrupt(SIInterruptType type);
+
+  void ChangeDeviceDeterministic(SIDevices device, int channel);
+
+  void RegisterEvents();
+  void RunSIBuffer(u64 user_data, s64 cycles_late);
+  static void GlobalRunSIBuffer(Core::System& system, u64 user_data, s64 cycles_late);
+  static void ChangeDeviceCallback(Core::System& system, u64 user_data, s64 cycles_late);
+  template <int device_number>
+  static void DeviceEventCallback(Core::System& system, u64 userdata, s64 cyclesLate);
+
+  // SI Channel Output
+  union USIChannelOut
+  {
+    u32 hex = 0;
+
+    BitField<0, 8, u32> OUTPUT1;
+    BitField<8, 8, u32> OUTPUT0;
+    BitField<16, 8, u32> CMD;
+    BitField<24, 8, u32> reserved;
+  };
+
+  // SI Channel Input High u32
+  union USIChannelIn_Hi
+  {
+    u32 hex = 0;
+
+    BitField<0, 8, u32> INPUT3;
+    BitField<8, 8, u32> INPUT2;
+    BitField<16, 8, u32> INPUT1;
+    BitField<24, 6, u32> INPUT0;
+    BitField<30, 1, u32> ERRLATCH;  // 0: no error  1: Error latched. Check SISR.
+    BitField<31, 1, u32> ERRSTAT;   // 0: no error  1: error on last transfer
+  };
+
+  // SI Channel Input Low u32
+  union USIChannelIn_Lo
+  {
+    u32 hex = 0;
+
+    BitField<0, 8, u32> INPUT7;
+    BitField<8, 8, u32> INPUT6;
+    BitField<16, 8, u32> INPUT5;
+    BitField<24, 8, u32> INPUT4;
+  };
+
+  // SI Channel
+  struct SSIChannel
+  {
+    USIChannelOut out{};
+    USIChannelIn_Hi in_hi{};
+    USIChannelIn_Lo in_lo{};
+    std::unique_ptr<ISIDevice> device;
+
+    bool has_recent_device_change = false;
+  };
+
+  // SI Poll: Controls how often a device is polled
+  union USIPoll
+  {
+    u32 hex = 0;
+
+    BitField<0, 1, u32> VBCPY3;  // 1: write to output buffer only on vblank
+    BitField<1, 1, u32> VBCPY2;
+    BitField<2, 1, u32> VBCPY1;
+    BitField<3, 1, u32> VBCPY0;
+    BitField<4, 1, u32> EN3;  // Enable polling of channel
+    BitField<5, 1, u32> EN2;  //  does not affect communication RAM transfers
+    BitField<6, 1, u32> EN1;
+    BitField<7, 1, u32> EN0;
+    BitField<8, 8, u32> Y;  // Polls per frame
+    BitField<16, 10, u32>
+        X;  // Polls per X lines. begins at vsync, min 7, max depends on video mode
+    BitField<26, 6, u32> reserved;
+  };
+
+  // SI Communication Control Status Register
+  union USIComCSR
+  {
+    u32 hex = 0;
+
+    BitField<0, 1, u32> TSTART;   // write: start transfer  read: transfer status
+    BitField<1, 2, u32> CHANNEL;  // determines which SI channel will be
+                                  // used on the communication interface.
+    BitField<3, 3, u32> reserved_1;
+    BitField<6, 1, u32> CALLBEN;  // Callback enable
+    BitField<7, 1, u32> CMDEN;    // Command enable?
+    BitField<8, 7, u32> INLNGTH;
+    BitField<15, 1, u32> reserved_2;
+    BitField<16, 7, u32> OUTLNGTH;  // Communication Channel Output Length in bytes
+    BitField<23, 1, u32> reserved_3;
+    BitField<24, 1, u32> CHANEN;      // Channel enable?
+    BitField<25, 2, u32> CHANNUM;     // Channel number?
+    BitField<27, 1, u32> RDSTINTMSK;  // Read Status Interrupt Status Mask
+    BitField<28, 1, u32> RDSTINT;     // Read Status Interrupt Status
+    BitField<29, 1, u32> COMERR;      // Communication Error (set 0)
+    BitField<30, 1, u32> TCINTMSK;    // Transfer Complete Interrupt Mask
+    BitField<31, 1, u32> TCINT;       // Transfer Complete Interrupt
+
+    USIComCSR() = default;
+    explicit USIComCSR(u32 value) : hex{value} {}
+  };
+
+  // SI Status Register
+  union USIStatusReg
+  {
+    u32 hex = 0;
+
+    BitField<0, 1, u32> UNRUN3;      // (RWC) write 1: bit cleared  read 1: main proc underrun error
+    BitField<1, 1, u32> OVRUN3;      // (RWC) write 1: bit cleared  read 1: overrun error
+    BitField<2, 1, u32> COLL3;       // (RWC) write 1: bit cleared  read 1: collision error
+    BitField<3, 1, u32> NOREP3;      // (RWC) write 1: bit cleared  read 1: response error
+    BitField<4, 1, u32> WRST3;       // (R) 1: buffer channel0 not copied
+    BitField<5, 1, u32> RDST3;       // (R) 1: new Data available
+    BitField<6, 2, u32> reserved_1;  // 7:6
+    BitField<8, 1, u32> UNRUN2;      // (RWC) write 1: bit cleared  read 1: main proc underrun error
+    BitField<9, 1, u32> OVRUN2;      // (RWC) write 1: bit cleared  read 1: overrun error
+    BitField<10, 1, u32> COLL2;      // (RWC) write 1: bit cleared  read 1: collision error
+    BitField<11, 1, u32> NOREP2;     // (RWC) write 1: bit cleared  read 1: response error
+    BitField<12, 1, u32> WRST2;      // (R) 1: buffer channel0 not copied
+    BitField<13, 1, u32> RDST2;      // (R) 1: new Data available
+    BitField<14, 2, u32> reserved_2;  // 15:14
+    BitField<16, 1, u32> UNRUN1;  // (RWC) write 1: bit cleared  read 1: main proc underrun error
+    BitField<17, 1, u32> OVRUN1;  // (RWC) write 1: bit cleared  read 1: overrun error
+    BitField<18, 1, u32> COLL1;   // (RWC) write 1: bit cleared  read 1: collision error
+    BitField<19, 1, u32> NOREP1;  // (RWC) write 1: bit cleared  read 1: response error
+    BitField<20, 1, u32> WRST1;   // (R) 1: buffer channel0 not copied
+    BitField<21, 1, u32> RDST1;   // (R) 1: new Data available
+    BitField<22, 2, u32> reserved_3;  // 23:22
+    BitField<24, 1, u32> UNRUN0;  // (RWC) write 1: bit cleared  read 1: main proc underrun error
+    BitField<25, 1, u32> OVRUN0;  // (RWC) write 1: bit cleared  read 1: overrun error
+    BitField<26, 1, u32> COLL0;   // (RWC) write 1: bit cleared  read 1: collision error
+    BitField<27, 1, u32> NOREP0;  // (RWC) write 1: bit cleared  read 1: response error
+    BitField<28, 1, u32> WRST0;   // (R) 1: buffer channel0 not copied
+    BitField<29, 1, u32> RDST0;   // (R) 1: new Data available
+    BitField<30, 1, u32> reserved_4;
+    BitField<31, 1, u32> WR;  // (RW) write 1 start copy, read 0 copy done
+
+    USIStatusReg() = default;
+    explicit USIStatusReg(u32 value) : hex{value} {}
+  };
+
+  // SI EXI Clock Count
+  union USIEXIClockCount
+  {
+    u32 hex = 0;
+
+    BitField<0, 1, u32> LOCK;  // 1: prevents CPU from setting EXI clock to 32MHz
+    BitField<1, 30, u32> reserved;
+  };
+
+  CoreTiming::EventType* m_event_type_change_device = nullptr;
+  CoreTiming::EventType* m_event_type_tranfer_pending = nullptr;
+  std::array<CoreTiming::EventType*, MAX_SI_CHANNELS> m_event_types_device{};
+
+  // User-configured device type. possibly overridden by TAS/Netplay
+  std::array<std::atomic<SIDevices>, MAX_SI_CHANNELS> m_desired_device_types{};
+
+  std::array<SSIChannel, MAX_SI_CHANNELS> m_channel;
+  USIPoll m_poll;
+  USIComCSR m_com_csr;
+  USIStatusReg m_status_reg;
+  USIEXIClockCount m_exi_clock_count;
+  std::array<u8, 128> m_si_buffer{};
+
+  Core::System& m_system;
+};
 }  // namespace SerialInterface
@@ -34,12 +34,12 @@ CSIDevice_GBAEmu::CSIDevice_GBAEmu(Core::System& system, SIDevices device, int d
  m_core->Start(system.GetCoreTiming().GetTicks());
  m_gbahost = Host_CreateGBAHost(m_core);
  m_core->SetHost(m_gbahost);
-  ScheduleEvent(m_device_number, GetSyncInterval());
+  system.GetSerialInterface().ScheduleEvent(m_device_number, GetSyncInterval());
 }

 CSIDevice_GBAEmu::~CSIDevice_GBAEmu()
 {
-  RemoveEvent(m_device_number);
+  m_system.GetSerialInterface().RemoveEvent(m_device_number);
  m_core->Stop();
  m_gbahost.reset();
  m_core.reset();
@@ -59,14 +59,15 @@ int CSIDevice_GBAEmu::RunBuffer(u8* buffer, int request_length)
    m_timestamp_sent = m_system.GetCoreTiming().GetTicks();
    m_core->SendJoybusCommand(m_timestamp_sent, TransferInterval(), buffer, m_keys);

-    RemoveEvent(m_device_number);
-    ScheduleEvent(m_device_number, TransferInterval() + GetSyncInterval());
+    auto& si = m_system.GetSerialInterface();
+    si.RemoveEvent(m_device_number);
+    si.ScheduleEvent(m_device_number, TransferInterval() + GetSyncInterval());
    for (int i = 0; i < MAX_SI_CHANNELS; ++i)
    {
-      if (i == m_device_number || SerialInterface::GetDeviceType(i) != GetDeviceType())
+      if (i == m_device_number || si.GetDeviceType(i) != GetDeviceType())
        continue;
-      RemoveEvent(i);
-      ScheduleEvent(i, 0, static_cast<u64>(TransferInterval()));
+      si.RemoveEvent(i);
+      si.ScheduleEvent(i, 0, static_cast<u64>(TransferInterval()));
    }

    m_next_action = NextAction::WaitTransferTime;
@@ -164,6 +165,6 @@ void CSIDevice_GBAEmu::DoState(PointerWrap& p)
 void CSIDevice_GBAEmu::OnEvent(u64 userdata, s64 cycles_late)
 {
  m_core->SendJoybusCommand(m_system.GetCoreTiming().GetTicks() + userdata, 0, nullptr, m_keys);
-  ScheduleEvent(m_device_number, userdata + GetSyncInterval());
+  m_system.GetSerialInterface().ScheduleEvent(m_device_number, userdata + GetSyncInterval());
 }
 }  // namespace SerialInterface
@@ -885,8 +885,9 @@ void VideoInterfaceManager::Update(u64 ticks)
  {
    Core::UpdateInputGate(!Config::Get(Config::MAIN_INPUT_BACKGROUND_INPUT),
                          Config::Get(Config::MAIN_LOCK_CURSOR));
-    SerialInterface::UpdateDevices();
-    m_half_line_of_next_si_poll += 2 * SerialInterface::GetPollXLines();
+    auto& si = m_system.GetSerialInterface();
+    si.UpdateDevices();
+    m_half_line_of_next_si_poll += 2 * si.GetPollXLines();
  }

  // If this half-line is at the actual boundary of either field, schedule an SI poll to happen
@@ -169,9 +169,10 @@ std::string GetInputDisplay()
    s_wiimotes = {};
    for (int i = 0; i < 4; ++i)
    {
-      if (SerialInterface::GetDeviceType(i) == SerialInterface::SIDEVICE_GC_GBA_EMULATED)
+      auto& si = Core::System::GetInstance().GetSerialInterface();
+      if (si.GetDeviceType(i) == SerialInterface::SIDEVICE_GC_GBA_EMULATED)
        s_controllers[i] = ControllerType::GBA;
-      else if (SerialInterface::GetDeviceType(i) != SerialInterface::SIDEVICE_NONE)
+      else if (si.GetDeviceType(i) != SerialInterface::SIDEVICE_NONE)
        s_controllers[i] = ControllerType::GC;
      else
        s_controllers[i] = ControllerType::None;
@@ -484,6 +485,7 @@ void ChangePads()
  if (s_controllers == controllers)
    return;

+  auto& si = Core::System::GetInstance().GetSerialInterface();
  for (int i = 0; i < SerialInterface::MAX_SI_CHANNELS; ++i)
  {
    SerialInterface::SIDevices device = SerialInterface::SIDEVICE_NONE;
@@ -505,7 +507,7 @@ void ChangePads()
      }
    }

-    SerialInterface::ChangeDevice(device, i);
+    si.ChangeDevice(device, i);
  }
 }

@@ -67,6 +67,7 @@
 #include "Core/NetPlayCommon.h"
 #include "Core/PowerPC/PowerPC.h"
 #include "Core/SyncIdentifier.h"
+#include "Core/System.h"
 #include "DiscIO/Blob.h"

 #include "InputCommon/ControllerEmu/ControlGroup/Attachments.h"
@@ -1833,11 +1834,12 @@ void NetPlayClient::UpdateDevices()
  u8 local_pad = 0;
  u8 pad = 0;

+  auto& si = Core::System::GetInstance().GetSerialInterface();
  for (auto player_id : m_pad_map)
  {
    if (m_gba_config[pad].enabled && player_id > 0)
    {
-      SerialInterface::ChangeDevice(SerialInterface::SIDEVICE_GC_GBA_EMULATED, pad);
+      si.ChangeDevice(SerialInterface::SIDEVICE_GC_GBA_EMULATED, pad);
    }
    else if (player_id == m_local_player->pid)
    {
@@ -1846,7 +1848,7 @@ void NetPlayClient::UpdateDevices()
          Config::Get(Config::GetInfoForSIDevice(local_pad));
      if (SerialInterface::SIDevice_IsGCController(si_device))
      {
-        SerialInterface::ChangeDevice(si_device, pad);
+        si.ChangeDevice(si_device, pad);

        if (si_device == SerialInterface::SIDEVICE_WIIU_ADAPTER)
        {
@@ -1855,17 +1857,17 @@ void NetPlayClient::UpdateDevices()
      }
      else
      {
-        SerialInterface::ChangeDevice(SerialInterface::SIDEVICE_GC_CONTROLLER, pad);
+        si.ChangeDevice(SerialInterface::SIDEVICE_GC_CONTROLLER, pad);
      }
      local_pad++;
    }
    else if (player_id > 0)
    {
-      SerialInterface::ChangeDevice(SerialInterface::SIDEVICE_GC_CONTROLLER, pad);
+      si.ChangeDevice(SerialInterface::SIDEVICE_GC_CONTROLLER, pad);
    }
    else
    {
-      SerialInterface::ChangeDevice(SerialInterface::SIDEVICE_NONE, pad);
+      si.ChangeDevice(SerialInterface::SIDEVICE_NONE, pad);
    }
    pad++;
  }
@@ -38,7 +38,7 @@ struct System::Impl
  explicit Impl(System& system)
      : m_audio_interface(system), m_core_timing(system), m_dsp(system), m_dvd_interface(system),
        m_dvd_thread(system), m_expansion_interface(system), m_gp_fifo(system),
-        m_ppc_state(PowerPC::ppcState), m_video_interface(system)
+        m_ppc_state(PowerPC::ppcState), m_serial_interface(system), m_video_interface(system)
  {
  }

@@ -65,7 +65,7 @@ struct System::Impl
  PixelShaderManager m_pixel_shader_manager;
  PowerPC::PowerPCState& m_ppc_state;
  ProcessorInterface::ProcessorInterfaceManager m_processor_interface;
-  SerialInterface::SerialInterfaceState m_serial_interface_state;
+  SerialInterface::SerialInterfaceManager m_serial_interface;
  Sram m_sram;
  VertexShaderManager m_vertex_shader_manager;
  VideoInterface::VideoInterfaceManager m_video_interface;
@@ -209,9 +209,9 @@ ProcessorInterface::ProcessorInterfaceManager& System::GetProcessorInterface() c
  return m_impl->m_processor_interface;
 }

-SerialInterface::SerialInterfaceState& System::GetSerialInterfaceState() const
+SerialInterface::SerialInterfaceManager& System::GetSerialInterface() const
 {
-  return m_impl->m_serial_interface_state;
+  return m_impl->m_serial_interface;
 }

 Sram& System::GetSRAM() const
@@ -78,7 +78,7 @@ class ProcessorInterfaceManager;
 }
 namespace SerialInterface
 {
-class SerialInterfaceState;
+class SerialInterfaceManager;
 };
 namespace VideoInterface
 {
@@ -138,7 +138,7 @@ public:
  PixelShaderManager& GetPixelShaderManager() const;
  PowerPC::PowerPCState& GetPPCState() const;
  ProcessorInterface::ProcessorInterfaceManager& GetProcessorInterface() const;
-  SerialInterface::SerialInterfaceState& GetSerialInterfaceState() const;
+  SerialInterface::SerialInterfaceManager& GetSerialInterface() const;
  Sram& GetSRAM() const;
  VertexShaderManager& GetVertexShaderManager() const;
  VideoInterface::VideoInterfaceManager& GetVideoInterface() const;
@@ -19,6 +19,7 @@
 #include "Core/HW/SI/SI.h"
 #include "Core/HW/SI/SI_Device.h"
 #include "Core/NetPlayProto.h"
+#include "Core/System.h"

 #include "DolphinQt/Config/Mapping/GCPadWiiUConfigDialog.h"
 #include "DolphinQt/Config/Mapping/MappingWindow.h"
@@ -192,7 +193,10 @@ void GamecubeControllersWidget::SaveSettings()
      Config::SetBaseOrCurrent(Config::GetInfoForSIDevice(static_cast<int>(i)), si_device);

      if (Core::IsRunning())
-        SerialInterface::ChangeDevice(si_device, static_cast<s32>(i));
+      {
+        Core::System::GetInstance().GetSerialInterface().ChangeDevice(si_device,
+                                                                      static_cast<s32>(i));
+      }
    }

    if (GCAdapter::UseAdapter())