SIO0 overhaul

src/core/memorycard.h

@@ -21,18 +21,27 @@
 
 #include <stdint.h>
 
+#include "core/psxemulator.h"
 #include "core/sstate.h"
+#include "magic_enum/include/magic_enum/magic_enum_all.hpp"
 
 namespace PCSX {
 class SIO;
 
+/// <summary>
+/// Implements a memory card for SIO
+/// </summary>
 class MemoryCard {
   public:
-    MemoryCard() : m_sio(nullptr) { memset(m_mcdData, 0, c_cardSize); }
-    MemoryCard(SIO *parent) : m_sio(parent) { memset(m_mcdData, 0, c_cardSize); }
+    enum class Which : uint8_t {
+        One = 0,
+        Two = 1,
+    };
+
+    MemoryCard(Which which) : m_whichDevice(which) {}
 
     // Hardware events
-    void acknowledge();
+
     void deselect() {
         memset(&m_tempBuffer, 0, c_sectorSize);
         m_currentCommand = Commands::None;
@@ -41,21 +50,16 @@ class MemoryCard {
         m_sector = 0;
         m_spdr = Responses::IdleHighZ;
     }
+    void reset() {
+        deselect();
+        m_directoryFlag = Flags::DirectoryUnread;
+    }
+
+    void setPocketstationEnabled(bool enabled) { m_pocketstationEnabled = enabled; };
 
     // File system / data manipulation
-    void commit(const PCSX::u8string path) {
-        if (!m_savedToDisk) {
-            saveMcd(path);
-        }
-    }
-    void createMcd(PCSX::u8string mcd);
-    bool dataChanged() { return !m_savedToDisk; }
-    void disablePocketstation() { m_pocketstationEnabled = false; };
-    void enablePocketstation() { m_pocketstationEnabled = true; };
+    void commit();
     char *getMcdData() { return m_mcdData; }
-    void loadMcd(PCSX::u8string mcd);
-    void saveMcd(PCSX::u8string mcd, const char *data, uint32_t adr, size_t size);
-    void saveMcd(PCSX::u8string mcd) { saveMcd(mcd, m_mcdData, 0, c_cardSize); }
 
   private:
     enum Commands : uint8_t {
@@ -97,21 +101,21 @@ class MemoryCard {
     friend class SIO;
     friend SaveStates::SaveState SaveStates::constructSaveState();
 
-    static constexpr size_t c_sectorSize = 8 * 16;
-    static constexpr size_t c_blockSize = 8192;
-    static constexpr size_t c_cardSize = 1024 * c_sectorSize;
+    static constexpr size_t c_sectorSize = 8 * 16;            // 80h bytes per sector/frame
+    static constexpr size_t c_blockSize = c_sectorSize * 64;  // 40h sectors per block
+    static constexpr size_t c_cardSize = c_blockSize * 16;    // 16 blocks per frame(directory+15 saves);
 
     // State machine / handlers
-    uint8_t transceive(uint8_t value);
-    uint8_t tickReadCommand(uint8_t value);
-    uint8_t tickWriteCommand(uint8_t value);
-    uint8_t tickPS_GetDirIndex(uint8_t value);   // 5Ah
-    uint8_t tickPS_GetVersion(uint8_t value);    // 58h
-    uint8_t tickPS_PrepFileExec(uint8_t value);  // 59h
-    uint8_t tickPS_ExecCustom(uint8_t value);    // 5Dh
-
-    char m_mcdData[c_cardSize];
-    uint8_t m_tempBuffer[c_sectorSize];
+    uint8_t transceive(uint8_t value, bool *ack);           // *
+    uint8_t tickReadCommand(uint8_t value, bool *ack);      // 52h
+    uint8_t tickWriteCommand(uint8_t value, bool *ack);     // 57h
+    uint8_t tickPS_GetDirIndex(uint8_t value, bool *ack);   // 5Ah
+    uint8_t tickPS_GetVersion(uint8_t value, bool *ack);    // 58h
+    uint8_t tickPS_PrepFileExec(uint8_t value, bool *ack);  // 59h
+    uint8_t tickPS_ExecCustom(uint8_t value, bool *ack);    // 5Dh
+
+    char m_mcdData[c_cardSize] = {0};
+    uint8_t m_tempBuffer[c_blockSize] = {0};
     bool m_savedToDisk = false;
 
     uint8_t m_checksumIn = 0, m_checksumOut = 0;
@@ -128,7 +132,109 @@ class MemoryCard {
     bool m_pocketstationEnabled = false;
     uint16_t m_directoryIndex = 0;
 
-    SIO *m_sio;
+    SIO *m_sio = nullptr;
+    Which m_whichDevice = Which::One;
+};
+
+/// <summary>
+/// Helper functions for MemoryCard class, gui, and filesystem
+/// </summary>
+class MemoryCards {
+  public:
+    void deselect() {
+        m_memoryCard[0].deselect();
+        m_memoryCard[1].deselect();
+    }
+
+    void reset() {
+        m_memoryCard[0].reset();
+        m_memoryCard[1].reset();
+    }
+
+    struct McdBlock {
+        McdBlock() { reset(); }
+        MemoryCard::Which mcd;
+        int number;
+        std::string titleAscii;
+        std::string titleSjis;
+        std::string titleUtf8;
+        std::string id;
+        std::string name;
+        uint32_t fileSize;
+        uint32_t iconCount;
+        uint16_t icon[16 * 16 * 3];
+        uint32_t allocState;
+        int16_t nextBlock;
+        void reset() {
+            mcd = MemoryCard::Which::One;
+            number = 0;
+            titleAscii.clear();
+            titleSjis.clear();
+            titleUtf8.clear();
+            id.clear();
+            name.clear();
+            fileSize = 0;
+            iconCount = 0;
+            memset(icon, 0, sizeof(icon));
+            allocState = 0;
+            nextBlock = -1;
+        }
+        bool isErased() const { return (allocState & 0xa0) == 0xa0; }
+        bool isChained() const { return (allocState & ~1) == 0x52; }
+    };
+
+    static constexpr size_t c_sectorSize = 8 * 16;            // 80h bytes per sector/frame
+    static constexpr size_t c_blockSize = c_sectorSize * 64;  // 40h sectors per block
+    static constexpr size_t c_cardSize = c_blockSize * 16;    // 16 blocks per frame(directory+15 saves)
+
+    bool copyMcdFile(McdBlock block);
+    void eraseMcdFile(const McdBlock &block);
+    void eraseMcdFile(MemoryCard::Which mcd, int block) {
+        McdBlock info;
+        getMcdBlockInfo(mcd, block, info);
+        eraseMcdFile(info);
+    }
+    int findFirstFree(MemoryCard::Which mcd);
+    unsigned getFreeSpace(MemoryCard::Which mcd);
+    unsigned getFileBlockCount(McdBlock block);
+    void getMcdBlockInfo(MemoryCard::Which mcd, int block, McdBlock &info);
+    char *getMcdData(MemoryCard::Which mcd);
+    char *getMcdData(const McdBlock &block) { return getMcdData(block.mcd); }
+
+    // File operations
+    void createMcd(PCSX::u8string mcd);
+    void loadMcds(const CommandLine::args &args);
+    bool saveMcd(MemoryCard::Which which);
+
+    bool loadMcd(PCSX::u8string mcd, char *data);
+    bool saveMcd(PCSX::u8string mcd, const char *data, uint32_t adr, size_t size);
+
+    static constexpr MemoryCard::Which otherMcd(MemoryCard::Which mcd) {
+        if ((mcd != MemoryCard::Which::One) && (mcd != MemoryCard::Which::Two))
+            throw std::runtime_error("Bad memory card number");
+        if (mcd == MemoryCard::Which::One) return MemoryCard::Which::Two;
+        return MemoryCard::Which::One;
+    }
+
+    PCSX::u8string getMcdPath(MemoryCard::Which which) {
+        std::filesystem::path *paths[] = {&PCSX::g_emulator->settings.get<PCSX::Emulator::SettingMcd1>().value,
+                                          &PCSX::g_emulator->settings.get<PCSX::Emulator::SettingMcd2>().value};
+
+        PCSX::u8string thepath = paths[magic_enum::enum_integer(which)]->u8string();
+        return thepath;
+    }
+    bool isCardInserted(MemoryCard::Which which) {
+        bool *const inserted_lut[] = {&PCSX::g_emulator->settings.get<PCSX::Emulator::SettingMcd1Inserted>().value,
+                                      &PCSX::g_emulator->settings.get<PCSX::Emulator::SettingMcd2Inserted>().value};
+
+        return *inserted_lut[magic_enum::enum_integer(which)];
+    }
+
+    static constexpr MemoryCard::Which otherMcd(const McdBlock &block) { return otherMcd(block.mcd); }
+    void resetCard(MemoryCard::Which which);
+    void setPocketstationEnabled(MemoryCard::Which which, bool enabled);
+
+    MemoryCard m_memoryCard[2] = {MemoryCard(MemoryCard::Which::One), MemoryCard(MemoryCard::Which::Two)};
 };
 
 }  // namespace PCSX

src/core/pad.cc

@@ -1,4 +1,4 @@
 /***************************************************************************
  *   Copyright (C) 2019 PCSX-Redux authors                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -45,8 +45,6 @@
     PadsImpl();
     void init() override;
     void shutdown() override;
-    uint8_t startPoll(Port port) override;
-    uint8_t poll(uint8_t value, Port port, uint32_t& padState) override;
 
     json getCfg() override;
     void setCfg(const json& j) override;
@@ -63,10 +61,18 @@
         if (pad > m_pads.size()) {
             return false;
         } else {
-            return m_pads[pad - 1].isControllerConnected();
+            return m_pads[pad].isControllerConnected();
         }
     }
 
+    void deselect() {
+        for (int i = 0; i < m_pads.size(); i++) {
+            m_pads[i].deselect();
+        }
+    }
+
+    uint8_t transceive(int index, uint8_t value, bool* ack) override { return m_pads[index].transceive(value, ack); }
+
   private:
     PCSX::EventBus::Listener m_listener;
     // This is a list of all of the valid GLFW gamepad IDs that we have found querying GLFW.
@@ -168,6 +174,12 @@
         bool isControllerButtonPressed(int button, GLFWgamepadstate* state);
         bool isControllerConnected() { return m_settings.get<SettingConnected>(); }
 
+        void deselect() {
+            m_bufferIndex = 0;
+            m_padState = Pads::PAD_STATE_IDLE;
+        }
+        uint8_t transceive(uint8_t value, bool* ack);
+
         json getCfg();
         void setCfg(const json& j);
         void setDefaults(bool firstController);
@@ -199,6 +211,13 @@
         uint8_t m_stdpar[8] = {0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
         uint8_t m_mousepar[6] = {0x12, 0x5a, 0xff, 0xff, 0xff, 0xff};
         uint8_t m_analogpar[8] = {0x73, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+        static constexpr size_t c_padBufferSize = 0x1010;
+
+        uint8_t m_buffer[c_padBufferSize];
+        uint32_t m_bufferIndex = 0;
+        uint32_t m_maxBufferIndex = 0;
+        uint32_t m_padState = Pads::PAD_STATE_IDLE;
     };
 
     std::array<Pad, 2> m_pads;
@@ -678,15 +697,49 @@
     pad.buttonStatus = result ^ 0xffff;  // Controls are inverted, so 0 = pressed
 }
 
-uint8_t PadsImpl::startPoll(Port port) {
-    int index = magic_enum::enum_integer(port);
-    m_pads[index].getButtons();
-    return m_pads[index].startPoll();
-}
+uint8_t PadsImpl::Pad::transceive(uint8_t value, bool* ack) {
+    uint8_t dataOut = 0xff;
+
+    switch (m_padState) {
+        case Pads::PAD_STATE_IDLE:  // start pad
+            getButtons();
+            m_buffer[0] = startPoll();
+            m_maxBufferIndex = 2;
+            m_bufferIndex = 0;
+            m_padState = Pads::PAD_STATE_READ_COMMAND;
+            break;
+
+        case Pads::PAD_STATE_READ_COMMAND:
+            m_padState = Pads::PAD_STATE_READ_DATA;
+            m_bufferIndex = 1;
+            m_buffer[m_bufferIndex] = poll(value, m_padState);
+
+            if (!(m_buffer[m_bufferIndex] & 0x0f)) {
+                m_maxBufferIndex = 2 + 32;
+            } else {
+                m_maxBufferIndex = 2 + (m_buffer[m_bufferIndex] & 0x0f) * 2;
+            }
+
+            break;
+
+        case Pads::PAD_STATE_READ_DATA:
+            m_bufferIndex++;
+            m_buffer[m_bufferIndex] = poll(value, m_padState);
+
+            if (m_bufferIndex == m_maxBufferIndex) {
+                m_padState = Pads::PAD_STATE_BAD_COMMAND;
+            }
+            break;
+    }
+
+    dataOut = m_buffer[m_bufferIndex];
+
+    if (m_padState == Pads::PAD_STATE_BAD_COMMAND) {
+    } else {
+        *ack = true;
+    }
 
-uint8_t PadsImpl::poll(uint8_t value, Port port, uint32_t& padState) {
-    int index = magic_enum::enum_integer(port);
-    return m_pads[index].poll(value, padState);
+    return dataOut;
 }
 
 uint8_t PadsImpl::Pad::poll(uint8_t value, uint32_t& padState) {

src/core/pad.h

@@ -29,17 +29,25 @@ using json = nlohmann::json;
 namespace PCSX {
 
 class GUI;
+class SIO;
 
 class Pads {
   public:
     enum class Port { Port1 = 0, Port2 };
 
     virtual ~Pads() = default;
 
+    class InputDevice {
+        virtual void* getPadState() = 0;
+        virtual bool isButtonPressed(int button) = 0;
+        virtual void updateInput() = 0;
+    };
+
     virtual void init() = 0;
     virtual void shutdown() = 0;
-    virtual uint8_t startPoll(Port port) = 0;
-    virtual uint8_t poll(uint8_t value, Port port, uint32_t& padState) = 0;
+
+    virtual void deselect() = 0;
+    virtual uint8_t transceive(int index, uint8_t value, bool* ack) = 0;
 
     virtual json getCfg() = 0;
     virtual void setCfg(const json& j) = 0;

src/core/psxemulator.cc

@@ -66,6 +66,7 @@ PCSX::Emulator::Emulator()
       m_lua(new PCSX::Lua()),
       m_mdec(new PCSX::MDEC()),
       m_mem(new PCSX::Memory()),
+      m_memoryCards(new PCSX::MemoryCards()),
       m_pads(PCSX::Pads::factory()),
       m_patchManager(new PatchManager()),
       m_pioCart(new PCSX::PIOCart),

src/core/psxemulator.h

@@ -78,6 +78,7 @@ class HW;
 class Lua;
 class MDEC;
 class Memory;
+class MemoryCards;
 class Pads;
 class PatchManager;
 class R3000Acpu;
@@ -264,6 +265,7 @@ class Emulator {
     std::unique_ptr<Lua> m_lua;
     std::unique_ptr<MDEC> m_mdec;
     std::unique_ptr<Memory> m_mem;
+    std::unique_ptr<MemoryCards> m_memoryCards;
     std::unique_ptr<Pads> m_pads;
     std::unique_ptr<PatchManager> m_patchManager;
     std::unique_ptr<PIOCart> m_pioCart;