13 files changed, 207 insertions, 202 deletions

diff --git a/src/hid_core/irsensor/image_transfer_processor.cpp b/src/hid_core/irsensor/image_transfer_processor.cpp
index d6573f8dc..2b5a50ef6 100644
--- a/src/hid_core/irsensor/image_transfer_processor.cpp
+++ b/src/hid_core/irsensor/image_transfer_processor.cpp
@@ -145,9 +145,8 @@ void ImageTransferProcessor::SetTransferMemoryAddress(Common::ProcessAddress t_m
 }
 
 Core::IrSensor::ImageTransferProcessorState ImageTransferProcessor::GetState(
-    std::vector<u8>& data) const {
-    const auto size = GetDataSize(current_config.trimming_format);
-    data.resize(size);
+    std::span<u8> data) const {
+    const auto size = std::min(GetDataSize(current_config.trimming_format), data.size());
     system.ApplicationMemory().ReadBlock(transfer_memory, data.data(), size);
     return processor_state;
 }
diff --git a/src/hid_core/irsensor/image_transfer_processor.h b/src/hid_core/irsensor/image_transfer_processor.h
index 4e0117084..df1c9d920 100644
--- a/src/hid_core/irsensor/image_transfer_processor.h
+++ b/src/hid_core/irsensor/image_transfer_processor.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <span>
+
 #include "common/typed_address.h"
 #include "hid_core/irsensor/irs_types.h"
 #include "hid_core/irsensor/processor_base.h"
@@ -39,7 +41,7 @@ public:
     // Transfer memory where the image data will be stored
     void SetTransferMemoryAddress(Common::ProcessAddress t_mem);
 
-    Core::IrSensor::ImageTransferProcessorState GetState(std::vector<u8>& data) const;
+    Core::IrSensor::ImageTransferProcessorState GetState(std::span<u8> data) const;
 
 private:
     // This is nn::irsensor::ImageTransferProcessorConfig
diff --git a/src/hid_core/resource_manager.cpp b/src/hid_core/resource_manager.cpp
index 68ce2c7ae..245da582e 100644
--- a/src/hid_core/resource_manager.cpp
+++ b/src/hid_core/resource_manager.cpp
@@ -52,9 +52,42 @@ ResourceManager::ResourceManager(Core::System& system_,
                                  std::shared_ptr<HidFirmwareSettings> settings)
     : firmware_settings{settings}, system{system_}, service_context{system_, "hid"} {
     applet_resource = std::make_shared<AppletResource>(system);
+
+    // Register update callbacks
+    npad_update_event = Core::Timing::CreateEvent("HID::UpdatePadCallback",
+                                                  [this](s64 time, std::chrono::nanoseconds ns_late)
+                                                      -> std::optional<std::chrono::nanoseconds> {
+                                                      UpdateNpad(ns_late);
+                                                      return std::nullopt;
+                                                  });
+    default_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateDefaultCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateControllers(ns_late);
+            return std::nullopt;
+        });
+    mouse_keyboard_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateMouseKeyboardCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateMouseKeyboard(ns_late);
+            return std::nullopt;
+        });
+    motion_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateMotionCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateMotion(ns_late);
+            return std::nullopt;
+        });
 }
 
 ResourceManager::~ResourceManager() {
+    system.CoreTiming().UnscheduleEvent(npad_update_event);
+    system.CoreTiming().UnscheduleEvent(default_update_event);
+    system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
+    system.CoreTiming().UnscheduleEvent(motion_update_event);
     system.CoreTiming().UnscheduleEvent(touch_update_event);
     input_event->Finalize();
 };
@@ -201,6 +234,7 @@ void ResourceManager::InitializeHidCommonSampler() {
 
     debug_pad->SetAppletResource(applet_resource, &shared_mutex);
     digitizer->SetAppletResource(applet_resource, &shared_mutex);
+    unique_pad->SetAppletResource(applet_resource, &shared_mutex);
     keyboard->SetAppletResource(applet_resource, &shared_mutex);
 
     const auto settings =
@@ -214,6 +248,14 @@ void ResourceManager::InitializeHidCommonSampler() {
     home_button->SetAppletResource(applet_resource, &shared_mutex);
     sleep_button->SetAppletResource(applet_resource, &shared_mutex);
     capture_button->SetAppletResource(applet_resource, &shared_mutex);
+
+    system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
+                                             default_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
+                                             mouse_keyboard_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
+                                             motion_update_event);
 }
 
 void ResourceManager::InitializeTouchScreenSampler() {
@@ -465,55 +507,9 @@ IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<Resource
         {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
     };
     RegisterHandlers(functions);
-
-    // Register update callbacks
-    npad_update_event = Core::Timing::CreateEvent(
-        "HID::UpdatePadCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateNpad(ns_late);
-            return std::nullopt;
-        });
-    default_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateDefaultCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateControllers(ns_late);
-            return std::nullopt;
-        });
-    mouse_keyboard_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateMouseKeyboardCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateMouseKeyboard(ns_late);
-            return std::nullopt;
-        });
-    motion_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateMotionCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateMotion(ns_late);
-            return std::nullopt;
-        });
-
-    system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
-                                             default_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
-                                             mouse_keyboard_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
-                                             motion_update_event);
 }
 
 IAppletResource::~IAppletResource() {
-    system.CoreTiming().UnscheduleEvent(npad_update_event);
-    system.CoreTiming().UnscheduleEvent(default_update_event);
-    system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
-    system.CoreTiming().UnscheduleEvent(motion_update_event);
     resource_manager->FreeAppletResourceId(aruid);
 }
 
diff --git a/src/hid_core/resource_manager.h b/src/hid_core/resource_manager.h
index 0bfe09511..dc3ff01f8 100644
--- a/src/hid_core/resource_manager.h
+++ b/src/hid_core/resource_manager.h
@@ -147,6 +147,10 @@ private:
     std::shared_ptr<SixAxis> six_axis{nullptr};
     std::shared_ptr<SleepButton> sleep_button{nullptr};
     std::shared_ptr<UniquePad> unique_pad{nullptr};
+    std::shared_ptr<Core::Timing::EventType> npad_update_event;
+    std::shared_ptr<Core::Timing::EventType> default_update_event;
+    std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event;
+    std::shared_ptr<Core::Timing::EventType> motion_update_event;
 
     // TODO: Create these resources
     // std::shared_ptr<AudioControl> audio_control{nullptr};
@@ -179,11 +183,6 @@ public:
 private:
     void GetSharedMemoryHandle(HLERequestContext& ctx);
 
-    std::shared_ptr<Core::Timing::EventType> npad_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> default_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> motion_update_event{nullptr};
-
     u64 aruid{};
     std::shared_ptr<ResourceManager> resource_manager;
 };
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 6d759298e..0dde244ef 100644
--- a/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp
+++ b/src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp
@@ -57,7 +57,7 @@ Result NpadAbstractSixAxisHandler::UpdateSixAxisState() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        if (data->flag.is_assigned) {
+        if (data == nullptr || !data->flag.is_assigned) {
             continue;
         }
         auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
diff --git a/src/hid_core/resources/digitizer/digitizer.cpp b/src/hid_core/resources/digitizer/digitizer.cpp
index cd72fd6e5..5d7dcadfe 100644
--- a/src/hid_core/resources/digitizer/digitizer.cpp
+++ b/src/hid_core/resources/digitizer/digitizer.cpp
@@ -17,10 +17,6 @@ void Digitizer::OnInit() {}
 void Digitizer::OnRelease() {}
 
 void Digitizer::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     std::scoped_lock shared_lock{*shared_mutex};
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
diff --git a/src/hid_core/resources/digitizer/digitizer.h b/src/hid_core/resources/digitizer/digitizer.h
index e031a16b0..68b03111c 100644
--- a/src/hid_core/resources/digitizer/digitizer.h
+++ b/src/hid_core/resources/digitizer/digitizer.h
@@ -20,8 +20,5 @@ public:
 
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
-
-private:
-    bool smart_update{};
 };
 } // namespace Service::HID
diff --git a/src/hid_core/resources/npad/npad.cpp b/src/hid_core/resources/npad/npad.cpp
index 1a58eff4a..053625b55 100644
--- a/src/hid_core/resources/npad/npad.cpp
+++ b/src/hid_core/resources/npad/npad.cpp
@@ -102,6 +102,8 @@ Result NPad::Activate(u64 aruid) {
         for (std::size_t i = 0; i < 19; ++i) {
             WriteEmptyEntry(npad);
         }
+
+        controller.is_active = true;
     }
 
     return ResultSuccess;
@@ -129,7 +131,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
 
         auto* data = applet_resource_holder.applet_resource->GetAruidDataByIndex(aruid_index);
 
-        if (!data->flag.is_assigned) {
+        if (data == nullptr || !data->flag.is_assigned) {
             continue;
         }
 
@@ -461,9 +463,16 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     std::scoped_lock lock{*applet_resource_holder.shared_mutex};
     for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
         const auto* data = applet_resource_holder.applet_resource->GetAruidDataByIndex(aruid_index);
-        const auto aruid = data->aruid;
 
-        if (!data->flag.is_assigned) {
+        if (data == nullptr || !data->flag.is_assigned) {
+            continue;
+        }
+
+        bool is_set{};
+        const auto aruid = data->aruid;
+        npad_resource.IsSupportedNpadStyleSet(is_set, aruid);
+        // Wait until style is defined
+        if (!is_set) {
             continue;
         }
 
@@ -484,6 +493,10 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
                 continue;
             }
 
+            if (!controller.is_active) {
+                continue;
+            }
+
             RequestPadStateUpdate(aruid, controller.device->GetNpadIdType());
             auto& pad_state = controller.npad_pad_state;
             auto& libnx_state = controller.npad_libnx_state;
@@ -592,7 +605,9 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
             libnx_state.npad_buttons.raw = pad_state.npad_buttons.raw;
             libnx_state.l_stick = pad_state.l_stick;
             libnx_state.r_stick = pad_state.r_stick;
-            npad->system_ext_lifo.WriteNextEntry(pad_state);
+            libnx_state.sampling_number =
+                npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad->system_ext_lifo.WriteNextEntry(libnx_state);
 
             press_state |= static_cast<u64>(pad_state.npad_buttons.raw);
         }
@@ -1060,6 +1075,7 @@ void NPad::UnregisterAppletResourceUserId(u64 aruid) {
     // TODO: Remove this once abstract pad is emulated properly
     const auto aruid_index = npad_resource.GetIndexFromAruid(aruid);
     for (auto& controller : controller_data[aruid_index]) {
+        controller.is_active = false;
         controller.is_connected = false;
         controller.shared_memory = nullptr;
     }
diff --git a/src/hid_core/resources/npad/npad.h b/src/hid_core/resources/npad/npad.h
index 4e26ed2e8..c63488346 100644
--- a/src/hid_core/resources/npad/npad.h
+++ b/src/hid_core/resources/npad/npad.h
@@ -164,6 +164,7 @@ private:
         NpadInternalState* shared_memory = nullptr;
         Core::HID::EmulatedController* device = nullptr;
 
+        bool is_active{};
         bool is_connected{};
 
         // Dual joycons can have only one side connected
diff --git a/src/hid_core/resources/six_axis/six_axis.cpp b/src/hid_core/resources/six_axis/six_axis.cpp
index abb6fd152..b407a5c76 100644
--- a/src/hid_core/resources/six_axis/six_axis.cpp
+++ b/src/hid_core/resources/six_axis/six_axis.cpp
@@ -28,142 +28,148 @@ void SixAxis::OnRelease() {}
 
 void SixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     std::scoped_lock shared_lock{*shared_mutex};
-    const u64 aruid = applet_resource->GetActiveAruid();
-    auto* data = applet_resource->GetAruidData(aruid);
 
-    if (data == nullptr || !data->flag.is_assigned) {
-        return;
-    }
-
-    if (!IsControllerActivated()) {
-        return;
-    }
+    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
+        const auto* data = applet_resource->GetAruidDataByIndex(aruid_index);
 
-    for (std::size_t i = 0; i < controller_data.size(); ++i) {
-        NpadSharedMemoryEntry& shared_memory = data->shared_memory_format->npad.npad_entry[i];
-        auto& controller = controller_data[i];
-        const auto& controller_type = controller.device->GetNpadStyleIndex();
-
-        if (controller_type == Core::HID::NpadStyleIndex::None ||
-            !controller.device->IsConnected()) {
+        if (data == nullptr || !data->flag.is_assigned) {
             continue;
         }
 
-        const auto& motion_state = controller.device->GetMotions();
-        auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
-        auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
-        auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
-        auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
-        auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
-        auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
-
-        auto& sixaxis_fullkey_lifo = shared_memory.internal_state.sixaxis_fullkey_lifo;
-        auto& sixaxis_handheld_lifo = shared_memory.internal_state.sixaxis_handheld_lifo;
-        auto& sixaxis_dual_left_lifo = shared_memory.internal_state.sixaxis_dual_left_lifo;
-        auto& sixaxis_dual_right_lifo = shared_memory.internal_state.sixaxis_dual_right_lifo;
-        auto& sixaxis_left_lifo = shared_memory.internal_state.sixaxis_left_lifo;
-        auto& sixaxis_right_lifo = shared_memory.internal_state.sixaxis_right_lifo;
-
-        // Clear previous state
-        sixaxis_fullkey_state = {};
-        sixaxis_handheld_state = {};
-        sixaxis_dual_left_state = {};
-        sixaxis_dual_right_state = {};
-        sixaxis_left_lifo_state = {};
-        sixaxis_right_lifo_state = {};
-
-        if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
-            controller.sixaxis_at_rest = true;
-            for (std::size_t e = 0; e < motion_state.size(); ++e) {
-                controller.sixaxis_at_rest =
-                    controller.sixaxis_at_rest && motion_state[e].is_at_rest;
-            }
+        if (!IsControllerActivated()) {
+            return;
         }
 
-        const auto set_motion_state = [&](Core::HID::SixAxisSensorState& state,
-                                          const Core::HID::ControllerMotion& hid_state) {
-            using namespace std::literals::chrono_literals;
-            static constexpr Core::HID::SixAxisSensorState default_motion_state = {
-                .delta_time = std::chrono::nanoseconds(5ms).count(),
-                .accel = {0, 0, -1.0f},
-                .orientation =
-                    {
-                        Common::Vec3f{1.0f, 0, 0},
-                        Common::Vec3f{0, 1.0f, 0},
-                        Common::Vec3f{0, 0, 1.0f},
-                    },
-                .attribute = {1},
+        for (std::size_t i = 0; i < controller_data.size(); ++i) {
+            NpadSharedMemoryEntry& shared_memory = data->shared_memory_format->npad.npad_entry[i];
+            auto& controller = controller_data[i];
+            const auto& controller_type = controller.device->GetNpadStyleIndex();
+
+            if (!data->flag.enable_six_axis_sensor) {
+                continue;
+            }
+
+            if (controller_type == Core::HID::NpadStyleIndex::None ||
+                !controller.device->IsConnected()) {
+                continue;
+            }
+
+            const auto& motion_state = controller.device->GetMotions();
+            auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
+            auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
+            auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
+            auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
+            auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
+            auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
+
+            auto& sixaxis_fullkey_lifo = shared_memory.internal_state.sixaxis_fullkey_lifo;
+            auto& sixaxis_handheld_lifo = shared_memory.internal_state.sixaxis_handheld_lifo;
+            auto& sixaxis_dual_left_lifo = shared_memory.internal_state.sixaxis_dual_left_lifo;
+            auto& sixaxis_dual_right_lifo = shared_memory.internal_state.sixaxis_dual_right_lifo;
+            auto& sixaxis_left_lifo = shared_memory.internal_state.sixaxis_left_lifo;
+            auto& sixaxis_right_lifo = shared_memory.internal_state.sixaxis_right_lifo;
+
+            // Clear previous state
+            sixaxis_fullkey_state = {};
+            sixaxis_handheld_state = {};
+            sixaxis_dual_left_state = {};
+            sixaxis_dual_right_state = {};
+            sixaxis_left_lifo_state = {};
+            sixaxis_right_lifo_state = {};
+
+            if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
+                controller.sixaxis_at_rest = true;
+                for (std::size_t e = 0; e < motion_state.size(); ++e) {
+                    controller.sixaxis_at_rest =
+                        controller.sixaxis_at_rest && motion_state[e].is_at_rest;
+                }
+            }
+
+            const auto set_motion_state = [&](Core::HID::SixAxisSensorState& state,
+                                              const Core::HID::ControllerMotion& hid_state) {
+                using namespace std::literals::chrono_literals;
+                static constexpr Core::HID::SixAxisSensorState default_motion_state = {
+                    .delta_time = std::chrono::nanoseconds(5ms).count(),
+                    .accel = {0, 0, -1.0f},
+                    .orientation =
+                        {
+                            Common::Vec3f{1.0f, 0, 0},
+                            Common::Vec3f{0, 1.0f, 0},
+                            Common::Vec3f{0, 0, 1.0f},
+                        },
+                    .attribute = {1},
+                };
+                if (!controller.sixaxis_sensor_enabled) {
+                    state = default_motion_state;
+                    return;
+                }
+                if (!Settings::values.motion_enabled.GetValue()) {
+                    state = default_motion_state;
+                    return;
+                }
+                state.attribute.is_connected.Assign(1);
+                state.delta_time = std::chrono::nanoseconds(5ms).count();
+                state.accel = hid_state.accel;
+                state.gyro = hid_state.gyro;
+                state.rotation = hid_state.rotation;
+                state.orientation = hid_state.orientation;
             };
-            if (!controller.sixaxis_sensor_enabled) {
-                state = default_motion_state;
-                return;
+
+            switch (controller_type) {
+            case Core::HID::NpadStyleIndex::None:
+                ASSERT(false);
+                break;
+            case Core::HID::NpadStyleIndex::Fullkey:
+                set_motion_state(sixaxis_fullkey_state, motion_state[0]);
+                break;
+            case Core::HID::NpadStyleIndex::Handheld:
+                set_motion_state(sixaxis_handheld_state, motion_state[0]);
+                break;
+            case Core::HID::NpadStyleIndex::JoyconDual:
+                set_motion_state(sixaxis_dual_left_state, motion_state[0]);
+                set_motion_state(sixaxis_dual_right_state, motion_state[1]);
+                break;
+            case Core::HID::NpadStyleIndex::JoyconLeft:
+                set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
+                break;
+            case Core::HID::NpadStyleIndex::JoyconRight:
+                set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
+                break;
+            case Core::HID::NpadStyleIndex::Pokeball:
+                using namespace std::literals::chrono_literals;
+                set_motion_state(sixaxis_fullkey_state, motion_state[0]);
+                sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
+                break;
+            default:
+                break;
             }
-            if (!Settings::values.motion_enabled.GetValue()) {
-                state = default_motion_state;
-                return;
+
+            sixaxis_fullkey_state.sampling_number =
+                sixaxis_fullkey_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+            sixaxis_handheld_state.sampling_number =
+                sixaxis_handheld_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+            sixaxis_dual_left_state.sampling_number =
+                sixaxis_dual_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+            sixaxis_dual_right_state.sampling_number =
+                sixaxis_dual_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+            sixaxis_left_lifo_state.sampling_number =
+                sixaxis_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+            sixaxis_right_lifo_state.sampling_number =
+                sixaxis_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+
+            if (IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
+                // This buffer only is updated on handheld on HW
+                sixaxis_handheld_lifo.lifo.WriteNextEntry(sixaxis_handheld_state);
+            } else {
+                // Handheld doesn't update this buffer on HW
+                sixaxis_fullkey_lifo.lifo.WriteNextEntry(sixaxis_fullkey_state);
             }
-            state.attribute.is_connected.Assign(1);
-            state.delta_time = std::chrono::nanoseconds(5ms).count();
-            state.accel = hid_state.accel;
-            state.gyro = hid_state.gyro;
-            state.rotation = hid_state.rotation;
-            state.orientation = hid_state.orientation;
-        };
-
-        switch (controller_type) {
-        case Core::HID::NpadStyleIndex::None:
-            ASSERT(false);
-            break;
-        case Core::HID::NpadStyleIndex::Fullkey:
-            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::Handheld:
-            set_motion_state(sixaxis_handheld_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconDual:
-            set_motion_state(sixaxis_dual_left_state, motion_state[0]);
-            set_motion_state(sixaxis_dual_right_state, motion_state[1]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconLeft:
-            set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconRight:
-            set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
-            break;
-        case Core::HID::NpadStyleIndex::Pokeball:
-            using namespace std::literals::chrono_literals;
-            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
-            sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
-            break;
-        default:
-            break;
-        }
 
-        sixaxis_fullkey_state.sampling_number =
-            sixaxis_fullkey_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_handheld_state.sampling_number =
-            sixaxis_handheld_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_dual_left_state.sampling_number =
-            sixaxis_dual_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_dual_right_state.sampling_number =
-            sixaxis_dual_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_left_lifo_state.sampling_number =
-            sixaxis_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_right_lifo_state.sampling_number =
-            sixaxis_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-
-        if (IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
-            // This buffer only is updated on handheld on HW
-            sixaxis_handheld_lifo.lifo.WriteNextEntry(sixaxis_handheld_state);
-        } else {
-            // Handheld doesn't update this buffer on HW
-            sixaxis_fullkey_lifo.lifo.WriteNextEntry(sixaxis_fullkey_state);
+            sixaxis_dual_left_lifo.lifo.WriteNextEntry(sixaxis_dual_left_state);
+            sixaxis_dual_right_lifo.lifo.WriteNextEntry(sixaxis_dual_right_state);
+            sixaxis_left_lifo.lifo.WriteNextEntry(sixaxis_left_lifo_state);
+            sixaxis_right_lifo.lifo.WriteNextEntry(sixaxis_right_lifo_state);
         }
-
-        sixaxis_dual_left_lifo.lifo.WriteNextEntry(sixaxis_dual_left_state);
-        sixaxis_dual_right_lifo.lifo.WriteNextEntry(sixaxis_dual_right_state);
-        sixaxis_left_lifo.lifo.WriteNextEntry(sixaxis_left_lifo_state);
-        sixaxis_right_lifo.lifo.WriteNextEntry(sixaxis_right_lifo_state);
     }
 }
 
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 56e8e8e51..c39321915 100644
--- a/src/hid_core/resources/touch_screen/touch_screen_resource.cpp
+++ b/src/hid_core/resources/touch_screen/touch_screen_resource.cpp
@@ -63,7 +63,7 @@ Result TouchResource::ActivateTouch(u64 aruid) {
         auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& touch_data = aruid_data[aruid_index];
 
-        if (!applet_data->flag.is_assigned) {
+        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
             touch_data = {};
             continue;
         }
@@ -124,7 +124,7 @@ Result TouchResource::ActivateGesture(u64 aruid, u32 basic_gesture_id) {
         auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& touch_data = aruid_data[aruid_index];
 
-        if (!applet_data->flag.is_assigned) {
+        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
             touch_data = {};
             continue;
         }
@@ -324,7 +324,7 @@ Result TouchResource::SetTouchScreenConfiguration(
         const auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& data = aruid_data[aruid_index];
 
-        if (!applet_data->flag.is_assigned) {
+        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
             continue;
         }
         if (aruid != data.aruid) {
@@ -344,7 +344,7 @@ Result TouchResource::GetTouchScreenConfiguration(
         const auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         const TouchAruidData& data = aruid_data[aruid_index];
 
-        if (!applet_data->flag.is_assigned) {
+        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
             continue;
         }
         if (aruid != data.aruid) {
diff --git a/src/hid_core/resources/unique_pad/unique_pad.cpp b/src/hid_core/resources/unique_pad/unique_pad.cpp
index 89fc57269..b2db55c5a 100644
--- a/src/hid_core/resources/unique_pad/unique_pad.cpp
+++ b/src/hid_core/resources/unique_pad/unique_pad.cpp
@@ -17,10 +17,6 @@ void UniquePad::OnInit() {}
 void UniquePad::OnRelease() {}
 
 void UniquePad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
 
diff --git a/src/hid_core/resources/unique_pad/unique_pad.h b/src/hid_core/resources/unique_pad/unique_pad.h
index 674ad1691..4873b7f7e 100644
--- a/src/hid_core/resources/unique_pad/unique_pad.h
+++ b/src/hid_core/resources/unique_pad/unique_pad.h
@@ -20,8 +20,5 @@ public:
 
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
-
-private:
-    bool smart_update{};
 };
 } // namespace Service::HID