Sio0 rework/pocketstation command additions

src/core/memorycard.h

@@ -0,0 +1,134 @@
+/***************************************************************************
+ *   Copyright (C) 2022 PCSX-Redux authors                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ ***************************************************************************/
+
+#pragma once
+
+#include <stdint.h>
+
+#include "core/sstate.h"
+
+namespace PCSX {
+class SIO;
+
+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); }
+
+    // Hardware events
+    void acknowledge();
+    void deselect() {
+        memset(&m_tempBuffer, 0, c_sectorSize);
+        m_currentCommand = Commands::None;
+        m_commandTicks = 0;
+        m_dataOffset = 0;
+        m_sector = 0;
+        m_spdr = Responses::IdleHighZ;
+    }
+
+    // File system / data manipulation
+    void commit(const PCSX::u8string path) {
+        if (!m_savedToDisk) {
+            saveMcd(path);
+        }
+    }
+    void createMcd(const PCSX::u8string mcd);
+    bool dataChanged() { return !m_savedToDisk; }
+    void disablePocketstation() { m_pocketstationEnabled = false; };
+    void enablePocketstation() { m_pocketstationEnabled = true; };
+    char *getMcdData() { return m_mcdData; }
+    void loadMcd(const PCSX::u8string str);
+    void saveMcd(const PCSX::u8string mcd, const char *data, uint32_t adr, size_t size);
+    void saveMcd(const PCSX::u8string path) { saveMcd(path, m_mcdData, 0, c_cardSize); }
+
+  private:
+    enum Commands : uint8_t {
+        Access = 0x81,  // Memory Card Select
+        Read = 0x52,    // Read Command
+        GetID = 0x53,   // Get ID Command
+        Write = 0x57,   // Write Command
+        None = 0x00,    // No command, idle state
+        Error = 0xFF,   // Bad command
+
+        // PocketStation command extensions
+        PS_ChangeFuncValue = 0x50,  // Change a FUNC 03h related value or so
+        PS_GetVersion = 0x58,       // Get an ID or Version value or so
+        PS_PrepFileExec = 0x59,     // Prepare File Execution with Dir_index, and Parameter
+        PS_GetDirIndex = 0x5A,      // Get Dir_index, ComFlags, F_SN, Date, and Time
+        PS_ExecXferPSToPSX = 0x5B,  // Execute Function and transfer data from Pocketstation to PSX
+        PS_ExecXferPSXToPS = 0x5C,  // Execute Function and transfer data from PSX to Pocketstation
+        PS_ExecCustom = 0x5D,       // Execute Custom Download Notification Function   ;via SWI 01h with r0=3
+        PS_GetComFlagsHi = 0x5E,    // Get-and-Send ComFlags.bit1,3,2
+        PS_GetComFlagsLo = 0x5F,    // Get-and-Send ComFlags.bit0
+    };
+    enum Flags : uint8_t {
+        DirectoryUnread = 0x08,  // Initial power on value
+        DirectoryRead = 0x00     // Cleared after good MC Write
+                                 // (test write sector 3F = 0x1F80) offset
+    };
+    enum Responses : uint8_t {
+        IdleHighZ = 0xFF,            // High default state
+        Dummy = 0x00,                // Filler Data
+        ID1 = 0x5A,                  // Memory Card ID1
+        ID2 = 0x5D,                  // Memory Card ID2
+        CommandAcknowledge1 = 0x5C,  // Command Acknowledge 1
+        CommandAcknowledge2 = 0x5D,  // Command Acknowledge 2
+        GoodReadWrite = 0x47,        // Good Read/Write
+        BadChecksum = 0x4E,          // Bad Checksum during Write
+        BadSector = 0xFF,            // Bad Memory Card Sector
+    };
+
+    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;
+
+    // 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];
+    bool m_savedToDisk = false;
+
+    uint8_t m_checksumIn = 0, m_checksumOut = 0;
+    uint16_t m_commandTicks = 0;
+    uint8_t m_currentCommand = Commands::None;
+    uint16_t m_sector = 0;
+    uint32_t m_dataOffset = 0;
+
+    uint8_t m_directoryFlag = Flags::DirectoryUnread;
+
+    uint8_t m_spdr = Responses::IdleHighZ;
+
+    // PocketStation Specific
+    bool m_pocketstationEnabled = false;
+    uint16_t m_directoryIndex = 0;
+
+    SIO *m_sio;
+};
+
+}  // namespace PCSX

src/core/pad.cc

@@ -170,6 +170,7 @@ bool PCSX::Pads::Pad::isControllerButtonPressed(int button, GLFWgamepadstate* st
             return false;
         default:
             return state->buttons[mapped];
+            break;
     }
 }
 
@@ -240,7 +241,9 @@ void PCSX::Pads::Pad::getButtons() {
             float a = 0;
             if ((x * x) > (y * y)) {
                 a = std::acos(x);
-                if (y < 0) a = π(2.0f) - a;
+                if (y < 0) {
+                    a = π(2.0f) - a;
+                }
             } else {
                 a = std::asin(y);
                 if (x < 0) {
@@ -309,7 +312,7 @@ uint8_t PCSX::Pads::Pad::poll(uint8_t value, uint32_t& padState) {
             PCSX::g_system->log(PCSX::LogClass::SIO0, _("Unknown command for pad: %02X\n"), value);
             m_cmd = magic_enum::enum_integer(PadCommands::Idle);
             m_bufferLen = 0;
-            padState = PAD_STATE_IDLE;  // Tell the SIO class we're in an invalid state
+            padState = PAD_STATE_BAD_COMMAND;  // Tell the SIO class we're in an invalid state
             return 0xff;
         }
     } else if (m_currentByte >= m_bufferLen) {
@@ -361,7 +364,7 @@ uint8_t PCSX::Pads::Pad::doDualshockCommand(uint32_t& padState) {
 
     if (m_cmd == magic_enum::enum_integer(PadCommands::SetConfigMode)) {
         if (m_configMode) {  // The config mode version of this command does not reply with pad data
-            static const uint8_t reply[] = {0x00, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+            static constexpr uint8_t reply[] = {0x00, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
             std::memcpy(m_buf, reply, 8);
             return 0xf3;
         } else {
@@ -402,7 +405,7 @@ uint8_t PCSX::Pads::Pad::doDualshockCommand(uint32_t& padState) {
         PCSX::g_system->log(PCSX::LogClass::SIO0, _("Unknown command for pad: %02X\n"), static_cast<uint8_t>(m_cmd));
         m_cmd = magic_enum::enum_integer(PadCommands::Idle);
         m_bufferLen = 0;
-        padState = PAD_STATE_IDLE;  // Tell the SIO class we're in an invalid state
+        padState = PAD_STATE_BAD_COMMAND;  // Tell the SIO class we're in an invalid state
         return 0xff;
     }
 }
@@ -479,6 +482,7 @@ uint8_t PCSX::Pads::Pad::read() {
             memcpy(m_buf, m_stdpar, 4);
             m_bufferLen = 4;
             return 0x41;
+            break;
     }
 }
 
@@ -776,6 +780,7 @@ int& PCSX::Pads::Pad::getButtonFromGUIIndex(int buttonIndex) {
             return m_settings.get<Keyboard_PadLeft>().value;
         default:
             abort();
+            break;
     }
 }
 
@@ -827,8 +832,12 @@ void PCSX::Pads::Pad::setDefaults(bool firstController) {
 void PCSX::Pads::setLua(Lua L) {
     auto getButton = [this](Lua L, unsigned pad) -> int {
         int n = L.gettop();
-        if (n == 0) return L.error("Not enough arguments to getButton");
-        if (!L.isnumber(1)) return L.error("Invalid argument to getButton");
+        if (n == 0) {
+            return L.error("Not enough arguments to getButton");
+        }
+        if (!L.isnumber(1)) {
+            return L.error("Invalid argument to getButton");
+        }
         auto buttons = m_pads[pad].m_data.buttonStatus;
         unsigned button = L.checknumber(1);
         L.push((buttons & (1 << button)) == 0);
@@ -837,8 +846,12 @@ void PCSX::Pads::setLua(Lua L) {
 
     auto setOverride = [this](Lua L, unsigned pad) -> int {
         int n = L.gettop();
-        if (n == 0) return L.error("Not enough arguments to setOverride");
-        if (!L.isnumber(1)) return L.error("Invalid argument to setOverride");
+        if (n == 0) {
+            return L.error("Not enough arguments to setOverride");
+        }
+        if (!L.isnumber(1)) {
+            return L.error("Invalid argument to setOverride");
+        }
         auto& overrides = m_pads[pad].m_data.overrides;
         unsigned button = L.checknumber(1);
         button = 1 << button;
@@ -848,8 +861,12 @@ void PCSX::Pads::setLua(Lua L) {
 
     auto clearOverride = [this](Lua L, unsigned pad) -> int {
         int n = L.gettop();
-        if (n == 0) return L.error("Not enough arguments to clearOverride");
-        if (!L.isnumber(1)) return L.error("Invalid argument to clearOverride");
+        if (n == 0) {
+            return L.error("Not enough arguments to clearOverride");
+        }
+        if (!L.isnumber(1)) {
+            return L.error("Invalid argument to clearOverride");
+        }
         auto& overrides = m_pads[pad].m_data.overrides;
         unsigned button = L.checknumber(1);
         button = 1 << button;

src/core/pad.h

@@ -42,6 +42,7 @@ enum {
     PAD_STATE_IDLE = 0,
     PAD_STATE_READ_COMMAND = 1,
     PAD_STATE_READ_DATA = 2,
+    PAD_STATE_BAD_COMMAND = 3,
 };
 
 class Pads {
@@ -68,13 +69,21 @@ class Pads {
 
     void setLua(Lua L);
 
+    bool isPadConnected(int pad) {
+        if (pad > m_pads.size()) {
+            return false;
+        } else {
+            return m_pads[pad - 1].isControllerConnected();
+        }
+    }
+
   private:
     EventBus::Listener m_listener;
     int m_gamepadsMap[16] = {0};
 
-    static const int GLFW_GAMEPAD_BUTTON_LEFT_TRIGGER = GLFW_GAMEPAD_BUTTON_LAST + 1;
-    static const int GLFW_GAMEPAD_BUTTON_RIGHT_TRIGGER = GLFW_GAMEPAD_BUTTON_LAST + 2;
-    static const int GLFW_GAMEPAD_BUTTON_INVALID = GLFW_GAMEPAD_BUTTON_LAST + 3;
+    static constexpr int GLFW_GAMEPAD_BUTTON_LEFT_TRIGGER = GLFW_GAMEPAD_BUTTON_LAST + 1;
+    static constexpr int GLFW_GAMEPAD_BUTTON_RIGHT_TRIGGER = GLFW_GAMEPAD_BUTTON_LAST + 2;
+    static constexpr int GLFW_GAMEPAD_BUTTON_INVALID = GLFW_GAMEPAD_BUTTON_LAST + 3;
 
     // settings block
     // Pad keyboard bindings
@@ -164,6 +173,7 @@ class Pads {
         uint8_t doDualshockCommand(uint32_t &padState);
         void getButtons();
         bool isControllerButtonPressed(int button, GLFWgamepadstate *state);
+        bool isControllerConnected() { return m_settings.get<SettingConnected>(); }
 
         json getCfg();
         void setCfg(const json &j);

src/core/psxemulator.cc

@@ -124,7 +124,7 @@ int PCSX::Emulator::init() {
     }
 
     setPGXPMode(m_config.PGXP_Mode);
-    m_pads->init();
+    m_sio->init();
     return ret;
 }
 

src/core/psxemulator.h

@@ -179,13 +179,16 @@ class Emulator {
     typedef Setting<int, TYPESTRING("MSAA"), 1> SettingMSAA;
     typedef Setting<bool, TYPESTRING("LinearFiltering"), true> SettingLinearFiltering;
     typedef Setting<bool, TYPESTRING("KioskMode"), false> SettingKioskMode;
+    typedef Setting<bool, TYPESTRING("Mcd1Pocketstation"), false> SettingMcd1Pocketstation;
+    typedef Setting<bool, TYPESTRING("Mcd2Pocketstation"), false> SettingMcd2Pocketstation;
 
     Settings<SettingStdout, SettingLogfile, SettingMcd1, SettingMcd2, SettingBios, SettingPpfDir, SettingPsxExe,
              SettingXa, SettingSpuIrq, SettingBnWMdec, SettingScaler, SettingAutoVideo, SettingVideo, SettingFastBoot,
              SettingDebugSettings, SettingRCntFix, SettingIsoPath, SettingLocale, SettingMcd1Inserted,
              SettingMcd2Inserted, SettingDynarec, Setting8MB, SettingGUITheme, SettingDither, SettingGLErrorReporting,
              SettingGLErrorReportingSeverity, SettingFullCaching, SettingHardwareRenderer, SettingShownAutoUpdateConfig,
-             SettingAutoUpdate, SettingMSAA, SettingLinearFiltering, SettingKioskMode>
+             SettingAutoUpdate, SettingMSAA, SettingLinearFiltering, SettingKioskMode, SettingMcd1Pocketstation,
+             SettingMcd2Pocketstation>
         settings;
     class PcsxConfig {
       public: