2026-09-12 01:12:32

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

src/core/hle/service/ipc_helpers.h

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

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

@@ -6,15 +6,10 @@
 
 #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 {
 
@@ -171,117 +166,12 @@ 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,8 +28,10 @@ JoyconDriver::~JoyconDriver() {
 }
 
 void JoyconDriver::Stop() {
-    is_connected = false;
-    input_thread = {};
+    if (input_thread.joinable()) {
+        input_thread.request_stop();
+        input_thread.join();
+    }
 }
 
 Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info) {
@@ -58,7 +60,6 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
         return Common::Input::DriverResult::InvalidHandle;
     }
     std::scoped_lock lock{mutex};
-    disable_input_thread = true;
 
     // Reset Counters
     error_counter = 0;
@@ -126,62 +127,44 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
                                                    right_stick_calibration, motion_calibration);
 
     // Start polling for data
-    is_connected = true;
-    if (!input_thread_running) {
-        input_thread =
-            std::jthread([this](std::stop_token stop_token) { InputThread(stop_token); });
+    if (!input_thread.joinable()) {
+        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()) {
-            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);
+        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 {
-            std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
+            input_thread.request_stop();
         }
-
-        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");
 }
 
@@ -271,11 +254,6 @@ 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) {
@@ -382,17 +360,12 @@ JoyconDriver::SupportedFeatures JoyconDriver::GetSupportedFeatures() {
 }
 
 bool JoyconDriver::IsInputThreadValid() const {
-    if (!is_connected.load()) {
+    if (hidapi_handle == nullptr || hidapi_handle->handle == nullptr)
         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 true;
+    return input_thread.joinable();
 }
 
 bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
@@ -415,30 +388,18 @@ 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};
-    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;
+    return irs_protocol->SetIrsConfig(mode_, format_);
 }
 
 Common::Input::DriverResult JoyconDriver::SetPassiveMode() {
@@ -532,12 +493,7 @@ Common::Input::DriverResult JoyconDriver::StartNfcPolling() {
     if (!nfc_protocol->IsEnabled()) {
         return Common::Input::DriverResult::Disabled;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->StartNFCPollingMode();
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->StartNFCPollingMode();
 }
 
 Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
@@ -550,10 +506,7 @@ 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({});
@@ -576,11 +529,7 @@ Common::Input::DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_da
     }
 
     out_data.resize(0x21C);
-    disable_input_thread = true;
-    const auto result = nfc_protocol->ReadAmiibo(out_data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->ReadAmiibo(out_data);
 }
 
 Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) {
@@ -595,12 +544,7 @@ Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data)
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->WriteAmiibo(data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->WriteAmiibo(data);
 }
 
 Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data,
@@ -616,12 +560,7 @@ Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareR
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->ReadMifare(data, out_data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->ReadMifare(data, out_data);
 }
 
 Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const MifareWriteChunk> data) {
@@ -636,17 +575,11 @@ Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const Mifare
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->WriteMifare(data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->WriteMifare(data);
 }
 
 bool JoyconDriver::IsConnected() const {
-    std::scoped_lock lock{mutex};
-    return is_connected.load();
+    return input_thread.joinable();
 }
 
 bool JoyconDriver::IsVibrationEnabled() const {

src/input_common/helpers/joycon_driver.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -160,8 +163,6 @@ 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{};
-    memcpy(&data, buffer.data(), sizeof(InputReportActive));
+    std::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{};
-    memcpy(&data, buffer.data(), sizeof(InputReportPassive));
+    std::memcpy(&data, buffer.data(), sizeof(InputReportPassive));
 
     switch (device_type) {
     case ControllerType::Left: