2026-09-15 08:51:45

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/core/hle/service/ipc_helpers.h

@@ -22,6 +22,7 @@
 
 namespace IPC {
 
+constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};
 
 struct ResponseBuilder {

src/core/hle/service/ngc/ngc.cpp

@@ -6,10 +6,15 @@
 
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_client_session.h"
+#include "core/hle/result.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
+#include "frontend_common/firmware_manager.h"
 
 namespace Service::NGC {
 
@@ -166,12 +171,117 @@ public:
     }
 };
 
+struct UndefinedIUserShimScopedObjectParam {
+    std::array<u8, 0x10> unk0;
+};
+static_assert(sizeof(UndefinedIUserShimScopedObjectParam) == 0x10);
+
+class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
+public:
+    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {450, nullptr, "Cmd450"},
+            {451, nullptr, "Cmd451"},
+            {452, D<&IUserShimScopedObject::Cmd452>, "Cmd451"},
+            {453, nullptr, "Cmd453"},
+            {454, D<&IUserShimScopedObject::Cmd454>, "Cmd454"},
+            {455, nullptr, "Cmd455"},
+            {456, nullptr, "Cmd456"},
+            {457, nullptr, "Cmd457"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result Cmd452(UndefinedIUserShimScopedObjectParam unk0, Out<u64> unk1) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result Cmd454(UndefinedIUserShimScopedObjectParam unk0, Out<u32> unk1, OutBuffer<BufferAttr_HipcAutoSelect> unk2) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+};
+
+class IUserService final : public ServiceFramework<IUserService> {
+public:
+    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&IUserService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(OutInterface<IUserShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<IUserShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
+class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
+public:
+    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {106, nullptr, "Cmd106"},
+            {107, nullptr, "Cmd107"},
+            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
+            {207, nullptr, "Cmd207"},
+            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
+            {209, nullptr, "Cmd209"},
+            {210, nullptr, "Cmd210"},
+            {211, nullptr, "Cmd211"},
+            {212, nullptr, "Cmd212"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result Cmd108() {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+};
+
+class ISystemService final : public ServiceFramework<ISystemService> {
+public:
+    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
     server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
     server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
+
+    // +23.0.0
+    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
+        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
+        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
+    }
+
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/input_common/helpers/joycon_driver.cpp

@@ -28,10 +28,8 @@ JoyconDriver::~JoyconDriver() {
 }
 
 void JoyconDriver::Stop() {
-    if (input_thread.joinable()) {
-        input_thread.request_stop();
-        input_thread.join();
-    }
+    is_connected = false;
+    input_thread = {};
 }
 
 Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info) {
@@ -60,6 +58,7 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
         return Common::Input::DriverResult::InvalidHandle;
     }
     std::scoped_lock lock{mutex};
+    disable_input_thread = true;
 
     // Reset Counters
     error_counter = 0;
@@ -127,44 +126,62 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
                                                    right_stick_calibration, motion_calibration);
 
     // Start polling for data
-    if (!input_thread.joinable()) {
-        input_thread = std::jthread([this](std::stop_token stop_token) {
-            InputThread(stop_token);
-        });
+    is_connected = true;
+    if (!input_thread_running) {
+        input_thread =
+            std::jthread([this](std::stop_token stop_token) { InputThread(stop_token); });
     }
+
+    disable_input_thread = false;
     return Common::Input::DriverResult::Success;
 }
 
 void JoyconDriver::InputThread(std::stop_token stop_token) {
     LOG_INFO(Input, "Joycon Adapter input thread started");
     Common::SetCurrentThreadName("JoyconInput");
+    input_thread_running = true;
+
+    // Max update rate is 5ms, ensure we are always able to read a bit faster
+    constexpr int ThreadDelay = 3;
+    std::vector<u8> buffer(MaxBufferSize);
 
     while (!stop_token.stop_requested()) {
-        // Max update rate is 5ms, so just (timeout) at 300ms
-        constexpr int READ_TIMEOUT_MS = 300;
-        constexpr size_t MAX_VIBRATIONS = 4;
-        std::array<u8, MaxBufferSize> buffer; // Filled by SDL, don't zero-init
         int status = 0;
-        if (IsInputThreadValid()) {
-            // By disabling the input thread we can ensure custom commands will succeed as no package is
-            // skipped
-            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(), READ_TIMEOUT_MS);
-            if (IsPayloadCorrect(status, buffer)) {
-                OnNewData(buffer);
-            }
-            if (!vibration_queue.Empty()) {
-                VibrationValue vibration_value;
-                vibration_queue.Pop(vibration_value);
-                last_vibration_result = rumble_protocol->SendVibration(vibration_value);
-            }
-            // We can't keep up with vibrations. Start skipping.
-            while (vibration_queue.Size() >= MAX_VIBRATIONS) {
-                vibration_queue.Pop();
-            }
-        } else {
+
+        if (!IsInputThreadValid()) {
             input_thread.request_stop();
+            continue;
         }
+
+        // By disabling the input thread we can ensure custom commands will succeed as no package is
+        // skipped
+        if (!disable_input_thread) {
+            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(),
+                                          ThreadDelay);
+        } else {
+            std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
+        }
+
+        if (IsPayloadCorrect(status, buffer)) {
+            OnNewData(buffer);
+        }
+
+        if (!vibration_queue.Empty()) {
+            VibrationValue vibration_value;
+            vibration_queue.Pop(vibration_value);
+            last_vibration_result = rumble_protocol->SendVibration(vibration_value);
+        }
+
+        // We can't keep up with vibrations. Start skipping.
+        while (vibration_queue.Size() > 6) {
+            vibration_queue.Pop();
+        }
+
+        std::this_thread::yield();
     }
+
+    is_connected = false;
+    input_thread_running = false;
     LOG_INFO(Input, "Joycon Adapter input thread stopped");
 }
 
@@ -254,6 +271,11 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
 }
 
 Common::Input::DriverResult JoyconDriver::SetPollingMode() {
+    SCOPE_EXIT {
+        disable_input_thread = false;
+    };
+    disable_input_thread = true;
+
     rumble_protocol->EnableRumble(vibration_enabled && supported_features.vibration);
 
     if (motion_enabled && supported_features.motion) {
@@ -360,12 +382,17 @@ JoyconDriver::SupportedFeatures JoyconDriver::GetSupportedFeatures() {
 }
 
 bool JoyconDriver::IsInputThreadValid() const {
-    if (hidapi_handle == nullptr || hidapi_handle->handle == nullptr)
+    if (!is_connected.load()) {
         return false;
+    }
+    if (hidapi_handle->handle == nullptr) {
+        return false;
+    }
     // Controller is not responding. Terminate connection
-    if (error_counter > MaxErrorCount)
+    if (error_counter > MaxErrorCount) {
         return false;
-    return input_thread.joinable();
+    }
+    return true;
 }
 
 bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
@@ -388,18 +415,30 @@ bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
 
 Common::Input::DriverResult JoyconDriver::SetVibration(const VibrationValue& vibration) {
     std::scoped_lock lock{mutex};
+    if (disable_input_thread) {
+        return Common::Input::DriverResult::HandleInUse;
+    }
     vibration_queue.Push(vibration);
     return last_vibration_result;
 }
 
 Common::Input::DriverResult JoyconDriver::SetLedConfig(u8 led_pattern) {
     std::scoped_lock lock{mutex};
+    if (disable_input_thread) {
+        return Common::Input::DriverResult::HandleInUse;
+    }
     return generic_protocol->SetLedPattern(led_pattern);
 }
 
 Common::Input::DriverResult JoyconDriver::SetIrsConfig(IrsMode mode_, IrsResolution format_) {
     std::scoped_lock lock{mutex};
-    return irs_protocol->SetIrsConfig(mode_, format_);
+    if (disable_input_thread) {
+        return Common::Input::DriverResult::HandleInUse;
+    }
+    disable_input_thread = true;
+    const auto result = irs_protocol->SetIrsConfig(mode_, format_);
+    disable_input_thread = false;
+    return result;
 }
 
 Common::Input::DriverResult JoyconDriver::SetPassiveMode() {
@@ -493,7 +532,12 @@ Common::Input::DriverResult JoyconDriver::StartNfcPolling() {
     if (!nfc_protocol->IsEnabled()) {
         return Common::Input::DriverResult::Disabled;
     }
-    return nfc_protocol->StartNFCPollingMode();
+
+    disable_input_thread = true;
+    const auto result = nfc_protocol->StartNFCPollingMode();
+    disable_input_thread = false;
+
+    return result;
 }
 
 Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
@@ -506,7 +550,10 @@ Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
         return Common::Input::DriverResult::Disabled;
     }
 
+    disable_input_thread = true;
     const auto result = nfc_protocol->StopNFCPollingMode();
+    disable_input_thread = false;
+
     if (amiibo_detected) {
         amiibo_detected = false;
         joycon_poller->UpdateAmiibo({});
@@ -529,7 +576,11 @@ Common::Input::DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_da
     }
 
     out_data.resize(0x21C);
-    return nfc_protocol->ReadAmiibo(out_data);
+    disable_input_thread = true;
+    const auto result = nfc_protocol->ReadAmiibo(out_data);
+    disable_input_thread = false;
+
+    return result;
 }
 
 Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) {
@@ -544,7 +595,12 @@ Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data)
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-    return nfc_protocol->WriteAmiibo(data);
+
+    disable_input_thread = true;
+    const auto result = nfc_protocol->WriteAmiibo(data);
+    disable_input_thread = false;
+
+    return result;
 }
 
 Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data,
@@ -560,7 +616,12 @@ Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareR
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-    return nfc_protocol->ReadMifare(data, out_data);
+
+    disable_input_thread = true;
+    const auto result = nfc_protocol->ReadMifare(data, out_data);
+    disable_input_thread = false;
+
+    return result;
 }
 
 Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const MifareWriteChunk> data) {
@@ -575,11 +636,17 @@ Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const Mifare
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-    return nfc_protocol->WriteMifare(data);
+
+    disable_input_thread = true;
+    const auto result = nfc_protocol->WriteMifare(data);
+    disable_input_thread = false;
+
+    return result;
 }
 
 bool JoyconDriver::IsConnected() const {
-    return input_thread.joinable();
+    std::scoped_lock lock{mutex};
+    return is_connected.load();
 }
 
 bool JoyconDriver::IsVibrationEnabled() const {

src/input_common/helpers/joycon_driver.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -163,6 +160,8 @@ private:
     // Thread related
     mutable std::mutex mutex;
     std::jthread input_thread;
+    bool input_thread_running{};
+    bool disable_input_thread{};
 };
 
 } // namespace InputCommon::Joycon

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -22,7 +22,7 @@ void JoyconPoller::SetCallbacks(const JoyconCallbacks& callbacks_) {
 void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status,
                                   const RingStatus& ring_status) {
     InputReportActive data{};
-    std::memcpy(&data, buffer.data(), sizeof(InputReportActive));
+    memcpy(&data, buffer.data(), sizeof(InputReportActive));
 
     switch (device_type) {
     case ControllerType::Left:
@@ -47,7 +47,7 @@ void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& moti
 
 void JoyconPoller::ReadPassiveMode(std::span<u8> buffer) {
     InputReportPassive data{};
-    std::memcpy(&data, buffer.data(), sizeof(InputReportPassive));
+    memcpy(&data, buffer.data(), sizeof(InputReportPassive));
 
     switch (device_type) {
     case ControllerType::Left: