[video_core, hle] remove redundant parent references in system structs (#3908)

reworked a bit to remove references of parent objects and instead pass as arguments to methods to prevent useless reloads

Signed-off-by: lizzie <lizzie@eden-emu.dev>
Co-authored-by: maufeat <sahyno1996@gmail.com>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3908
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: crueter <crueter@eden-emu.dev>

35 files changed, 363 insertions, 248 deletions

diff --git a/src/hid_core/hid_core.cpp b/src/hid_core/hid_core.cpp
index 410c84afbc..12cd0c1f27 100644
--- a/src/hid_core/hid_core.cpp
+++ b/src/hid_core/hid_core.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,18 +13,20 @@
 
 namespace Core::HID {
 
-HIDCore::HIDCore()
-    : player_1{std::make_unique<EmulatedController>(NpadIdType::Player1)},
-      player_2{std::make_unique<EmulatedController>(NpadIdType::Player2)},
-      player_3{std::make_unique<EmulatedController>(NpadIdType::Player3)},
-      player_4{std::make_unique<EmulatedController>(NpadIdType::Player4)},
-      player_5{std::make_unique<EmulatedController>(NpadIdType::Player5)},
-      player_6{std::make_unique<EmulatedController>(NpadIdType::Player6)},
-      player_7{std::make_unique<EmulatedController>(NpadIdType::Player7)},
-      player_8{std::make_unique<EmulatedController>(NpadIdType::Player8)},
-      other{std::make_unique<EmulatedController>(NpadIdType::Other)},
-      handheld{std::make_unique<EmulatedController>(NpadIdType::Handheld)},
-      console{std::make_unique<EmulatedConsole>()}, devices{std::make_unique<EmulatedDevices>()} {}
+HIDCore::HIDCore(Kernel::KernelCore& kernel_)
+    : player_1{std::make_unique<EmulatedController>(NpadIdType::Player1)}
+    , player_2{std::make_unique<EmulatedController>(NpadIdType::Player2)}
+    , player_3{std::make_unique<EmulatedController>(NpadIdType::Player3)}
+    , player_4{std::make_unique<EmulatedController>(NpadIdType::Player4)}
+    , player_5{std::make_unique<EmulatedController>(NpadIdType::Player5)}
+    , player_6{std::make_unique<EmulatedController>(NpadIdType::Player6)}
+    , player_7{std::make_unique<EmulatedController>(NpadIdType::Player7)}
+    , player_8{std::make_unique<EmulatedController>(NpadIdType::Player8)}
+    , other{std::make_unique<EmulatedController>(NpadIdType::Other)}
+    , handheld{std::make_unique<EmulatedController>(NpadIdType::Handheld)}
+    , console{std::make_unique<EmulatedConsole>()}, devices{std::make_unique<EmulatedDevices>()}
+    , kernel{kernel_}
+{}
 
 HIDCore::~HIDCore() = default;
 
diff --git a/src/hid_core/hid_core.h b/src/hid_core/hid_core.h
index dae29c5062..7da11897ca 100644
--- a/src/hid_core/hid_core.h
+++ b/src/hid_core/hid_core.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,6 +11,10 @@
 #include "common/common_funcs.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Core::HID {
 class EmulatedConsole;
 class EmulatedController;
@@ -18,7 +25,7 @@ namespace Core::HID {
 
 class HIDCore {
 public:
-    explicit HIDCore();
+    explicit HIDCore(Kernel::KernelCore& kernel);
     ~HIDCore();
 
     YUZU_NON_COPYABLE(HIDCore);
@@ -69,7 +76,6 @@ public:
     /// Number of emulated controllers
     static constexpr std::size_t available_controllers{10};
 
-private:
     std::unique_ptr<EmulatedController> player_1;
     std::unique_ptr<EmulatedController> player_2;
     std::unique_ptr<EmulatedController> player_3;
@@ -82,6 +88,7 @@ private:
     std::unique_ptr<EmulatedController> handheld;
     std::unique_ptr<EmulatedConsole> console;
     std::unique_ptr<EmulatedDevices> devices;
+    Kernel::KernelCore& kernel;
     NpadStyleTag supported_style_tag{NpadStyleSet::All};
     NpadIdType last_active_controller{NpadIdType::Handheld};
 };
diff --git a/src/hid_core/hidbus/ringcon.cpp b/src/hid_core/hidbus/ringcon.cpp
index 1927a6f856..b942cad480 100644
--- a/src/hid_core/hidbus/ringcon.cpp
+++ b/src/hid_core/hidbus/ringcon.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -141,12 +141,12 @@ bool RingController::SetCommand(std::span<const u8> data) {
     case RingConCommands::ReadRepCount:
     case RingConCommands::ReadTotalPushCount:
         ASSERT_MSG(data.size() == 0x4, "data.size is not 0x4 bytes");
-        send_command_async_event->Signal();
+        send_command_async_event->Signal(system.Kernel());
         return true;
     case RingConCommands::ResetRepCount:
         ASSERT_MSG(data.size() == 0x4, "data.size is not 0x4 bytes");
         total_rep_count = 0;
-        send_command_async_event->Signal();
+        send_command_async_event->Signal(system.Kernel());
         return true;
     case RingConCommands::SaveCalData: {
         ASSERT_MSG(data.size() == 0x14, "data.size is not 0x14 bytes");
@@ -154,14 +154,14 @@ bool RingController::SetCommand(std::span<const u8> data) {
         SaveCalData save_info{};
         std::memcpy(&save_info, data.data(), sizeof(SaveCalData));
         user_calibration = save_info.calibration;
-        send_command_async_event->Signal();
+        send_command_async_event->Signal(system.Kernel());
         return true;
     }
     default:
         LOG_ERROR(Service_HID, "Command not implemented {}", command);
         command = RingConCommands::Error;
         // Signal a reply to avoid softlocking the game
-        send_command_async_event->Signal();
+        send_command_async_event->Signal(system.Kernel());
         return false;
     }
 }
diff --git a/src/hid_core/resource_manager.cpp b/src/hid_core/resource_manager.cpp
index 0c10d1bec9..d4d62ea4ba 100644
--- a/src/hid_core/resource_manager.cpp
+++ b/src/hid_core/resource_manager.cpp
@@ -91,7 +91,7 @@ ResourceManager::~ResourceManager() {
     system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
     system.CoreTiming().UnscheduleEvent(motion_update_event);
     system.CoreTiming().UnscheduleEvent(touch_update_event);
-    input_event->Finalize();
+    input_event->Finalize(system.Kernel());
 };
 
 void ResourceManager::Initialize() {
@@ -486,7 +486,7 @@ void ResourceManager::UpdateControllers(std::chrono::nanoseconds ns_late) {
 
 void ResourceManager::UpdateNpad(std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
-    npad->OnUpdate(core_timing);
+    npad->OnUpdate(system.Kernel(), core_timing);
 }
 
 void ResourceManager::UpdateMouseKeyboard(std::chrono::nanoseconds ns_late) {
diff --git a/src/hid_core/resources/abstracted_pad/abstract_battery_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_battery_handler.cpp
index d5f37247e1..a80f8271f9 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_battery_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_battery_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -16,7 +16,9 @@
 
 namespace Service::HID {
 
-NpadAbstractBatteryHandler::NpadAbstractBatteryHandler() {}
+NpadAbstractBatteryHandler::NpadAbstractBatteryHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractBatteryHandler::~NpadAbstractBatteryHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_battery_handler.h b/src/hid_core/resources/abstracted_pad/abstract_battery_handler.h
index 85ac5eb72f..9c270aa92d 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_battery_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_battery_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,6 +10,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 struct AppletResourceHolder;
 class NpadAbstractedPadHolder;
@@ -15,7 +22,7 @@ class NpadAbstractPropertiesHandler;
 /// Handles Npad request from HID interfaces
 class NpadAbstractBatteryHandler final {
 public:
-    explicit NpadAbstractBatteryHandler();
+    explicit NpadAbstractBatteryHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractBatteryHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -44,6 +51,7 @@ private:
     Core::HID::NpadPowerInfo left_battery{};
     Core::HID::NpadPowerInfo right_battery{};
     bool has_new_battery_data{};
+    Kernel::KernelCore& kernel;
 };
 
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp
index 36deb25c94..239fc7656e 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -16,7 +16,9 @@
 
 namespace Service::HID {
 
-NpadAbstractButtonHandler::NpadAbstractButtonHandler() {}
+NpadAbstractButtonHandler::NpadAbstractButtonHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractButtonHandler::~NpadAbstractButtonHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_button_handler.h b/src/hid_core/resources/abstracted_pad/abstract_button_handler.h
index 01eafe96df..6e49471b5e 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_button_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_button_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,6 +10,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 struct NpadSharedMemoryEntry;
 
@@ -17,7 +24,7 @@ class NpadAbstractPropertiesHandler;
 /// Handles Npad request from HID interfaces
 class NpadAbstractButtonHandler final {
 public:
-    explicit NpadAbstractButtonHandler();
+    explicit NpadAbstractButtonHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractButtonHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -70,6 +77,7 @@ private:
 
     u64 gc_sampling_number{};
     GcTrigger gc_trigger_state{};
+    Kernel::KernelCore& kernel;
 };
 
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp
index 16ec2257fb..a2aaa1d8ec 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -14,7 +14,9 @@
 
 namespace Service::HID {
 
-NpadAbstractIrSensorHandler::NpadAbstractIrSensorHandler() {}
+NpadAbstractIrSensorHandler::NpadAbstractIrSensorHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractIrSensorHandler::~NpadAbstractIrSensorHandler() = default;
 
@@ -52,7 +54,7 @@ void NpadAbstractIrSensorHandler::UpdateIrSensorState() {
         if (sensor_state == previous_state) {
             return;
         }
-        ir_sensor_event->Signal();
+        ir_sensor_event->Signal(kernel);
         return;
     }
 
@@ -77,7 +79,7 @@ void NpadAbstractIrSensorHandler::UpdateIrSensorState() {
         if (sensor_state == previous_state) {
             return;
         }
-        ir_sensor_event->Signal();
+        ir_sensor_event->Signal(kernel);
         return;
     }
 
@@ -86,7 +88,7 @@ void NpadAbstractIrSensorHandler::UpdateIrSensorState() {
         return;
     }
 
-    ir_sensor_event->Signal();
+    ir_sensor_event->Signal(kernel);
     return;
 }
 
@@ -105,7 +107,7 @@ Result NpadAbstractIrSensorHandler::ActivateIrSensor(bool is_enabled) {
         }
         sensor_state = NpadIrSensorState::Available;
     }
-    ir_sensor_event->Signal();
+    ir_sensor_event->Signal(kernel);
     return ResultSuccess;
 }
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h
index 9978115116..799d83e82f 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -12,6 +15,7 @@ class EmulatedController;
 }
 
 namespace Kernel {
+class KernelCore;
 class KEvent;
 class KReadableEvent;
 } // namespace Kernel
@@ -30,7 +34,7 @@ class NpadAbstractPropertiesHandler;
 /// Handles Npad request from HID interfaces
 class NpadAbstractIrSensorHandler final {
 public:
-    explicit NpadAbstractIrSensorHandler();
+    explicit NpadAbstractIrSensorHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractIrSensorHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -56,5 +60,6 @@ private:
     Kernel::KEvent* ir_sensor_event{nullptr};
     Core::HID::EmulatedController* xcd_handle{};
     NpadIrSensorState sensor_state{};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_led_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_led_handler.cpp
index 813d3d3188..94d895509b 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_led_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_led_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -15,7 +15,9 @@
 
 namespace Service::HID {
 
-NpadAbstractLedHandler::NpadAbstractLedHandler() {}
+NpadAbstractLedHandler::NpadAbstractLedHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractLedHandler::~NpadAbstractLedHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_led_handler.h b/src/hid_core/resources/abstracted_pad/abstract_led_handler.h
index 09528129b6..7ff12a9e75 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_led_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_led_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,6 +10,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 struct AppletResourceHolder;
 class NpadAbstractedPadHolder;
@@ -15,7 +22,7 @@ class NpadAbstractPropertiesHandler;
 /// Handles Npad request from HID interfaces
 class NpadAbstractLedHandler final {
 public:
-    explicit NpadAbstractLedHandler();
+    explicit NpadAbstractLedHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractLedHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -39,5 +46,6 @@ private:
     Core::HID::LedPattern left_pattern{0, 0, 0, 0};
     Core::HID::LedPattern right_pattern{0, 0, 0, 0};
     u64 led_interval{};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.cpp
index 2b763d8e0f..d87446030a 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -12,7 +12,9 @@
 
 namespace Service::HID {
 
-NpadAbstractMcuHandler::NpadAbstractMcuHandler() {}
+NpadAbstractMcuHandler::NpadAbstractMcuHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractMcuHandler::~NpadAbstractMcuHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.h b/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.h
index 9902dd03a7..44be82cd43 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_mcu_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,6 +10,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 struct IAbstractedPad;
 class NpadAbstractedPadHolder;
@@ -28,7 +35,7 @@ static_assert(sizeof(NpadMcuHolder) == 0x10, "NpadMcuHolder is an invalid size")
 /// Handles Npad request from HID interfaces
 class NpadAbstractMcuHandler final {
 public:
-    explicit NpadAbstractMcuHandler();
+    explicit NpadAbstractMcuHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractMcuHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -48,5 +55,6 @@ private:
 
     s32 ref_counter{};
     std::array<NpadMcuHolder, 2> mcu_holder{};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.cpp
index 80f5f3ba62..9990add4cc 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -14,7 +14,9 @@
 
 namespace Service::HID {
 
-NpadAbstractNfcHandler::NpadAbstractNfcHandler() {}
+NpadAbstractNfcHandler::NpadAbstractNfcHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractNfcHandler::~NpadAbstractNfcHandler() = default;
 
@@ -48,13 +50,13 @@ void NpadAbstractNfcHandler::UpdateNfcState() {
 
     if (count == 0) {
         if (sensor_state == NpadNfcState::Active) {
-            nfc_activate_event->Signal();
+            nfc_activate_event->Signal(kernel);
         }
         if (sensor_state == NpadNfcState::Unavailable) {
             return;
         }
         sensor_state = NpadNfcState::Unavailable;
-        input_event->Signal();
+        input_event->Signal(kernel);
         return;
     }
 
@@ -79,19 +81,18 @@ void NpadAbstractNfcHandler::UpdateNfcState() {
             return;
         }
         sensor_state = NpadNfcState::Available;
-        input_event->Signal();
+        input_event->Signal(kernel);
         return;
     }
 
     if (sensor_state == NpadNfcState::Active) {
-        nfc_activate_event->Signal();
+        nfc_activate_event->Signal(kernel);
     }
     if (sensor_state == NpadNfcState::Unavailable) {
         return;
     }
     sensor_state = NpadNfcState::Unavailable;
-    input_event->Signal();
-    return;
+    input_event->Signal(kernel);
 }
 
 bool NpadAbstractNfcHandler::HasNfcSensor() {
@@ -123,7 +124,7 @@ Result NpadAbstractNfcHandler::ActivateNfc(bool is_enabled) {
     }
     if (sensor_state != new_state) {
         sensor_state = new_state;
-        nfc_activate_event->Signal();
+        nfc_activate_event->Signal(kernel);
     }
     return ResultSuccess;
 }
diff --git a/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.h b/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.h
index 0702722a6b..223a0afd4e 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_nfc_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -8,7 +11,9 @@
 #include "hid_core/hid_types.h"
 
 namespace Kernel {
+class KernelCore;
 class KReadableEvent;
+class KEvent;
 }
 
 enum class NpadNfcState : u32 {
@@ -24,7 +29,7 @@ class NpadAbstractPropertiesHandler;
 /// Handles Npad request from HID interfaces
 class NpadAbstractNfcHandler final {
 public:
-    explicit NpadAbstractNfcHandler();
+    explicit NpadAbstractNfcHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractNfcHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -53,5 +58,6 @@ private:
     Kernel::KEvent* input_event{nullptr};
     u64 xcd_handle{};
     NpadNfcState sensor_state{NpadNfcState::Unavailable};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_pad.cpp b/src/hid_core/resources/abstracted_pad/abstract_pad.cpp
index d7cf2bba9b..b828c9b11e 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_pad.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_pad.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -12,7 +12,20 @@
 
 namespace Service::HID {
 
-AbstractPad::AbstractPad() {}
+AbstractPad::AbstractPad(Kernel::KernelCore& kernel_)
+    //: abstract_pad_holder{kernel_}
+    : properties_handler{kernel_}
+    , led_handler{kernel_}
+    , ir_sensor_handler{kernel_}
+    , nfc_handler{kernel_}
+    , mcu_handler{kernel_}
+    , vibration_handler{kernel_}
+    , sixaxis_handler{kernel_}
+    , button_handler{kernel_}
+    , battery_handler{kernel_}
+    , palma_handler{kernel_}
+    , kernel{kernel_}
+{}
 
 AbstractPad::~AbstractPad() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_pad.h b/src/hid_core/resources/abstracted_pad/abstract_pad.h
index 3297924574..99d886d40c 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_pad.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_pad.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -27,6 +30,10 @@
 #include "hid_core/resources/vibration/n64_vibration_device.h"
 #include "hid_core/resources/vibration/vibration_device.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 class AppletResource;
 class SixAxisResource;
@@ -49,7 +56,7 @@ struct HandheldConfig;
 /// Handles Npad request from HID interfaces
 class AbstractPad final {
 public:
-    explicit AbstractPad();
+    explicit AbstractPad(Kernel::KernelCore& kernel_);
     ~AbstractPad();
 
     void SetExternals(AppletResourceHolder* applet_resource,
@@ -88,17 +95,19 @@ public:
 
 private:
     AppletResourceHolder* applet_resource_holder{nullptr};
+
+    // TODO: fix
     NpadAbstractedPadHolder abstract_pad_holder{};
-    NpadAbstractPropertiesHandler properties_handler{};
-    NpadAbstractLedHandler led_handler{};
-    NpadAbstractIrSensorHandler ir_sensor_handler{};
-    NpadAbstractNfcHandler nfc_handler{};
-    NpadAbstractMcuHandler mcu_handler{};
-    NpadAbstractVibrationHandler vibration_handler{};
-    NpadAbstractSixAxisHandler sixaxis_handler{};
-    NpadAbstractButtonHandler button_handler{};
-    NpadAbstractBatteryHandler battery_handler{};
-    NpadAbstractPalmaHandler palma_handler{};
+    NpadAbstractPropertiesHandler properties_handler;
+    NpadAbstractLedHandler led_handler;
+    NpadAbstractIrSensorHandler ir_sensor_handler;
+    NpadAbstractNfcHandler nfc_handler;
+    NpadAbstractMcuHandler mcu_handler;
+    NpadAbstractVibrationHandler vibration_handler;
+    NpadAbstractSixAxisHandler sixaxis_handler;
+    NpadAbstractButtonHandler button_handler;
+    NpadAbstractBatteryHandler battery_handler;
+    NpadAbstractPalmaHandler palma_handler;
 
     NpadN64VibrationDevice vibration_n64{};
     NpadVibrationDevice vibration_left{};
@@ -114,6 +123,7 @@ private:
 
     s32 ref_counter{};
     Core::HID::NpadInterfaceType interface_type{Core::HID::NpadInterfaceType::None};
+    Kernel::KernelCore& kernel;
 };
 
 using FullAbstractPad = std::array<AbstractPad, MaxSupportedNpadIdTypes>;
diff --git a/src/hid_core/resources/abstracted_pad/abstract_palma_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_palma_handler.cpp
index 7766bedfd0..981f92ea00 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_palma_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_palma_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -10,7 +10,9 @@
 
 namespace Service::HID {
 
-NpadAbstractPalmaHandler::NpadAbstractPalmaHandler() {}
+NpadAbstractPalmaHandler::NpadAbstractPalmaHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractPalmaHandler::~NpadAbstractPalmaHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_palma_handler.h b/src/hid_core/resources/abstracted_pad/abstract_palma_handler.h
index fbd2e67e53..c09572a7b6 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_palma_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_palma_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,6 +10,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 class NpadAbstractedPadHolder;
 class NpadAbstractPropertiesHandler;
@@ -14,7 +21,7 @@ class PalmaResource;
 
 class NpadAbstractPalmaHandler final {
 public:
-    explicit NpadAbstractPalmaHandler();
+    explicit NpadAbstractPalmaHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractPalmaHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -32,6 +39,7 @@ private:
     PalmaResource* palma_resource{nullptr};
 
     s32 ref_counter{};
+    Kernel::KernelCore& kernel;
 };
 
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_properties_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_properties_handler.cpp
index c225670043..db011bc6dd 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_properties_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_properties_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -14,7 +14,9 @@
 
 namespace Service::HID {
 
-NpadAbstractPropertiesHandler::NpadAbstractPropertiesHandler() {}
+NpadAbstractPropertiesHandler::NpadAbstractPropertiesHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractPropertiesHandler::~NpadAbstractPropertiesHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_properties_handler.h b/src/hid_core/resources/abstracted_pad/abstract_properties_handler.h
index fa68278998..1b8cf4be82 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_properties_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_properties_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -10,6 +13,10 @@
 #include "hid_core/hid_types.h"
 #include "hid_core/resources/npad/npad_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Service::HID {
 struct NpadSharedMemoryEntry;
 
@@ -25,7 +32,7 @@ struct ColorProperties {
 /// Handles Npad request from HID interfaces
 class NpadAbstractPropertiesHandler final {
 public:
-    explicit NpadAbstractPropertiesHandler();
+    explicit NpadAbstractPropertiesHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractPropertiesHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -82,5 +89,6 @@ private:
     ColorProperties fullkey_color{};
     ColorProperties left_color{};
     ColorProperties right_color{};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp
index a8d2e5b2a0..54055751a2 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -15,7 +15,9 @@
 
 namespace Service::HID {
 
-NpadAbstractSixAxisHandler::NpadAbstractSixAxisHandler() {}
+NpadAbstractSixAxisHandler::NpadAbstractSixAxisHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractSixAxisHandler::~NpadAbstractSixAxisHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.h b/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.h
index 9c20459e91..c126c25a23 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,6 +9,11 @@
 #include "common/common_types.h"
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
+#include "hid_core/resources/shared_memory_format.h"
+
+namespace Kernel {
+class KernelCore;
+}
 
 namespace Service::HID {
 class SixAxisResource;
@@ -17,7 +25,7 @@ struct NpadSixAxisSensorLifo;
 /// Handles Npad request from HID interfaces
 class NpadAbstractSixAxisHandler final {
 public:
-    explicit NpadAbstractSixAxisHandler();
+    explicit NpadAbstractSixAxisHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractSixAxisHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -56,6 +64,7 @@ private:
     SixAxisResource* six_axis_resource{nullptr};
 
     s32 ref_counter{};
+    Kernel::KernelCore& kernel;
 };
 
 } // namespace Service::HID
diff --git a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp
index 3266422133..a0a37806fc 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -19,7 +19,9 @@
 
 namespace Service::HID {
 
-NpadAbstractVibrationHandler::NpadAbstractVibrationHandler() {}
+NpadAbstractVibrationHandler::NpadAbstractVibrationHandler(Kernel::KernelCore& kernel_)
+    : kernel{kernel_}
+{}
 
 NpadAbstractVibrationHandler::~NpadAbstractVibrationHandler() = default;
 
diff --git a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h
index 8bc8129c24..d57bf27814 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h
+++ b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -9,6 +12,10 @@
 #include "core/hle/result.h"
 #include "hid_core/hid_types.h"
 
+namespace Kernel {
+class KernelCore;
+}
+
 namespace Core::HID {
 class HIDCore;
 }
@@ -25,7 +32,7 @@ class NpadVibration;
 /// Keeps track of battery levels and updates npad battery shared memory values
 class NpadAbstractVibrationHandler final {
 public:
-    explicit NpadAbstractVibrationHandler();
+    explicit NpadAbstractVibrationHandler(Kernel::KernelCore& kernel_);
     ~NpadAbstractVibrationHandler();
 
     void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);
@@ -55,5 +62,6 @@ private:
     NpadGcVibrationDevice* gc_vibration_device{nullptr};
     NpadVibration* vibration_handler{nullptr};
     s32 ref_counter{};
+    Kernel::KernelCore& kernel;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/applet_resource.cpp b/src/hid_core/resources/applet_resource.cpp
index 31480a0e90..a7b9658cac 100644
--- a/src/hid_core/resources/applet_resource.cpp
+++ b/src/hid_core/resources/applet_resource.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -14,7 +14,10 @@ namespace Service::HID {
 
 AppletResource::AppletResource(Core::System& system_) : system{system_} {}
 
-AppletResource::~AppletResource() = default;
+AppletResource::~AppletResource() {
+    for (size_t i = 0; i < shared_memory_holder.size(); ++i)
+        shared_memory_holder[i].Finalize(system);
+}
 
 Result AppletResource::CreateAppletResource(u64 aruid) {
     const u64 index = GetIndexFromAruid(aruid);
@@ -34,7 +37,7 @@ Result AppletResource::CreateAppletResource(u64 aruid) {
             return result;
         }
         if (shared_memory.GetAddress() == nullptr) {
-            shared_memory.Finalize();
+            shared_memory.Finalize(system);
             return ResultSharedMemoryNotInitialized;
         }
     }
@@ -139,7 +142,7 @@ void AppletResource::FreeAppletResourceId(u64 aruid) {
     if (aruid_data.flag.is_assigned) {
         aruid_data.shared_memory_format = nullptr;
         aruid_data.flag.is_assigned.Assign(false);
-        shared_memory_holder[index].Finalize();
+        shared_memory_holder[index].Finalize(system);
     }
 }
 
diff --git a/src/hid_core/resources/npad/npad.cpp b/src/hid_core/resources/npad/npad.cpp
index 04d8a85301..8e309238d2 100644
--- a/src/hid_core/resources/npad/npad.cpp
+++ b/src/hid_core/resources/npad/npad.cpp
@@ -29,21 +29,36 @@
 namespace Service::HID {
 
 NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service_context_)
-    : hid_core{hid_core_}, service_context{service_context_}, npad_resource{service_context} {
+    : hid_core{hid_core_}
+    , service_context{service_context_}
+    , npad_resource{hid_core_.kernel, service_context}
+    , abstracted_pads{{
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+        AbstractPad{hid_core_.kernel},
+    }}
+{
     for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
         for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
             auto& controller = controller_data[aruid_index][i];
             controller.device = hid_core.GetEmulatedControllerByIndex(i);
             Core::HID::ControllerUpdateCallback engine_callback{
-                .on_change =
-                    [this, i](Core::HID::ControllerTriggerType type) { ControllerUpdate(type, i); },
+                .on_change = [this, i](Core::HID::ControllerTriggerType type) {
+                    ControllerUpdate(hid_core.kernel, type, i);
+                },
                 .is_npad_service = true,
             };
             controller.callback_key = controller.device->SetCallback(engine_callback);
         }
     }
     for (std::size_t i = 0; i < abstracted_pads.size(); ++i) {
-        abstracted_pads[i] = AbstractPad{};
         abstracted_pads[i].SetNpadId(IndexToNpadIdType(i));
     }
 }
@@ -123,10 +138,10 @@ void NPad::FreeAppletResourceId(u64 aruid) {
     return npad_resource.FreeAppletResourceId(aruid);
 }
 
-void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx) {
+void NPad::ControllerUpdate(Kernel::KernelCore& kernel, Core::HID::ControllerTriggerType type, std::size_t controller_idx) {
     if (type == Core::HID::ControllerTriggerType::All) {
-        ControllerUpdate(Core::HID::ControllerTriggerType::Connected, controller_idx);
-        ControllerUpdate(Core::HID::ControllerTriggerType::Battery, controller_idx);
+        ControllerUpdate(kernel, Core::HID::ControllerTriggerType::Connected, controller_idx);
+        ControllerUpdate(kernel, Core::HID::ControllerTriggerType::Battery, controller_idx);
         return;
     }
 
@@ -151,7 +166,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
             if (is_connected == controller.is_connected) {
                 return;
             }
-            UpdateControllerAt(data->aruid, npad_type, npad_id, is_connected);
+            UpdateControllerAt(kernel, data->aruid, npad_type, npad_id, is_connected);
             break;
         case Core::HID::ControllerTriggerType::Battery: {
             if (!controller.device->IsConnected()) {
@@ -173,7 +188,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
     }
 }
 
-void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
+void NPad::InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
     auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
     if (!npad_resource.IsControllerSupported(aruid, controller.device->GetNpadStyleIndex())) {
         return;
@@ -188,7 +203,7 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
         return;
     }
     if (controller_type == Core::HID::NpadStyleIndex::None) {
-        npad_resource.SignalStyleSetUpdateEvent(aruid, npad_id);
+        npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
         return;
     }
 
@@ -372,7 +387,7 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
                                           Common::Input::PollingMode::Active);
     }
 
-    npad_resource.SignalStyleSetUpdateEvent(aruid, npad_id);
+    npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
     WriteEmptyEntry(controller.shared_memory);
     hid_core.SetLastActiveController(npad_id);
     abstracted_pads[NpadIdTypeToIndex(npad_id)].Update();
@@ -399,20 +414,20 @@ void NPad::WriteEmptyEntry(NpadInternalState* npad) {
     npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }
 
-void NPad::RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id) {
+void NPad::RequestPadStateUpdate(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
     std::scoped_lock lock{*applet_resource_holder.shared_mutex};
     auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
     const auto controller_type = controller.device->GetNpadStyleIndex();
 
     if (!controller.device->IsConnected() && controller.is_connected) {
-        DisconnectNpad(aruid, npad_id);
+        DisconnectNpad(kernel, aruid, npad_id);
         return;
     }
     if (!controller.device->IsConnected()) {
         return;
     }
     if (controller.device->IsConnected() && !controller.is_connected) {
-        InitNewlyAddedController(aruid, npad_id);
+        InitNewlyAddedController(kernel, aruid, npad_id);
     }
 
     // This function is unique to yuzu for the turbo buttons and motion to work properly
@@ -468,7 +483,7 @@ void NPad::RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id) {
     }
 }
 
-void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void NPad::OnUpdate(Kernel::KernelCore& kernel, const Core::Timing::CoreTiming& core_timing) {
     if (ref_counter == 0) {
         return;
     }
@@ -510,7 +525,7 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
                 continue;
             }
 
-            RequestPadStateUpdate(aruid, controller.device->GetNpadIdType());
+            RequestPadStateUpdate(kernel, aruid, controller.device->GetNpadIdType());
             auto& pad_state = controller.npad_pad_state;
             auto& libnx_state = controller.npad_libnx_state;
             auto& trigger_state = controller.npad_trigger_state;
@@ -627,17 +642,17 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     }
 }
 
-Result NPad::SetSupportedNpadStyleSet(u64 aruid, Core::HID::NpadStyleSet supported_style_set) {
+Result NPad::SetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet supported_style_set) {
     std::scoped_lock lock{mutex};
     hid_core.SetSupportedStyleTag({supported_style_set});
     const Result result = npad_resource.SetSupportedNpadStyleSet(aruid, supported_style_set);
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
     return result;
 }
 
-Result NPad::GetSupportedNpadStyleSet(u64 aruid,
+Result NPad::GetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid,
                                       Core::HID::NpadStyleSet& out_supported_style_set) const {
     std::scoped_lock lock{mutex};
     const Result result = npad_resource.GetSupportedNpadStyleSet(out_supported_style_set, aruid);
@@ -650,8 +665,7 @@ Result NPad::GetSupportedNpadStyleSet(u64 aruid,
     return result;
 }
 
-Result NPad::GetMaskedSupportedNpadStyleSet(
-    u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const {
+Result NPad::GetMaskedSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const {
     std::scoped_lock lock{mutex};
     const Result result =
         npad_resource.GetMaskedSupportedNpadStyleSet(out_supported_style_set, aruid);
@@ -664,8 +678,7 @@ Result NPad::GetMaskedSupportedNpadStyleSet(
     return result;
 }
 
-Result NPad::SetSupportedNpadIdType(u64 aruid,
-                                    std::span<const Core::HID::NpadIdType> supported_npad_list) {
+Result NPad::SetSupportedNpadIdType(Kernel::KernelCore& kernel, u64 aruid, std::span<const Core::HID::NpadIdType> supported_npad_list) {
     std::scoped_lock lock{mutex};
     if (supported_npad_list.size() > MaxSupportedNpadIdTypes) {
         return ResultInvalidArraySize;
@@ -674,7 +687,7 @@ Result NPad::SetSupportedNpadIdType(u64 aruid,
     Result result = npad_resource.SetSupportedNpadIdType(aruid, supported_npad_list);
 
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
 
     return result;
@@ -690,22 +703,21 @@ Result NPad::GetNpadJoyHoldType(u64 aruid, NpadJoyHoldType& out_hold_type) const
     return npad_resource.GetNpadJoyHoldType(out_hold_type, aruid);
 }
 
-Result NPad::SetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode mode) {
+Result NPad::SetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode mode) {
     std::scoped_lock lock{mutex};
     Result result = npad_resource.SetNpadHandheldActivationMode(aruid, mode);
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
     return result;
 }
 
-Result NPad::GetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode& out_mode) const {
+Result NPad::GetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode& out_mode) const {
     std::scoped_lock lock{mutex};
     return npad_resource.GetNpadHandheldActivationMode(out_mode, aruid);
 }
 
-bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
-                       NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
+bool NPad::SetNpadMode(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return false;
@@ -727,17 +739,17 @@ bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID:
 
     if (assignment_mode == NpadJoyAssignmentMode::Dual) {
         if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft) {
-            DisconnectNpad(aruid, npad_id);
+            DisconnectNpad(kernel, aruid, npad_id);
             controller.is_dual_left_connected = true;
             controller.is_dual_right_connected = false;
-            UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
+            UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
             return false;
         }
         if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight) {
-            DisconnectNpad(aruid, npad_id);
+            DisconnectNpad(kernel, aruid, npad_id);
             controller.is_dual_left_connected = false;
             controller.is_dual_right_connected = true;
-            UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
+            UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
             return false;
         }
         return false;
@@ -751,58 +763,55 @@ bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID:
     }
 
     if (controller.is_dual_left_connected && !controller.is_dual_right_connected) {
-        DisconnectNpad(aruid, npad_id);
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
+        DisconnectNpad(kernel, aruid, npad_id);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
         return false;
     }
     if (!controller.is_dual_left_connected && controller.is_dual_right_connected) {
-        DisconnectNpad(aruid, npad_id);
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
+        DisconnectNpad(kernel, aruid, npad_id);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
         return false;
     }
 
     // We have two controllers connected to the same npad_id we need to split them
     new_npad_id = hid_core.GetFirstDisconnectedNpadId();
     auto& controller_2 = GetControllerFromNpadIdType(aruid, new_npad_id);
-    DisconnectNpad(aruid, npad_id);
+    DisconnectNpad(kernel, aruid, npad_id);
     if (npad_device_type == NpadJoyDeviceType::Left) {
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
         controller_2.is_dual_left_connected = false;
         controller_2.is_dual_right_connected = true;
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
     } else {
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
         controller_2.is_dual_left_connected = true;
         controller_2.is_dual_right_connected = false;
-        UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
+        UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
     }
     return true;
 }
 
-Result NPad::AcquireNpadStyleSetUpdateEventHandle(u64 aruid, Kernel::KReadableEvent** out_event,
-                                                  Core::HID::NpadIdType npad_id) {
+Result NPad::AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u64 aruid, Kernel::KReadableEvent** out_event, Core::HID::NpadIdType npad_id) {
     std::scoped_lock lock{mutex};
-    return npad_resource.AcquireNpadStyleSetUpdateEventHandle(aruid, out_event, npad_id);
+    return npad_resource.AcquireNpadStyleSetUpdateEventHandle(kernel, aruid, out_event, npad_id);
 }
 
-void NPad::AddNewControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
-                              Core::HID::NpadIdType npad_id) {
-    UpdateControllerAt(aruid, controller, npad_id, true);
+void NPad::AddNewControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id) {
+    UpdateControllerAt(kernel, aruid, controller, npad_id, true);
 }
 
-void NPad::UpdateControllerAt(u64 aruid, Core::HID::NpadStyleIndex type,
-                              Core::HID::NpadIdType npad_id, bool connected) {
+void NPad::UpdateControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex type, Core::HID::NpadIdType npad_id, bool connected) {
     auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
     if (!connected) {
-        DisconnectNpad(aruid, npad_id);
+        DisconnectNpad(kernel, aruid, npad_id);
         return;
     }
 
     controller.device->SetNpadStyleIndex(type);
-    InitNewlyAddedController(aruid, npad_id);
+    InitNewlyAddedController(kernel, aruid, npad_id);
 }
 
-Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {
+Result NPad::DisconnectNpad(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return ResultInvalidNpadId;
@@ -845,7 +854,7 @@ Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {
     controller.is_dual_right_connected = true;
     controller.is_connected = false;
     controller.device->Disconnect();
-    npad_resource.SignalStyleSetUpdateEvent(aruid, npad_id);
+    npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
     WriteEmptyEntry(shared_memory);
     return ResultSuccess;
 }
@@ -878,8 +887,7 @@ Result NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
     return ResultSuccess;
 }
 
-Result NPad::MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
-                                     Core::HID::NpadIdType npad_id_2) {
+Result NPad::MergeSingleJoyAsDualJoy(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
                   npad_id_2);
@@ -933,11 +941,11 @@ Result NPad::MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
     }
 
     // Disconnect the joycons and connect them as dual joycon at the first index.
-    DisconnectNpad(aruid, npad_id_1);
-    DisconnectNpad(aruid, npad_id_2);
+    DisconnectNpad(kernel, aruid, npad_id_1);
+    DisconnectNpad(kernel, aruid, npad_id_2);
     controller_1.is_dual_left_connected = true;
     controller_1.is_dual_right_connected = true;
-    AddNewControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id_1);
+    AddNewControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id_1);
     return ResultSuccess;
 }
 
@@ -961,11 +969,9 @@ Result NPad::StopLrAssignmentMode(u64 aruid) {
     return result;
 }
 
-Result NPad::SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
-                                Core::HID::NpadIdType npad_id_2) {
+Result NPad::SwapNpadAssignment(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
-        LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
-                  npad_id_2);
+        LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1, npad_id_2);
         return ResultInvalidNpadId;
     }
     if (npad_id_1 == Core::HID::NpadIdType::Handheld ||
@@ -987,20 +993,17 @@ Result NPad::SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
         return ResultNpadNotConnected;
     }
 
-    UpdateControllerAt(aruid, type_index_2, npad_id_1, is_connected_2);
-    UpdateControllerAt(aruid, type_index_1, npad_id_2, is_connected_1);
-
+    UpdateControllerAt(kernel, aruid, type_index_2, npad_id_1, is_connected_2);
+    UpdateControllerAt(kernel, aruid, type_index_1, npad_id_2, is_connected_1);
     return ResultSuccess;
 }
 
-Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, u64 aruid,
-                                                          Core::HID::NpadIdType npad_id) const {
+Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, u64 aruid, Core::HID::NpadIdType npad_id) const {
     std::scoped_lock lock{mutex};
     return npad_resource.GetHomeProtectionEnabled(out_is_enabled, aruid, npad_id);
 }
 
-Result NPad::EnableUnintendedHomeButtonInputProtection(u64 aruid, Core::HID::NpadIdType npad_id,
-                                                       bool is_enabled) {
+Result NPad::EnableUnintendedHomeButtonInputProtection(u64 aruid, Core::HID::NpadIdType npad_id, bool is_enabled) {
     std::scoped_lock lock{mutex};
     return npad_resource.SetHomeProtectionEnabled(aruid, npad_id, is_enabled);
 }
@@ -1054,29 +1057,29 @@ Core::HID::NpadButton NPad::GetAndResetPressState() {
     return static_cast<Core::HID::NpadButton>(press_state.exchange(0));
 }
 
-Result NPad::ApplyNpadSystemCommonPolicy(u64 aruid) {
+Result NPad::ApplyNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid) {
     std::scoped_lock lock{mutex};
     const Result result = npad_resource.ApplyNpadSystemCommonPolicy(aruid, false);
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
     return result;
 }
 
-Result NPad::ApplyNpadSystemCommonPolicyFull(u64 aruid) {
+Result NPad::ApplyNpadSystemCommonPolicyFull(Kernel::KernelCore& kernel, u64 aruid) {
     std::scoped_lock lock{mutex};
     const Result result = npad_resource.ApplyNpadSystemCommonPolicy(aruid, true);
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
     return result;
 }
 
-Result NPad::ClearNpadSystemCommonPolicy(u64 aruid) {
+Result NPad::ClearNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid) {
     std::scoped_lock lock{mutex};
     const Result result = npad_resource.ClearNpadSystemCommonPolicy(aruid);
     if (result.IsSuccess()) {
-        OnUpdate({});
+        OnUpdate(kernel, {});
     }
     return result;
 }
diff --git a/src/hid_core/resources/npad/npad.h b/src/hid_core/resources/npad/npad.h
index 99e761127d..3e10f02a7c 100644
--- a/src/hid_core/resources/npad/npad.h
+++ b/src/hid_core/resources/npad/npad.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -61,37 +64,31 @@ public:
     void FreeAppletResourceId(u64 aruid);
 
     // When the controller is requesting an update for the shared memory
-    void OnUpdate(const Core::Timing::CoreTiming& core_timing);
-
-    Result SetSupportedNpadStyleSet(u64 aruid, Core::HID::NpadStyleSet supported_style_set);
-    Result GetSupportedNpadStyleSet(u64 aruid,
-                                    Core::HID::NpadStyleSet& out_supported_style_set) const;
-    Result GetMaskedSupportedNpadStyleSet(u64 aruid,
-                                          Core::HID::NpadStyleSet& out_supported_style_set) const;
+    void OnUpdate(Kernel::KernelCore& kernel, const Core::Timing::CoreTiming& core_timing);
 
-    Result SetSupportedNpadIdType(u64 aruid,
-                                  std::span<const Core::HID::NpadIdType> supported_npad_list);
+    Result SetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet supported_style_set);
+    Result GetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const;
+    Result GetMaskedSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const;
+    Result SetSupportedNpadIdType(Kernel::KernelCore& kernel, u64 aruid, std::span<const Core::HID::NpadIdType> supported_npad_list);
 
     Result SetNpadJoyHoldType(u64 aruid, NpadJoyHoldType hold_type);
     Result GetNpadJoyHoldType(u64 aruid, NpadJoyHoldType& out_hold_type) const;
 
-    Result SetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode mode);
-    Result GetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode& out_mode) const;
+    Result SetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode mode);
+    Result GetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode& out_mode) const;
 
-    bool SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
+    bool SetNpadMode(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
                      NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode);
 
-    Result AcquireNpadStyleSetUpdateEventHandle(u64 aruid, Kernel::KReadableEvent** out_event,
+    Result AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u64 aruid, Kernel::KReadableEvent** out_event,
                                                 Core::HID::NpadIdType npad_id);
 
     // Adds a new controller at an index.
-    void AddNewControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
-                            Core::HID::NpadIdType npad_id);
+    void AddNewControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id);
     // Adds a new controller at an index with connection status.
-    void UpdateControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
-                            Core::HID::NpadIdType npad_id, bool connected);
+    void UpdateControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id, bool connected);
 
-    Result DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id);
+    Result DisconnectNpad(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
 
     Result IsFirmwareUpdateAvailableForSixAxisSensor(
         u64 aruid, const Core::HID::SixAxisSensorHandle& sixaxis_handle,
@@ -110,20 +107,18 @@ public:
     void ConnectAllDisconnectedControllers();
     void ClearAllControllers();
 
-    Result MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
-                                   Core::HID::NpadIdType npad_id_2);
+    Result MergeSingleJoyAsDualJoy(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
     Result StartLrAssignmentMode(u64 aruid);
     Result StopLrAssignmentMode(u64 aruid);
-    Result SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
-                              Core::HID::NpadIdType npad_id_2);
+    Result SwapNpadAssignment(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
 
     // Logical OR for all buttons presses on all controllers
     // Specifically for cheat engine and other features.
     Core::HID::NpadButton GetAndResetPressState();
 
-    Result ApplyNpadSystemCommonPolicy(u64 aruid);
-    Result ApplyNpadSystemCommonPolicyFull(u64 aruid);
-    Result ClearNpadSystemCommonPolicy(u64 aruid);
+    Result ApplyNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid);
+    Result ApplyNpadSystemCommonPolicyFull(Kernel::KernelCore& kernel, u64 aruid);
+    Result ClearNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid);
 
     void SetRevision(u64 aruid, NpadRevision revision);
     NpadRevision GetRevision(u64 aruid);
@@ -180,9 +175,9 @@ private:
         int callback_key{};
     };
 
-    void ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx);
-    void InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id);
-    void RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id);
+    void ControllerUpdate(Kernel::KernelCore& kernel, Core::HID::ControllerTriggerType type, std::size_t controller_idx);
+    void InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
+    void RequestPadStateUpdate(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
     void WriteEmptyEntry(NpadInternalState* npad);
 
     NpadControllerData& GetControllerFromHandle(
@@ -209,7 +204,6 @@ private:
     NpadVibration vibration_handler{};
 
     std::atomic<u64> press_state{};
-    std::array<std::array<NpadControllerData, MaxSupportedNpadIdTypes>, AruidIndexMax>
-        controller_data{};
+    std::array<std::array<NpadControllerData, MaxSupportedNpadIdTypes>, AruidIndexMax> controller_data{};
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/npad/npad_resource.cpp b/src/hid_core/resources/npad/npad_resource.cpp
index 08546f8dc4..54f7acab12 100644
--- a/src/hid_core/resources/npad/npad_resource.cpp
+++ b/src/hid_core/resources/npad/npad_resource.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -13,7 +13,9 @@
 
 namespace Service::HID {
 
-NPadResource::NPadResource(KernelHelpers::ServiceContext& context) : service_context{context} {}
+NPadResource::NPadResource(Kernel::KernelCore& kernel_, KernelHelpers::ServiceContext& context)
+    : service_context{context}
+{}
 
 NPadResource::~NPadResource() = default;
 
@@ -505,9 +507,7 @@ Result NPadResource::IsAssigningSingleOnSlSrPressEnabled(bool& is_enabled, u64 a
     return ResultSuccess;
 }
 
-Result NPadResource::AcquireNpadStyleSetUpdateEventHandle(u64 aruid,
-                                                          Kernel::KReadableEvent** out_event,
-                                                          Core::HID::NpadIdType npad_id) {
+Result NPadResource::AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u64 aruid, Kernel::KReadableEvent** out_event, Core::HID::NpadIdType npad_id) {
     const u64 aruid_index = GetIndexFromAruid(aruid);
     if (aruid_index >= AruidIndexMax) {
         return ResultNpadNotConnected;
@@ -526,26 +526,25 @@ Result NPadResource::AcquireNpadStyleSetUpdateEventHandle(u64 aruid,
     *out_event = &controller_state.style_set_update_event->GetReadableEvent();
 
     if (controller_state.is_styleset_update_event_initialized) {
-        controller_state.style_set_update_event->Signal();
+        controller_state.style_set_update_event->Signal(kernel);
     }
 
     return ResultSuccess;
 }
 
-Result NPadResource::SignalStyleSetUpdateEvent(u64 aruid, Core::HID::NpadIdType npad_id) {
+Result NPadResource::SignalStyleSetUpdateEvent(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
     const u64 aruid_index = GetIndexFromAruid(aruid);
     if (aruid_index >= AruidIndexMax) {
         return ResultNpadNotConnected;
     }
-    auto controller = state[aruid_index].controller_state[NpadIdTypeToIndex(npad_id)];
-    if (controller.is_styleset_update_event_initialized) {
-        controller.style_set_update_event->Signal();
+    auto& controller_state = state[aruid_index].controller_state[NpadIdTypeToIndex(npad_id)];
+    if (controller_state.is_styleset_update_event_initialized) {
+        controller_state.style_set_update_event->Signal(kernel);
     }
     return ResultSuccess;
 }
 
-Result NPadResource::GetHomeProtectionEnabled(bool& is_enabled, u64 aruid,
-                                              Core::HID::NpadIdType npad_id) const {
+Result NPadResource::GetHomeProtectionEnabled(bool& is_enabled, u64 aruid, Core::HID::NpadIdType npad_id) const {
     const u64 aruid_index = GetIndexFromAruid(aruid);
     if (aruid_index >= AruidIndexMax) {
         return ResultNpadNotConnected;
@@ -555,8 +554,7 @@ Result NPadResource::GetHomeProtectionEnabled(bool& is_enabled, u64 aruid,
     return ResultSuccess;
 }
 
-Result NPadResource::SetHomeProtectionEnabled(u64 aruid, Core::HID::NpadIdType npad_id,
-                                              bool is_enabled) {
+Result NPadResource::SetHomeProtectionEnabled(u64 aruid, Core::HID::NpadIdType npad_id, bool is_enabled) {
     const u64 aruid_index = GetIndexFromAruid(aruid);
     if (aruid_index >= AruidIndexMax) {
         return ResultNpadNotConnected;
diff --git a/src/hid_core/resources/npad/npad_resource.h b/src/hid_core/resources/npad/npad_resource.h
index 8ee5702fd4..2d381c4642 100644
--- a/src/hid_core/resources/npad/npad_resource.h
+++ b/src/hid_core/resources/npad/npad_resource.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -20,6 +23,7 @@ class System;
 }
 
 namespace Kernel {
+class KernelCore;
 class KReadableEvent;
 }
 
@@ -37,8 +41,7 @@ struct NpadState {
     DataStatusFlag flag{};
     u64 aruid{};
     NPadData data{};
-    std::array<std::array<Core::HID::NpadButton, StyleIndexCount>, MaxSupportedNpadIdTypes>
-        button_config;
+    std::array<std::array<Core::HID::NpadButton, StyleIndexCount>, MaxSupportedNpadIdTypes> button_config;
     std::array<NpadControllerState, MaxSupportedNpadIdTypes> controller_state;
     NpadRevision npad_revision;
 };
@@ -46,7 +49,7 @@ struct NpadState {
 /// Handles Npad request from HID interfaces
 class NPadResource final {
 public:
-    explicit NPadResource(KernelHelpers::ServiceContext& context);
+    explicit NPadResource(Kernel::KernelCore& kernel, KernelHelpers::ServiceContext& context);
     ~NPadResource();
 
     NPadData* GetActiveData();
@@ -81,11 +84,9 @@ public:
     Result GetNpadJoyHoldType(NpadJoyHoldType& hold_type, u64 aruid) const;
 
     Result SetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode activation_mode);
-    Result GetNpadHandheldActivationMode(NpadHandheldActivationMode& activation_mode,
-                                         u64 aruid) const;
+    Result GetNpadHandheldActivationMode(NpadHandheldActivationMode& activation_mode, u64 aruid) const;
 
-    Result SetSupportedNpadIdType(u64 aruid,
-                                  std::span<const Core::HID::NpadIdType> supported_npad_list);
+    Result SetSupportedNpadIdType(u64 aruid, std::span<const Core::HID::NpadIdType> supported_npad_list);
     bool IsControllerSupported(u64 aruid, Core::HID::NpadStyleIndex style_index) const;
 
     Result SetLrAssignmentMode(u64 aruid, bool is_enabled);
@@ -94,28 +95,20 @@ public:
     Result SetAssigningSingleOnSlSrPress(u64 aruid, bool is_enabled);
     Result IsAssigningSingleOnSlSrPressEnabled(bool& is_enabled, u64 aruid) const;
 
-    Result AcquireNpadStyleSetUpdateEventHandle(u64 aruid, Kernel::KReadableEvent** out_event,
-                                                Core::HID::NpadIdType npad_id);
-    Result SignalStyleSetUpdateEvent(u64 aruid, Core::HID::NpadIdType npad_id);
-
-    Result GetHomeProtectionEnabled(bool& is_enabled, u64 aruid,
-                                    Core::HID::NpadIdType npad_id) const;
+    Result AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u64 aruid, Kernel::KReadableEvent** out_event, Core::HID::NpadIdType npad_id);
+    Result SignalStyleSetUpdateEvent(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
+    Result GetHomeProtectionEnabled(bool& is_enabled, u64 aruid, Core::HID::NpadIdType npad_id) const;
     Result SetHomeProtectionEnabled(u64 aruid, Core::HID::NpadIdType npad_id, bool is_enabled);
 
     Result SetNpadAnalogStickUseCenterClamp(u64 aruid, bool is_enabled);
 
-    Result SetButtonConfig(u64 aruid, Core::HID::NpadIdType npad_id, std::size_t index,
-                           Core::HID::NpadButton button_config);
-    Core::HID::NpadButton GetButtonConfig(u64 aruid, Core::HID::NpadIdType npad_id,
-                                          std::size_t index, Core::HID::NpadButton mask,
-                                          bool is_enabled);
+    Result SetButtonConfig(u64 aruid, Core::HID::NpadIdType npad_id, std::size_t index, Core::HID::NpadButton button_config);
+    Core::HID::NpadButton GetButtonConfig(u64 aruid, Core::HID::NpadIdType npad_id, std::size_t index, Core::HID::NpadButton mask, bool is_enabled);
     void ResetButtonConfig();
 
-    Result SetNpadCaptureButtonAssignment(u64 aruid, Core::HID::NpadStyleSet npad_style_set,
-                                          Core::HID::NpadButton button_assignment);
+    Result SetNpadCaptureButtonAssignment(u64 aruid, Core::HID::NpadStyleSet npad_style_set, Core::HID::NpadButton button_assignment);
     Result ClearNpadCaptureButtonAssignment(u64 aruid);
-    std::size_t GetNpadCaptureButtonAssignment(std::span<Core::HID::NpadButton> out_list,
-                                               u64 aruid) const;
+    std::size_t GetNpadCaptureButtonAssignment(std::span<Core::HID::NpadButton> out_list, u64 aruid) const;
 
     Result SetNpadSystemExtStateEnabled(u64 aruid, bool is_enabled);
 
@@ -124,9 +117,8 @@ private:
     AruidRegisterList registration_list{};
     std::array<NpadState, AruidIndexMax> state{};
     u64 active_data_aruid{};
+    KernelHelpers::ServiceContext& service_context;
     NpadJoyHoldType default_hold_type{};
     s32 ref_counter{};
-
-    KernelHelpers::ServiceContext& service_context;
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/palma/palma.cpp b/src/hid_core/resources/palma/palma.cpp
index 0652455f5f..1a1a3aae18 100644
--- a/src/hid_core/resources/palma/palma.cpp
+++ b/src/hid_core/resources/palma/palma.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -77,7 +77,7 @@ Result Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_a
     operation.operation = PackedPalmaOperationType::PlayActivity;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -96,7 +96,7 @@ Result Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
     operation.operation = PackedPalmaOperationType::ReadStep;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -125,7 +125,7 @@ Result Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
     operation.operation = PackedPalmaOperationType::ReadUniqueCode;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -136,7 +136,7 @@ Result Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
     operation.operation = PackedPalmaOperationType::SetUniqueCodeInvalid;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -149,7 +149,7 @@ Result Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle,
     operation.operation = PackedPalmaOperationType::WriteRgbLedPatternEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -161,7 +161,7 @@ Result Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWave
     operation.operation = PackedPalmaOperationType::WriteWaveEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -174,7 +174,7 @@ Result Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
     operation.operation = PackedPalmaOperationType::ReadDataBaseIdentificationVersion;
     operation.result = PalmaResultSuccess;
     operation.data[0] = {};
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
@@ -186,7 +186,7 @@ Result Palma::GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation.data[0] = static_cast<u8>(database_id_version);
-    operation_complete_event->Signal();
+    operation_complete_event->Signal(hid_core.kernel);
     return ResultSuccess;
 }
 
diff --git a/src/hid_core/resources/shared_memory_holder.cpp b/src/hid_core/resources/shared_memory_holder.cpp
index ada593d8ba..c94829821a 100644
--- a/src/hid_core/resources/shared_memory_holder.cpp
+++ b/src/hid_core/resources/shared_memory_holder.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -9,17 +12,10 @@
 #include "hid_core/resources/shared_memory_holder.h"
 
 namespace Service::HID {
-SharedMemoryHolder::SharedMemoryHolder() {}
-
-SharedMemoryHolder::~SharedMemoryHolder() {
-    Finalize();
-}
 
 Result SharedMemoryHolder::Initialize(Core::System& system) {
     shared_memory = Kernel::KSharedMemory::Create(system.Kernel());
-    const Result result = shared_memory->Initialize(
-        system.DeviceMemory(), nullptr, Kernel::Svc::MemoryPermission::None,
-        Kernel::Svc::MemoryPermission::Read, sizeof(SharedMemoryFormat));
+    const Result result = shared_memory->Initialize(system.Kernel(), system.DeviceMemory(), nullptr, Kernel::Svc::MemoryPermission::None, Kernel::Svc::MemoryPermission::Read, sizeof(SharedMemoryFormat));
     if (result.IsError()) {
         return result;
     }
@@ -31,9 +27,9 @@ Result SharedMemoryHolder::Initialize(Core::System& system) {
     return ResultSuccess;
 }
 
-void SharedMemoryHolder::Finalize() {
+void SharedMemoryHolder::Finalize(Core::System& system) {
     if (address != nullptr) {
-        shared_memory->Close();
+        shared_memory->Close(system.Kernel());
     }
     is_created = false;
     is_mapped = false;
diff --git a/src/hid_core/resources/shared_memory_holder.h b/src/hid_core/resources/shared_memory_holder.h
index 943407c00a..5fcaddecc0 100644
--- a/src/hid_core/resources/shared_memory_holder.h
+++ b/src/hid_core/resources/shared_memory_holder.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -19,17 +22,13 @@ struct SharedMemoryFormat;
 // This is nn::hid::detail::SharedMemoryHolder
 class SharedMemoryHolder {
 public:
-    SharedMemoryHolder();
-    ~SharedMemoryHolder();
-
     Result Initialize(Core::System& system);
-    void Finalize();
+    void Finalize(Core::System& system);
 
     bool IsMapped();
     SharedMemoryFormat* GetAddress();
     Kernel::KSharedMemory* GetHandle();
 
-private:
     bool is_owner{};
     bool is_created{};
     bool is_mapped{};
diff --git a/src/hid_core/resources/touch_screen/touch_screen_resource.cpp b/src/hid_core/resources/touch_screen/touch_screen_resource.cpp
index 018a43b6c0..d340f186b3 100644
--- a/src/hid_core/resources/touch_screen/touch_screen_resource.cpp
+++ b/src/hid_core/resources/touch_screen/touch_screen_resource.cpp
@@ -494,7 +494,7 @@ void TouchResource::ReadTouchInput() {
             has_moved |= (delta_x > 1 || delta_y > 1);
         }
         if (has_moved) {
-            input_event->Signal();
+            input_event->Signal(system.Kernel());
         }
     }
 }