From 621b25b6be99d357c9996fcb2df77f42c7dc2001 Mon Sep 17 00:00:00 2001
From: Zach Hilman <zachhilman@gmail.com>
Date: Mon, 24 Dec 2018 16:19:16 -0500
Subject: [PATCH] hid: Make Hid service accessible and add GetPressState

---
 src/core/hle/service/hid/controllers/npad.cpp |   8 +
 src/core/hle/service/hid/controllers/npad.h   |   6 +
 src/core/hle/service/hid/hid.cpp              | 941 +++++++++---------
 src/core/hle/service/hid/hid.h                | 110 ++
 4 files changed, 573 insertions(+), 492 deletions(-)

diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 75fdb861a..2829f64e9 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -410,6 +410,8 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
         libnx_entry.pad.pad_states.raw = pad_state.pad_states.raw;
         libnx_entry.pad.l_stick = pad_state.l_stick;
         libnx_entry.pad.r_stick = pad_state.r_stick;
+
+        press_state |= static_cast<u32>(pad_state.pad_states.raw);
     }
     std::memcpy(data + NPAD_OFFSET, shared_memory_entries.data(),
                 shared_memory_entries.size() * sizeof(NPadEntry));
@@ -636,6 +638,12 @@ void Controller_NPad::ClearAllControllers() {
                   });
 }
 
+u32 Controller_NPad::GetPressState() {
+    const auto res = press_state;
+    press_state = 0;
+    return res;
+}
+
 bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const {
     const bool support_handheld =
         std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), NPAD_HANDHELD) !=
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index 29851f16a..6906d9ffb 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -124,6 +124,10 @@ public:
     void ConnectAllDisconnectedControllers();
     void ClearAllControllers();
 
+    // Logical OR for all buttons presses on all controllers
+    // Specifically for cheat engine and other features.
+    u32 GetPressState();
+
     static std::size_t NPadIdToIndex(u32 npad_id);
     static u32 IndexToNPad(std::size_t index);
 
@@ -292,6 +296,8 @@ private:
         bool is_connected;
     };
 
+    u32 press_state{};
+
     NPadType style{};
     std::array<NPadEntry, 10> shared_memory_entries{};
     std::array<
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 268409257..acb4152a4 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -40,119 +40,82 @@ constexpr u64 pad_update_ticks = CoreTiming::BASE_CLOCK_RATE / 66;
 constexpr u64 accelerometer_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
 constexpr u64 gyroscope_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
-enum class HidController : std::size_t {
-    DebugPad,
-    Touchscreen,
-    Mouse,
-    Keyboard,
-    XPad,
-    Unknown1,
-    Unknown2,
-    Unknown3,
-    SixAxisSensor,
-    NPad,
-    Gesture,
 
-    MaxControllers,
-};
+IAppletResource::IAppletResource() : ServiceFramework("IAppletResource") {
+    static const FunctionInfo functions[] = {
+        {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
+    };
+    RegisterHandlers(functions);
 
-class IAppletResource final : public ServiceFramework<IAppletResource> {
-public:
-    IAppletResource() : ServiceFramework("IAppletResource") {
-        static const FunctionInfo functions[] = {
-            {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
-        };
-        RegisterHandlers(functions);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    shared_mem = Kernel::SharedMemory::Create(
+        kernel, nullptr, SHARED_MEMORY_SIZE, Kernel::MemoryPermission::ReadWrite,
+        Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        shared_mem = Kernel::SharedMemory::Create(
-            kernel, nullptr, SHARED_MEMORY_SIZE, Kernel::MemoryPermission::ReadWrite,
-            Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
+    MakeController<Controller_DebugPad>(HidController::DebugPad);
+    MakeController<Controller_Touchscreen>(HidController::Touchscreen);
+    MakeController<Controller_Mouse>(HidController::Mouse);
+    MakeController<Controller_Keyboard>(HidController::Keyboard);
+    MakeController<Controller_XPad>(HidController::XPad);
+    MakeController<Controller_Stubbed>(HidController::Unknown1);
+    MakeController<Controller_Stubbed>(HidController::Unknown2);
+    MakeController<Controller_Stubbed>(HidController::Unknown3);
+    MakeController<Controller_Stubbed>(HidController::SixAxisSensor);
+    MakeController<Controller_NPad>(HidController::NPad);
+    MakeController<Controller_Gesture>(HidController::Gesture);
 
-        MakeController<Controller_DebugPad>(HidController::DebugPad);
-        MakeController<Controller_Touchscreen>(HidController::Touchscreen);
-        MakeController<Controller_Mouse>(HidController::Mouse);
-        MakeController<Controller_Keyboard>(HidController::Keyboard);
-        MakeController<Controller_XPad>(HidController::XPad);
-        MakeController<Controller_Stubbed>(HidController::Unknown1);
-        MakeController<Controller_Stubbed>(HidController::Unknown2);
-        MakeController<Controller_Stubbed>(HidController::Unknown3);
-        MakeController<Controller_Stubbed>(HidController::SixAxisSensor);
-        MakeController<Controller_NPad>(HidController::NPad);
-        MakeController<Controller_Gesture>(HidController::Gesture);
+    // Homebrew doesn't try to activate some controllers, so we activate them by default
+    GetController<Controller_NPad>(HidController::NPad).ActivateController();
+    GetController<Controller_Touchscreen>(HidController::Touchscreen).ActivateController();
 
-        // Homebrew doesn't try to activate some controllers, so we activate them by default
-        GetController<Controller_NPad>(HidController::NPad).ActivateController();
-        GetController<Controller_Touchscreen>(HidController::Touchscreen).ActivateController();
+    GetController<Controller_Stubbed>(HidController::Unknown1).SetCommonHeaderOffset(0x4c00);
+    GetController<Controller_Stubbed>(HidController::Unknown2).SetCommonHeaderOffset(0x4e00);
+    GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);
 
-        GetController<Controller_Stubbed>(HidController::Unknown1).SetCommonHeaderOffset(0x4c00);
-        GetController<Controller_Stubbed>(HidController::Unknown2).SetCommonHeaderOffset(0x4e00);
-        GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);
+    // Register update callbacks
+    pad_update_event =
+        CoreTiming::RegisterEvent("HID::UpdatePadCallback", [this](u64 userdata, int cycles_late) {
+            UpdateControllers(userdata, cycles_late);
+        });
 
-        // Register update callbacks
-        pad_update_event = CoreTiming::RegisterEvent(
-            "HID::UpdatePadCallback",
-            [this](u64 userdata, int cycles_late) { UpdateControllers(userdata, cycles_late); });
+    // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
-        // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
+    CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event);
 
-        CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event);
+    ReloadInputDevices();
+}
 
-        ReloadInputDevices();
-    }
+void IAppletResource::ActivateController(HidController controller) {
+    controllers[static_cast<size_t>(controller)]->ActivateController();
+}
 
-    void ActivateController(HidController controller) {
-        controllers[static_cast<size_t>(controller)]->ActivateController();
-    }
+void IAppletResource::DeactivateController(HidController controller) {
+    controllers[static_cast<size_t>(controller)]->DeactivateController();
+}
 
-    void DeactivateController(HidController controller) {
-        controllers[static_cast<size_t>(controller)]->DeactivateController();
-    }
+IAppletResource ::~IAppletResource() {
+    CoreTiming::UnscheduleEvent(pad_update_event, 0);
+}
 
-    template <typename T>
-    void MakeController(HidController controller) {
-        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>();
-    }
+void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_HID, "called");
 
-    template <typename T>
-    T& GetController(HidController controller) {
-        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
-    }
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(shared_mem);
+}
 
-    ~IAppletResource() {
-        CoreTiming::UnscheduleEvent(pad_update_event, 0);
-    }
-
-private:
-    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_HID, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(shared_mem);
-    }
-
-    void UpdateControllers(u64 userdata, int cycles_late) {
-        const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
-        for (const auto& controller : controllers) {
-            if (should_reload) {
-                controller->OnLoadInputDevices();
-            }
-            controller->OnUpdate(shared_mem->GetPointer(), SHARED_MEMORY_SIZE);
+void IAppletResource::UpdateControllers(u64 userdata, int cycles_late) {
+    const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
+    for (const auto& controller : controllers) {
+        if (should_reload) {
+            controller->OnLoadInputDevices();
         }
-
-        CoreTiming::ScheduleEvent(pad_update_ticks - cycles_late, pad_update_event);
+        controller->OnUpdate(shared_mem->GetPointer(), SHARED_MEMORY_SIZE);
     }
 
-    // Handle to shared memory region designated to HID service
-    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
-
-    // CoreTiming update events
-    CoreTiming::EventType* pad_update_event;
-
-    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
-        controllers{};
-};
+    CoreTiming::ScheduleEvent(pad_update_ticks - cycles_late, pad_update_event);
+}
 
 class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
 public:
@@ -172,10 +135,12 @@ private:
     }
 };
 
-class Hid final : public ServiceFramework<Hid> {
-public:
-    Hid() : ServiceFramework("hid") {
-        // clang-format off
+std::shared_ptr<IAppletResource> Hid::GetAppletResource() {
+    return applet_resource;
+}
+
+Hid::Hid() : ServiceFramework("hid") {
+    // clang-format off
         static const FunctionInfo functions[] = {
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
@@ -296,475 +261,467 @@ public:
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
-        // clang-format on
+    // clang-format on
 
-        RegisterHandlers(functions);
-    }
-    ~Hid() = default;
+    RegisterHandlers(functions);
+}
 
-private:
-    std::shared_ptr<IAppletResource> applet_resource;
+Hid::~Hid() = default;
 
-    void CreateAppletResource(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::CreateAppletResource(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-        if (applet_resource == nullptr) {
-            applet_resource = std::make_shared<IAppletResource>();
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IAppletResource>(applet_resource);
+    if (applet_resource == nullptr) {
+        applet_resource = std::make_shared<IAppletResource>();
     }
 
-    void ActivateXpad(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto basic_xpad_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, basic_xpad_id={}, applet_resource_user_id={}",
-                  basic_xpad_id, applet_resource_user_id);
-
-        applet_resource->ActivateController(HidController::XPad);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void ActivateDebugPad(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IAppletResource>(applet_resource);
+}
+
+void Hid::ActivateXpad(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto basic_xpad_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, basic_xpad_id={}, applet_resource_user_id={}", basic_xpad_id,
+              applet_resource_user_id);
+
+    applet_resource->ActivateController(HidController::XPad);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::ActivateDebugPad(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+
+    applet_resource->ActivateController(HidController::DebugPad);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-        applet_resource->ActivateController(HidController::DebugPad);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    applet_resource->ActivateController(HidController::Touchscreen);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::ActivateMouse(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-        applet_resource->ActivateController(HidController::Touchscreen);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    applet_resource->ActivateController(HidController::Mouse);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void ActivateMouse(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::ActivateKeyboard(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-        applet_resource->ActivateController(HidController::Mouse);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    applet_resource->ActivateController(HidController::Keyboard);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::ActivateGesture(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto unknown{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    LOG_DEBUG(Service_HID, "called, unknown={}, applet_resource_user_id={}", unknown,
+              applet_resource_user_id);
 
-        applet_resource->ActivateController(HidController::Keyboard);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    applet_resource->ActivateController(HidController::Gesture);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void ActivateGesture(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto unknown{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::ActivateNpadWithRevision(Kernel::HLERequestContext& ctx) {
+    // Should have no effect with how our npad sets up the data
+    IPC::RequestParser rp{ctx};
+    const auto unknown{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_DEBUG(Service_HID, "called, unknown={}, applet_resource_user_id={}", unknown,
-                  applet_resource_user_id);
+    LOG_DEBUG(Service_HID, "called, unknown={}, applet_resource_user_id={}", unknown,
+              applet_resource_user_id);
 
-        applet_resource->ActivateController(HidController::Gesture);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    applet_resource->ActivateController(HidController::NPad);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx) {
-        // Should have no effect with how our npad sets up the data
-        IPC::RequestParser rp{ctx};
-        const auto unknown{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto handle{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_DEBUG(Service_HID, "called, unknown={}, applet_resource_user_id={}", unknown,
-                  applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        applet_resource->ActivateController(HidController::NPad);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto handle{rp.Pop<u32>()};
+    const auto drift_mode{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto handle{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, handle={}, drift_mode={}, applet_resource_user_id={}", handle,
+                drift_mode, applet_resource_user_id);
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                    applet_resource_user_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto handle{rp.Pop<u32>()};
-        const auto drift_mode{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto handle{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_WARNING(Service_HID,
-                    "(STUBBED) called, handle={}, drift_mode={}, applet_resource_user_id={}",
-                    handle, drift_mode, applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
+    rb.Push(true);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto supported_styleset{rp.Pop<u32>()};
 
-    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto handle{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+    LOG_DEBUG(Service_HID, "called, supported_styleset={}", supported_styleset);
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                    applet_resource_user_id);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
-        rb.Push(true);
-    }
+    applet_resource->GetController<Controller_NPad>(HidController::NPad)
+        .SetSupportedStyleSet({supported_styleset});
 
-    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto supported_styleset{rp.Pop<u32>()};
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        LOG_DEBUG(Service_HID, "called, supported_styleset={}", supported_styleset);
+void Hid::GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .SetSupportedStyleSet({supported_styleset});
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+
+    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(controller.GetSupportedStyleSet().raw);
+}
 
-    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(controller.GetSupportedStyleSet().raw);
-    }
-
-    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .SetSupportedNPadIdTypes(ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+
+    applet_resource->GetController<Controller_NPad>(HidController::NPad)
+        .SetSupportedNPadIdTypes(ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void ActivateNpad(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        applet_resource->ActivateController(HidController::NPad);
-    }
-
-    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto npad_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-        const auto unknown{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}, unknown={}",
-                  npad_id, applet_resource_user_id, unknown);
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                               .GetStyleSetChangedEvent());
-    }
+void Hid::ActivateNpad(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-    void DisconnectNpad(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto npad_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id,
-                  applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    applet_resource->ActivateController(HidController::NPad);
+}
 
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .DisconnectNPad(npad_id);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto unknown{rp.Pop<u64>()};
 
-    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto npad_id{rp.Pop<u32>()};
+    LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}, unknown={}", npad_id,
+              applet_resource_user_id, unknown);
 
-        LOG_DEBUG(Service_HID, "called, npad_id={}", npad_id);
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(applet_resource->GetController<Controller_NPad>(HidController::NPad)
+                           .GetStyleSetChangedEvent());
+}
 
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u64>(applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                            .GetLedPattern(npad_id)
-                            .raw);
-    }
+void Hid::DisconnectNpad(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-        const auto hold_type{rp.Pop<u64>()};
+    LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id,
+              applet_resource_user_id);
 
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, hold_type={}",
-                  applet_resource_user_id, hold_type);
+    applet_resource->GetController<Controller_NPad>(HidController::NPad).DisconnectNPad(npad_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-        controller.SetHoldType(Controller_NPad::NpadHoldType{hold_type});
+void Hid::GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id{rp.Pop<u32>()};
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    LOG_DEBUG(Service_HID, "called, npad_id={}", npad_id);
 
-    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        const auto& controller =
-            applet_resource->GetController<Controller_NPad>(HidController::NPad);
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(static_cast<u64>(controller.GetHoldType()));
-    }
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<u64>(applet_resource->GetController<Controller_NPad>(HidController::NPad)
+                        .GetLedPattern(npad_id)
+                        .raw);
+}
 
-    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto npad_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
-                    npad_id, applet_resource_user_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .SetVibrationEnabled(true);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void EndPermitVibrationSession(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_HID, "called");
-
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .SetVibrationEnabled(false);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto controller_id{rp.Pop<u32>()};
-        const auto vibration_values{rp.PopRaw<Controller_NPad::Vibration>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, controller_id={}, applet_resource_user_id={}",
-                  controller_id, applet_resource_user_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .VibrateController({controller_id}, {vibration_values});
-    }
-
-    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-        const auto controllers = ctx.ReadBuffer(0);
-        const auto vibrations = ctx.ReadBuffer(1);
+void Hid::SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto hold_type{rp.Pop<u64>()};
 
-        std::vector<u32> controller_list(controllers.size() / sizeof(u32));
-        std::vector<Controller_NPad::Vibration> vibration_list(vibrations.size() /
-                                                               sizeof(Controller_NPad::Vibration));
-
-        std::memcpy(controller_list.data(), controllers.data(), controllers.size());
-        std::memcpy(vibration_list.data(), vibrations.data(), vibrations.size());
-        std::transform(controller_list.begin(), controller_list.end(), controller_list.begin(),
-                       [](u32 controller_id) { return controller_id - 3; });
-
-        applet_resource->GetController<Controller_NPad>(HidController::NPad)
-            .VibrateController(controller_list, vibration_list);
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, hold_type={}",
+              applet_resource_user_id, hold_type);
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
+    controller.SetHoldType(Controller_NPad::NpadHoldType{hold_type});
 
-    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto controller_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        LOG_DEBUG(Service_HID, "called, controller_id={}, applet_resource_user_id={}",
-                  controller_id, applet_resource_user_id);
+void Hid::GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<Controller_NPad::Vibration>(
-            applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                .GetLastVibration());
-    }
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-    void SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto npad_id{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id,
-                  applet_resource_user_id);
+    const auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(static_cast<u64>(controller.GetHoldType()));
+}
 
-        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-        controller.SetNpadMode(npad_id, Controller_NPad::NPadAssignments::Dual);
+void Hid::SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}", npad_id,
+                applet_resource_user_id);
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-    void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto unknown_1{rp.Pop<u32>()};
-        const auto unknown_2{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+void Hid::BeginPermitVibrationSession(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+
+    applet_resource->GetController<Controller_NPad>(HidController::NPad).SetVibrationEnabled(true);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        LOG_WARNING(Service_HID,
-                    "(STUBBED) called, unknown_1={}, unknown_2={}, applet_resource_user_id={}",
-                    unknown_1, unknown_2, applet_resource_user_id);
+void Hid::EndPermitVibrationSession(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_HID, "called");
+
+    applet_resource->GetController<Controller_NPad>(HidController::NPad).SetVibrationEnabled(false);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::SendVibrationValue(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto controller_id{rp.Pop<u32>()};
+    const auto vibration_values{rp.PopRaw<Controller_NPad::Vibration>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-        const auto mode{rp.Pop<u64>()};
+    LOG_DEBUG(Service_HID, "called, controller_id={}, applet_resource_user_id={}", controller_id,
+              applet_resource_user_id);
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, mode={}",
-                    applet_resource_user_id, mode);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+
+    applet_resource->GetController<Controller_NPad>(HidController::NPad)
+        .VibrateController({controller_id}, {vibration_values});
+}
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::SendVibrationValues(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_HID, "called");
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(1);
-        rb.Push<u32>(0);
-    }
+    const auto controllers = ctx.ReadBuffer(0);
+    const auto vibrations = ctx.ReadBuffer(1);
 
-    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_HID, "called");
+    std::vector<u32> controller_list(controllers.size() / sizeof(u32));
+    std::vector<Controller_NPad::Vibration> vibration_list(vibrations.size() /
+                                                           sizeof(Controller_NPad::Vibration));
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IActiveVibrationDeviceList>();
-    }
+    std::memcpy(controller_list.data(), controllers.data(), controllers.size());
+    std::memcpy(vibration_list.data(), vibrations.data(), vibrations.size());
+    std::transform(controller_list.begin(), controller_list.end(), controller_list.begin(),
+                   [](u32 controller_id) { return controller_id - 3; });
 
-    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
+    applet_resource->GetController<Controller_NPad>(HidController::NPad)
+        .VibrateController(controller_list, vibration_list);
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                    applet_resource_user_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+void Hid::GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto controller_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto handle{rp.Pop<u32>()};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-
-        LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                    applet_resource_user_id);
+    LOG_DEBUG(Service_HID, "called, controller_id={}, applet_resource_user_id={}", controller_id,
+              applet_resource_user_id);
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<Controller_NPad::Vibration>(
+        applet_resource->GetController<Controller_NPad>(HidController::NPad).GetLastVibration());
+}
 
-    void StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto handle{rp.Pop<u32>()};
+void Hid::SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, handle={}", handle);
+    LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id,
+              applet_resource_user_id);
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
+    controller.SetNpadMode(npad_id, Controller_NPad::NPadAssignments::Dual);
 
-    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto applet_resource_user_id{rp.Pop<u64>()};
-        const auto unknown{rp.Pop<u32>()};
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, unknown={}",
-                    applet_resource_user_id, unknown);
+void Hid::MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto unknown_1{rp.Pop<u32>()};
+    const auto unknown_2{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, unknown_1={}, unknown_2={}, applet_resource_user_id={}",
+                unknown_1, unknown_2, applet_resource_user_id);
 
-    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto unknown{rp.Pop<u32>()};
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
-        LOG_WARNING(Service_HID, "(STUBBED) called, unknown={}", unknown);
+void Hid::SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto mode{rp.Pop<u64>()};
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-};
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, mode={}",
+                applet_resource_user_id, mode);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_HID, "called");
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(1);
+    rb.Push<u32>(0);
+}
+
+void Hid::CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_HID, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IActiveVibrationDeviceList>();
+}
+
+void Hid::ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto handle{rp.Pop<u32>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto handle{rp.Pop<u32>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}", handle);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto unknown{rp.Pop<u32>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, unknown={}",
+                applet_resource_user_id, unknown);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void Hid::SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto unknown{rp.Pop<u32>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, unknown={}", unknown);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
 
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 773035460..615d4e6d8 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -3,6 +3,15 @@
 // Refer to the license.txt file included.
 
 #pragma once
+#include "core/hle/service/service.h"
+
+namespace CoreTiming {
+struct EventType;
+}
+
+namespace Kernel {
+class SharedMemory;
+}
 
 namespace SM {
 class ServiceManager;
@@ -10,6 +19,107 @@ class ServiceManager;
 
 namespace Service::HID {
 
+class ControllerBase;
+
+enum class HidController : std::size_t {
+    DebugPad,
+    Touchscreen,
+    Mouse,
+    Keyboard,
+    XPad,
+    Unknown1,
+    Unknown2,
+    Unknown3,
+    SixAxisSensor,
+    NPad,
+    Gesture,
+
+    MaxControllers,
+};
+
+class IAppletResource final : public ServiceFramework<IAppletResource> {
+public:
+    IAppletResource();
+    ~IAppletResource() override;
+
+    void ActivateController(HidController controller);
+    void DeactivateController(HidController controller);
+
+    template <typename T>
+    T& GetController(HidController controller) {
+        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
+    }
+
+    template <typename T>
+    const T& GetController(HidController controller) const {
+        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
+    }
+
+private:
+    template <typename T>
+    void MakeController(HidController controller) {
+        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>();
+    }
+
+    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
+    void UpdateControllers(u64 userdata, int cycles_late);
+
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
+
+    CoreTiming::EventType* pad_update_event;
+
+    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
+        controllers{};
+};
+
+class Hid final : public ServiceFramework<Hid> {
+public:
+    Hid();
+    ~Hid() override;
+
+    std::shared_ptr<IAppletResource> GetAppletResource();
+
+private:
+    void CreateAppletResource(Kernel::HLERequestContext& ctx);
+    void ActivateXpad(Kernel::HLERequestContext& ctx);
+    void ActivateDebugPad(Kernel::HLERequestContext& ctx);
+    void ActivateTouchScreen(Kernel::HLERequestContext& ctx);
+    void ActivateMouse(Kernel::HLERequestContext& ctx);
+    void ActivateKeyboard(Kernel::HLERequestContext& ctx);
+    void ActivateGesture(Kernel::HLERequestContext& ctx);
+    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx);
+    void StartSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
+    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx);
+    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
+    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
+    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx);
+    void ActivateNpad(Kernel::HLERequestContext& ctx);
+    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx);
+    void DisconnectNpad(Kernel::HLERequestContext& ctx);
+    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx);
+    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx);
+    void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx);
+    void EndPermitVibrationSession(Kernel::HLERequestContext& ctx);
+    void SendVibrationValue(Kernel::HLERequestContext& ctx);
+    void SendVibrationValues(Kernel::HLERequestContext& ctx);
+    void GetActualVibrationValue(Kernel::HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx);
+    void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx);
+    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx);
+    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx);
+    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx);
+    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx);
+    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
+
+    std::shared_ptr<IAppletResource> applet_resource;
+};
+
 /// Reload input devices. Used when input configuration changed
 void ReloadInputDevices();