[WIP] SD card adapter support

Source/Core/Common/Hash.cpp

@@ -446,4 +446,48 @@ u32 ComputeCRC32(std::string_view data)
 {
   return ComputeCRC32(reinterpret_cast<const u8*>(data.data()), data.size());
 }
+
+u8 HashCrc7(const u8* ptr, size_t length)
+{
+  // Used for SD cards
+  constexpr u8 CRC_POLYNOMIAL = 0x09;
+
+  u8 result = 0;
+  for (size_t i = 0; i < length; i++)
+  {
+    // TODO: Cache in a table
+    result ^= ptr[i];
+    for (auto bit = 0; bit < 8; bit++)
+    {
+      if (result & 0x80)
+        result = (result << 1) ^ (CRC_POLYNOMIAL << 1);
+      else
+        result = result << 1;
+    }
+  }
+
+  return result >> 1;
+}
+
+u16 HashCrc16(const u8* ptr, size_t length)
+{
+  // Specifically CRC-16-CCITT, used for SD cards
+  constexpr u16 CRC_POLYNOMIAL = 0x1021;
+
+  u16 result = 0;
+  for (size_t i = 0; i < length; i++)
+  {
+    // TODO: Cache in a table
+    result ^= (ptr[i] << 8);
+    for (auto bit = 0; bit < 8; bit++)
+    {
+      if (result & 0x8000)
+        result = (result << 1) ^ CRC_POLYNOMIAL;
+      else
+        result = result << 1;
+    }
+  }
+
+  return result;
+}
 }  // namespace Common

Source/Core/Common/Hash.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <cstddef>
 #include <string_view>
 
@@ -21,4 +22,19 @@ u32 StartCRC32();
 u32 UpdateCRC32(u32 crc, const u8* data, size_t len);
 u32 ComputeCRC32(const u8* data, size_t len);
 u32 ComputeCRC32(std::string_view data);
+
+// For SD card emulation
+u8 HashCrc7(const u8* ptr, size_t length);
+u16 HashCrc16(const u8* ptr, size_t length);
+
+template <size_t N>
+u8 HashCrc7(const std::array<u8, N>& data)
+{
+  return HashCrc7(data.data(), N);
+}
+template <size_t N>
+u16 HashCrc16(const std::array<u8, N>& data)
+{
+  return HashCrc16(data.data(), N);
+}
 }  // namespace Common

Source/Core/Core/CMakeLists.txt

@@ -217,6 +217,8 @@ add_library(core
   HW/EXI/EXI_DeviceMic.h
   HW/EXI/EXI_DeviceModem.cpp
   HW/EXI/EXI_DeviceModem.h
+  HW/EXI/EXI_DeviceSD.cpp
+  HW/EXI/EXI_DeviceSD.h
   HW/EXI/EXI.cpp
   HW/EXI/EXI.h
   HW/GBAPad.cpp

Source/Core/Core/Config/MainSettings.cpp

@@ -111,12 +111,29 @@ const Info<std::string>& GetInfoForGCIPathOverride(ExpansionInterface::Slot slot
 
 const Info<int> MAIN_MEMORY_CARD_SIZE{{System::Main, "Core", "MemoryCardSize"}, -1};
 
+const Info<std::string> MAIN_SLOT_A_SD_CARD_PATH{{System::Main, "Core", "SlotASDCardPath"}, ""};
+const Info<std::string> MAIN_SLOT_B_SD_CARD_PATH{{System::Main, "Core", "SlotBSDCardPath"}, ""};
+const Info<std::string> MAIN_SP2_SD_CARD_PATH{{System::Main, "Core", "SP2SDCardPath"}, ""};
+const Info<std::string>& GetInfoForSDCardPath(ExpansionInterface::Slot slot)
+{
+  ASSERT(slot != ExpansionInterface::Slot::SP1);
+  static constexpr Common::EnumMap<const Info<std::string>*, ExpansionInterface::MAX_SLOT> infos{
+      &MAIN_SLOT_A_SD_CARD_PATH,
+      &MAIN_SLOT_B_SD_CARD_PATH,
+      nullptr,
+      &MAIN_SP2_SD_CARD_PATH,
+  };
+  return *infos[slot];
+}
+
 const Info<ExpansionInterface::EXIDeviceType> MAIN_SLOT_A{
     {System::Main, "Core", "SlotA"}, ExpansionInterface::EXIDeviceType::MemoryCardFolder};
 const Info<ExpansionInterface::EXIDeviceType> MAIN_SLOT_B{{System::Main, "Core", "SlotB"},
                                                           ExpansionInterface::EXIDeviceType::None};
 const Info<ExpansionInterface::EXIDeviceType> MAIN_SERIAL_PORT_1{
     {System::Main, "Core", "SerialPort1"}, ExpansionInterface::EXIDeviceType::None};
+const Info<ExpansionInterface::EXIDeviceType> MAIN_SERIAL_PORT_2{
+    {System::Main, "Core", "SerialPort2"}, ExpansionInterface::EXIDeviceType::None};
 
 const Info<ExpansionInterface::EXIDeviceType>& GetInfoForEXIDevice(ExpansionInterface::Slot slot)
 {
@@ -126,6 +143,7 @@ const Info<ExpansionInterface::EXIDeviceType>& GetInfoForEXIDevice(ExpansionInte
           &MAIN_SLOT_A,
           &MAIN_SLOT_B,
           &MAIN_SERIAL_PORT_1,
+          &MAIN_SERIAL_PORT_2,
       };
   return *infos[slot];
 }

Source/Core/Core/Config/MainSettings.h

@@ -87,9 +87,14 @@ extern const Info<std::string> MAIN_GCI_FOLDER_A_PATH_OVERRIDE;
 extern const Info<std::string> MAIN_GCI_FOLDER_B_PATH_OVERRIDE;
 const Info<std::string>& GetInfoForGCIPathOverride(ExpansionInterface::Slot slot);
 extern const Info<int> MAIN_MEMORY_CARD_SIZE;
+extern const Info<std::string> MAIN_SLOT_A_SD_CARD_PATH;
+extern const Info<std::string> MAIN_SLOT_B_SD_CARD_PATH;
+extern const Info<std::string> MAIN_SP2_SD_CARD_PATH;
+const Info<std::string>& GetInfoForSDCardPath(ExpansionInterface::Slot slot);
 extern const Info<ExpansionInterface::EXIDeviceType> MAIN_SLOT_A;
 extern const Info<ExpansionInterface::EXIDeviceType> MAIN_SLOT_B;
 extern const Info<ExpansionInterface::EXIDeviceType> MAIN_SERIAL_PORT_1;
+extern const Info<ExpansionInterface::EXIDeviceType> MAIN_SERIAL_PORT_2;
 const Info<ExpansionInterface::EXIDeviceType>& GetInfoForEXIDevice(ExpansionInterface::Slot slot);
 extern const Info<std::string> MAIN_BBA_MAC;
 extern const Info<std::string> MAIN_BBA_XLINK_IP;

Source/Core/Core/HLE/HLE.cpp

@@ -27,7 +27,7 @@ namespace HLE
 static std::map<u32, u32> s_hooked_addresses;
 
 // clang-format off
-constexpr std::array<Hook, 23> os_patches{{
+constexpr std::array<Hook, 24> os_patches{{
     // Placeholder, os_patches[0] is the "non-existent function" index
     {"FAKE_TO_SKIP_0",               HLE_Misc::UnimplementedFunction,       HookType::Replace, HookFlag::Generic},
 

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

@@ -76,6 +76,8 @@ u8 SlotToEXIChannel(Slot slot)
     return 1;
   case Slot::SP1:
     return 0;
+  case Slot::SP2:
+    return 2;
   default:
     PanicAlertFmt("Unhandled slot {}", slot);
     return 0;
@@ -92,6 +94,8 @@ u8 SlotToEXIDevice(Slot slot)
     return 0;
   case Slot::SP1:
     return 2;
+  case Slot::SP2:
+    return 0;
   default:
     PanicAlertFmt("Unhandled slot {}", slot);
     return 0;
@@ -143,7 +147,8 @@ void ExpansionInterfaceManager::Init(const Sram* override_sram)
   m_channels[0]->AddDevice(EXIDeviceType::MaskROM, 1);
   m_channels[SlotToEXIChannel(Slot::SP1)]->AddDevice(Config::Get(Config::MAIN_SERIAL_PORT_1),
                                                      SlotToEXIDevice(Slot::SP1));
-  m_channels[2]->AddDevice(EXIDeviceType::AD16, 0);
+  m_channels[SlotToEXIChannel(Slot::SP2)]->AddDevice(Config::Get(Config::MAIN_SERIAL_PORT_2),
+                                                     SlotToEXIDevice(Slot::SP2));
 
   m_event_type_change_device = core_timing.RegisterEvent("ChangeEXIDevice", ChangeDeviceCallback);
   m_event_type_update_interrupts =

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

@@ -44,11 +44,12 @@ enum class Slot : int
   A,
   B,
   SP1,
+  SP2,
 };
 // Note: using auto here results in a false warning on GCC
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80351
-constexpr std::initializer_list<Slot> SLOTS = {Slot::A, Slot::B, Slot::SP1};
-constexpr auto MAX_SLOT = Slot::SP1;
+constexpr std::initializer_list<Slot> SLOTS = {Slot::A, Slot::B, Slot::SP1, Slot::SP2};
+constexpr auto MAX_SLOT = Slot::SP2;
 constexpr std::initializer_list<Slot> MEMCARD_SLOTS = {Slot::A, Slot::B};
 constexpr auto MAX_MEMCARD_SLOT = Slot::B;
 constexpr bool IsMemcardSlot(Slot slot)
@@ -106,5 +107,5 @@ class ExpansionInterfaceManager
 template <>
 struct fmt::formatter<ExpansionInterface::Slot> : EnumFormatter<ExpansionInterface::MAX_SLOT>
 {
-  constexpr formatter() : EnumFormatter({"Slot A", "Slot B", "Serial Port 1"}) {}
+  constexpr formatter() : EnumFormatter({"Slot A", "Slot B", "Serial Port 1", "Serial Port 2"}) {}
 };

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

@@ -87,10 +87,16 @@ void CEXIChannel::RegisterMMIO(MMIO::Mapping* mmio, u32 base)
                    if (m_channel_id == 0)
                      m_status.ROMDIS = new_status.ROMDIS;
 
-                   IEXIDevice* device = GetDevice(m_status.CHIP_SELECT ^ new_status.CHIP_SELECT);
+                   for (int device = 0; device < NUM_DEVICES; device++)
+                   {
+                     if (m_devices[device])
+                     {
+                       bool was_selected = m_status.CHIP_SELECT & (1 << device);
+                       bool is_selected = new_status.CHIP_SELECT & (1 << device);
+                       m_devices[device]->SetCS(new_status.CHIP_SELECT, was_selected, is_selected);
+                     }
+                   }
                    m_status.CHIP_SELECT = new_status.CHIP_SELECT;
-                   if (device != nullptr)
-                     device->SetCS(m_status.CHIP_SELECT);
 
                    system.GetExpansionInterface().UpdateInterrupts();
                  }));
@@ -224,6 +230,11 @@ IEXIDevice* CEXIChannel::GetDevice(const u8 chip_select)
 {
   switch (chip_select)
   {
+  case 0:  // SD responds when the CS signal is 0, instead of 1.
+    if (m_devices[0] && m_devices[0]->m_device_type == EXIDeviceType::SD)
+      return m_devices[0].get();
+    else
+      return nullptr;
   case 1:
     return m_devices[0].get();
   case 2:

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

@@ -15,6 +15,7 @@
 #include "Core/HW/EXI/EXI_DeviceMemoryCard.h"
 #include "Core/HW/EXI/EXI_DeviceMic.h"
 #include "Core/HW/EXI/EXI_DeviceModem.h"
+#include "Core/HW/EXI/EXI_DeviceSD.h"
 #include "Core/HW/Memmap.h"
 #include "Core/System.h"
 
@@ -82,7 +83,7 @@ bool IEXIDevice::IsPresent() const
   return false;
 }
 
-void IEXIDevice::SetCS(int cs)
+void IEXIDevice::SetCS(u32 cs, bool was_selected, bool is_selected)
 {
 }
 
@@ -162,6 +163,10 @@ std::unique_ptr<IEXIDevice> EXIDevice_Create(Core::System& system, const EXIDevi
     result = std::make_unique<CEXIAgp>(system, slot);
     break;
 
+  case EXIDeviceType::SD:
+    result = std::make_unique<CEXISD>(system, channel_num);
+    break;
+
   case EXIDeviceType::AMBaseboard:
   case EXIDeviceType::None:
   default:

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

@@ -42,6 +42,7 @@ enum class EXIDeviceType : int
   EthernetTapServer,
   EthernetBuiltIn,
   ModemTapServer,
+  SD,
   None = 0xFF
 };
 
@@ -62,7 +63,7 @@ class IEXIDevice
 
   virtual bool UseDelayedTransferCompletion() const;
   virtual bool IsPresent() const;
-  virtual void SetCS(int cs);
+  virtual void SetCS(u32 cs, bool was_selected, bool is_selected);
   virtual void DoState(PointerWrap& p);
 
   // Is generating interrupt ?
@@ -88,7 +89,7 @@ std::unique_ptr<IEXIDevice> EXIDevice_Create(Core::System& system, EXIDeviceType
 
 template <>
 struct fmt::formatter<ExpansionInterface::EXIDeviceType>
-    : EnumFormatter<ExpansionInterface::EXIDeviceType::ModemTapServer>
+    : EnumFormatter<ExpansionInterface::EXIDeviceType::SD>
 {
   static constexpr array_type names = {
       _trans("Dummy"),
@@ -106,6 +107,7 @@ struct fmt::formatter<ExpansionInterface::EXIDeviceType>
       _trans("Broadband Adapter (tapserver)"),
       _trans("Broadband Adapter (HLE)"),
       _trans("Modem Adapter (tapserver)"),
+      _trans("SD Adapter"),
   };
 
   constexpr formatter() : EnumFormatter(names) {}

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

@@ -13,9 +13,9 @@ CEXIAD16::CEXIAD16(Core::System& system) : IEXIDevice(system)
 {
 }
 
-void CEXIAD16::SetCS(int cs)
+void CEXIAD16::SetCS(u32 cs, bool was_selected, bool is_selected)
 {
-  if (cs)
+  if (!was_selected && is_selected)
     m_position = 0;
 }
 

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

@@ -13,7 +13,8 @@ class CEXIAD16 : public IEXIDevice
 {
 public:
   explicit CEXIAD16(Core::System& system);
-  void SetCS(int cs) override;
+
+  void SetCS(u32 cs, bool was_selected, bool is_selected) override;
   bool IsPresent() const override;
   void DoState(PointerWrap& p) override;
 

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

@@ -26,6 +26,11 @@ u32 CEXIDummy::ImmRead(u32 size)
   return 0;
 }
 
+void CEXIDummy::ImmReadWrite(u32& data, u32 size)
+{
+  INFO_LOG_FMT(EXPANSIONINTERFACE, "EXI Dummy {} ImmReadWrite {}", m_name, data);
+}
+
 void CEXIDummy::DMAWrite(u32 address, u32 size)
 {
   INFO_LOG_FMT(EXPANSIONINTERFACE, "EXI DUMMY {} DMAWrite: {:08x} bytes, from {:08x} to device",

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

@@ -20,6 +20,7 @@ class CEXIDummy final : public IEXIDevice
 
   void ImmWrite(u32 data, u32 size) override;
   u32 ImmRead(u32 size) override;
+  void ImmReadWrite(u32& data, u32 size) override;
 
   void DMAWrite(u32 address, u32 size) override;
   void DMARead(u32 address, u32 size) override;

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

@@ -103,9 +103,9 @@ CEXIETHERNET::~CEXIETHERNET()
   m_network_interface->Deactivate();
 }
 
-void CEXIETHERNET::SetCS(int cs)
+void CEXIETHERNET::SetCS(u32 cs, bool was_selected, bool is_selected)
 {
-  if (cs)
+  if (!was_selected && is_selected)
   {
     // Invalidate the previous transfer
     transfer.valid = false;

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

@@ -216,7 +216,7 @@ class CEXIETHERNET : public IEXIDevice
 public:
   CEXIETHERNET(Core::System& system, BBADeviceType type);
   virtual ~CEXIETHERNET();
-  void SetCS(int cs) override;
+  void SetCS(u32 cs, bool was_selected, bool is_selected) override;
   bool IsPresent() const override;
   bool IsInterruptSet() override;
   void ImmWrite(u32 data, u32 size) override;

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

@@ -246,9 +246,9 @@ void CEXIIPL::LoadFontFile(const std::string& filename, u32 offset)
   m_fonts_loaded = true;
 }
 
-void CEXIIPL::SetCS(int cs)
+void CEXIIPL::SetCS(u32 cs, bool was_selected, bool is_selected)
 {
-  if (cs)
+  if (!was_selected && is_selected)
   {
     m_command_bytes_received = 0;
     m_cursor = 0;

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

@@ -19,7 +19,7 @@ class CEXIIPL : public IEXIDevice
   explicit CEXIIPL(Core::System& system);
   ~CEXIIPL() override;
 
-  void SetCS(int cs) override;
+  void SetCS(u32 cs, bool was_selected, bool is_selected) override;
   bool IsPresent() const override;
   void DoState(PointerWrap& p) override;
 

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

@@ -276,9 +276,9 @@ void CEXIMemoryCard::CmdDoneLater(u64 cycles)
   core_timing.ScheduleEvent(cycles, s_et_cmd_done[m_card_slot], static_cast<u64>(m_card_slot));
 }
 
-void CEXIMemoryCard::SetCS(int cs)
+void CEXIMemoryCard::SetCS(u32 cs, bool was_selected, bool is_selected)
 {
-  if (cs)  // not-selected to selected
+  if (!was_selected && is_selected)
   {
     m_position = 0;
   }

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

@@ -47,7 +47,7 @@ class CEXIMemoryCard : public IEXIDevice
   CEXIMemoryCard(Core::System& system, Slot slot, bool gci_folder,
                  const Memcard::HeaderData& header_data);
   ~CEXIMemoryCard() override;
-  void SetCS(int cs) override;
+  void SetCS(u32 cs, bool was_selected, bool is_selected) override;
   bool IsInterruptSet() override;
   bool UseDelayedTransferCompletion() const override;
   bool IsPresent() const override;