78 files changed, 4631 insertions, 1644 deletions
diff --git a/src/common/input.h b/src/common/input.h
index 825b0d650..bfa0639f5 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -76,6 +76,19 @@ enum class PollingError {
    Unknown,
 };
+// Nfc reply from the controller
+enum class NfcState {
+    Success,
+    NewAmiibo,
+    WaitingForAmiibo,
+    AmiiboRemoved,
+    NotAnAmiibo,
+    NotSupported,
+    WrongDeviceState,
+    WriteFailed,
+    Unknown,
+};
 // Ir camera reply from the controller
 enum class CameraError {
    None,
@@ -202,6 +215,11 @@ struct CameraStatus {
    std::vector<u8> data{};
 };
+struct NfcStatus {
+    NfcState state{};
+    std::vector<u8> data{};
+};
 // List of buttons to be passed to Qt that can be translated
 enum class ButtonNames {
    Undefined,
@@ -260,6 +278,7 @@ struct CallbackStatus {
    BatteryStatus battery_status{};
    VibrationStatus vibration_status{};
    CameraStatus camera_status{};
+    NfcStatus nfc_status{};
 };
 // Triggered once every input change
@@ -312,6 +331,14 @@ public:
    virtual CameraError SetCameraFormat([[maybe_unused]] CameraFormat camera_format) {
        return CameraError::NotSupported;
    }
+    virtual NfcState SupportsNfc() const {
+        return NfcState::NotSupported;
+    }
+    virtual NfcState WriteNfcData([[maybe_unused]] const std::vector<u8>& data) {
+        return NfcState::NotSupported;
+    }
 };
 /// An abstract class template for a factory that can create input devices.
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 33cf470d5..8e3fd4505 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -460,6 +460,8 @@ add_library(core STATIC
    hle/service/hid/controllers/mouse.h
    hle/service/hid/controllers/npad.cpp
    hle/service/hid/controllers/npad.h
+    hle/service/hid/controllers/palma.cpp
+    hle/service/hid/controllers/palma.h
    hle/service/hid/controllers/stubbed.cpp
    hle/service/hid/controllers/stubbed.h
    hle/service/hid/controllers/touchscreen.cpp
@@ -494,6 +496,8 @@ add_library(core STATIC
    hle/service/jit/jit.h
    hle/service/lbl/lbl.cpp
    hle/service/lbl/lbl.h
+    hle/service/ldn/lan_discovery.cpp
+    hle/service/ldn/lan_discovery.h
    hle/service/ldn/ldn_results.h
    hle/service/ldn/ldn.cpp
    hle/service/ldn/ldn.h
@@ -521,9 +525,12 @@ add_library(core STATIC
    hle/service/nfc/nfc.h
    hle/service/nfp/amiibo_crypto.cpp
    hle/service/nfp/amiibo_crypto.h
-    hle/service/nfp/amiibo_types.h
    hle/service/nfp/nfp.cpp
    hle/service/nfp/nfp.h
+    hle/service/nfp/nfp_device.cpp
+    hle/service/nfp/nfp_device.h
+    hle/service/nfp/nfp_result.h
+    hle/service/nfp/nfp_types.h
    hle/service/nfp/nfp_user.cpp
    hle/service/nfp/nfp_user.h
    hle/service/ngct/ngct.cpp
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 01c43be93..e27d84734 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -93,7 +93,7 @@ void EmulatedController::ReloadFromSettings() {
        .body = GetNpadColor(player.body_color_left),
        .button = GetNpadColor(player.button_color_left),
    };
-    controller.colors_state.left = {
+    controller.colors_state.right = {
        .body = GetNpadColor(player.body_color_right),
        .button = GetNpadColor(player.button_color_right),
    };
@@ -131,13 +131,16 @@ void EmulatedController::LoadDevices() {
    battery_params[RightIndex].Set("battery", true);
    camera_params = Common::ParamPackage{"engine:camera,camera:1"};
+    nfc_params = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
    output_params[LeftIndex] = left_joycon;
    output_params[RightIndex] = right_joycon;
    output_params[2] = camera_params;
+    output_params[3] = nfc_params;
    output_params[LeftIndex].Set("output", true);
    output_params[RightIndex].Set("output", true);
    output_params[2].Set("output", true);
+    output_params[3].Set("output", true);
    LoadTASParams();
@@ -155,6 +158,7 @@ void EmulatedController::LoadDevices() {
    std::transform(battery_params.begin(), battery_params.end(), battery_devices.begin(),
                   Common::Input::CreateDevice<Common::Input::InputDevice>);
    camera_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(camera_params);
+    nfc_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(nfc_params);
    std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
@@ -284,6 +288,16 @@ void EmulatedController::ReloadInput() {
        camera_devices->ForceUpdate();
    }
+    if (nfc_devices) {
+        if (npad_id_type == NpadIdType::Handheld || npad_id_type == NpadIdType::Player1) {
+            nfc_devices->SetCallback({
+                .on_change =
+                    [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
+            });
+            nfc_devices->ForceUpdate();
+        }
+    }
    // Use a common UUID for TAS
    static constexpr Common::UUID TAS_UUID = Common::UUID{
        {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
@@ -339,6 +353,8 @@ void EmulatedController::UnloadInput() {
    for (auto& stick : tas_stick_devices) {
        stick.reset();
    }
+    camera_devices.reset();
+    nfc_devices.reset();
 }
 void EmulatedController::EnableConfiguration() {
@@ -903,6 +919,25 @@ void EmulatedController::SetCamera(const Common::Input::CallbackStatus& callback
    TriggerOnChange(ControllerTriggerType::IrSensor, true);
 }
+void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
+    std::unique_lock lock{mutex};
+    controller.nfc_values = TransformToNfc(callback);
+    if (is_configuring) {
+        lock.unlock();
+        TriggerOnChange(ControllerTriggerType::Nfc, false);
+        return;
+    }
+    controller.nfc_state = {
+        controller.nfc_values.state,
+        controller.nfc_values.data,
+    };
+    lock.unlock();
+    TriggerOnChange(ControllerTriggerType::Nfc, true);
+}
 bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
    if (device_index >= output_devices.size()) {
        return false;
@@ -980,6 +1015,10 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
 bool EmulatedController::SetPollingMode(Common::Input::PollingMode polling_mode) {
    LOG_INFO(Service_HID, "Set polling mode {}", polling_mode);
    auto& output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_output_device = output_devices[3];
+    nfc_output_device->SetPollingMode(polling_mode);
    return output_device->SetPollingMode(polling_mode) == Common::Input::PollingError::None;
 }
@@ -1000,6 +1039,32 @@ bool EmulatedController::SetCameraFormat(
               camera_format)) == Common::Input::CameraError::None;
 }
+bool EmulatedController::HasNfc() const {
+    const auto& nfc_output_device = output_devices[3];
+    switch (npad_type) {
+    case NpadStyleIndex::JoyconRight:
+    case NpadStyleIndex::JoyconDual:
+    case NpadStyleIndex::ProController:
+        break;
+    default:
+        return false;
+    }
+    const bool has_virtual_nfc =
+        npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld;
+    const bool is_virtual_nfc_supported =
+        nfc_output_device->SupportsNfc() != Common::Input::NfcState::NotSupported;
+    return is_connected && (has_virtual_nfc && is_virtual_nfc_supported);
+}
+bool EmulatedController::WriteNfc(const std::vector<u8>& data) {
+    auto& nfc_output_device = output_devices[3];
+    return nfc_output_device->WriteNfcData(data) == Common::Input::NfcState::Success;
+}
 void EmulatedController::SetLedPattern() {
    for (auto& device : output_devices) {
        if (!device) {
@@ -1363,6 +1428,11 @@ const CameraState& EmulatedController::GetCamera() const {
    return controller.camera_state;
 }
+const NfcState& EmulatedController::GetNfc() const {
+    std::scoped_lock lock{mutex};
+    return controller.nfc_state;
+}
 NpadColor EmulatedController::GetNpadColor(u32 color) {
    return {
        .r = static_cast<u8>((color >> 16) & 0xFF),
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index c3aa8f9d3..319226bf8 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -20,7 +20,7 @@
 namespace Core::HID {
 const std::size_t max_emulated_controllers = 2;
-const std::size_t output_devices = 3;
+const std::size_t output_devices_size = 4;
 struct ControllerMotionInfo {
    Common::Input::MotionStatus raw_status{};
    MotionInput emulated{};
@@ -37,7 +37,8 @@ using TriggerDevices =
 using BatteryDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
 using CameraDevices = std::unique_ptr<Common::Input::InputDevice>;
-using OutputDevices = std::array<std::unique_ptr<Common::Input::OutputDevice>, output_devices>;
+using NfcDevices = std::unique_ptr<Common::Input::InputDevice>;
+using OutputDevices = std::array<std::unique_ptr<Common::Input::OutputDevice>, output_devices_size>;
 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
@@ -45,7 +46,8 @@ using ControllerMotionParams = std::array<Common::ParamPackage, Settings::Native
 using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::NumTriggers>;
 using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using CameraParams = Common::ParamPackage;
-using OutputParams = std::array<Common::ParamPackage, output_devices>;
+using NfcParams = Common::ParamPackage;
+using OutputParams = std::array<Common::ParamPackage, output_devices_size>;
 using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
 using SticksValues = std::array<Common::Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
@@ -55,6 +57,7 @@ using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::Native
 using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
 using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
 using CameraValues = Common::Input::CameraStatus;
+using NfcValues = Common::Input::NfcStatus;
 using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;
 struct AnalogSticks {
@@ -80,6 +83,11 @@ struct CameraState {
    std::size_t sample{};
 };
+struct NfcState {
+    Common::Input::NfcState state{};
+    std::vector<u8> data{};
+};
 struct ControllerMotion {
    Common::Vec3f accel{};
    Common::Vec3f gyro{};
@@ -107,6 +115,7 @@ struct ControllerStatus {
    BatteryValues battery_values{};
    VibrationValues vibration_values{};
    CameraValues camera_values{};
+    NfcValues nfc_values{};
    // Data for HID serices
    HomeButtonState home_button_state{};
@@ -119,6 +128,7 @@ struct ControllerStatus {
    ControllerColors colors_state{};
    BatteryLevelState battery_state{};
    CameraState camera_state{};
+    NfcState nfc_state{};
 };
 enum class ControllerTriggerType {
@@ -130,6 +140,7 @@ enum class ControllerTriggerType {
    Battery,
    Vibration,
    IrSensor,
+    Nfc,
    Connected,
    Disconnected,
    Type,
@@ -315,6 +326,9 @@ public:
    /// Returns the latest camera status from the controller
    const CameraState& GetCamera() const;
+    /// Returns the latest ntag status from the controller
+    const NfcState& GetNfc() const;
    /**
     * Sends a specific vibration to the output device
     * @return true if vibration had no errors
@@ -341,6 +355,12 @@ public:
     */
    bool SetCameraFormat(Core::IrSensor::ImageTransferProcessorFormat camera_format);
+    /// Returns true if the device has nfc support
+    bool HasNfc() const;
+    /// Returns true if the nfc tag was written
+    bool WriteNfc(const std::vector<u8>& data);
    /// Returns the led pattern corresponding to this emulated controller
    LedPattern GetLedPattern() const;
@@ -425,6 +445,12 @@ private:
    void SetCamera(const Common::Input::CallbackStatus& callback);
    /**
+     * Updates the nfc status of the controller
+     * @param callback A CallbackStatus containing the nfc status
+     */
+    void SetNfc(const Common::Input::CallbackStatus& callback);
+    /**
     * Converts a color format from bgra to rgba
     * @param color in bgra format
     * @return NpadColor in rgba format
@@ -458,6 +484,7 @@ private:
    TriggerParams trigger_params;
    BatteryParams battery_params;
    CameraParams camera_params;
+    NfcParams nfc_params;
    OutputParams output_params;
    ButtonDevices button_devices;
@@ -466,6 +493,7 @@ private:
    TriggerDevices trigger_devices;
    BatteryDevices battery_devices;
    CameraDevices camera_devices;
+    NfcDevices nfc_devices;
    OutputDevices output_devices;
    // TAS related variables
diff --git a/src/core/hid/input_converter.cpp b/src/core/hid/input_converter.cpp
index 52fb69e9c..fe9915abe 100644
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -287,6 +287,20 @@ Common::Input::CameraStatus TransformToCamera(const Common::Input::CallbackStatu
    return camera;
 }
+Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& callback) {
+    Common::Input::NfcStatus nfc{};
+    switch (callback.type) {
+    case Common::Input::InputType::Nfc:
+        return callback.nfc_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to NFC not implemented", callback.type);
+        break;
+    }
+    return nfc;
+}
 void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
    const auto& properties = analog.properties;
    float& raw_value = analog.raw_value;
diff --git a/src/core/hid/input_converter.h b/src/core/hid/input_converter.h
index 143c50cc0..b7eb6e660 100644
--- a/src/core/hid/input_converter.h
+++ b/src/core/hid/input_converter.h
@@ -85,6 +85,14 @@ Common::Input::AnalogStatus TransformToAnalog(const Common::Input::CallbackStatu
 Common::Input::CameraStatus TransformToCamera(const Common::Input::CallbackStatus& callback);
 /**
+ * Converts raw input data into a valid nfc status.
+ *
+ * @param callback Supported callbacks: Nfc.
+ * @return A valid CameraObject object.
+ */
+Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& callback);
+/**
 * Converts raw analog data into a valid analog value
 * @param analog An analog object containing raw data and properties
 * @param clamp_value determines if the value needs to be clamped between -1.0f and 1.0f.
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index cb29004e8..f8972ec7a 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -660,7 +660,6 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
            ASSERT(false);
            break;
        case Core::HID::NpadStyleIndex::ProController:
-        case Core::HID::NpadStyleIndex::Pokeball:
            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
            break;
        case Core::HID::NpadStyleIndex::Handheld:
@@ -676,6 +675,11 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
        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;
        }
diff --git a/src/core/hle/service/hid/controllers/palma.cpp b/src/core/hle/service/hid/controllers/palma.cpp
new file mode 100644
index 000000000..575d4e626
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/palma.cpp
@@ -0,0 +1,229 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include "core/core_timing.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/service/hid/controllers/palma.h"
+#include "core/hle/service/kernel_helpers.h"
+namespace Service::HID {
+Controller_Palma::Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+                                   KernelHelpers::ServiceContext& service_context_)
+    : ControllerBase{hid_core_}, service_context{service_context_} {
+    controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other);
+    operation_complete_event = service_context.CreateEvent("hid:PalmaOperationCompleteEvent");
+}
+Controller_Palma::~Controller_Palma() = default;
+void Controller_Palma::OnInit() {}
+void Controller_Palma::OnRelease() {}
+void Controller_Palma::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+    if (!IsControllerActivated()) {
+        return;
+    }
+}
+Result Controller_Palma::GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id,
+                                                  PalmaConnectionHandle& handle) {
+    active_handle.npad_id = npad_id;
+    handle = active_handle;
+    return ResultSuccess;
+}
+Result Controller_Palma::InitializePalma(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    ActivateController();
+    return ResultSuccess;
+}
+Kernel::KReadableEvent& Controller_Palma::AcquirePalmaOperationCompleteEvent(
+    const PalmaConnectionHandle& handle) const {
+    if (handle.npad_id != active_handle.npad_id) {
+        LOG_ERROR(Service_HID, "Invalid npad id {}", handle.npad_id);
+    }
+    return operation_complete_event->GetReadableEvent();
+}
+Result Controller_Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
+                                               PalmaOperationType& operation_type,
+                                               PalmaOperationData& data) const {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation_type = operation.operation;
+    data = operation.data;
+    return ResultSuccess;
+}
+Result Controller_Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle,
+                                           u64 palma_activity) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::PlayActivity;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle,
+                                            PalmaFrModeType fr_mode_) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    fr_mode = fr_mode_;
+    return ResultSuccess;
+}
+Result Controller_Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::ReadStep;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    return ResultSuccess;
+}
+Result Controller_Palma::ResetPalmaStep(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    return ResultSuccess;
+}
+void Controller_Palma::ReadPalmaApplicationSection() {}
+void Controller_Palma::WritePalmaApplicationSection() {}
+Result Controller_Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::ReadUniqueCode;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::SetUniqueCodeInvalid;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+void Controller_Palma::WritePalmaActivityEntry() {}
+Result Controller_Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle,
+                                                      u64 unknown) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::WriteRgbLedPatternEntry;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave,
+                                             u8* t_mem, u64 size) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::WriteWaveEntry;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle,
+                                                               s32 database_id_version_) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    database_id_version = database_id_version_;
+    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.result = PalmaResultSuccess;
+    operation.data[0] = {};
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+Result Controller_Palma::GetPalmaDataBaseIdentificationVersion(
+    const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.result = PalmaResultSuccess;
+    operation.data = {};
+    operation.data[0] = static_cast<u8>(database_id_version);
+    operation_complete_event->GetWritableEvent().Signal();
+    return ResultSuccess;
+}
+void Controller_Palma::SuspendPalmaFeature() {}
+Result Controller_Palma::GetPalmaOperationResult(const PalmaConnectionHandle& handle) const {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    return operation.result;
+}
+void Controller_Palma::ReadPalmaPlayLog() {}
+void Controller_Palma::ResetPalmaPlayLog() {}
+void Controller_Palma::SetIsPalmaAllConnectable(bool is_all_connectable) {
+    // If true controllers are able to be paired
+    is_connectable = is_all_connectable;
+}
+void Controller_Palma::SetIsPalmaPairedConnectable() {}
+Result Controller_Palma::PairPalma(const PalmaConnectionHandle& handle) {
+    if (handle.npad_id != active_handle.npad_id) {
+        return InvalidPalmaHandle;
+    }
+    // TODO: Do something
+    return ResultSuccess;
+}
+void Controller_Palma::SetPalmaBoostMode(bool boost_mode) {}
+void Controller_Palma::CancelWritePalmaWaveEntry() {}
+void Controller_Palma::EnablePalmaBoostMode() {}
+void Controller_Palma::GetPalmaBluetoothAddress() {}
+void Controller_Palma::SetDisallowedPalmaConnection() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/palma.h b/src/core/hle/service/hid/controllers/palma.h
new file mode 100644
index 000000000..1d7fc94e1
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/palma.h
@@ -0,0 +1,163 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+#include <array>
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/hle/service/hid/errors.h"
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+namespace Service::KernelHelpers {
+class ServiceContext;
+}
+namespace Core::HID {
+class EmulatedController;
+} // namespace Core::HID
+namespace Service::HID {
+class Controller_Palma final : public ControllerBase {
+public:
+    using PalmaOperationData = std::array<u8, 0x140>;
+    // This is nn::hid::PalmaOperationType
+    enum class PalmaOperationType {
+        PlayActivity,
+        SetFrModeType,
+        ReadStep,
+        EnableStep,
+        ResetStep,
+        ReadApplicationSection,
+        WriteApplicationSection,
+        ReadUniqueCode,
+        SetUniqueCodeInvalid,
+        WriteActivityEntry,
+        WriteRgbLedPatternEntry,
+        WriteWaveEntry,
+        ReadDataBaseIdentificationVersion,
+        WriteDataBaseIdentificationVersion,
+        SuspendFeature,
+        ReadPlayLog,
+        ResetPlayLog,
+    };
+    // This is nn::hid::PalmaWaveSet
+    enum class PalmaWaveSet : u64 {
+        Small,
+        Medium,
+        Large,
+    };
+    // This is nn::hid::PalmaFrModeType
+    enum class PalmaFrModeType : u64 {
+        Off,
+        B01,
+        B02,
+        B03,
+        Downloaded,
+    };
+    // This is nn::hid::PalmaFeature
+    enum class PalmaFeature : u64 {
+        FrMode,
+        RumbleFeedback,
+        Step,
+        MuteSwitch,
+    };
+    // This is nn::hid::PalmaOperationInfo
+    struct PalmaOperationInfo {
+        PalmaOperationType operation{};
+        Result result{PalmaResultSuccess};
+        PalmaOperationData data{};
+    };
+    static_assert(sizeof(PalmaOperationInfo) == 0x148, "PalmaOperationInfo is an invalid size");
+    // This is nn::hid::PalmaActivityEntry
+    struct PalmaActivityEntry {
+        u32 rgb_led_pattern_index;
+        INSERT_PADDING_BYTES(2);
+        PalmaWaveSet wave_set;
+        u32 wave_index;
+        INSERT_PADDING_BYTES(12);
+    };
+    static_assert(sizeof(PalmaActivityEntry) == 0x20, "PalmaActivityEntry is an invalid size");
+    struct PalmaConnectionHandle {
+        Core::HID::NpadIdType npad_id;
+        INSERT_PADDING_BYTES(4); // Unknown
+    };
+    static_assert(sizeof(PalmaConnectionHandle) == 0x8,
+                  "PalmaConnectionHandle has incorrect size.");
+    explicit Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+                              KernelHelpers::ServiceContext& service_context_);
+    ~Controller_Palma() override;
+    // Called when the controller is initialized
+    void OnInit() override;
+    // When the controller is released
+    void OnRelease() override;
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
+    Result GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id, PalmaConnectionHandle& handle);
+    Result InitializePalma(const PalmaConnectionHandle& handle);
+    Kernel::KReadableEvent& AcquirePalmaOperationCompleteEvent(
+        const PalmaConnectionHandle& handle) const;
+    Result GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
+                                 PalmaOperationType& operation_type,
+                                 PalmaOperationData& data) const;
+    Result PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_activity);
+    Result SetPalmaFrModeType(const PalmaConnectionHandle& handle, PalmaFrModeType fr_mode_);
+    Result ReadPalmaStep(const PalmaConnectionHandle& handle);
+    Result EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled);
+    Result ResetPalmaStep(const PalmaConnectionHandle& handle);
+    Result ReadPalmaUniqueCode(const PalmaConnectionHandle& handle);
+    Result SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle);
+    Result WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle, u64 unknown);
+    Result WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave, u8* t_mem,
+                               u64 size);
+    Result SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle,
+                                                 s32 database_id_version_);
+    Result GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle);
+    Result GetPalmaOperationResult(const PalmaConnectionHandle& handle) const;
+    void SetIsPalmaAllConnectable(bool is_all_connectable);
+    Result PairPalma(const PalmaConnectionHandle& handle);
+    void SetPalmaBoostMode(bool boost_mode);
+private:
+    void ReadPalmaApplicationSection();
+    void WritePalmaApplicationSection();
+    void WritePalmaActivityEntry();
+    void SuspendPalmaFeature();
+    void ReadPalmaPlayLog();
+    void ResetPalmaPlayLog();
+    void SetIsPalmaPairedConnectable();
+    void CancelWritePalmaWaveEntry();
+    void EnablePalmaBoostMode();
+    void GetPalmaBluetoothAddress();
+    void SetDisallowedPalmaConnection();
+    bool is_connectable{};
+    s32 database_id_version{};
+    PalmaOperationInfo operation{};
+    PalmaFrModeType fr_mode{};
+    PalmaConnectionHandle active_handle{};
+    Core::HID::EmulatedController* controller;
+    Kernel::KEvent* operation_complete_event;
+    KernelHelpers::ServiceContext& service_context;
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/errors.h b/src/core/hle/service/hid/errors.h
index 4613a4e60..76208e9a4 100644
--- a/src/core/hle/service/hid/errors.h
+++ b/src/core/hle/service/hid/errors.h
@@ -7,6 +7,7 @@
 namespace Service::HID {
+constexpr Result PalmaResultSuccess{ErrorModule::HID, 0};
 constexpr Result NpadInvalidHandle{ErrorModule::HID, 100};
 constexpr Result NpadDeviceIndexOutOfRange{ErrorModule::HID, 107};
 constexpr Result VibrationInvalidStyleIndex{ErrorModule::HID, 122};
@@ -17,6 +18,7 @@ constexpr Result NpadIsDualJoycon{ErrorModule::HID, 601};
 constexpr Result NpadIsSameType{ErrorModule::HID, 602};
 constexpr Result InvalidNpadId{ErrorModule::HID, 709};
 constexpr Result NpadNotConnected{ErrorModule::HID, 710};
+constexpr Result InvalidPalmaHandle{ErrorModule::HID, 3302};
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 3d3457160..46bad7871 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -27,6 +27,7 @@
 #include "core/hle/service/hid/controllers/keyboard.h"
 #include "core/hle/service/hid/controllers/mouse.h"
 #include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/controllers/palma.h"
 #include "core/hle/service/hid/controllers/stubbed.h"
 #include "core/hle/service/hid/controllers/touchscreen.h"
 #include "core/hle/service/hid/controllers/xpad.h"
@@ -35,7 +36,8 @@ namespace Service::HID {
 // Updating period for each HID device.
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
-constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};            // (4ms, 250Hz)
+// Correct pad_update_ns is 4ms this is overclocked to lower input lag
+constexpr auto pad_update_ns = std::chrono::nanoseconds{1 * 1000 * 1000}; // (1ms, 1000Hz)
 constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};         // (5ms, 200Hz)
@@ -60,6 +62,7 @@ IAppletResource::IAppletResource(Core::System& system_,
    MakeControllerWithServiceContext<Controller_NPad>(HidController::NPad, shared_memory);
    MakeController<Controller_Gesture>(HidController::Gesture, shared_memory);
    MakeController<Controller_ConsoleSixAxis>(HidController::ConsoleSixAxisSensor, shared_memory);
+    MakeControllerWithServiceContext<Controller_Palma>(HidController::Palma, shared_memory);
    // Homebrew doesn't try to activate some controllers, so we activate them by default
    GetController<Controller_NPad>(HidController::NPad).ActivateController();
@@ -310,36 +313,36 @@ Hid::Hid(Core::System& system_)
        {406, nullptr, "GetNpadLeftRightInterfaceType"},
        {407, nullptr, "GetNpadOfHighestBatteryLevel"},
        {408, nullptr, "GetNpadOfHighestBatteryLevelForJoyRight"},
-        {500, nullptr, "GetPalmaConnectionHandle"},
+        {500, &Hid::GetPalmaConnectionHandle, "GetPalmaConnectionHandle"},
-        {501, nullptr, "InitializePalma"},
+        {501, &Hid::InitializePalma, "InitializePalma"},
-        {502, nullptr, "AcquirePalmaOperationCompleteEvent"},
+        {502, &Hid::AcquirePalmaOperationCompleteEvent, "AcquirePalmaOperationCompleteEvent"},
-        {503, nullptr, "GetPalmaOperationInfo"},
+        {503, &Hid::GetPalmaOperationInfo, "GetPalmaOperationInfo"},
-        {504, nullptr, "PlayPalmaActivity"},
+        {504, &Hid::PlayPalmaActivity, "PlayPalmaActivity"},
-        {505, nullptr, "SetPalmaFrModeType"},
+        {505, &Hid::SetPalmaFrModeType, "SetPalmaFrModeType"},
-        {506, nullptr, "ReadPalmaStep"},
+        {506, &Hid::ReadPalmaStep, "ReadPalmaStep"},
-        {507, nullptr, "EnablePalmaStep"},
+        {507, &Hid::EnablePalmaStep, "EnablePalmaStep"},
-        {508, nullptr, "ResetPalmaStep"},
+        {508, &Hid::ResetPalmaStep, "ResetPalmaStep"},
-        {509, nullptr, "ReadPalmaApplicationSection"},
+        {509, &Hid::ReadPalmaApplicationSection, "ReadPalmaApplicationSection"},
-        {510, nullptr, "WritePalmaApplicationSection"},
+        {510, &Hid::WritePalmaApplicationSection, "WritePalmaApplicationSection"},
-        {511, nullptr, "ReadPalmaUniqueCode"},
+        {511, &Hid::ReadPalmaUniqueCode, "ReadPalmaUniqueCode"},
-        {512, nullptr, "SetPalmaUniqueCodeInvalid"},
+        {512, &Hid::SetPalmaUniqueCodeInvalid, "SetPalmaUniqueCodeInvalid"},
-        {513, nullptr, "WritePalmaActivityEntry"},
+        {513, &Hid::WritePalmaActivityEntry, "WritePalmaActivityEntry"},
-        {514, nullptr, "WritePalmaRgbLedPatternEntry"},
+        {514, &Hid::WritePalmaRgbLedPatternEntry, "WritePalmaRgbLedPatternEntry"},
-        {515, nullptr, "WritePalmaWaveEntry"},
+        {515, &Hid::WritePalmaWaveEntry, "WritePalmaWaveEntry"},
-        {516, nullptr, "SetPalmaDataBaseIdentificationVersion"},
+        {516, &Hid::SetPalmaDataBaseIdentificationVersion, "SetPalmaDataBaseIdentificationVersion"},
-        {517, nullptr, "GetPalmaDataBaseIdentificationVersion"},
+        {517, &Hid::GetPalmaDataBaseIdentificationVersion, "GetPalmaDataBaseIdentificationVersion"},
-        {518, nullptr, "SuspendPalmaFeature"},
+        {518, &Hid::SuspendPalmaFeature, "SuspendPalmaFeature"},
-        {519, nullptr, "GetPalmaOperationResult"},
+        {519, &Hid::GetPalmaOperationResult, "GetPalmaOperationResult"},
-        {520, nullptr, "ReadPalmaPlayLog"},
+        {520, &Hid::ReadPalmaPlayLog, "ReadPalmaPlayLog"},
-        {521, nullptr, "ResetPalmaPlayLog"},
+        {521, &Hid::ResetPalmaPlayLog, "ResetPalmaPlayLog"},
        {522, &Hid::SetIsPalmaAllConnectable, "SetIsPalmaAllConnectable"},
-        {523, nullptr, "SetIsPalmaPairedConnectable"},
+        {523, &Hid::SetIsPalmaPairedConnectable, "SetIsPalmaPairedConnectable"},
-        {524, nullptr, "PairPalma"},
+        {524, &Hid::PairPalma, "PairPalma"},
        {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
-        {526, nullptr, "CancelWritePalmaWaveEntry"},
+        {526, &Hid::CancelWritePalmaWaveEntry, "CancelWritePalmaWaveEntry"},
-        {527, nullptr, "EnablePalmaBoostMode"},
+        {527, &Hid::EnablePalmaBoostMode, "EnablePalmaBoostMode"},
-        {528, nullptr, "GetPalmaBluetoothAddress"},
+        {528, &Hid::GetPalmaBluetoothAddress, "GetPalmaBluetoothAddress"},
-        {529, nullptr, "SetDisallowedPalmaConnection"},
+        {529, &Hid::SetDisallowedPalmaConnection, "SetDisallowedPalmaConnection"},
        {1000, &Hid::SetNpadCommunicationMode, "SetNpadCommunicationMode"},
        {1001, &Hid::GetNpadCommunicationMode, "GetNpadCommunicationMode"},
        {1002, &Hid::SetTouchScreenConfiguration, "SetTouchScreenConfiguration"},
@@ -1878,14 +1881,361 @@ void Hid::IsUsbFullKeyControllerEnabled(Kernel::HLERequestContext& ctx) {
    rb.Push(false);
 }
+void Hid::GetPalmaConnectionHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        Core::HID::NpadIdType npad_id;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
+                parameters.npad_id, parameters.applet_resource_user_id);
+    Controller_Palma::PalmaConnectionHandle handle;
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.GetPalmaConnectionHandle(parameters.npad_id, handle);
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(result);
+    rb.PushRaw(handle);
+}
+void Hid::InitializePalma(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.InitializePalma(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::AcquirePalmaOperationCompleteEvent(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(controller.AcquirePalmaOperationCompleteEvent(connection_handle));
+}
+void Hid::GetPalmaOperationInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    Controller_Palma::PalmaOperationType operation_type;
+    Controller_Palma::PalmaOperationData data;
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.GetPalmaOperationInfo(connection_handle, operation_type, data);
+    if (result.IsError()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+    ctx.WriteBuffer(data);
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(result);
+    rb.Push(static_cast<u64>(operation_type));
+}
+void Hid::PlayPalmaActivity(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    const auto palma_activity{rp.Pop<u64>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}, palma_activity={}",
+                connection_handle.npad_id, palma_activity);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.PlayPalmaActivity(connection_handle, palma_activity);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::SetPalmaFrModeType(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    const auto fr_mode{rp.PopEnum<Controller_Palma::PalmaFrModeType>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}, fr_mode={}",
+                connection_handle.npad_id, fr_mode);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.SetPalmaFrModeType(connection_handle, fr_mode);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::ReadPalmaStep(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.ReadPalmaStep(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::EnablePalmaStep(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        bool is_enabled;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        Controller_Palma::PalmaConnectionHandle connection_handle;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}, is_enabled={}",
+                parameters.connection_handle.npad_id, parameters.is_enabled);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result =
+        controller.EnablePalmaStep(parameters.connection_handle, parameters.is_enabled);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::ResetPalmaStep(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    auto& controller = GetAppletResource()->GetController<Controller_Palma>(HidController::Palma);
+    const auto result = controller.ResetPalmaStep(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::ReadPalmaApplicationSection(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::WritePalmaApplicationSection(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::ReadPalmaUniqueCode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .ReadPalmaUniqueCode(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::SetPalmaUniqueCodeInvalid(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .SetPalmaUniqueCodeInvalid(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::WritePalmaActivityEntry(Kernel::HLERequestContext& ctx) {
+    LOG_CRITICAL(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::WritePalmaRgbLedPatternEntry(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    const auto unknown{rp.Pop<u64>()};
+    const auto buffer = ctx.ReadBuffer();
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}, unknown={}",
+                connection_handle.npad_id, unknown);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .WritePalmaRgbLedPatternEntry(connection_handle, unknown);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::WritePalmaWaveEntry(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    const auto wave_set{rp.PopEnum<Controller_Palma::PalmaWaveSet>()};
+    const auto unknown{rp.Pop<u64>()};
+    const auto t_mem_size{rp.Pop<u64>()};
+    const auto t_mem_handle{ctx.GetCopyHandle(0)};
+    const auto size{rp.Pop<u64>()};
+    ASSERT_MSG(t_mem_size == 0x3000, "t_mem_size is not 0x3000 bytes");
+    auto t_mem =
+        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(t_mem_handle);
+    if (t_mem.IsNull()) {
+        LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultUnknown);
+        return;
+    }
+    ASSERT_MSG(t_mem->GetSize() == 0x3000, "t_mem has incorrect size");
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, connection_handle={}, wave_set={}, unkown={}, "
+                "t_mem_handle=0x{:08X}, t_mem_size={}, size={}",
+                connection_handle.npad_id, wave_set, unknown, t_mem_handle, t_mem_size, size);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .WritePalmaWaveEntry(connection_handle, wave_set,
+                             system.Memory().GetPointer(t_mem->GetSourceAddress()), t_mem_size);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::SetPalmaDataBaseIdentificationVersion(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        s32 database_id_version;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        Controller_Palma::PalmaConnectionHandle connection_handle;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}, database_id_version={}",
+                parameters.connection_handle.npad_id, parameters.database_id_version);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .SetPalmaDataBaseIdentificationVersion(parameters.connection_handle,
+                                               parameters.database_id_version);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::GetPalmaDataBaseIdentificationVersion(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .GetPalmaDataBaseIdentificationVersion(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::SuspendPalmaFeature(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::GetPalmaOperationResult(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    const auto result = applet_resource->GetController<Controller_Palma>(HidController::Palma)
+                            .GetPalmaOperationResult(connection_handle);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void Hid::ReadPalmaPlayLog(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::ResetPalmaPlayLog(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 void Hid::SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
+    struct Parameters {
-    const auto is_palma_all_connectable{rp.Pop<bool>()};
+        bool is_palma_all_connectable;
+        INSERT_PADDING_BYTES_NOINIT(7);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+    const auto parameters{rp.PopRaw<Parameters>()};
    LOG_WARNING(Service_HID,
-                "(STUBBED) called, applet_resource_user_id={}, is_palma_all_connectable={}",
+                "(STUBBED) called, is_palma_all_connectable={},applet_resource_user_id={}",
-                applet_resource_user_id, is_palma_all_connectable);
+                parameters.is_palma_all_connectable, parameters.applet_resource_user_id);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .SetIsPalmaAllConnectable(parameters.is_palma_all_connectable);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::SetIsPalmaPairedConnectable(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::PairPalma(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto connection_handle{rp.PopRaw<Controller_Palma::PalmaConnectionHandle>()};
+    LOG_WARNING(Service_HID, "(STUBBED) called, connection_handle={}", connection_handle.npad_id);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .PairPalma(connection_handle);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
@@ -1897,6 +2247,37 @@ void Hid::SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_HID, "(STUBBED) called, palma_boost_mode={}", palma_boost_mode);
+    applet_resource->GetController<Controller_Palma>(HidController::Palma)
+        .SetPalmaBoostMode(palma_boost_mode);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::CancelWritePalmaWaveEntry(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::EnablePalmaBoostMode(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::GetPalmaBluetoothAddress(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void Hid::SetDisallowedPalmaConnection(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
 }
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index ac4333022..340d26fdc 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -33,6 +33,7 @@ enum class HidController : std::size_t {
    NPad,
    Gesture,
    ConsoleSixAxisSensor,
+    Palma,
    MaxControllers,
 };
@@ -166,8 +167,36 @@ private:
    void FinalizeSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
    void ResetSevenSixAxisSensorTimestamp(Kernel::HLERequestContext& ctx);
    void IsUsbFullKeyControllerEnabled(Kernel::HLERequestContext& ctx);
+    void GetPalmaConnectionHandle(Kernel::HLERequestContext& ctx);
+    void InitializePalma(Kernel::HLERequestContext& ctx);
+    void AcquirePalmaOperationCompleteEvent(Kernel::HLERequestContext& ctx);
+    void GetPalmaOperationInfo(Kernel::HLERequestContext& ctx);
+    void PlayPalmaActivity(Kernel::HLERequestContext& ctx);
+    void SetPalmaFrModeType(Kernel::HLERequestContext& ctx);
+    void ReadPalmaStep(Kernel::HLERequestContext& ctx);
+    void EnablePalmaStep(Kernel::HLERequestContext& ctx);
+    void ResetPalmaStep(Kernel::HLERequestContext& ctx);
+    void ReadPalmaApplicationSection(Kernel::HLERequestContext& ctx);
+    void WritePalmaApplicationSection(Kernel::HLERequestContext& ctx);
+    void ReadPalmaUniqueCode(Kernel::HLERequestContext& ctx);
+    void SetPalmaUniqueCodeInvalid(Kernel::HLERequestContext& ctx);
+    void WritePalmaActivityEntry(Kernel::HLERequestContext& ctx);
+    void WritePalmaRgbLedPatternEntry(Kernel::HLERequestContext& ctx);
+    void WritePalmaWaveEntry(Kernel::HLERequestContext& ctx);
+    void SetPalmaDataBaseIdentificationVersion(Kernel::HLERequestContext& ctx);
+    void GetPalmaDataBaseIdentificationVersion(Kernel::HLERequestContext& ctx);
+    void SuspendPalmaFeature(Kernel::HLERequestContext& ctx);
+    void GetPalmaOperationResult(Kernel::HLERequestContext& ctx);
+    void ReadPalmaPlayLog(Kernel::HLERequestContext& ctx);
+    void ResetPalmaPlayLog(Kernel::HLERequestContext& ctx);
    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx);
+    void SetIsPalmaPairedConnectable(Kernel::HLERequestContext& ctx);
+    void PairPalma(Kernel::HLERequestContext& ctx);
    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
+    void CancelWritePalmaWaveEntry(Kernel::HLERequestContext& ctx);
+    void EnablePalmaBoostMode(Kernel::HLERequestContext& ctx);
+    void GetPalmaBluetoothAddress(Kernel::HLERequestContext& ctx);
+    void SetDisallowedPalmaConnection(Kernel::HLERequestContext& ctx);
    void SetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
    void GetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
    void SetTouchScreenConfiguration(Kernel::HLERequestContext& ctx);
diff --git a/src/core/hle/service/hid/irs.cpp b/src/core/hle/service/hid/irs.cpp
index c4b44cbf9..6a3453457 100644
--- a/src/core/hle/service/hid/irs.cpp
+++ b/src/core/hle/service/hid/irs.cpp
@@ -542,7 +542,8 @@ Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_h
 Core::IrSensor::DeviceFormat& IRS::GetIrCameraSharedMemoryDeviceEntry(
    const Core::IrSensor::IrCameraHandle& camera_handle) {
-    ASSERT_MSG(sizeof(StatusManager::device) > camera_handle.npad_id, "invalid npad_id");
+    const auto npad_id_max_index = static_cast<u8>(sizeof(StatusManager::device));
+    ASSERT_MSG(camera_handle.npad_id < npad_id_max_index, "invalid npad_id");
    return shared_memory->device[camera_handle.npad_id];
 }
diff --git a/src/core/hle/service/ldn/lan_discovery.cpp b/src/core/hle/service/ldn/lan_discovery.cpp
new file mode 100644
index 000000000..8f3c04550
--- /dev/null
+++ b/src/core/hle/service/ldn/lan_discovery.cpp
@@ -0,0 +1,633 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include "core/hle/service/ldn/lan_discovery.h"
+#include "core/internal_network/network.h"
+#include "core/internal_network/network_interface.h"
+namespace Service::LDN {
+LanStation::LanStation(s8 node_id_, LANDiscovery* discovery_)
+    : node_info(nullptr), status(NodeStatus::Disconnected), node_id(node_id_),
+      discovery(discovery_) {}
+LanStation::~LanStation() = default;
+NodeStatus LanStation::GetStatus() const {
+    return status;
+}
+void LanStation::OnClose() {
+    LOG_INFO(Service_LDN, "OnClose {}", node_id);
+    Reset();
+    discovery->UpdateNodes();
+}
+void LanStation::Reset() {
+    status = NodeStatus::Disconnected;
+};
+void LanStation::OverrideInfo() {
+    bool connected = GetStatus() == NodeStatus::Connected;
+    node_info->node_id = node_id;
+    node_info->is_connected = connected ? 1 : 0;
+}
+LANDiscovery::LANDiscovery(Network::RoomNetwork& room_network_)
+    : stations({{{1, this}, {2, this}, {3, this}, {4, this}, {5, this}, {6, this}, {7, this}}}),
+      room_network{room_network_} {}
+LANDiscovery::~LANDiscovery() {
+    if (inited) {
+        Result rc = Finalize();
+        LOG_INFO(Service_LDN, "Finalize: {}", rc.raw);
+    }
+}
+void LANDiscovery::InitNetworkInfo() {
+    network_info.common.bssid = GetFakeMac();
+    network_info.common.channel = WifiChannel::Wifi24_6;
+    network_info.common.link_level = LinkLevel::Good;
+    network_info.common.network_type = PackedNetworkType::Ldn;
+    network_info.common.ssid = fake_ssid;
+    auto& nodes = network_info.ldn.nodes;
+    for (std::size_t i = 0; i < NodeCountMax; i++) {
+        nodes[i].node_id = static_cast<s8>(i);
+        nodes[i].is_connected = 0;
+    }
+}
+void LANDiscovery::InitNodeStateChange() {
+    for (auto& node_update : node_changes) {
+        node_update.state_change = NodeStateChange::None;
+    }
+    for (auto& node_state : node_last_states) {
+        node_state = 0;
+    }
+}
+State LANDiscovery::GetState() const {
+    return state;
+}
+void LANDiscovery::SetState(State new_state) {
+    state = new_state;
+}
+Result LANDiscovery::GetNetworkInfo(NetworkInfo& out_network) const {
+    if (state == State::AccessPointCreated || state == State::StationConnected) {
+        std::memcpy(&out_network, &network_info, sizeof(network_info));
+        return ResultSuccess;
+    }
+    return ResultBadState;
+}
+Result LANDiscovery::GetNetworkInfo(NetworkInfo& out_network,
+                                    std::vector<NodeLatestUpdate>& out_updates,
+                                    std::size_t buffer_count) {
+    if (buffer_count > NodeCountMax) {
+        return ResultInvalidBufferCount;
+    }
+    if (state == State::AccessPointCreated || state == State::StationConnected) {
+        std::memcpy(&out_network, &network_info, sizeof(network_info));
+        for (std::size_t i = 0; i < buffer_count; i++) {
+            out_updates[i].state_change = node_changes[i].state_change;
+            node_changes[i].state_change = NodeStateChange::None;
+        }
+        return ResultSuccess;
+    }
+    return ResultBadState;
+}
+DisconnectReason LANDiscovery::GetDisconnectReason() const {
+    return disconnect_reason;
+}
+Result LANDiscovery::Scan(std::vector<NetworkInfo>& networks, u16& count,
+                          const ScanFilter& filter) {
+    if (!IsFlagSet(filter.flag, ScanFilterFlag::NetworkType) ||
+        filter.network_type <= NetworkType::All) {
+        if (!IsFlagSet(filter.flag, ScanFilterFlag::Ssid) && filter.ssid.length >= SsidLengthMax) {
+            return ResultBadInput;
+        }
+    }
+    {
+        std::scoped_lock lock{packet_mutex};
+        scan_results.clear();
+        SendBroadcast(Network::LDNPacketType::Scan);
+    }
+    LOG_INFO(Service_LDN, "Waiting for scan replies");
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    std::scoped_lock lock{packet_mutex};
+    for (const auto& [key, info] : scan_results) {
+        if (count >= networks.size()) {
+            break;
+        }
+        if (IsFlagSet(filter.flag, ScanFilterFlag::LocalCommunicationId)) {
+            if (filter.network_id.intent_id.local_communication_id !=
+                info.network_id.intent_id.local_communication_id) {
+                continue;
+            }
+        }
+        if (IsFlagSet(filter.flag, ScanFilterFlag::SessionId)) {
+            if (filter.network_id.session_id != info.network_id.session_id) {
+                continue;
+            }
+        }
+        if (IsFlagSet(filter.flag, ScanFilterFlag::NetworkType)) {
+            if (filter.network_type != static_cast<NetworkType>(info.common.network_type)) {
+                continue;
+            }
+        }
+        if (IsFlagSet(filter.flag, ScanFilterFlag::Ssid)) {
+            if (filter.ssid != info.common.ssid) {
+                continue;
+            }
+        }
+        if (IsFlagSet(filter.flag, ScanFilterFlag::SceneId)) {
+            if (filter.network_id.intent_id.scene_id != info.network_id.intent_id.scene_id) {
+                continue;
+            }
+        }
+        networks[count++] = info;
+    }
+    return ResultSuccess;
+}
+Result LANDiscovery::SetAdvertiseData(std::span<const u8> data) {
+    std::scoped_lock lock{packet_mutex};
+    const std::size_t size = data.size();
+    if (size > AdvertiseDataSizeMax) {
+        return ResultAdvertiseDataTooLarge;
+    }
+    std::memcpy(network_info.ldn.advertise_data.data(), data.data(), size);
+    network_info.ldn.advertise_data_size = static_cast<u16>(size);
+    UpdateNodes();
+    return ResultSuccess;
+}
+Result LANDiscovery::OpenAccessPoint() {
+    std::scoped_lock lock{packet_mutex};
+    disconnect_reason = DisconnectReason::None;
+    if (state == State::None) {
+        return ResultBadState;
+    }
+    ResetStations();
+    SetState(State::AccessPointOpened);
+    return ResultSuccess;
+}
+Result LANDiscovery::CloseAccessPoint() {
+    std::scoped_lock lock{packet_mutex};
+    if (state == State::None) {
+        return ResultBadState;
+    }
+    if (state == State::AccessPointCreated) {
+        DestroyNetwork();
+    }
+    ResetStations();
+    SetState(State::Initialized);
+    return ResultSuccess;
+}
+Result LANDiscovery::OpenStation() {
+    std::scoped_lock lock{packet_mutex};
+    disconnect_reason = DisconnectReason::None;
+    if (state == State::None) {
+        return ResultBadState;
+    }
+    ResetStations();
+    SetState(State::StationOpened);
+    return ResultSuccess;
+}
+Result LANDiscovery::CloseStation() {
+    std::scoped_lock lock{packet_mutex};
+    if (state == State::None) {
+        return ResultBadState;
+    }
+    if (state == State::StationConnected) {
+        Disconnect();
+    }
+    ResetStations();
+    SetState(State::Initialized);
+    return ResultSuccess;
+}
+Result LANDiscovery::CreateNetwork(const SecurityConfig& security_config,
+                                   const UserConfig& user_config,
+                                   const NetworkConfig& network_config) {
+    std::scoped_lock lock{packet_mutex};
+    if (state != State::AccessPointOpened) {
+        return ResultBadState;
+    }
+    InitNetworkInfo();
+    network_info.ldn.node_count_max = network_config.node_count_max;
+    network_info.ldn.security_mode = security_config.security_mode;
+    if (network_config.channel == WifiChannel::Default) {
+        network_info.common.channel = WifiChannel::Wifi24_6;
+    } else {
+        network_info.common.channel = network_config.channel;
+    }
+    std::independent_bits_engine<std::mt19937, 64, u64> bits_engine;
+    network_info.network_id.session_id.high = bits_engine();
+    network_info.network_id.session_id.low = bits_engine();
+    network_info.network_id.intent_id = network_config.intent_id;
+    NodeInfo& node0 = network_info.ldn.nodes[0];
+    const Result rc2 = GetNodeInfo(node0, user_config, network_config.local_communication_version);
+    if (rc2.IsError()) {
+        return ResultAccessPointConnectionFailed;
+    }
+    SetState(State::AccessPointCreated);
+    InitNodeStateChange();
+    node0.is_connected = 1;
+    UpdateNodes();
+    return rc2;
+}
+Result LANDiscovery::DestroyNetwork() {
+    for (auto local_ip : connected_clients) {
+        SendPacket(Network::LDNPacketType::DestroyNetwork, local_ip);
+    }
+    ResetStations();
+    SetState(State::AccessPointOpened);
+    lan_event();
+    return ResultSuccess;
+}
+Result LANDiscovery::Connect(const NetworkInfo& network_info_, const UserConfig& user_config,
+                             u16 local_communication_version) {
+    std::scoped_lock lock{packet_mutex};
+    if (network_info_.ldn.node_count == 0) {
+        return ResultInvalidNodeCount;
+    }
+    Result rc = GetNodeInfo(node_info, user_config, local_communication_version);
+    if (rc.IsError()) {
+        return ResultConnectionFailed;
+    }
+    Ipv4Address node_host = network_info_.ldn.nodes[0].ipv4_address;
+    std::reverse(std::begin(node_host), std::end(node_host)); // htonl
+    host_ip = node_host;
+    SendPacket(Network::LDNPacketType::Connect, node_info, *host_ip);
+    InitNodeStateChange();
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    return ResultSuccess;
+}
+Result LANDiscovery::Disconnect() {
+    if (host_ip) {
+        SendPacket(Network::LDNPacketType::Disconnect, node_info, *host_ip);
+    }
+    SetState(State::StationOpened);
+    lan_event();
+    return ResultSuccess;
+}
+Result LANDiscovery::Initialize(LanEventFunc lan_event_, bool listening) {
+    std::scoped_lock lock{packet_mutex};
+    if (inited) {
+        return ResultSuccess;
+    }
+    for (auto& station : stations) {
+        station.discovery = this;
+        station.node_info = &network_info.ldn.nodes[station.node_id];
+        station.Reset();
+    }
+    connected_clients.clear();
+    lan_event = lan_event_;
+    SetState(State::Initialized);
+    inited = true;
+    return ResultSuccess;
+}
+Result LANDiscovery::Finalize() {
+    std::scoped_lock lock{packet_mutex};
+    Result rc = ResultSuccess;
+    if (inited) {
+        if (state == State::AccessPointCreated) {
+            DestroyNetwork();
+        }
+        if (state == State::StationConnected) {
+            Disconnect();
+        }
+        ResetStations();
+        inited = false;
+    }
+    SetState(State::None);
+    return rc;
+}
+void LANDiscovery::ResetStations() {
+    for (auto& station : stations) {
+        station.Reset();
+    }
+    connected_clients.clear();
+}
+void LANDiscovery::UpdateNodes() {
+    u8 count = 0;
+    for (auto& station : stations) {
+        bool connected = station.GetStatus() == NodeStatus::Connected;
+        if (connected) {
+            count++;
+        }
+        station.OverrideInfo();
+    }
+    network_info.ldn.node_count = count + 1;
+    for (auto local_ip : connected_clients) {
+        SendPacket(Network::LDNPacketType::SyncNetwork, network_info, local_ip);
+    }
+    OnNetworkInfoChanged();
+}
+void LANDiscovery::OnSyncNetwork(const NetworkInfo& info) {
+    network_info = info;
+    if (state == State::StationOpened) {
+        SetState(State::StationConnected);
+    }
+    OnNetworkInfoChanged();
+}
+void LANDiscovery::OnDisconnectFromHost() {
+    LOG_INFO(Service_LDN, "OnDisconnectFromHost state: {}", static_cast<int>(state));
+    host_ip = std::nullopt;
+    if (state == State::StationConnected) {
+        SetState(State::StationOpened);
+        lan_event();
+    }
+}
+void LANDiscovery::OnNetworkInfoChanged() {
+    if (IsNodeStateChanged()) {
+        lan_event();
+    }
+    return;
+}
+Network::IPv4Address LANDiscovery::GetLocalIp() const {
+    Network::IPv4Address local_ip{0xFF, 0xFF, 0xFF, 0xFF};
+    if (auto room_member = room_network.GetRoomMember().lock()) {
+        if (room_member->IsConnected()) {
+            local_ip = room_member->GetFakeIpAddress();
+        }
+    }
+    return local_ip;
+}
+template <typename Data>
+void LANDiscovery::SendPacket(Network::LDNPacketType type, const Data& data,
+                              Ipv4Address remote_ip) {
+    Network::LDNPacket packet;
+    packet.type = type;
+    packet.broadcast = false;
+    packet.local_ip = GetLocalIp();
+    packet.remote_ip = remote_ip;
+    packet.data.resize(sizeof(data));
+    std::memcpy(packet.data.data(), &data, sizeof(data));
+    SendPacket(packet);
+}
+void LANDiscovery::SendPacket(Network::LDNPacketType type, Ipv4Address remote_ip) {
+    Network::LDNPacket packet;
+    packet.type = type;
+    packet.broadcast = false;
+    packet.local_ip = GetLocalIp();
+    packet.remote_ip = remote_ip;
+    SendPacket(packet);
+}
+template <typename Data>
+void LANDiscovery::SendBroadcast(Network::LDNPacketType type, const Data& data) {
+    Network::LDNPacket packet;
+    packet.type = type;
+    packet.broadcast = true;
+    packet.local_ip = GetLocalIp();
+    packet.data.resize(sizeof(data));
+    std::memcpy(packet.data.data(), &data, sizeof(data));
+    SendPacket(packet);
+}
+void LANDiscovery::SendBroadcast(Network::LDNPacketType type) {
+    Network::LDNPacket packet;
+    packet.type = type;
+    packet.broadcast = true;
+    packet.local_ip = GetLocalIp();
+    SendPacket(packet);
+}
+void LANDiscovery::SendPacket(const Network::LDNPacket& packet) {
+    if (auto room_member = room_network.GetRoomMember().lock()) {
+        if (room_member->IsConnected()) {
+            room_member->SendLdnPacket(packet);
+        }
+    }
+}
+void LANDiscovery::ReceivePacket(const Network::LDNPacket& packet) {
+    std::scoped_lock lock{packet_mutex};
+    switch (packet.type) {
+    case Network::LDNPacketType::Scan: {
+        LOG_INFO(Frontend, "Scan packet received!");
+        if (state == State::AccessPointCreated) {
+            // Reply to the sender
+            SendPacket(Network::LDNPacketType::ScanResp, network_info, packet.local_ip);
+        }
+        break;
+    }
+    case Network::LDNPacketType::ScanResp: {
+        LOG_INFO(Frontend, "ScanResp packet received!");
+        NetworkInfo info{};
+        std::memcpy(&info, packet.data.data(), sizeof(NetworkInfo));
+        scan_results.insert({info.common.bssid, info});
+        break;
+    }
+    case Network::LDNPacketType::Connect: {
+        LOG_INFO(Frontend, "Connect packet received!");
+        NodeInfo info{};
+        std::memcpy(&info, packet.data.data(), sizeof(NodeInfo));
+        connected_clients.push_back(packet.local_ip);
+        for (LanStation& station : stations) {
+            if (station.status != NodeStatus::Connected) {
+                *station.node_info = info;
+                station.status = NodeStatus::Connected;
+                break;
+            }
+        }
+        UpdateNodes();
+        break;
+    }
+    case Network::LDNPacketType::Disconnect: {
+        LOG_INFO(Frontend, "Disconnect packet received!");
+        connected_clients.erase(
+            std::remove(connected_clients.begin(), connected_clients.end(), packet.local_ip),
+            connected_clients.end());
+        NodeInfo info{};
+        std::memcpy(&info, packet.data.data(), sizeof(NodeInfo));
+        for (LanStation& station : stations) {
+            if (station.status == NodeStatus::Connected &&
+                station.node_info->mac_address == info.mac_address) {
+                station.OnClose();
+                break;
+            }
+        }
+        break;
+    }
+    case Network::LDNPacketType::DestroyNetwork: {
+        ResetStations();
+        OnDisconnectFromHost();
+        break;
+    }
+    case Network::LDNPacketType::SyncNetwork: {
+        if (state == State::StationOpened || state == State::StationConnected) {
+            LOG_INFO(Frontend, "SyncNetwork packet received!");
+            NetworkInfo info{};
+            std::memcpy(&info, packet.data.data(), sizeof(NetworkInfo));
+            OnSyncNetwork(info);
+        } else {
+            LOG_INFO(Frontend, "SyncNetwork packet received but in wrong State!");
+        }
+        break;
+    }
+    default: {
+        LOG_INFO(Frontend, "ReceivePacket unhandled type {}", static_cast<int>(packet.type));
+        break;
+    }
+    }
+}
+bool LANDiscovery::IsNodeStateChanged() {
+    bool changed = false;
+    const auto& nodes = network_info.ldn.nodes;
+    for (int i = 0; i < NodeCountMax; i++) {
+        if (nodes[i].is_connected != node_last_states[i]) {
+            if (nodes[i].is_connected) {
+                node_changes[i].state_change |= NodeStateChange::Connect;
+            } else {
+                node_changes[i].state_change |= NodeStateChange::Disconnect;
+            }
+            node_last_states[i] = nodes[i].is_connected;
+            changed = true;
+        }
+    }
+    return changed;
+}
+bool LANDiscovery::IsFlagSet(ScanFilterFlag flag, ScanFilterFlag search_flag) const {
+    const auto flag_value = static_cast<u32>(flag);
+    const auto search_flag_value = static_cast<u32>(search_flag);
+    return (flag_value & search_flag_value) == search_flag_value;
+}
+int LANDiscovery::GetStationCount() const {
+    return static_cast<int>(
+        std::count_if(stations.begin(), stations.end(), [](const auto& station) {
+            return station.GetStatus() != NodeStatus::Disconnected;
+        }));
+}
+MacAddress LANDiscovery::GetFakeMac() const {
+    MacAddress mac{};
+    mac.raw[0] = 0x02;
+    mac.raw[1] = 0x00;
+    const auto ip = GetLocalIp();
+    memcpy(mac.raw.data() + 2, &ip, sizeof(ip));
+    return mac;
+}
+Result LANDiscovery::GetNodeInfo(NodeInfo& node, const UserConfig& userConfig,
+                                 u16 localCommunicationVersion) {
+    const auto network_interface = Network::GetSelectedNetworkInterface();
+    if (!network_interface) {
+        LOG_ERROR(Service_LDN, "No network interface available");
+        return ResultNoIpAddress;
+    }
+    node.mac_address = GetFakeMac();
+    node.is_connected = 1;
+    std::memcpy(node.user_name.data(), userConfig.user_name.data(), UserNameBytesMax + 1);
+    node.local_communication_version = localCommunicationVersion;
+    Ipv4Address current_address = GetLocalIp();
+    std::reverse(std::begin(current_address), std::end(current_address)); // ntohl
+    node.ipv4_address = current_address;
+    return ResultSuccess;
+}
+} // namespace Service::LDN
diff --git a/src/core/hle/service/ldn/lan_discovery.h b/src/core/hle/service/ldn/lan_discovery.h
new file mode 100644
index 000000000..3833cd764
--- /dev/null
+++ b/src/core/hle/service/ldn/lan_discovery.h
@@ -0,0 +1,134 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+#include <array>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <random>
+#include <span>
+#include <thread>
+#include <unordered_map>
+#include "common/logging/log.h"
+#include "common/socket_types.h"
+#include "core/hle/result.h"
+#include "core/hle/service/ldn/ldn_results.h"
+#include "core/hle/service/ldn/ldn_types.h"
+#include "network/network.h"
+namespace Service::LDN {
+class LANDiscovery;
+class LanStation {
+public:
+    LanStation(s8 node_id_, LANDiscovery* discovery_);
+    ~LanStation();
+    void OnClose();
+    NodeStatus GetStatus() const;
+    void Reset();
+    void OverrideInfo();
+protected:
+    friend class LANDiscovery;
+    NodeInfo* node_info;
+    NodeStatus status;
+    s8 node_id;
+    LANDiscovery* discovery;
+};
+class LANDiscovery {
+public:
+    using LanEventFunc = std::function<void()>;
+    LANDiscovery(Network::RoomNetwork& room_network_);
+    ~LANDiscovery();
+    State GetState() const;
+    void SetState(State new_state);
+    Result GetNetworkInfo(NetworkInfo& out_network) const;
+    Result GetNetworkInfo(NetworkInfo& out_network, std::vector<NodeLatestUpdate>& out_updates,
+                          std::size_t buffer_count);
+    DisconnectReason GetDisconnectReason() const;
+    Result Scan(std::vector<NetworkInfo>& networks, u16& count, const ScanFilter& filter);
+    Result SetAdvertiseData(std::span<const u8> data);
+    Result OpenAccessPoint();
+    Result CloseAccessPoint();
+    Result OpenStation();
+    Result CloseStation();
+    Result CreateNetwork(const SecurityConfig& security_config, const UserConfig& user_config,
+                         const NetworkConfig& network_config);
+    Result DestroyNetwork();
+    Result Connect(const NetworkInfo& network_info_, const UserConfig& user_config,
+                   u16 local_communication_version);
+    Result Disconnect();
+    Result Initialize(LanEventFunc lan_event_ = empty_func, bool listening = true);
+    Result Finalize();
+    void ReceivePacket(const Network::LDNPacket& packet);
+protected:
+    friend class LanStation;
+    void InitNetworkInfo();
+    void InitNodeStateChange();
+    void ResetStations();
+    void UpdateNodes();
+    void OnSyncNetwork(const NetworkInfo& info);
+    void OnDisconnectFromHost();
+    void OnNetworkInfoChanged();
+    bool IsNodeStateChanged();
+    bool IsFlagSet(ScanFilterFlag flag, ScanFilterFlag search_flag) const;
+    int GetStationCount() const;
+    MacAddress GetFakeMac() const;
+    Result GetNodeInfo(NodeInfo& node, const UserConfig& user_config,
+                       u16 local_communication_version);
+    Network::IPv4Address GetLocalIp() const;
+    template <typename Data>
+    void SendPacket(Network::LDNPacketType type, const Data& data, Ipv4Address remote_ip);
+    void SendPacket(Network::LDNPacketType type, Ipv4Address remote_ip);
+    template <typename Data>
+    void SendBroadcast(Network::LDNPacketType type, const Data& data);
+    void SendBroadcast(Network::LDNPacketType type);
+    void SendPacket(const Network::LDNPacket& packet);
+    static const LanEventFunc empty_func;
+    static constexpr Ssid fake_ssid{"YuzuFakeSsidForLdn"};
+    bool inited{};
+    std::mutex packet_mutex;
+    std::array<LanStation, StationCountMax> stations;
+    std::array<NodeLatestUpdate, NodeCountMax> node_changes{};
+    std::array<u8, NodeCountMax> node_last_states{};
+    std::unordered_map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
+    NodeInfo node_info{};
+    NetworkInfo network_info{};
+    State state{State::None};
+    DisconnectReason disconnect_reason{DisconnectReason::None};
+    // TODO (flTobi): Should this be an std::set?
+    std::vector<Ipv4Address> connected_clients;
+    std::optional<Ipv4Address> host_ip;
+    LanEventFunc lan_event;
+    Network::RoomNetwork& room_network;
+};
+} // namespace Service::LDN
diff --git a/src/core/hle/service/ldn/ldn.cpp b/src/core/hle/service/ldn/ldn.cpp
index c11daff54..ea3e7e55a 100644
--- a/src/core/hle/service/ldn/ldn.cpp
+++ b/src/core/hle/service/ldn/ldn.cpp
@@ -4,11 +4,13 @@
 #include <memory>
 #include "core/core.h"
+#include "core/hle/service/ldn/lan_discovery.h"
 #include "core/hle/service/ldn/ldn.h"
 #include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/ldn_types.h"
 #include "core/internal_network/network.h"
 #include "core/internal_network/network_interface.h"
+#include "network/network.h"
 // This is defined by synchapi.h and conflicts with ServiceContext::CreateEvent
 #undef CreateEvent
@@ -105,13 +107,13 @@ class IUserLocalCommunicationService final
 public:
    explicit IUserLocalCommunicationService(Core::System& system_)
        : ServiceFramework{system_, "IUserLocalCommunicationService", ServiceThreadType::CreateNew},
-          service_context{system, "IUserLocalCommunicationService"}, room_network{
+          service_context{system, "IUserLocalCommunicationService"},
-                                                                         system_.GetRoomNetwork()} {
+          room_network{system_.GetRoomNetwork()}, lan_discovery{room_network} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &IUserLocalCommunicationService::GetState, "GetState"},
            {1, &IUserLocalCommunicationService::GetNetworkInfo, "GetNetworkInfo"},
-            {2, nullptr, "GetIpv4Address"},
+            {2, &IUserLocalCommunicationService::GetIpv4Address, "GetIpv4Address"},
            {3, &IUserLocalCommunicationService::GetDisconnectReason, "GetDisconnectReason"},
            {4, &IUserLocalCommunicationService::GetSecurityParameter, "GetSecurityParameter"},
            {5, &IUserLocalCommunicationService::GetNetworkConfig, "GetNetworkConfig"},
@@ -119,7 +121,7 @@ public:
            {101, &IUserLocalCommunicationService::GetNetworkInfoLatestUpdate, "GetNetworkInfoLatestUpdate"},
            {102, &IUserLocalCommunicationService::Scan, "Scan"},
            {103, &IUserLocalCommunicationService::ScanPrivate, "ScanPrivate"},
-            {104, nullptr, "SetWirelessControllerRestriction"},
+            {104, &IUserLocalCommunicationService::SetWirelessControllerRestriction, "SetWirelessControllerRestriction"},
            {200, &IUserLocalCommunicationService::OpenAccessPoint, "OpenAccessPoint"},
            {201, &IUserLocalCommunicationService::CloseAccessPoint, "CloseAccessPoint"},
            {202, &IUserLocalCommunicationService::CreateNetwork, "CreateNetwork"},
@@ -148,16 +150,30 @@ public:
    }
    ~IUserLocalCommunicationService() {
+        if (is_initialized) {
+            if (auto room_member = room_network.GetRoomMember().lock()) {
+                room_member->Unbind(ldn_packet_received);
+            }
+        }
        service_context.CloseEvent(state_change_event);
    }
+    /// Callback to parse and handle a received LDN packet.
+    void OnLDNPacketReceived(const Network::LDNPacket& packet) {
+        lan_discovery.ReceivePacket(packet);
+    }
    void OnEventFired() {
        state_change_event->GetWritableEvent().Signal();
    }
    void GetState(Kernel::HLERequestContext& ctx) {
        State state = State::Error;
-        LOG_WARNING(Service_LDN, "(STUBBED) called, state = {}", state);
+        if (is_initialized) {
+            state = lan_discovery.GetState();
+        }
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
@@ -175,7 +191,7 @@ public:
        }
        NetworkInfo network_info{};
-        const auto rc = ResultSuccess;
+        const auto rc = lan_discovery.GetNetworkInfo(network_info);
        if (rc.IsError()) {
            LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
            IPC::ResponseBuilder rb{ctx, 2};
@@ -183,28 +199,50 @@ public:
            return;
        }
-        LOG_WARNING(Service_LDN, "(STUBBED) called, ssid='{}', nodes={}",
-                    network_info.common.ssid.GetStringValue(), network_info.ldn.node_count);
        ctx.WriteBuffer<NetworkInfo>(network_info);
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(rc);
+        rb.Push(ResultSuccess);
    }
-    void GetDisconnectReason(Kernel::HLERequestContext& ctx) {
+    void GetIpv4Address(Kernel::HLERequestContext& ctx) {
-        const auto disconnect_reason = DisconnectReason::None;
+        const auto network_interface = Network::GetSelectedNetworkInterface();
+        if (!network_interface) {
+            LOG_ERROR(Service_LDN, "No network interface available");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ResultNoIpAddress);
+            return;
+        }
-        LOG_WARNING(Service_LDN, "(STUBBED) called, disconnect_reason={}", disconnect_reason);
+        Ipv4Address current_address{Network::TranslateIPv4(network_interface->ip_address)};
+        Ipv4Address subnet_mask{Network::TranslateIPv4(network_interface->subnet_mask)};
+        // When we're connected to a room, spoof the hosts IP address
+        if (auto room_member = room_network.GetRoomMember().lock()) {
+            if (room_member->IsConnected()) {
+                current_address = room_member->GetFakeIpAddress();
+            }
+        }
+        std::reverse(std::begin(current_address), std::end(current_address)); // ntohl
+        std::reverse(std::begin(subnet_mask), std::end(subnet_mask));         // ntohl
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(current_address);
+        rb.PushRaw(subnet_mask);
+    }
+    void GetDisconnectReason(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.PushEnum(disconnect_reason);
+        rb.PushEnum(lan_discovery.GetDisconnectReason());
    }
    void GetSecurityParameter(Kernel::HLERequestContext& ctx) {
        SecurityParameter security_parameter{};
        NetworkInfo info{};
-        const Result rc = ResultSuccess;
+        const Result rc = lan_discovery.GetNetworkInfo(info);
        if (rc.IsError()) {
            LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
@@ -217,8 +255,6 @@ public:
        std::memcpy(security_parameter.data.data(), info.ldn.security_parameter.data(),
                    sizeof(SecurityParameter::data));
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 10};
        rb.Push(rc);
        rb.PushRaw<SecurityParameter>(security_parameter);
@@ -227,7 +263,7 @@ public:
    void GetNetworkConfig(Kernel::HLERequestContext& ctx) {
        NetworkConfig config{};
        NetworkInfo info{};
-        const Result rc = ResultSuccess;
+        const Result rc = lan_discovery.GetNetworkInfo(info);
        if (rc.IsError()) {
            LOG_ERROR(Service_LDN, "NetworkConfig is not valid {}", rc.raw);
@@ -241,12 +277,6 @@ public:
        config.node_count_max = info.ldn.node_count_max;
        config.local_communication_version = info.ldn.nodes[0].local_communication_version;
-        LOG_WARNING(Service_LDN,
-                    "(STUBBED) called, intent_id={}/{}, channel={}, node_count_max={}, "
-                    "local_communication_version={}",
-                    config.intent_id.local_communication_id, config.intent_id.scene_id,
-                    config.channel, config.node_count_max, config.local_communication_version);
        IPC::ResponseBuilder rb{ctx, 10};
        rb.Push(rc);
        rb.PushRaw<NetworkConfig>(config);
@@ -265,17 +295,17 @@ public:
        const std::size_t node_buffer_count = ctx.GetWriteBufferSize(1) / sizeof(NodeLatestUpdate);
        if (node_buffer_count == 0 || network_buffer_size != sizeof(NetworkInfo)) {
-            LOG_ERROR(Service_LDN, "Invalid buffer size {}, {}", network_buffer_size,
+            LOG_ERROR(Service_LDN, "Invalid buffer, size = {}, count = {}", network_buffer_size,
                      node_buffer_count);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(ResultBadInput);
            return;
        }
-        NetworkInfo info;
+        NetworkInfo info{};
        std::vector<NodeLatestUpdate> latest_update(node_buffer_count);
-        const auto rc = ResultSuccess;
+        const auto rc = lan_discovery.GetNetworkInfo(info, latest_update, latest_update.size());
        if (rc.IsError()) {
            LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
            IPC::ResponseBuilder rb{ctx, 2};
@@ -283,9 +313,6 @@ public:
            return;
        }
-        LOG_WARNING(Service_LDN, "(STUBBED) called, ssid='{}', nodes={}",
-                    info.common.ssid.GetStringValue(), info.ldn.node_count);
        ctx.WriteBuffer(info, 0);
        ctx.WriteBuffer(latest_update, 1);
@@ -317,92 +344,78 @@ public:
        u16 count = 0;
        std::vector<NetworkInfo> network_infos(network_info_size);
+        Result rc = lan_discovery.Scan(network_infos, count, scan_filter);
-        LOG_WARNING(Service_LDN,
+        LOG_INFO(Service_LDN,
-                    "(STUBBED) called, channel={}, filter_scan_flag={}, filter_network_type={}",
+                 "called, channel={}, filter_scan_flag={}, filter_network_type={}, is_private={}",
-                    channel, scan_filter.flag, scan_filter.network_type);
+                 channel, scan_filter.flag, scan_filter.network_type, is_private);
        ctx.WriteBuffer(network_infos);
        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
+        rb.Push(rc);
        rb.Push<u32>(count);
    }
-    void OpenAccessPoint(Kernel::HLERequestContext& ctx) {
+    void SetWirelessControllerRestriction(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_LDN, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultSuccess);
    }
+    void OpenAccessPoint(Kernel::HLERequestContext& ctx) {
+        LOG_INFO(Service_LDN, "called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(lan_discovery.OpenAccessPoint());
+    }
    void CloseAccessPoint(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        LOG_INFO(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.CloseAccessPoint());
    }
    void CreateNetwork(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
+        LOG_INFO(Service_LDN, "called");
-        struct Parameters {
-            SecurityConfig security_config;
-            UserConfig user_config;
-            INSERT_PADDING_WORDS_NOINIT(1);
-            NetworkConfig network_config;
-        };
-        static_assert(sizeof(Parameters) == 0x98, "Parameters has incorrect size.");
-        const auto parameters{rp.PopRaw<Parameters>()};
+        CreateNetworkImpl(ctx);
+    }
-        LOG_WARNING(Service_LDN,
+    void CreateNetworkPrivate(Kernel::HLERequestContext& ctx) {
-                    "(STUBBED) called, passphrase_size={}, security_mode={}, "
+        LOG_INFO(Service_LDN, "called");
-                    "local_communication_version={}",
-                    parameters.security_config.passphrase_size,
-                    parameters.security_config.security_mode,
-                    parameters.network_config.local_communication_version);
-        IPC::ResponseBuilder rb{ctx, 2};
+        CreateNetworkImpl(ctx, true);
-        rb.Push(ResultSuccess);
    }
-    void CreateNetworkPrivate(Kernel::HLERequestContext& ctx) {
+    void CreateNetworkImpl(Kernel::HLERequestContext& ctx, bool is_private = false) {
        IPC::RequestParser rp{ctx};
-        struct Parameters {
-            SecurityConfig security_config;
-            SecurityParameter security_parameter;
-            UserConfig user_config;
-            NetworkConfig network_config;
-        };
-        static_assert(sizeof(Parameters) == 0xB8, "Parameters has incorrect size.");
-        const auto parameters{rp.PopRaw<Parameters>()};
-        LOG_WARNING(Service_LDN,
+        const auto security_config{rp.PopRaw<SecurityConfig>()};
-                    "(STUBBED) called, passphrase_size={}, security_mode={}, "
+        [[maybe_unused]] const auto security_parameter{is_private ? rp.PopRaw<SecurityParameter>()
-                    "local_communication_version={}",
+                                                                  : SecurityParameter{}};
-                    parameters.security_config.passphrase_size,
+        const auto user_config{rp.PopRaw<UserConfig>()};
-                    parameters.security_config.security_mode,
+        rp.Pop<u32>(); // Padding
-                    parameters.network_config.local_communication_version);
+        const auto network_Config{rp.PopRaw<NetworkConfig>()};
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.CreateNetwork(security_config, user_config, network_Config));
    }
    void DestroyNetwork(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        LOG_INFO(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.DestroyNetwork());
    }
    void SetAdvertiseData(Kernel::HLERequestContext& ctx) {
        std::vector<u8> read_buffer = ctx.ReadBuffer();
-        LOG_WARNING(Service_LDN, "(STUBBED) called, size {}", read_buffer.size());
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.SetAdvertiseData(read_buffer));
    }
    void SetStationAcceptPolicy(Kernel::HLERequestContext& ctx) {
@@ -420,17 +433,17 @@ public:
    }
    void OpenStation(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        LOG_INFO(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.OpenStation());
    }
    void CloseStation(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        LOG_INFO(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.CloseStation());
    }
    void Connect(Kernel::HLERequestContext& ctx) {
@@ -445,16 +458,13 @@ public:
        const auto parameters{rp.PopRaw<Parameters>()};
-        LOG_WARNING(Service_LDN,
+        LOG_INFO(Service_LDN,
-                    "(STUBBED) called, passphrase_size={}, security_mode={}, "
+                 "called, passphrase_size={}, security_mode={}, "
-                    "local_communication_version={}",
+                 "local_communication_version={}",
-                    parameters.security_config.passphrase_size,
+                 parameters.security_config.passphrase_size,
-                    parameters.security_config.security_mode,
+                 parameters.security_config.security_mode, parameters.local_communication_version);
-                    parameters.local_communication_version);
        const std::vector<u8> read_buffer = ctx.ReadBuffer();
-        NetworkInfo network_info{};
        if (read_buffer.size() != sizeof(NetworkInfo)) {
            LOG_ERROR(Frontend, "NetworkInfo doesn't match read_buffer size!");
            IPC::ResponseBuilder rb{ctx, 2};
@@ -462,40 +472,47 @@ public:
            return;
        }
+        NetworkInfo network_info{};
        std::memcpy(&network_info, read_buffer.data(), read_buffer.size());
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.Connect(network_info, parameters.user_config,
+                                      static_cast<u16>(parameters.local_communication_version)));
    }
    void Disconnect(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        LOG_INFO(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.Disconnect());
    }
-    void Initialize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+    void Initialize(Kernel::HLERequestContext& ctx) {
        const auto rc = InitializeImpl(ctx);
+        if (rc.IsError()) {
+            LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
+        }
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(rc);
    }
    void Finalize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
+        if (auto room_member = room_network.GetRoomMember().lock()) {
+            room_member->Unbind(ldn_packet_received);
+        }
        is_initialized = false;
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        rb.Push(lan_discovery.Finalize());
    }
    void Initialize2(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
        const auto rc = InitializeImpl(ctx);
+        if (rc.IsError()) {
+            LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
+        }
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(rc);
@@ -508,14 +525,26 @@ public:
            return ResultAirplaneModeEnabled;
        }
+        if (auto room_member = room_network.GetRoomMember().lock()) {
+            ldn_packet_received = room_member->BindOnLdnPacketReceived(
+                [this](const Network::LDNPacket& packet) { OnLDNPacketReceived(packet); });
+        } else {
+            LOG_ERROR(Service_LDN, "Couldn't bind callback!");
+            return ResultAirplaneModeEnabled;
+        }
+        lan_discovery.Initialize([&]() { OnEventFired(); });
        is_initialized = true;
-        // TODO (flTobi): Change this to ResultSuccess when LDN is fully implemented
+        return ResultSuccess;
-        return ResultAirplaneModeEnabled;
    }
    KernelHelpers::ServiceContext service_context;
    Kernel::KEvent* state_change_event;
    Network::RoomNetwork& room_network;
+    LANDiscovery lan_discovery;
+    // Callback identifier for the OnLDNPacketReceived event.
+    Network::RoomMember::CallbackHandle<Network::LDNPacket> ldn_packet_received;
    bool is_initialized{};
 };
diff --git a/src/core/hle/service/ldn/ldn_types.h b/src/core/hle/service/ldn/ldn_types.h
index 6231e936d..44c2c773b 100644
--- a/src/core/hle/service/ldn/ldn_types.h
+++ b/src/core/hle/service/ldn/ldn_types.h
@@ -31,6 +31,8 @@ enum class NodeStateChange : u8 {
    DisconnectAndConnect,
 };
+DECLARE_ENUM_FLAG_OPERATORS(NodeStateChange)
 enum class ScanFilterFlag : u32 {
    None = 0,
    LocalCommunicationId = 1 << 0,
@@ -100,13 +102,13 @@ enum class AcceptPolicy : u8 {
 enum class WifiChannel : s16 {
    Default = 0,
-    wifi24_1 = 1,
+    Wifi24_1 = 1,
-    wifi24_6 = 6,
+    Wifi24_6 = 6,
-    wifi24_11 = 11,
+    Wifi24_11 = 11,
-    wifi50_36 = 36,
+    Wifi50_36 = 36,
-    wifi50_40 = 40,
+    Wifi50_40 = 40,
-    wifi50_44 = 44,
+    Wifi50_44 = 44,
-    wifi50_48 = 48,
+    Wifi50_48 = 48,
 };
 enum class LinkLevel : s8 {
@@ -116,6 +118,11 @@ enum class LinkLevel : s8 {
    Excellent,
 };
+enum class NodeStatus : u8 {
+    Disconnected,
+    Connected,
+};
 struct NodeLatestUpdate {
    NodeStateChange state_change;
    INSERT_PADDING_BYTES(0x7); // Unknown
@@ -150,7 +157,7 @@ struct Ssid {
    Ssid() = default;
-    explicit Ssid(std::string_view data) {
+    constexpr explicit Ssid(std::string_view data) {
        length = static_cast<u8>(std::min(data.size(), SsidLengthMax));
        data.copy(raw.data(), length);
        raw[length] = 0;
@@ -159,19 +166,18 @@ struct Ssid {
    std::string GetStringValue() const {
        return std::string(raw.data());
    }
-};
-static_assert(sizeof(Ssid) == 0x22, "Ssid is an invalid size");
-struct Ipv4Address {
+    bool operator==(const Ssid& b) const {
-    union {
+        return (length == b.length) && (std::memcmp(raw.data(), b.raw.data(), length) == 0);
-        u32 raw{};
+    }
-        std::array<u8, 4> bytes;
-    };
-    std::string GetStringValue() const {
+    bool operator!=(const Ssid& b) const {
-        return fmt::format("{}.{}.{}.{}", bytes[3], bytes[2], bytes[1], bytes[0]);
+        return !operator==(b);
    }
 };
+static_assert(sizeof(Ssid) == 0x22, "Ssid is an invalid size");
+using Ipv4Address = std::array<u8, 4>;
 static_assert(sizeof(Ipv4Address) == 0x4, "Ipv4Address is an invalid size");
 struct MacAddress {
@@ -181,6 +187,14 @@ struct MacAddress {
 };
 static_assert(sizeof(MacAddress) == 0x6, "MacAddress is an invalid size");
+struct MACAddressHash {
+    size_t operator()(const MacAddress& address) const {
+        u64 value{};
+        std::memcpy(&value, address.raw.data(), sizeof(address.raw));
+        return value;
+    }
+};
 struct ScanFilter {
    NetworkId network_id;
    NetworkType network_type;
diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp
index c484a9c8d..3a2fe938f 100644
--- a/src/core/hle/service/mii/mii_manager.cpp
+++ b/src/core/hle/service/mii/mii_manager.cpp
@@ -427,12 +427,11 @@ CharInfo MiiManager::BuildDefault(std::size_t index) {
    return ConvertStoreDataToInfo(BuildDefaultStoreData(RawData::DefaultMii.at(index), user_id));
 }
-CharInfo MiiManager::ConvertV3ToCharInfo(Ver3StoreData mii_v3) const {
+CharInfo MiiManager::ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const {
    Service::Mii::MiiManager manager;
    auto mii = manager.BuildDefault(0);
-    // Check if mii data exist
+    if (!ValidateV3Info(mii_v3)) {
-    if (mii_v3.mii_name[0] == 0) {
        return mii;
    }
@@ -443,8 +442,15 @@ CharInfo MiiManager::ConvertV3ToCharInfo(Ver3StoreData mii_v3) const {
    mii.height = mii_v3.height;
    mii.build = mii_v3.build;
-    memset(mii.name.data(), 0, sizeof(mii.name));
+    // Copy name until string terminator
-    memcpy(mii.name.data(), mii_v3.mii_name.data(), sizeof(mii_v3.mii_name));
+    mii.name = {};
+    for (std::size_t index = 0; index < mii.name.size() - 1; index++) {
+        mii.name[index] = mii_v3.mii_name[index];
+        if (mii.name[index] == 0) {
+            break;
+        }
+    }
    mii.font_region = mii_v3.region_information.character_set;
    mii.faceline_type = mii_v3.appearance_bits1.face_shape;
@@ -504,6 +510,151 @@ CharInfo MiiManager::ConvertV3ToCharInfo(Ver3StoreData mii_v3) const {
    return mii;
 }
+Ver3StoreData MiiManager::ConvertCharInfoToV3(const CharInfo& mii) const {
+    Service::Mii::MiiManager manager;
+    Ver3StoreData mii_v3{};
+    // TODO: We are ignoring a bunch of data from the mii_v3
+    mii_v3.version = 1;
+    mii_v3.mii_information.gender.Assign(mii.gender);
+    mii_v3.mii_information.favorite_color.Assign(mii.favorite_color);
+    mii_v3.height = mii.height;
+    mii_v3.build = mii.build;
+    // Copy name until string terminator
+    mii_v3.mii_name = {};
+    for (std::size_t index = 0; index < mii.name.size() - 1; index++) {
+        mii_v3.mii_name[index] = mii.name[index];
+        if (mii_v3.mii_name[index] == 0) {
+            break;
+        }
+    }
+    mii_v3.region_information.character_set.Assign(mii.font_region);
+    mii_v3.appearance_bits1.face_shape.Assign(mii.faceline_type);
+    mii_v3.appearance_bits1.skin_color.Assign(mii.faceline_color);
+    mii_v3.appearance_bits2.wrinkles.Assign(mii.faceline_wrinkle);
+    mii_v3.appearance_bits2.makeup.Assign(mii.faceline_make);
+    mii_v3.hair_style = mii.hair_type;
+    mii_v3.appearance_bits3.hair_color.Assign(mii.hair_color);
+    mii_v3.appearance_bits3.flip_hair.Assign(mii.hair_flip);
+    mii_v3.appearance_bits4.eye_type.Assign(mii.eye_type);
+    mii_v3.appearance_bits4.eye_color.Assign(mii.eye_color);
+    mii_v3.appearance_bits4.eye_scale.Assign(mii.eye_scale);
+    mii_v3.appearance_bits4.eye_vertical_stretch.Assign(mii.eye_aspect);
+    mii_v3.appearance_bits4.eye_rotation.Assign(mii.eye_rotate);
+    mii_v3.appearance_bits4.eye_spacing.Assign(mii.eye_x);
+    mii_v3.appearance_bits4.eye_y_position.Assign(mii.eye_y);
+    mii_v3.appearance_bits5.eyebrow_style.Assign(mii.eyebrow_type);
+    mii_v3.appearance_bits5.eyebrow_color.Assign(mii.eyebrow_color);
+    mii_v3.appearance_bits5.eyebrow_scale.Assign(mii.eyebrow_scale);
+    mii_v3.appearance_bits5.eyebrow_yscale.Assign(mii.eyebrow_aspect);
+    mii_v3.appearance_bits5.eyebrow_rotation.Assign(mii.eyebrow_rotate);
+    mii_v3.appearance_bits5.eyebrow_spacing.Assign(mii.eyebrow_x);
+    mii_v3.appearance_bits5.eyebrow_y_position.Assign(mii.eyebrow_y);
+    mii_v3.appearance_bits6.nose_type.Assign(mii.nose_type);
+    mii_v3.appearance_bits6.nose_scale.Assign(mii.nose_scale);
+    mii_v3.appearance_bits6.nose_y_position.Assign(mii.nose_y);
+    mii_v3.appearance_bits7.mouth_type.Assign(mii.mouth_type);
+    mii_v3.appearance_bits7.mouth_color.Assign(mii.mouth_color);
+    mii_v3.appearance_bits7.mouth_scale.Assign(mii.mouth_scale);
+    mii_v3.appearance_bits7.mouth_horizontal_stretch.Assign(mii.mouth_aspect);
+    mii_v3.appearance_bits8.mouth_y_position.Assign(mii.mouth_y);
+    mii_v3.appearance_bits8.mustache_type.Assign(mii.mustache_type);
+    mii_v3.appearance_bits9.mustache_scale.Assign(mii.mustache_scale);
+    mii_v3.appearance_bits9.mustache_y_position.Assign(mii.mustache_y);
+    mii_v3.appearance_bits9.bear_type.Assign(mii.beard_type);
+    mii_v3.appearance_bits9.facial_hair_color.Assign(mii.beard_color);
+    mii_v3.appearance_bits10.glasses_type.Assign(mii.glasses_type);
+    mii_v3.appearance_bits10.glasses_color.Assign(mii.glasses_color);
+    mii_v3.appearance_bits10.glasses_scale.Assign(mii.glasses_scale);
+    mii_v3.appearance_bits10.glasses_y_position.Assign(mii.glasses_y);
+    mii_v3.appearance_bits11.mole_enabled.Assign(mii.mole_type);
+    mii_v3.appearance_bits11.mole_scale.Assign(mii.mole_scale);
+    mii_v3.appearance_bits11.mole_x_position.Assign(mii.mole_x);
+    mii_v3.appearance_bits11.mole_y_position.Assign(mii.mole_y);
+    // TODO: Validate mii_v3 data
+    return mii_v3;
+}
+bool MiiManager::ValidateV3Info(const Ver3StoreData& mii_v3) const {
+    bool is_valid = mii_v3.version == 0 || mii_v3.version == 3;
+    is_valid = is_valid && (mii_v3.mii_name[0] != 0);
+    is_valid = is_valid && (mii_v3.mii_information.birth_month < 13);
+    is_valid = is_valid && (mii_v3.mii_information.birth_day < 32);
+    is_valid = is_valid && (mii_v3.mii_information.favorite_color < 12);
+    is_valid = is_valid && (mii_v3.height < 128);
+    is_valid = is_valid && (mii_v3.build < 128);
+    is_valid = is_valid && (mii_v3.appearance_bits1.face_shape < 12);
+    is_valid = is_valid && (mii_v3.appearance_bits1.skin_color < 7);
+    is_valid = is_valid && (mii_v3.appearance_bits2.wrinkles < 12);
+    is_valid = is_valid && (mii_v3.appearance_bits2.makeup < 12);
+    is_valid = is_valid && (mii_v3.hair_style < 132);
+    is_valid = is_valid && (mii_v3.appearance_bits3.hair_color < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_type < 60);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_color < 6);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_scale < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_vertical_stretch < 7);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_rotation < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_spacing < 13);
+    is_valid = is_valid && (mii_v3.appearance_bits4.eye_y_position < 19);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_style < 25);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_color < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_scale < 9);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_yscale < 7);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_rotation < 12);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_spacing < 12);
+    is_valid = is_valid && (mii_v3.appearance_bits5.eyebrow_y_position < 19);
+    is_valid = is_valid && (mii_v3.appearance_bits6.nose_type < 18);
+    is_valid = is_valid && (mii_v3.appearance_bits6.nose_scale < 9);
+    is_valid = is_valid && (mii_v3.appearance_bits6.nose_y_position < 19);
+    is_valid = is_valid && (mii_v3.appearance_bits7.mouth_type < 36);
+    is_valid = is_valid && (mii_v3.appearance_bits7.mouth_color < 5);
+    is_valid = is_valid && (mii_v3.appearance_bits7.mouth_scale < 9);
+    is_valid = is_valid && (mii_v3.appearance_bits7.mouth_horizontal_stretch < 7);
+    is_valid = is_valid && (mii_v3.appearance_bits8.mouth_y_position < 19);
+    is_valid = is_valid && (mii_v3.appearance_bits8.mustache_type < 6);
+    is_valid = is_valid && (mii_v3.appearance_bits9.mustache_scale < 7);
+    is_valid = is_valid && (mii_v3.appearance_bits9.mustache_y_position < 17);
+    is_valid = is_valid && (mii_v3.appearance_bits9.bear_type < 6);
+    is_valid = is_valid && (mii_v3.appearance_bits9.facial_hair_color < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits10.glasses_type < 9);
+    is_valid = is_valid && (mii_v3.appearance_bits10.glasses_color < 6);
+    is_valid = is_valid && (mii_v3.appearance_bits10.glasses_scale < 8);
+    is_valid = is_valid && (mii_v3.appearance_bits10.glasses_y_position < 21);
+    is_valid = is_valid && (mii_v3.appearance_bits11.mole_enabled < 2);
+    is_valid = is_valid && (mii_v3.appearance_bits11.mole_scale < 9);
+    is_valid = is_valid && (mii_v3.appearance_bits11.mole_x_position < 17);
+    is_valid = is_valid && (mii_v3.appearance_bits11.mole_y_position < 31);
+    return is_valid;
+}
 ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_flag) {
    std::vector<MiiInfoElement> result;
diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h
index d847de0bd..83ad3d343 100644
--- a/src/core/hle/service/mii/mii_manager.h
+++ b/src/core/hle/service/mii/mii_manager.h
@@ -22,7 +22,9 @@ public:
    ResultVal<CharInfo> UpdateLatest(const CharInfo& info, SourceFlag source_flag);
    CharInfo BuildRandom(Age age, Gender gender, Race race);
    CharInfo BuildDefault(std::size_t index);
-    CharInfo ConvertV3ToCharInfo(Ver3StoreData mii_v3) const;
+    CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const;
+    Ver3StoreData ConvertCharInfoToV3(const CharInfo& mii) const;
+    bool ValidateV3Info(const Ver3StoreData& mii_v3) const;
    ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag);
    Result GetIndex(const CharInfo& info, u32& index);
diff --git a/src/core/hle/service/nfc/nfc.cpp b/src/core/hle/service/nfc/nfc.cpp
index 13a843a28..046c5f18f 100644
--- a/src/core/hle/service/nfc/nfc.cpp
+++ b/src/core/hle/service/nfc/nfc.cpp
@@ -106,10 +106,10 @@ public:
            {1, &IUser::FinalizeOld, "FinalizeOld"},
            {2, &IUser::GetStateOld, "GetStateOld"},
            {3, &IUser::IsNfcEnabledOld, "IsNfcEnabledOld"},
-            {400, nullptr, "Initialize"},
+            {400, &IUser::InitializeOld, "Initialize"},
-            {401, nullptr, "Finalize"},
+            {401, &IUser::FinalizeOld, "Finalize"},
-            {402, nullptr, "GetState"},
+            {402, &IUser::GetStateOld, "GetState"},
-            {403, nullptr, "IsNfcEnabled"},
+            {403, &IUser::IsNfcEnabledOld, "IsNfcEnabled"},
            {404, nullptr, "ListDevices"},
            {405, nullptr, "GetDeviceState"},
            {406, nullptr, "GetNpadId"},
diff --git a/src/core/hle/service/nfp/amiibo_crypto.cpp b/src/core/hle/service/nfp/amiibo_crypto.cpp
index 31dd3a307..ce0bc3f75 100644
--- a/src/core/hle/service/nfp/amiibo_crypto.cpp
+++ b/src/core/hle/service/nfp/amiibo_crypto.cpp
@@ -20,13 +20,14 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
    const auto& amiibo_data = ntag_file.user_memory;
    LOG_DEBUG(Service_NFP, "uuid_lock=0x{0:x}", ntag_file.static_lock);
    LOG_DEBUG(Service_NFP, "compability_container=0x{0:x}", ntag_file.compability_container);
-    LOG_INFO(Service_NFP, "write_count={}", amiibo_data.write_counter);
+    LOG_DEBUG(Service_NFP, "write_count={}", static_cast<u16>(amiibo_data.write_counter));
-    LOG_INFO(Service_NFP, "character_id=0x{0:x}", amiibo_data.model_info.character_id);
+    LOG_DEBUG(Service_NFP, "character_id=0x{0:x}", amiibo_data.model_info.character_id);
-    LOG_INFO(Service_NFP, "character_variant={}", amiibo_data.model_info.character_variant);
+    LOG_DEBUG(Service_NFP, "character_variant={}", amiibo_data.model_info.character_variant);
-    LOG_INFO(Service_NFP, "amiibo_type={}", amiibo_data.model_info.amiibo_type);
+    LOG_DEBUG(Service_NFP, "amiibo_type={}", amiibo_data.model_info.amiibo_type);
-    LOG_INFO(Service_NFP, "model_number=0x{0:x}", amiibo_data.model_info.model_number);
+    LOG_DEBUG(Service_NFP, "model_number=0x{0:x}",
-    LOG_INFO(Service_NFP, "series={}", amiibo_data.model_info.series);
+              static_cast<u16>(amiibo_data.model_info.model_number));
+    LOG_DEBUG(Service_NFP, "series={}", amiibo_data.model_info.series);
    LOG_DEBUG(Service_NFP, "fixed_value=0x{0:x}", amiibo_data.model_info.constant_value);
    LOG_DEBUG(Service_NFP, "tag_dynamic_lock=0x{0:x}", ntag_file.dynamic_lock);
@@ -35,11 +36,12 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
    // Validate UUID
    constexpr u8 CT = 0x88; // As defined in `ISO / IEC 14443 - 3`
-    if ((CT ^ ntag_file.uuid[0] ^ ntag_file.uuid[1] ^ ntag_file.uuid[2]) != ntag_file.uuid[3]) {
+    if ((CT ^ ntag_file.uuid.uid[0] ^ ntag_file.uuid.uid[1] ^ ntag_file.uuid.uid[2]) !=
+        ntag_file.uuid.uid[3]) {
        return false;
    }
-    if ((ntag_file.uuid[4] ^ ntag_file.uuid[5] ^ ntag_file.uuid[6] ^ ntag_file.uuid[7]) !=
+    if ((ntag_file.uuid.uid[4] ^ ntag_file.uuid.uid[5] ^ ntag_file.uuid.uid[6] ^
-        ntag_file.uuid[8]) {
+         ntag_file.uuid.nintendo_id) != ntag_file.uuid.lock_bytes[0]) {
        return false;
    }
@@ -56,8 +58,9 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
    if (amiibo_data.model_info.constant_value != 0x02) {
        return false;
    }
-    // dynamic_lock value apparently is not constant
+    if ((ntag_file.dynamic_lock & 0xFFFFFF) != 0x0F0001U) {
-    // ntag_file.dynamic_lock == 0x0F0001
+        return false;
+    }
    if (ntag_file.CFG0 != 0x04000000U) {
        return false;
    }
@@ -70,7 +73,8 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
 NTAG215File NfcDataToEncodedData(const EncryptedNTAG215File& nfc_data) {
    NTAG215File encoded_data{};
-    memcpy(encoded_data.uuid2.data(), nfc_data.uuid.data() + 0x8, sizeof(encoded_data.uuid2));
+    encoded_data.uid = nfc_data.uuid.uid;
+    encoded_data.nintendo_id = nfc_data.uuid.nintendo_id;
    encoded_data.static_lock = nfc_data.static_lock;
    encoded_data.compability_container = nfc_data.compability_container;
    encoded_data.hmac_data = nfc_data.user_memory.hmac_data;
@@ -82,10 +86,10 @@ NTAG215File NfcDataToEncodedData(const EncryptedNTAG215File& nfc_data) {
    encoded_data.applicaton_write_counter = nfc_data.user_memory.applicaton_write_counter;
    encoded_data.application_area_id = nfc_data.user_memory.application_area_id;
    encoded_data.unknown = nfc_data.user_memory.unknown;
-    encoded_data.hash = nfc_data.user_memory.hash;
+    encoded_data.unknown2 = nfc_data.user_memory.unknown2;
    encoded_data.application_area = nfc_data.user_memory.application_area;
    encoded_data.hmac_tag = nfc_data.user_memory.hmac_tag;
-    memcpy(encoded_data.uuid.data(), nfc_data.uuid.data(), sizeof(encoded_data.uuid));
+    encoded_data.lock_bytes = nfc_data.uuid.lock_bytes;
    encoded_data.model_info = nfc_data.user_memory.model_info;
    encoded_data.keygen_salt = nfc_data.user_memory.keygen_salt;
    encoded_data.dynamic_lock = nfc_data.dynamic_lock;
@@ -99,8 +103,9 @@ NTAG215File NfcDataToEncodedData(const EncryptedNTAG215File& nfc_data) {
 EncryptedNTAG215File EncodedDataToNfcData(const NTAG215File& encoded_data) {
    EncryptedNTAG215File nfc_data{};
-    memcpy(nfc_data.uuid.data() + 0x8, encoded_data.uuid2.data(), sizeof(encoded_data.uuid2));
+    nfc_data.uuid.uid = encoded_data.uid;
-    memcpy(nfc_data.uuid.data(), encoded_data.uuid.data(), sizeof(encoded_data.uuid));
+    nfc_data.uuid.nintendo_id = encoded_data.nintendo_id;
+    nfc_data.uuid.lock_bytes = encoded_data.lock_bytes;
    nfc_data.static_lock = encoded_data.static_lock;
    nfc_data.compability_container = encoded_data.compability_container;
    nfc_data.user_memory.hmac_data = encoded_data.hmac_data;
@@ -112,7 +117,7 @@ EncryptedNTAG215File EncodedDataToNfcData(const NTAG215File& encoded_data) {
    nfc_data.user_memory.applicaton_write_counter = encoded_data.applicaton_write_counter;
    nfc_data.user_memory.application_area_id = encoded_data.application_area_id;
    nfc_data.user_memory.unknown = encoded_data.unknown;
-    nfc_data.user_memory.hash = encoded_data.hash;
+    nfc_data.user_memory.unknown2 = encoded_data.unknown2;
    nfc_data.user_memory.application_area = encoded_data.application_area;
    nfc_data.user_memory.hmac_tag = encoded_data.hmac_tag;
    nfc_data.user_memory.model_info = encoded_data.model_info;
@@ -127,10 +132,10 @@ EncryptedNTAG215File EncodedDataToNfcData(const NTAG215File& encoded_data) {
 u32 GetTagPassword(const TagUuid& uuid) {
    // Verifiy that the generated password is correct
-    u32 password = 0xAA ^ (uuid[1] ^ uuid[3]);
+    u32 password = 0xAA ^ (uuid.uid[1] ^ uuid.uid[3]);
-    password &= (0x55 ^ (uuid[2] ^ uuid[4])) << 8;
+    password &= (0x55 ^ (uuid.uid[2] ^ uuid.uid[4])) << 8;
-    password &= (0xAA ^ (uuid[3] ^ uuid[5])) << 16;
+    password &= (0xAA ^ (uuid.uid[3] ^ uuid.uid[5])) << 16;
-    password &= (0x55 ^ (uuid[4] ^ uuid[6])) << 24;
+    password &= (0x55 ^ (uuid.uid[4] ^ uuid.uid[6])) << 24;
    return password;
 }
@@ -138,15 +143,13 @@ HashSeed GetSeed(const NTAG215File& data) {
    HashSeed seed{
        .magic = data.write_counter,
        .padding = {},
-        .uuid1 = {},
+        .uid_1 = data.uid,
-        .uuid2 = {},
+        .nintendo_id_1 = data.nintendo_id,
+        .uid_2 = data.uid,
+        .nintendo_id_2 = data.nintendo_id,
        .keygen_salt = data.keygen_salt,
    };
-    // Copy the first 8 bytes of uuid
-    memcpy(seed.uuid1.data(), data.uuid.data(), sizeof(seed.uuid1));
-    memcpy(seed.uuid2.data(), data.uuid.data(), sizeof(seed.uuid2));
    return seed;
 }
@@ -165,8 +168,10 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed
    output.insert(output.end(), key.magic_bytes.begin(),
                  key.magic_bytes.begin() + key.magic_length);
-    output.insert(output.end(), seed.uuid1.begin(), seed.uuid1.end());
+    output.insert(output.end(), seed.uid_1.begin(), seed.uid_1.end());
-    output.insert(output.end(), seed.uuid2.begin(), seed.uuid2.end());
+    output.emplace_back(seed.nintendo_id_1);
+    output.insert(output.end(), seed.uid_2.begin(), seed.uid_2.end());
+    output.emplace_back(seed.nintendo_id_2);
    for (std::size_t i = 0; i < sizeof(seed.keygen_salt); i++) {
        output.emplace_back(static_cast<u8>(seed.keygen_salt[i] ^ key.xor_pad[i]));
@@ -177,7 +182,6 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed
 void CryptoInit(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, const HmacKey& hmac_key,
                const std::vector<u8>& seed) {
    // Initialize context
    ctx.used = false;
    ctx.counter = 0;
@@ -250,14 +254,15 @@ void Cipher(const DerivedKeys& keys, const NTAG215File& in_data, NTAG215File& ou
                          reinterpret_cast<unsigned char*>(&out_data.settings));
    // Copy the rest of the data directly
-    out_data.uuid2 = in_data.uuid2;
+    out_data.uid = in_data.uid;
+    out_data.nintendo_id = in_data.nintendo_id;
+    out_data.lock_bytes = in_data.lock_bytes;
    out_data.static_lock = in_data.static_lock;
    out_data.compability_container = in_data.compability_container;
    out_data.constant_value = in_data.constant_value;
    out_data.write_counter = in_data.write_counter;
-    out_data.uuid = in_data.uuid;
    out_data.model_info = in_data.model_info;
    out_data.keygen_salt = in_data.keygen_salt;
    out_data.dynamic_lock = in_data.dynamic_lock;
@@ -309,7 +314,7 @@ bool DecodeAmiibo(const EncryptedNTAG215File& encrypted_tag_data, NTAG215File& t
    // Regenerate tag HMAC. Note: order matters, data HMAC depends on tag HMAC!
    constexpr std::size_t input_length = DYNAMIC_LOCK_START - UUID_START;
    mbedtls_md_hmac(mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), tag_keys.hmac_key.data(),
-                    sizeof(HmacKey), reinterpret_cast<const unsigned char*>(&tag_data.uuid),
+                    sizeof(HmacKey), reinterpret_cast<const unsigned char*>(&tag_data.uid),
                    input_length, reinterpret_cast<unsigned char*>(&tag_data.hmac_tag));
    // Regenerate data HMAC
@@ -350,7 +355,7 @@ bool EncodeAmiibo(const NTAG215File& tag_data, EncryptedNTAG215File& encrypted_t
    constexpr std::size_t input_length = DYNAMIC_LOCK_START - UUID_START;
    constexpr std::size_t input_length2 = HMAC_TAG_START - WRITE_COUNTER_START;
    mbedtls_md_hmac(mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), tag_keys.hmac_key.data(),
-                    sizeof(HmacKey), reinterpret_cast<const unsigned char*>(&tag_data.uuid),
+                    sizeof(HmacKey), reinterpret_cast<const unsigned char*>(&tag_data.uid),
                    input_length, reinterpret_cast<unsigned char*>(&encoded_tag_data.hmac_tag));
    // Init mbedtls HMAC context
@@ -364,7 +369,7 @@ bool EncodeAmiibo(const NTAG215File& tag_data, EncryptedNTAG215File& encrypted_t
                           input_length2); // Data
    mbedtls_md_hmac_update(&ctx, reinterpret_cast<unsigned char*>(&encoded_tag_data.hmac_tag),
                           sizeof(HashData)); // Tag HMAC
-    mbedtls_md_hmac_update(&ctx, reinterpret_cast<const unsigned char*>(&tag_data.uuid),
+    mbedtls_md_hmac_update(&ctx, reinterpret_cast<const unsigned char*>(&tag_data.uid),
                           input_length);
    mbedtls_md_hmac_finish(&ctx, reinterpret_cast<unsigned char*>(&encoded_tag_data.hmac_data));
diff --git a/src/core/hle/service/nfp/amiibo_crypto.h b/src/core/hle/service/nfp/amiibo_crypto.h
index af7335912..0175ced91 100644
--- a/src/core/hle/service/nfp/amiibo_crypto.h
+++ b/src/core/hle/service/nfp/amiibo_crypto.h
@@ -5,7 +5,7 @@
 #include <array>
-#include "core/hle/service/nfp/amiibo_types.h"
+#include "core/hle/service/nfp/nfp_types.h"
 struct mbedtls_md_context_t;
@@ -22,10 +22,12 @@ using HmacKey = std::array<u8, 0x10>;
 using DrgbOutput = std::array<u8, 0x20>;
 struct HashSeed {
-    u16 magic;
+    u16_be magic;
    std::array<u8, 0xE> padding;
-    std::array<u8, 0x8> uuid1;
+    UniqueSerialNumber uid_1;
-    std::array<u8, 0x8> uuid2;
+    u8 nintendo_id_1;
+    UniqueSerialNumber uid_2;
+    u8 nintendo_id_2;
    std::array<u8, 0x20> keygen_salt;
 };
 static_assert(sizeof(HashSeed) == 0x40, "HashSeed is an invalid size");
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 037b86653..0cb55ca49 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -1,1098 +1,43 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include <array>
-#include <atomic>
-#include "common/fs/file.h"
-#include "common/fs/path_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/hid/emulated_controller.h"
-#include "core/hid/hid_core.h"
-#include "core/hid/hid_types.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/mii/mii_manager.h"
-#include "core/hle/service/nfp/amiibo_crypto.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
 namespace Service::NFP {
-namespace ErrCodes {
-constexpr Result DeviceNotFound(ErrorModule::NFP, 64);
-constexpr Result WrongDeviceState(ErrorModule::NFP, 73);
-constexpr Result NfcDisabled(ErrorModule::NFP, 80);
-constexpr Result WriteAmiiboFailed(ErrorModule::NFP, 88);
-constexpr Result TagRemoved(ErrorModule::NFP, 97);
-constexpr Result ApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);
-constexpr Result WrongApplicationAreaId(ErrorModule::NFP, 152);
-constexpr Result ApplicationAreaExist(ErrorModule::NFP, 168);
-} // namespace ErrCodes
-IUser::IUser(Module::Interface& nfp_interface_, Core::System& system_)
-    : ServiceFramework{system_, "NFP::IUser"}, service_context{system_, service_name},
-      nfp_interface{nfp_interface_} {
-    static const FunctionInfo functions[] = {
-        {0, &IUser::Initialize, "Initialize"},
-        {1, &IUser::Finalize, "Finalize"},
-        {2, &IUser::ListDevices, "ListDevices"},
-        {3, &IUser::StartDetection, "StartDetection"},
-        {4, &IUser::StopDetection, "StopDetection"},
-        {5, &IUser::Mount, "Mount"},
-        {6, &IUser::Unmount, "Unmount"},
-        {7, &IUser::OpenApplicationArea, "OpenApplicationArea"},
-        {8, &IUser::GetApplicationArea, "GetApplicationArea"},
-        {9, &IUser::SetApplicationArea, "SetApplicationArea"},
-        {10, &IUser::Flush, "Flush"},
-        {11, nullptr, "Restore"},
-        {12, &IUser::CreateApplicationArea, "CreateApplicationArea"},
-        {13, &IUser::GetTagInfo, "GetTagInfo"},
-        {14, &IUser::GetRegisterInfo, "GetRegisterInfo"},
-        {15, &IUser::GetCommonInfo, "GetCommonInfo"},
-        {16, &IUser::GetModelInfo, "GetModelInfo"},
-        {17, &IUser::AttachActivateEvent, "AttachActivateEvent"},
-        {18, &IUser::AttachDeactivateEvent, "AttachDeactivateEvent"},
-        {19, &IUser::GetState, "GetState"},
-        {20, &IUser::GetDeviceState, "GetDeviceState"},
-        {21, &IUser::GetNpadId, "GetNpadId"},
-        {22, &IUser::GetApplicationAreaSize, "GetApplicationAreaSize"},
-        {23, &IUser::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},
-        {24, &IUser::RecreateApplicationArea, "RecreateApplicationArea"},
-    };
-    RegisterHandlers(functions);
-    availability_change_event = service_context.CreateEvent("IUser:AvailabilityChangeEvent");
-}
-void IUser::Initialize(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFC, "called");
-    state = State::Initialized;
-    // TODO(german77): Loop through all interfaces
-    nfp_interface.Initialize();
-    IPC::ResponseBuilder rb{ctx, 2, 0};
-    rb.Push(ResultSuccess);
-}
-void IUser::Finalize(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFP, "called");
-    state = State::NonInitialized;
-    // TODO(german77): Loop through all interfaces
-    nfp_interface.Finalize();
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFP, "called");
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    std::vector<u64> devices;
-    // TODO(german77): Loop through all interfaces
-    devices.push_back(nfp_interface.GetHandle());
-    if (devices.size() == 0) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::DeviceNotFound);
-        return;
-    }
-    ctx.WriteBuffer(devices);
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<s32>(devices.size()));
-}
-void IUser::StartDetection(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto nfp_protocol{rp.Pop<s32>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}, nfp_protocol={}", device_handle, nfp_protocol);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.StartDetection(nfp_protocol);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::StopDetection(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.StopDetection();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::Mount(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto model_type{rp.PopEnum<ModelType>()};
-    const auto mount_target{rp.PopEnum<MountTarget>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}, model_type={}, mount_target={}", device_handle,
-             model_type, mount_target);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.Mount();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::Unmount(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.Unmount();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::OpenApplicationArea(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto access_id{rp.Pop<u32>()};
-    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}, access_id={}", device_handle,
-                access_id);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.OpenApplicationArea(access_id);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetApplicationArea(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        ApplicationArea data{};
-        const auto result = nfp_interface.GetApplicationArea(data);
-        ctx.WriteBuffer(data);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(result);
-        rb.Push(static_cast<u32>(data.size()));
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::SetApplicationArea(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto data{ctx.ReadBuffer()};
-    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}, data_size={}", device_handle,
-                data.size());
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.SetApplicationArea(data);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::Flush(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.Flush();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::CreateApplicationArea(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto access_id{rp.Pop<u32>()};
-    const auto data{ctx.ReadBuffer()};
-    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}, data_size={}, access_id={}",
-                device_handle, access_id, data.size());
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.CreateApplicationArea(access_id, data);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetTagInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        TagInfo tag_info{};
-        const auto result = nfp_interface.GetTagInfo(tag_info);
-        ctx.WriteBuffer(tag_info);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetRegisterInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        RegisterInfo register_info{};
-        const auto result = nfp_interface.GetRegisterInfo(register_info);
-        ctx.WriteBuffer(register_info);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetCommonInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        CommonInfo common_info{};
-        const auto result = nfp_interface.GetCommonInfo(common_info);
-        ctx.WriteBuffer(common_info);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetModelInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        ModelInfo model_info{};
-        const auto result = nfp_interface.GetModelInfo(model_info);
-        ctx.WriteBuffer(model_info);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::AttachActivateEvent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(nfp_interface.GetActivateEvent());
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::AttachDeactivateEvent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(nfp_interface.GetDeactivateEvent());
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetState(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NFC, "called");
-    IPC::ResponseBuilder rb{ctx, 3, 0};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(state);
-}
-void IUser::GetDeviceState(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.PushEnum(nfp_interface.GetCurrentState());
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetNpadId(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.PushEnum(nfp_interface.GetNpadId());
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::GetApplicationAreaSize(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(sizeof(ApplicationArea));
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-void IUser::AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NFP, "(STUBBED) called");
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(availability_change_event->GetReadableEvent());
-}
-void IUser::RecreateApplicationArea(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto device_handle{rp.Pop<u64>()};
-    const auto access_id{rp.Pop<u32>()};
-    const auto data{ctx.ReadBuffer()};
-    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}, data_size={}, access_id={}",
-                device_handle, access_id, data.size());
-    if (state == State::NonInitialized) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ErrCodes::NfcDisabled);
-        return;
-    }
-    // TODO(german77): Loop through all interfaces
-    if (device_handle == nfp_interface.GetHandle()) {
-        const auto result = nfp_interface.RecreateApplicationArea(access_id, data);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-    LOG_ERROR(Service_NFP, "Handle not found, device_handle={}", device_handle);
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ErrCodes::DeviceNotFound);
-}
-Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,
-                             const char* name)
-    : ServiceFramework{system_, name}, module{std::move(module_)},
-      npad_id{Core::HID::NpadIdType::Player1}, service_context{system_, service_name} {
-    activate_event = service_context.CreateEvent("IUser:NFPActivateEvent");
-    deactivate_event = service_context.CreateEvent("IUser:NFPDeactivateEvent");
-}
-Module::Interface::~Interface() = default;
-void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NFP, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IUser>(*this, system);
-}
-bool Module::Interface::LoadAmiiboFile(const std::string& filename) {
-    constexpr auto tag_size_without_password = sizeof(NTAG215File) - sizeof(NTAG215Password);
-    const Common::FS::IOFile amiibo_file{filename, Common::FS::FileAccessMode::Read,
-                                         Common::FS::FileType::BinaryFile};
-    if (!amiibo_file.IsOpen()) {
-        LOG_ERROR(Service_NFP, "Amiibo is already on use");
-        return false;
-    }
-    // Workaround for files with missing password data
-    std::array<u8, sizeof(EncryptedNTAG215File)> buffer{};
-    if (amiibo_file.Read(buffer) < tag_size_without_password) {
-        LOG_ERROR(Service_NFP, "Failed to read amiibo file");
-        return false;
-    }
-    memcpy(&encrypted_tag_data, buffer.data(), sizeof(EncryptedNTAG215File));
-    if (!AmiiboCrypto::IsAmiiboValid(encrypted_tag_data)) {
-        LOG_INFO(Service_NFP, "Invalid amiibo");
-        return false;
-    }
-    file_path = filename;
-    return true;
-}
-bool Module::Interface::LoadAmiibo(const std::string& filename) {
-    if (device_state != DeviceState::SearchingForTag) {
-        LOG_ERROR(Service_NFP, "Game is not looking for amiibos, current state {}", device_state);
-        return false;
-    }
-    if (!LoadAmiiboFile(filename)) {
-        return false;
-    }
-    device_state = DeviceState::TagFound;
-    activate_event->GetWritableEvent().Signal();
-    return true;
-}
-void Module::Interface::CloseAmiibo() {
-    LOG_INFO(Service_NFP, "Remove amiibo");
-    device_state = DeviceState::TagRemoved;
-    is_data_decoded = false;
-    is_application_area_initialized = false;
-    encrypted_tag_data = {};
-    tag_data = {};
-    deactivate_event->GetWritableEvent().Signal();
-}
-Kernel::KReadableEvent& Module::Interface::GetActivateEvent() const {
-    return activate_event->GetReadableEvent();
-}
-Kernel::KReadableEvent& Module::Interface::GetDeactivateEvent() const {
-    return deactivate_event->GetReadableEvent();
-}
-void Module::Interface::Initialize() {
-    device_state = DeviceState::Initialized;
-    is_data_decoded = false;
-    is_application_area_initialized = false;
-    encrypted_tag_data = {};
-    tag_data = {};
-}
-void Module::Interface::Finalize() {
-    if (device_state == DeviceState::TagMounted) {
-        Unmount();
-    }
-    if (device_state == DeviceState::SearchingForTag || device_state == DeviceState::TagRemoved) {
-        StopDetection();
-    }
-    device_state = DeviceState::Unaviable;
-}
-Result Module::Interface::StartDetection(s32 protocol_) {
-    auto npad_device = system.HIDCore().GetEmulatedController(npad_id);
-    // TODO(german77): Add callback for when nfc data is available
-    if (device_state == DeviceState::Initialized || device_state == DeviceState::TagRemoved) {
-        npad_device->SetPollingMode(Common::Input::PollingMode::NFC);
-        device_state = DeviceState::SearchingForTag;
-        protocol = protocol_;
-        return ResultSuccess;
-    }
-    LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-    return ErrCodes::WrongDeviceState;
-}
-Result Module::Interface::StopDetection() {
-    auto npad_device = system.HIDCore().GetEmulatedController(npad_id);
-    npad_device->SetPollingMode(Common::Input::PollingMode::Active);
-    if (device_state == DeviceState::TagFound || device_state == DeviceState::TagMounted) {
-        CloseAmiibo();
-        return ResultSuccess;
-    }
-    if (device_state == DeviceState::SearchingForTag || device_state == DeviceState::TagRemoved) {
-        device_state = DeviceState::Initialized;
-        return ResultSuccess;
-    }
-    LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-    return ErrCodes::WrongDeviceState;
-}
-Result Module::Interface::Flush() {
-    // Ignore write command if we can't encrypt the data
-    if (!is_data_decoded) {
-        return ResultSuccess;
-    }
-    constexpr auto tag_size_without_password = sizeof(NTAG215File) - sizeof(NTAG215Password);
-    EncryptedNTAG215File tmp_encrypted_tag_data{};
-    const Common::FS::IOFile amiibo_file{file_path, Common::FS::FileAccessMode::ReadWrite,
-                                         Common::FS::FileType::BinaryFile};
-    if (!amiibo_file.IsOpen()) {
-        LOG_ERROR(Core, "Amiibo is already on use");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    // Workaround for files with missing password data
-    std::array<u8, sizeof(EncryptedNTAG215File)> buffer{};
-    if (amiibo_file.Read(buffer) < tag_size_without_password) {
-        LOG_ERROR(Core, "Failed to read amiibo file");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    memcpy(&tmp_encrypted_tag_data, buffer.data(), sizeof(EncryptedNTAG215File));
-    if (!AmiiboCrypto::IsAmiiboValid(tmp_encrypted_tag_data)) {
-        LOG_INFO(Service_NFP, "Invalid amiibo");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    bool is_uuid_equal = memcmp(tmp_encrypted_tag_data.uuid.data(), tag_data.uuid.data(), 8) == 0;
-    bool is_character_equal = tmp_encrypted_tag_data.user_memory.model_info.character_id ==
-                              tag_data.model_info.character_id;
-    if (!is_uuid_equal || !is_character_equal) {
-        LOG_ERROR(Service_NFP, "Not the same amiibo");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    if (!AmiiboCrypto::EncodeAmiibo(tag_data, encrypted_tag_data)) {
-        LOG_ERROR(Service_NFP, "Failed to encode data");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    // Return to the start of the file
-    if (!amiibo_file.Seek(0)) {
-        LOG_ERROR(Service_NFP, "Error writing to file");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    if (!amiibo_file.Write(encrypted_tag_data)) {
-        LOG_ERROR(Service_NFP, "Error writing to file");
-        return ErrCodes::WriteAmiiboFailed;
-    }
-    return ResultSuccess;
-}
-Result Module::Interface::Mount() {
-    if (device_state != DeviceState::TagFound) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        return ErrCodes::WrongDeviceState;
-    }
-    is_data_decoded = AmiiboCrypto::DecodeAmiibo(encrypted_tag_data, tag_data);
+class IUserManager final : public ServiceFramework<IUserManager> {
-    LOG_INFO(Service_NFP, "Is amiibo decoded {}", is_data_decoded);
+public:
+    explicit IUserManager(Core::System& system_) : ServiceFramework{system_, "nfp:user"} {
-    is_application_area_initialized = false;
+        // clang-format off
-    device_state = DeviceState::TagMounted;
+        static const FunctionInfo functions[] = {
-    return ResultSuccess;
+            {0, &IUserManager::CreateUserInterface, "CreateUserInterface"},
-}
-Result Module::Interface::Unmount() {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        return ErrCodes::WrongDeviceState;
-    }
-    is_data_decoded = false;
-    is_application_area_initialized = false;
-    device_state = DeviceState::TagFound;
-    return ResultSuccess;
-}
-Result Module::Interface::GetTagInfo(TagInfo& tag_info) const {
-    if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        return ErrCodes::WrongDeviceState;
-    }
-    tag_info = {
-        .uuid = encrypted_tag_data.uuid,
-        .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.size()),
-        .protocol = protocol,
-        .tag_type = static_cast<u32>(encrypted_tag_data.user_memory.model_info.amiibo_type),
-    };
-    return ResultSuccess;
-}
-Result Module::Interface::GetCommonInfo(CommonInfo& common_info) const {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        return ErrCodes::WrongDeviceState;
-    }
-    if (is_data_decoded && tag_data.settings.settings.amiibo_initialized != 0) {
-        const auto& settings = tag_data.settings;
-        // TODO: Validate this data
-        common_info = {
-            .last_write_year = settings.write_date.GetYear(),
-            .last_write_month = settings.write_date.GetMonth(),
-            .last_write_day = settings.write_date.GetDay(),
-            .write_counter = settings.crc_counter,
-            .version = 1,
-            .application_area_size = sizeof(ApplicationArea),
-        };
-        return ResultSuccess;
-    }
-    // Generate a generic answer
-    common_info = {
-        .last_write_year = 2022,
-        .last_write_month = 2,
-        .last_write_day = 7,
-        .write_counter = 0,
-        .version = 1,
-        .application_area_size = sizeof(ApplicationArea),
-    };
-    return ResultSuccess;
-}
-Result Module::Interface::GetModelInfo(ModelInfo& model_info) const {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        return ErrCodes::WrongDeviceState;
-    }
-    const auto& model_info_data = encrypted_tag_data.user_memory.model_info;
-    model_info = {
-        .character_id = model_info_data.character_id,
-        .character_variant = model_info_data.character_variant,
-        .amiibo_type = model_info_data.amiibo_type,
-        .model_number = model_info_data.model_number,
-        .series = model_info_data.series,
-        .constant_value = model_info_data.constant_value,
-    };
-    return ResultSuccess;
-}
-Result Module::Interface::GetRegisterInfo(RegisterInfo& register_info) const {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
-        }
-        return ErrCodes::WrongDeviceState;
-    }
-    Service::Mii::MiiManager manager;
-    if (is_data_decoded && tag_data.settings.settings.amiibo_initialized != 0) {
-        const auto& settings = tag_data.settings;
-        // TODO: Validate this data
-        register_info = {
-            .mii_char_info = manager.ConvertV3ToCharInfo(tag_data.owner_mii),
-            .first_write_year = settings.init_date.GetYear(),
-            .first_write_month = settings.init_date.GetMonth(),
-            .first_write_day = settings.init_date.GetDay(),
-            .amiibo_name = GetAmiiboName(settings),
-            .font_region = {},
        };
+        // clang-format on
-        return ResultSuccess;
+        RegisterHandlers(functions);
    }
-    // Generate a generic answer
+private:
-    register_info = {
+    void CreateUserInterface(Kernel::HLERequestContext& ctx) {
-        .mii_char_info = manager.BuildDefault(0),
+        LOG_DEBUG(Service_NFP, "called");
-        .first_write_year = 2022,
-        .first_write_month = 2,
-        .first_write_day = 7,
-        .amiibo_name = {'Y', 'u', 'z', 'u', 'A', 'm', 'i', 'i', 'b', 'o', 0},
-        .font_region = {},
-    };
-    return ResultSuccess;
-}
-Result Module::Interface::OpenApplicationArea(u32 access_id) {
+        if (user_interface == nullptr) {
-    if (device_state != DeviceState::TagMounted) {
+            user_interface = std::make_shared<IUser>(system);
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
        }
-        return ErrCodes::WrongDeviceState;
-    }
-    // Fallback for lack of amiibo keys
-    if (!is_data_decoded) {
-        LOG_WARNING(Service_NFP, "Application area is not initialized");
-        return ErrCodes::ApplicationAreaIsNotInitialized;
-    }
-    if (tag_data.settings.settings.appdata_initialized == 0) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        LOG_WARNING(Service_NFP, "Application area is not initialized");
+        rb.Push(ResultSuccess);
-        return ErrCodes::ApplicationAreaIsNotInitialized;
+        rb.PushIpcInterface<IUser>(user_interface);
-    }
-    if (tag_data.application_area_id != access_id) {
-        LOG_WARNING(Service_NFP, "Wrong application area id");
-        return ErrCodes::WrongApplicationAreaId;
-    }
-    is_application_area_initialized = true;
-    return ResultSuccess;
-}
-Result Module::Interface::GetApplicationArea(ApplicationArea& data) const {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
-        }
-        return ErrCodes::WrongDeviceState;
-    }
-    if (!is_application_area_initialized) {
-        LOG_ERROR(Service_NFP, "Application area is not initialized");
-        return ErrCodes::ApplicationAreaIsNotInitialized;
-    }
-    data = tag_data.application_area;
-    return ResultSuccess;
-}
-Result Module::Interface::SetApplicationArea(const std::vector<u8>& data) {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
-        }
-        return ErrCodes::WrongDeviceState;
-    }
-    if (!is_application_area_initialized) {
-        LOG_ERROR(Service_NFP, "Application area is not initialized");
-        return ErrCodes::ApplicationAreaIsNotInitialized;
-    }
-    if (data.size() != sizeof(ApplicationArea)) {
-        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
-        return ResultUnknown;
-    }
-    std::memcpy(&tag_data.application_area, data.data(), sizeof(ApplicationArea));
-    return ResultSuccess;
-}
-Result Module::Interface::CreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
-        }
-        return ErrCodes::WrongDeviceState;
-    }
-    if (tag_data.settings.settings.appdata_initialized != 0) {
-        LOG_ERROR(Service_NFP, "Application area already exist");
-        return ErrCodes::ApplicationAreaExist;
-    }
-    if (data.size() != sizeof(ApplicationArea)) {
-        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
-        return ResultUnknown;
-    }
-    std::memcpy(&tag_data.application_area, data.data(), sizeof(ApplicationArea));
-    tag_data.application_area_id = access_id;
-    return ResultSuccess;
-}
-Result Module::Interface::RecreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
-    if (device_state != DeviceState::TagMounted) {
-        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
-        if (device_state == DeviceState::TagRemoved) {
-            return ErrCodes::TagRemoved;
-        }
-        return ErrCodes::WrongDeviceState;
-    }
-    if (data.size() != sizeof(ApplicationArea)) {
-        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
-        return ResultUnknown;
-    }
-    std::memcpy(&tag_data.application_area, data.data(), sizeof(ApplicationArea));
-    tag_data.application_area_id = access_id;
-    return ResultSuccess;
-}
-u64 Module::Interface::GetHandle() const {
-    // Generate a handle based of the npad id
-    return static_cast<u64>(npad_id);
-}
-DeviceState Module::Interface::GetCurrentState() const {
-    return device_state;
-}
-Core::HID::NpadIdType Module::Interface::GetNpadId() const {
-    // Return first connected npad id as a workaround for lack of a single nfc interface per
-    // controller
-    return system.HIDCore().GetFirstNpadId();
-}
-AmiiboName Module::Interface::GetAmiiboName(const AmiiboSettings& settings) const {
-    std::array<char16_t, amiibo_name_length> settings_amiibo_name{};
-    AmiiboName amiibo_name{};
-    // Convert from big endian to little endian
-    for (std::size_t i = 0; i < amiibo_name_length; i++) {
-        settings_amiibo_name[i] = static_cast<u16>(settings.amiibo_name[i]);
    }
-    // Convert from utf16 to utf8
+    std::shared_ptr<IUser> user_interface;
-    const auto amiibo_name_utf8 = Common::UTF16ToUTF8(settings_amiibo_name.data());
+};
-    memcpy(amiibo_name.data(), amiibo_name_utf8.data(), amiibo_name_utf8.size());
-    return amiibo_name;
-}
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    auto module = std::make_shared<Module>();
+    std::make_shared<IUserManager>(system)->InstallAsService(service_manager);
-    std::make_shared<NFP_User>(module, system)->InstallAsService(service_manager);
 }
 } // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/nfp.h b/src/core/hle/service/nfp/nfp.h
index 0de0b48e7..a25c362b8 100644
--- a/src/core/hle/service/nfp/nfp.h
+++ b/src/core/hle/service/nfp/nfp.h
@@ -3,170 +3,9 @@
 #pragma once
-#include <array>
-#include <vector>
-#include "common/common_funcs.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/mii/types.h"
-#include "core/hle/service/nfp/amiibo_types.h"
 #include "core/hle/service/service.h"
-namespace Kernel {
-class KEvent;
-class KReadableEvent;
-} // namespace Kernel
-namespace Core::HID {
-enum class NpadIdType : u32;
-} // namespace Core::HID
 namespace Service::NFP {
-using AmiiboName = std::array<char, (amiibo_name_length * 4) + 1>;
-struct TagInfo {
-    TagUuid uuid;
-    u8 uuid_length;
-    INSERT_PADDING_BYTES(0x15);
-    s32 protocol;
-    u32 tag_type;
-    INSERT_PADDING_BYTES(0x30);
-};
-static_assert(sizeof(TagInfo) == 0x58, "TagInfo is an invalid size");
-struct CommonInfo {
-    u16 last_write_year;
-    u8 last_write_month;
-    u8 last_write_day;
-    u16 write_counter;
-    u16 version;
-    u32 application_area_size;
-    INSERT_PADDING_BYTES(0x34);
-};
-static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");
-struct ModelInfo {
-    u16 character_id;
-    u8 character_variant;
-    AmiiboType amiibo_type;
-    u16 model_number;
-    AmiiboSeries series;
-    u8 constant_value;          // Must be 02
-    INSERT_PADDING_BYTES(0x38); // Unknown
-};
-static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
-struct RegisterInfo {
-    Service::Mii::CharInfo mii_char_info;
-    u16 first_write_year;
-    u8 first_write_month;
-    u8 first_write_day;
-    AmiiboName amiibo_name;
-    u8 font_region;
-    INSERT_PADDING_BYTES(0x7A);
-};
-static_assert(sizeof(RegisterInfo) == 0x100, "RegisterInfo is an invalid size");
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(std::shared_ptr<Module> module_, Core::System& system_,
-                           const char* name);
-        ~Interface() override;
-        void CreateUserInterface(Kernel::HLERequestContext& ctx);
-        bool LoadAmiibo(const std::string& filename);
-        bool LoadAmiiboFile(const std::string& filename);
-        void CloseAmiibo();
-        void Initialize();
-        void Finalize();
-        Result StartDetection(s32 protocol_);
-        Result StopDetection();
-        Result Mount();
-        Result Unmount();
-        Result Flush();
-        Result GetTagInfo(TagInfo& tag_info) const;
-        Result GetCommonInfo(CommonInfo& common_info) const;
-        Result GetModelInfo(ModelInfo& model_info) const;
-        Result GetRegisterInfo(RegisterInfo& register_info) const;
-        Result OpenApplicationArea(u32 access_id);
-        Result GetApplicationArea(ApplicationArea& data) const;
-        Result SetApplicationArea(const std::vector<u8>& data);
-        Result CreateApplicationArea(u32 access_id, const std::vector<u8>& data);
-        Result RecreateApplicationArea(u32 access_id, const std::vector<u8>& data);
-        u64 GetHandle() const;
-        DeviceState GetCurrentState() const;
-        Core::HID::NpadIdType GetNpadId() const;
-        Kernel::KReadableEvent& GetActivateEvent() const;
-        Kernel::KReadableEvent& GetDeactivateEvent() const;
-    protected:
-        std::shared_ptr<Module> module;
-    private:
-        AmiiboName GetAmiiboName(const AmiiboSettings& settings) const;
-        const Core::HID::NpadIdType npad_id;
-        bool is_data_decoded{};
-        bool is_application_area_initialized{};
-        s32 protocol;
-        std::string file_path{};
-        Kernel::KEvent* activate_event;
-        Kernel::KEvent* deactivate_event;
-        DeviceState device_state{DeviceState::Unaviable};
-        KernelHelpers::ServiceContext service_context;
-        NTAG215File tag_data{};
-        EncryptedNTAG215File encrypted_tag_data{};
-    };
-};
-class IUser final : public ServiceFramework<IUser> {
-public:
-    explicit IUser(Module::Interface& nfp_interface_, Core::System& system_);
-private:
-    void Initialize(Kernel::HLERequestContext& ctx);
-    void Finalize(Kernel::HLERequestContext& ctx);
-    void ListDevices(Kernel::HLERequestContext& ctx);
-    void StartDetection(Kernel::HLERequestContext& ctx);
-    void StopDetection(Kernel::HLERequestContext& ctx);
-    void Mount(Kernel::HLERequestContext& ctx);
-    void Unmount(Kernel::HLERequestContext& ctx);
-    void OpenApplicationArea(Kernel::HLERequestContext& ctx);
-    void GetApplicationArea(Kernel::HLERequestContext& ctx);
-    void SetApplicationArea(Kernel::HLERequestContext& ctx);
-    void Flush(Kernel::HLERequestContext& ctx);
-    void CreateApplicationArea(Kernel::HLERequestContext& ctx);
-    void GetTagInfo(Kernel::HLERequestContext& ctx);
-    void GetRegisterInfo(Kernel::HLERequestContext& ctx);
-    void GetCommonInfo(Kernel::HLERequestContext& ctx);
-    void GetModelInfo(Kernel::HLERequestContext& ctx);
-    void AttachActivateEvent(Kernel::HLERequestContext& ctx);
-    void AttachDeactivateEvent(Kernel::HLERequestContext& ctx);
-    void GetState(Kernel::HLERequestContext& ctx);
-    void GetDeviceState(Kernel::HLERequestContext& ctx);
-    void GetNpadId(Kernel::HLERequestContext& ctx);
-    void GetApplicationAreaSize(Kernel::HLERequestContext& ctx);
-    void AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx);
-    void RecreateApplicationArea(Kernel::HLERequestContext& ctx);
-    KernelHelpers::ServiceContext service_context;
-    // TODO(german77): We should have a vector of interfaces
-    Module::Interface& nfp_interface;
-    State state{State::NonInitialized};
-    Kernel::KEvent* availability_change_event;
-};
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
diff --git a/src/core/hle/service/nfp/nfp_device.cpp b/src/core/hle/service/nfp/nfp_device.cpp
new file mode 100644
index 000000000..0d4ffd3a5
--- /dev/null
+++ b/src/core/hle/service/nfp/nfp_device.cpp
@@ -0,0 +1,676 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <array>
+#include <atomic>
+#include "common/fs/file.h"
+#include "common/fs/path_util.h"
+#include "common/input.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "common/tiny_mt.h"
+#include "core/core.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/nfp/amiibo_crypto.h"
+#include "core/hle/service/nfp/nfp.h"
+#include "core/hle/service/nfp/nfp_device.h"
+#include "core/hle/service/nfp/nfp_result.h"
+#include "core/hle/service/nfp/nfp_user.h"
+#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+#include "core/hle/service/time/time_zone_types.h"
+namespace Service::NFP {
+NfpDevice::NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,
+                     KernelHelpers::ServiceContext& service_context_,
+                     Kernel::KEvent* availability_change_event_)
+    : npad_id{npad_id_}, system{system_}, service_context{service_context_},
+      availability_change_event{availability_change_event_} {
+    activate_event = service_context.CreateEvent("IUser:NFPActivateEvent");
+    deactivate_event = service_context.CreateEvent("IUser:NFPDeactivateEvent");
+    npad_device = system.HIDCore().GetEmulatedController(npad_id);
+    Core::HID::ControllerUpdateCallback engine_callback{
+        .on_change = [this](Core::HID::ControllerTriggerType type) { NpadUpdate(type); },
+        .is_npad_service = false,
+    };
+    is_controller_set = true;
+    callback_key = npad_device->SetCallback(engine_callback);
+    auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
+    current_posix_time = standard_steady_clock.GetCurrentTimePoint(system).time_point;
+}
+NfpDevice::~NfpDevice() {
+    if (!is_controller_set) {
+        return;
+    }
+    npad_device->DeleteCallback(callback_key);
+    is_controller_set = false;
+};
+void NfpDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {
+    if (type == Core::HID::ControllerTriggerType::Connected ||
+        type == Core::HID::ControllerTriggerType::Disconnected) {
+        availability_change_event->GetWritableEvent().Signal();
+        return;
+    }
+    if (type != Core::HID::ControllerTriggerType::Nfc) {
+        return;
+    }
+    if (!npad_device->IsConnected()) {
+        return;
+    }
+    const auto nfc_status = npad_device->GetNfc();
+    switch (nfc_status.state) {
+    case Common::Input::NfcState::NewAmiibo:
+        LoadAmiibo(nfc_status.data);
+        break;
+    case Common::Input::NfcState::AmiiboRemoved:
+        if (device_state != DeviceState::SearchingForTag) {
+            CloseAmiibo();
+        }
+        break;
+    default:
+        break;
+    }
+}
+bool NfpDevice::LoadAmiibo(std::span<const u8> data) {
+    if (device_state != DeviceState::SearchingForTag) {
+        LOG_ERROR(Service_NFP, "Game is not looking for amiibos, current state {}", device_state);
+        return false;
+    }
+    if (data.size() != sizeof(EncryptedNTAG215File)) {
+        LOG_ERROR(Service_NFP, "Not an amiibo, size={}", data.size());
+        return false;
+    }
+    memcpy(&encrypted_tag_data, data.data(), sizeof(EncryptedNTAG215File));
+    if (!AmiiboCrypto::IsAmiiboValid(encrypted_tag_data)) {
+        LOG_INFO(Service_NFP, "Invalid amiibo");
+        return false;
+    }
+    device_state = DeviceState::TagFound;
+    deactivate_event->GetReadableEvent().Clear();
+    activate_event->GetWritableEvent().Signal();
+    return true;
+}
+void NfpDevice::CloseAmiibo() {
+    LOG_INFO(Service_NFP, "Remove amiibo");
+    if (device_state == DeviceState::TagMounted) {
+        Unmount();
+    }
+    device_state = DeviceState::TagRemoved;
+    encrypted_tag_data = {};
+    tag_data = {};
+    activate_event->GetReadableEvent().Clear();
+    deactivate_event->GetWritableEvent().Signal();
+}
+Kernel::KReadableEvent& NfpDevice::GetActivateEvent() const {
+    return activate_event->GetReadableEvent();
+}
+Kernel::KReadableEvent& NfpDevice::GetDeactivateEvent() const {
+    return deactivate_event->GetReadableEvent();
+}
+void NfpDevice::Initialize() {
+    device_state = npad_device->HasNfc() ? DeviceState::Initialized : DeviceState::Unavailable;
+    encrypted_tag_data = {};
+    tag_data = {};
+}
+void NfpDevice::Finalize() {
+    if (device_state == DeviceState::TagMounted) {
+        Unmount();
+    }
+    if (device_state == DeviceState::SearchingForTag || device_state == DeviceState::TagRemoved) {
+        StopDetection();
+    }
+    device_state = DeviceState::Unavailable;
+}
+Result NfpDevice::StartDetection(s32 protocol_) {
+    if (device_state == DeviceState::Initialized || device_state == DeviceState::TagRemoved) {
+        npad_device->SetPollingMode(Common::Input::PollingMode::NFC);
+        device_state = DeviceState::SearchingForTag;
+        protocol = protocol_;
+        return ResultSuccess;
+    }
+    LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+    return WrongDeviceState;
+}
+Result NfpDevice::StopDetection() {
+    npad_device->SetPollingMode(Common::Input::PollingMode::Active);
+    if (device_state == DeviceState::TagFound || device_state == DeviceState::TagMounted) {
+        CloseAmiibo();
+        return ResultSuccess;
+    }
+    if (device_state == DeviceState::SearchingForTag || device_state == DeviceState::TagRemoved) {
+        device_state = DeviceState::Initialized;
+        return ResultSuccess;
+    }
+    LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+    return WrongDeviceState;
+}
+Result NfpDevice::Flush() {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    auto& settings = tag_data.settings;
+    const auto& current_date = GetAmiiboDate(current_posix_time);
+    if (settings.write_date.raw_date != current_date.raw_date) {
+        settings.write_date = current_date;
+        settings.crc_counter++;
+        // TODO: Find how to calculate the crc check
+        // settings.crc = CalculateCRC(settings);
+    }
+    tag_data.write_counter++;
+    if (!AmiiboCrypto::EncodeAmiibo(tag_data, encrypted_tag_data)) {
+        LOG_ERROR(Service_NFP, "Failed to encode data");
+        return WriteAmiiboFailed;
+    }
+    std::vector<u8> data(sizeof(encrypted_tag_data));
+    memcpy(data.data(), &encrypted_tag_data, sizeof(encrypted_tag_data));
+    if (!npad_device->WriteNfc(data)) {
+        LOG_ERROR(Service_NFP, "Error writing to file");
+        return WriteAmiiboFailed;
+    }
+    is_data_moddified = false;
+    return ResultSuccess;
+}
+Result NfpDevice::Mount(MountTarget mount_target_) {
+    if (device_state != DeviceState::TagFound) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        return WrongDeviceState;
+    }
+    if (!AmiiboCrypto::DecodeAmiibo(encrypted_tag_data, tag_data)) {
+        LOG_ERROR(Service_NFP, "Can't decode amiibo {}", device_state);
+        return CorruptedData;
+    }
+    device_state = DeviceState::TagMounted;
+    mount_target = mount_target_;
+    return ResultSuccess;
+}
+Result NfpDevice::Unmount() {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        return WrongDeviceState;
+    }
+    // Save data before unloading the amiibo
+    if (is_data_moddified) {
+        Flush();
+    }
+    device_state = DeviceState::TagFound;
+    mount_target = MountTarget::None;
+    is_app_area_open = false;
+    return ResultSuccess;
+}
+Result NfpDevice::GetTagInfo(TagInfo& tag_info) const {
+    if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        return WrongDeviceState;
+    }
+    tag_info = {
+        .uuid = encrypted_tag_data.uuid.uid,
+        .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),
+        .protocol = TagProtocol::TypeA,
+        .tag_type = TagType::Type2,
+    };
+    return ResultSuccess;
+}
+Result NfpDevice::GetCommonInfo(CommonInfo& common_info) const {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    const auto& settings = tag_data.settings;
+    // TODO: Validate this data
+    common_info = {
+        .last_write_date =
+            {
+                settings.write_date.GetYear(),
+                settings.write_date.GetMonth(),
+                settings.write_date.GetDay(),
+            },
+        .write_counter = tag_data.write_counter,
+        .version = 0,
+        .application_area_size = sizeof(ApplicationArea),
+    };
+    return ResultSuccess;
+}
+Result NfpDevice::GetModelInfo(ModelInfo& model_info) const {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        return WrongDeviceState;
+    }
+    const auto& model_info_data = encrypted_tag_data.user_memory.model_info;
+    model_info = {
+        .character_id = model_info_data.character_id,
+        .character_variant = model_info_data.character_variant,
+        .amiibo_type = model_info_data.amiibo_type,
+        .model_number = model_info_data.model_number,
+        .series = model_info_data.series,
+    };
+    return ResultSuccess;
+}
+Result NfpDevice::GetRegisterInfo(RegisterInfo& register_info) const {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    if (tag_data.settings.settings.amiibo_initialized == 0) {
+        return RegistrationIsNotInitialized;
+    }
+    Service::Mii::MiiManager manager;
+    const auto& settings = tag_data.settings;
+    // TODO: Validate this data
+    register_info = {
+        .mii_char_info = manager.ConvertV3ToCharInfo(tag_data.owner_mii),
+        .creation_date =
+            {
+                settings.init_date.GetYear(),
+                settings.init_date.GetMonth(),
+                settings.init_date.GetDay(),
+            },
+        .amiibo_name = GetAmiiboName(settings),
+        .font_region = {},
+    };
+    return ResultSuccess;
+}
+Result NfpDevice::SetNicknameAndOwner(const AmiiboName& amiibo_name) {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    Service::Mii::MiiManager manager;
+    auto& settings = tag_data.settings;
+    settings.init_date = GetAmiiboDate(current_posix_time);
+    settings.write_date = GetAmiiboDate(current_posix_time);
+    settings.crc_counter++;
+    // TODO: Find how to calculate the crc check
+    // settings.crc = CalculateCRC(settings);
+    SetAmiiboName(settings, amiibo_name);
+    tag_data.owner_mii = manager.ConvertCharInfoToV3(manager.BuildDefault(0));
+    settings.settings.amiibo_initialized.Assign(1);
+    return Flush();
+}
+Result NfpDevice::RestoreAmiibo() {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    // TODO: Load amiibo from backup on system
+    LOG_ERROR(Service_NFP, "Not Implemented");
+    return ResultSuccess;
+}
+Result NfpDevice::DeleteAllData() {
+    const auto result = DeleteApplicationArea();
+    if (result.IsError()) {
+        return result;
+    }
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    Common::TinyMT rng{};
+    rng.GenerateRandomBytes(&tag_data.owner_mii, sizeof(tag_data.owner_mii));
+    tag_data.settings.settings.amiibo_initialized.Assign(0);
+    return Flush();
+}
+Result NfpDevice::OpenApplicationArea(u32 access_id) {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    if (tag_data.settings.settings.appdata_initialized.Value() == 0) {
+        LOG_WARNING(Service_NFP, "Application area is not initialized");
+        return ApplicationAreaIsNotInitialized;
+    }
+    if (tag_data.application_area_id != access_id) {
+        LOG_WARNING(Service_NFP, "Wrong application area id");
+        return WrongApplicationAreaId;
+    }
+    is_app_area_open = true;
+    return ResultSuccess;
+}
+Result NfpDevice::GetApplicationArea(std::vector<u8>& data) const {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    if (!is_app_area_open) {
+        LOG_ERROR(Service_NFP, "Application area is not open");
+        return WrongDeviceState;
+    }
+    if (tag_data.settings.settings.appdata_initialized.Value() == 0) {
+        LOG_ERROR(Service_NFP, "Application area is not initialized");
+        return ApplicationAreaIsNotInitialized;
+    }
+    if (data.size() > sizeof(ApplicationArea)) {
+        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
+        return ResultUnknown;
+    }
+    memcpy(data.data(), tag_data.application_area.data(), data.size());
+    return ResultSuccess;
+}
+Result NfpDevice::SetApplicationArea(std::span<const u8> data) {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    if (!is_app_area_open) {
+        LOG_ERROR(Service_NFP, "Application area is not open");
+        return WrongDeviceState;
+    }
+    if (tag_data.settings.settings.appdata_initialized.Value() == 0) {
+        LOG_ERROR(Service_NFP, "Application area is not initialized");
+        return ApplicationAreaIsNotInitialized;
+    }
+    if (data.size() > sizeof(ApplicationArea)) {
+        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
+        return ResultUnknown;
+    }
+    Common::TinyMT rng{};
+    std::memcpy(tag_data.application_area.data(), data.data(), data.size());
+    // HW seems to fill excess data with garbage
+    rng.GenerateRandomBytes(tag_data.application_area.data() + data.size(),
+                            sizeof(ApplicationArea) - data.size());
+    tag_data.applicaton_write_counter++;
+    is_data_moddified = true;
+    return ResultSuccess;
+}
+Result NfpDevice::CreateApplicationArea(u32 access_id, std::span<const u8> data) {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (tag_data.settings.settings.appdata_initialized.Value() != 0) {
+        LOG_ERROR(Service_NFP, "Application area already exist");
+        return ApplicationAreaExist;
+    }
+    return RecreateApplicationArea(access_id, data);
+}
+Result NfpDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> data) {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    if (data.size() > sizeof(ApplicationArea)) {
+        LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());
+        return ResultUnknown;
+    }
+    Common::TinyMT rng{};
+    std::memcpy(tag_data.application_area.data(), data.data(), data.size());
+    // HW seems to fill excess data with garbage
+    rng.GenerateRandomBytes(tag_data.application_area.data() + data.size(),
+                            sizeof(ApplicationArea) - data.size());
+    // TODO: Investigate why the title id needs to be moddified
+    tag_data.title_id = system.GetCurrentProcessProgramID();
+    tag_data.title_id = tag_data.title_id | 0x30000000ULL;
+    tag_data.settings.settings.appdata_initialized.Assign(1);
+    tag_data.application_area_id = access_id;
+    tag_data.applicaton_write_counter++;
+    tag_data.unknown = {};
+    return Flush();
+}
+Result NfpDevice::DeleteApplicationArea() {
+    if (device_state != DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
+        if (device_state == DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+    if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {
+        LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);
+        return WrongDeviceState;
+    }
+    Common::TinyMT rng{};
+    rng.GenerateRandomBytes(tag_data.application_area.data(), sizeof(ApplicationArea));
+    rng.GenerateRandomBytes(&tag_data.title_id, sizeof(u64));
+    rng.GenerateRandomBytes(&tag_data.application_area_id, sizeof(u32));
+    tag_data.settings.settings.appdata_initialized.Assign(0);
+    tag_data.applicaton_write_counter++;
+    tag_data.unknown = {};
+    return Flush();
+}
+u64 NfpDevice::GetHandle() const {
+    // Generate a handle based of the npad id
+    return static_cast<u64>(npad_id);
+}
+u32 NfpDevice::GetApplicationAreaSize() const {
+    // Investigate if this value is really constant
+    return sizeof(ApplicationArea);
+}
+DeviceState NfpDevice::GetCurrentState() const {
+    return device_state;
+}
+Core::HID::NpadIdType NfpDevice::GetNpadId() const {
+    return npad_id;
+}
+AmiiboName NfpDevice::GetAmiiboName(const AmiiboSettings& settings) const {
+    std::array<char16_t, amiibo_name_length> settings_amiibo_name{};
+    AmiiboName amiibo_name{};
+    // Convert from big endian to little endian
+    for (std::size_t i = 0; i < amiibo_name_length; i++) {
+        settings_amiibo_name[i] = static_cast<u16>(settings.amiibo_name[i]);
+    }
+    // Convert from utf16 to utf8
+    const auto amiibo_name_utf8 = Common::UTF16ToUTF8(settings_amiibo_name.data());
+    memcpy(amiibo_name.data(), amiibo_name_utf8.data(), amiibo_name_utf8.size());
+    return amiibo_name;
+}
+void NfpDevice::SetAmiiboName(AmiiboSettings& settings, const AmiiboName& amiibo_name) {
+    std::array<char16_t, amiibo_name_length> settings_amiibo_name{};
+    // Convert from utf8 to utf16
+    const auto amiibo_name_utf16 = Common::UTF8ToUTF16(amiibo_name.data());
+    memcpy(settings_amiibo_name.data(), amiibo_name_utf16.data(),
+           amiibo_name_utf16.size() * sizeof(char16_t));
+    // Convert from little endian to big endian
+    for (std::size_t i = 0; i < amiibo_name_length; i++) {
+        settings.amiibo_name[i] = static_cast<u16_be>(settings_amiibo_name[i]);
+    }
+}
+AmiiboDate NfpDevice::GetAmiiboDate(s64 posix_time) const {
+    const auto& time_zone_manager =
+        system.GetTimeManager().GetTimeZoneContentManager().GetTimeZoneManager();
+    Time::TimeZone::CalendarInfo calendar_info{};
+    AmiiboDate amiibo_date{};
+    amiibo_date.SetYear(2000);
+    amiibo_date.SetMonth(1);
+    amiibo_date.SetDay(1);
+    if (time_zone_manager.ToCalendarTime({}, posix_time, calendar_info) == ResultSuccess) {
+        amiibo_date.SetYear(calendar_info.time.year);
+        amiibo_date.SetMonth(calendar_info.time.month);
+        amiibo_date.SetDay(calendar_info.time.day);
+    }
+    return amiibo_date;
+}
+} // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/nfp_device.h b/src/core/hle/service/nfp/nfp_device.h
new file mode 100644
index 000000000..a5b72cf19
--- /dev/null
+++ b/src/core/hle/service/nfp/nfp_device.h
@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+#include <array>
+#include <vector>
+#include "common/common_funcs.h"
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/mii/types.h"
+#include "core/hle/service/nfp/nfp_types.h"
+#include "core/hle/service/service.h"
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+namespace Core {
+class System;
+} // namespace Core
+namespace Core::HID {
+class EmulatedController;
+enum class ControllerTriggerType;
+enum class NpadIdType : u32;
+} // namespace Core::HID
+namespace Service::NFP {
+class NfpDevice {
+public:
+    NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,
+              KernelHelpers::ServiceContext& service_context_,
+              Kernel::KEvent* availability_change_event_);
+    ~NfpDevice();
+    void Initialize();
+    void Finalize();
+    Result StartDetection(s32 protocol_);
+    Result StopDetection();
+    Result Mount(MountTarget mount_target);
+    Result Unmount();
+    Result Flush();
+    Result GetTagInfo(TagInfo& tag_info) const;
+    Result GetCommonInfo(CommonInfo& common_info) const;
+    Result GetModelInfo(ModelInfo& model_info) const;
+    Result GetRegisterInfo(RegisterInfo& register_info) const;
+    Result SetNicknameAndOwner(const AmiiboName& amiibo_name);
+    Result RestoreAmiibo();
+    Result DeleteAllData();
+    Result OpenApplicationArea(u32 access_id);
+    Result GetApplicationArea(std::vector<u8>& data) const;
+    Result SetApplicationArea(std::span<const u8> data);
+    Result CreateApplicationArea(u32 access_id, std::span<const u8> data);
+    Result RecreateApplicationArea(u32 access_id, std::span<const u8> data);
+    Result DeleteApplicationArea();
+    u64 GetHandle() const;
+    u32 GetApplicationAreaSize() const;
+    DeviceState GetCurrentState() const;
+    Core::HID::NpadIdType GetNpadId() const;
+    Kernel::KReadableEvent& GetActivateEvent() const;
+    Kernel::KReadableEvent& GetDeactivateEvent() const;
+private:
+    void NpadUpdate(Core::HID::ControllerTriggerType type);
+    bool LoadAmiibo(std::span<const u8> data);
+    void CloseAmiibo();
+    AmiiboName GetAmiiboName(const AmiiboSettings& settings) const;
+    void SetAmiiboName(AmiiboSettings& settings, const AmiiboName& amiibo_name);
+    AmiiboDate GetAmiiboDate(s64 posix_time) const;
+    bool is_controller_set{};
+    int callback_key;
+    const Core::HID::NpadIdType npad_id;
+    Core::System& system;
+    Core::HID::EmulatedController* npad_device = nullptr;
+    KernelHelpers::ServiceContext& service_context;
+    Kernel::KEvent* activate_event = nullptr;
+    Kernel::KEvent* deactivate_event = nullptr;
+    Kernel::KEvent* availability_change_event = nullptr;
+    bool is_data_moddified{};
+    bool is_app_area_open{};
+    s32 protocol{};
+    s64 current_posix_time{};
+    MountTarget mount_target{MountTarget::None};
+    DeviceState device_state{DeviceState::Unavailable};
+    NTAG215File tag_data{};
+    EncryptedNTAG215File encrypted_tag_data{};
+};
+} // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/nfp_result.h b/src/core/hle/service/nfp/nfp_result.h
new file mode 100644
index 000000000..ac259e2ff
--- /dev/null
+++ b/src/core/hle/service/nfp/nfp_result.h
@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+#include "core/hle/result.h"
+namespace Service::NFP {
+constexpr Result DeviceNotFound(ErrorModule::NFP, 64);
+constexpr Result WrongDeviceState(ErrorModule::NFP, 73);
+constexpr Result NfcDisabled(ErrorModule::NFP, 80);
+constexpr Result WriteAmiiboFailed(ErrorModule::NFP, 88);
+constexpr Result TagRemoved(ErrorModule::NFP, 97);
+constexpr Result RegistrationIsNotInitialized(ErrorModule::NFP, 120);
+constexpr Result ApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);
+constexpr Result CorruptedData(ErrorModule::NFP, 144);
+constexpr Result WrongApplicationAreaId(ErrorModule::NFP, 152);
+constexpr Result ApplicationAreaExist(ErrorModule::NFP, 168);
+constexpr Result NotAnAmiibo(ErrorModule::NFP, 178);
+} // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/amiibo_types.h b/src/core/hle/service/nfp/nfp_types.h
index bf2de811a..dd4525b61 100644
--- a/src/core/hle/service/nfp/amiibo_types.h
+++ b/src/core/hle/service/nfp/nfp_types.h
@@ -5,6 +5,7 @@
 #include <array>
+#include "common/swap.h"
 #include "core/hle/service/mii/types.h"
 namespace Service::NFP {
@@ -27,7 +28,7 @@ enum class DeviceState : u32 {
    TagFound,
    TagRemoved,
    TagMounted,
-    Unaviable,
+    Unavailable,
    Finalized,
 };
@@ -36,6 +37,7 @@ enum class ModelType : u32 {
 };
 enum class MountTarget : u32 {
+    None,
    Rom,
    Ram,
    All,
@@ -73,21 +75,63 @@ enum class AmiiboSeries : u8 {
    Diablo,
 };
-using TagUuid = std::array<u8, 10>;
+enum class TagType : u32 {
+    None,
+    Type1, // ISO14443A RW 96-2k bytes 106kbit/s
+    Type2, // ISO14443A RW/RO 540 bytes 106kbit/s
+    Type3, // Sony Felica RW/RO 2k bytes 212kbit/s
+    Type4, // ISO14443A RW/RO 4k-32k bytes 424kbit/s
+    Type5, // ISO15693 RW/RO 540 bytes 106kbit/s
+};
+enum class TagProtocol : u32 {
+    None,
+    TypeA, // ISO14443A
+    TypeB, // ISO14443B
+    TypeF, // Sony Felica
+};
+using UniqueSerialNumber = std::array<u8, 7>;
+using LockBytes = std::array<u8, 2>;
 using HashData = std::array<u8, 0x20>;
 using ApplicationArea = std::array<u8, 0xD8>;
+using AmiiboName = std::array<char, (amiibo_name_length * 4) + 1>;
+struct TagUuid {
+    UniqueSerialNumber uid;
+    u8 nintendo_id;
+    LockBytes lock_bytes;
+};
+static_assert(sizeof(TagUuid) == 10, "TagUuid is an invalid size");
 struct AmiiboDate {
    u16 raw_date{};
+    u16 GetValue() const {
+        return Common::swap16(raw_date);
+    }
    u16 GetYear() const {
-        return static_cast<u16>(((raw_date & 0xFE00) >> 9) + 2000);
+        return static_cast<u16>(((GetValue() & 0xFE00) >> 9) + 2000);
    }
    u8 GetMonth() const {
-        return static_cast<u8>(((raw_date & 0x01E0) >> 5) - 1);
+        return static_cast<u8>((GetValue() & 0x01E0) >> 5);
    }
    u8 GetDay() const {
-        return static_cast<u8>(raw_date & 0x001F);
+        return static_cast<u8>(GetValue() & 0x001F);
+    }
+    void SetYear(u16 year) {
+        const u16 year_converted = static_cast<u16>((year - 2000) << 9);
+        raw_date = Common::swap16((GetValue() & ~0xFE00) | year_converted);
+    }
+    void SetMonth(u8 month) {
+        const u16 month_converted = static_cast<u16>(month << 5);
+        raw_date = Common::swap16((GetValue() & ~0x01E0) | month_converted);
+    }
+    void SetDay(u8 day) {
+        const u16 day_converted = static_cast<u16>(day);
+        raw_date = Common::swap16((GetValue() & ~0x001F) | day_converted);
    }
 };
 static_assert(sizeof(AmiiboDate) == 2, "AmiiboDate is an invalid size");
@@ -117,7 +161,7 @@ struct AmiiboModelInfo {
    u16 character_id;
    u8 character_variant;
    AmiiboType amiibo_type;
-    u16 model_number;
+    u16_be model_number;
    AmiiboSeries series;
    u8 constant_value;         // Must be 02
    INSERT_PADDING_BYTES(0x4); // Unknown
@@ -134,7 +178,7 @@ static_assert(sizeof(NTAG215Password) == 0x8, "NTAG215Password is an invalid siz
 #pragma pack(1)
 struct EncryptedAmiiboFile {
    u8 constant_value;                     // Must be A5
-    u16 write_counter;                     // Number of times the amiibo has been written?
+    u16_be write_counter;                  // Number of times the amiibo has been written?
    INSERT_PADDING_BYTES(0x1);             // Unknown 1
    AmiiboSettings settings;               // Encrypted amiibo settings
    HashData hmac_tag;                     // Hash
@@ -146,18 +190,18 @@ struct EncryptedAmiiboFile {
    u16_be applicaton_write_counter;       // Encrypted Counter
    u32_be application_area_id;            // Encrypted Game id
    std::array<u8, 0x2> unknown;
-    HashData hash;                    // Probably a SHA256-HMAC hash?
+    std::array<u32, 0x8> unknown2;
    ApplicationArea application_area; // Encrypted Game data
 };
 static_assert(sizeof(EncryptedAmiiboFile) == 0x1F8, "AmiiboFile is an invalid size");
 struct NTAG215File {
-    std::array<u8, 0x2> uuid2;
+    LockBytes lock_bytes;      // Tag UUID
    u16 static_lock;           // Set defined pages as read only
    u32 compability_container; // Defines available memory
    HashData hmac_data;        // Hash
    u8 constant_value;         // Must be A5
-    u16 write_counter;         // Number of times the amiibo has been written?
+    u16_be write_counter;      // Number of times the amiibo has been written?
    INSERT_PADDING_BYTES(0x1); // Unknown 1
    AmiiboSettings settings;
    Service::Mii::Ver3StoreData owner_mii; // Encrypted Mii data
@@ -165,10 +209,11 @@ struct NTAG215File {
    u16_be applicaton_write_counter; // Encrypted Counter
    u32_be application_area_id;
    std::array<u8, 0x2> unknown;
-    HashData hash;                    // Probably a SHA256-HMAC hash?
+    std::array<u32, 0x8> unknown2;
    ApplicationArea application_area; // Encrypted Game data
    HashData hmac_tag;                // Hash
-    std::array<u8, 0x8> uuid;
+    UniqueSerialNumber uid;           // Unique serial number
+    u8 nintendo_id;                   // Tag UUID
    AmiiboModelInfo model_info;
    HashData keygen_salt;     // Salt
    u32 dynamic_lock;         // Dynamic lock
@@ -194,4 +239,51 @@ static_assert(sizeof(EncryptedNTAG215File) == 0x21C, "EncryptedNTAG215File is an
 static_assert(std::is_trivially_copyable_v<EncryptedNTAG215File>,
              "EncryptedNTAG215File must be trivially copyable.");
+struct TagInfo {
+    UniqueSerialNumber uuid;
+    INSERT_PADDING_BYTES(0x3);
+    u8 uuid_length;
+    INSERT_PADDING_BYTES(0x15);
+    TagProtocol protocol;
+    TagType tag_type;
+    INSERT_PADDING_BYTES(0x30);
+};
+static_assert(sizeof(TagInfo) == 0x58, "TagInfo is an invalid size");
+struct WriteDate {
+    u16 year;
+    u8 month;
+    u8 day;
+};
+static_assert(sizeof(WriteDate) == 0x4, "WriteDate is an invalid size");
+struct CommonInfo {
+    WriteDate last_write_date;
+    u16 write_counter;
+    u8 version;
+    INSERT_PADDING_BYTES(0x1);
+    u32 application_area_size;
+    INSERT_PADDING_BYTES(0x34);
+};
+static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");
+struct ModelInfo {
+    u16 character_id;
+    u8 character_variant;
+    AmiiboType amiibo_type;
+    u16 model_number;
+    AmiiboSeries series;
+    INSERT_PADDING_BYTES(0x39); // Unknown
+};
+static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
+struct RegisterInfo {
+    Service::Mii::CharInfo mii_char_info;
+    WriteDate creation_date;
+    AmiiboName amiibo_name;
+    u8 font_region;
+    INSERT_PADDING_BYTES(0x7A);
+};
+static_assert(sizeof(RegisterInfo) == 0x100, "RegisterInfo is an invalid size");
 } // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/nfp_user.cpp b/src/core/hle/service/nfp/nfp_user.cpp
index 2d7b156cf..c61df9401 100644
--- a/src/core/hle/service/nfp/nfp_user.cpp
+++ b/src/core/hle/service/nfp/nfp_user.cpp
@@ -1,18 +1,644 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
+#include <array>
+#include <atomic>
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/nfp/nfp_device.h"
+#include "core/hle/service/nfp/nfp_result.h"
 #include "core/hle/service/nfp/nfp_user.h"
 namespace Service::NFP {
-NFP_User::NFP_User(std::shared_ptr<Module> module_, Core::System& system_)
+IUser::IUser(Core::System& system_)
-    : Interface(std::move(module_), system_, "nfp:user") {
+    : ServiceFramework{system_, "NFP::IUser"}, service_context{system_, service_name} {
    static const FunctionInfo functions[] = {
-        {0, &NFP_User::CreateUserInterface, "CreateUserInterface"},
+        {0, &IUser::Initialize, "Initialize"},
+        {1, &IUser::Finalize, "Finalize"},
+        {2, &IUser::ListDevices, "ListDevices"},
+        {3, &IUser::StartDetection, "StartDetection"},
+        {4, &IUser::StopDetection, "StopDetection"},
+        {5, &IUser::Mount, "Mount"},
+        {6, &IUser::Unmount, "Unmount"},
+        {7, &IUser::OpenApplicationArea, "OpenApplicationArea"},
+        {8, &IUser::GetApplicationArea, "GetApplicationArea"},
+        {9, &IUser::SetApplicationArea, "SetApplicationArea"},
+        {10, &IUser::Flush, "Flush"},
+        {11, &IUser::Restore, "Restore"},
+        {12, &IUser::CreateApplicationArea, "CreateApplicationArea"},
+        {13, &IUser::GetTagInfo, "GetTagInfo"},
+        {14, &IUser::GetRegisterInfo, "GetRegisterInfo"},
+        {15, &IUser::GetCommonInfo, "GetCommonInfo"},
+        {16, &IUser::GetModelInfo, "GetModelInfo"},
+        {17, &IUser::AttachActivateEvent, "AttachActivateEvent"},
+        {18, &IUser::AttachDeactivateEvent, "AttachDeactivateEvent"},
+        {19, &IUser::GetState, "GetState"},
+        {20, &IUser::GetDeviceState, "GetDeviceState"},
+        {21, &IUser::GetNpadId, "GetNpadId"},
+        {22, &IUser::GetApplicationAreaSize, "GetApplicationAreaSize"},
+        {23, &IUser::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},
+        {24, &IUser::RecreateApplicationArea, "RecreateApplicationArea"},
    };
    RegisterHandlers(functions);
+    availability_change_event = service_context.CreateEvent("IUser:AvailabilityChangeEvent");
+    for (u32 device_index = 0; device_index < 10; device_index++) {
+        devices[device_index] =
+            std::make_shared<NfpDevice>(Core::HID::IndexToNpadIdType(device_index), system,
+                                        service_context, availability_change_event);
+    }
+}
+void IUser::Initialize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+    state = State::Initialized;
+    for (auto& device : devices) {
+        device->Initialize();
+    }
+    IPC::ResponseBuilder rb{ctx, 2, 0};
+    rb.Push(ResultSuccess);
+}
+void IUser::Finalize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFP, "called");
+    state = State::NonInitialized;
+    for (auto& device : devices) {
+        device->Finalize();
+    }
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFP, "called");
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    std::vector<u64> nfp_devices;
+    const std::size_t max_allowed_devices = ctx.GetWriteBufferSize() / sizeof(u64);
+    for (auto& device : devices) {
+        if (nfp_devices.size() >= max_allowed_devices) {
+            continue;
+        }
+        if (device->GetCurrentState() != DeviceState::Unavailable) {
+            nfp_devices.push_back(device->GetHandle());
+        }
+    }
+    if (nfp_devices.size() == 0) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    ctx.WriteBuffer(nfp_devices);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<s32>(nfp_devices.size()));
+}
+void IUser::StartDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto nfp_protocol{rp.Pop<s32>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, nfp_protocol={}", device_handle, nfp_protocol);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->StartDetection(nfp_protocol);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::StopDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->StopDetection();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::Mount(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto model_type{rp.PopEnum<ModelType>()};
+    const auto mount_target{rp.PopEnum<MountTarget>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, model_type={}, mount_target={}", device_handle,
+             model_type, mount_target);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->Mount(mount_target);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::Unmount(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->Unmount();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
-NFP_User::~NFP_User() = default;
+void IUser::OpenApplicationArea(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto access_id{rp.Pop<u32>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, access_id={}", device_handle, access_id);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->OpenApplicationArea(access_id);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::GetApplicationArea(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto data_size = ctx.GetWriteBufferSize();
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    std::vector<u8> data(data_size);
+    const auto result = device.value()->GetApplicationArea(data);
+    ctx.WriteBuffer(data);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(result);
+    rb.Push(static_cast<u32>(data_size));
+}
+void IUser::SetApplicationArea(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto data{ctx.ReadBuffer()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}", device_handle, data.size());
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->SetApplicationArea(data);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::Flush(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->Flush();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::Restore(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->RestoreAmiibo();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::CreateApplicationArea(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto access_id{rp.Pop<u32>()};
+    const auto data{ctx.ReadBuffer()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}, access_id={}", device_handle,
+             access_id, data.size());
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->CreateApplicationArea(access_id, data);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::GetTagInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    TagInfo tag_info{};
+    const auto result = device.value()->GetTagInfo(tag_info);
+    ctx.WriteBuffer(tag_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::GetRegisterInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    RegisterInfo register_info{};
+    const auto result = device.value()->GetRegisterInfo(register_info);
+    ctx.WriteBuffer(register_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::GetCommonInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    CommonInfo common_info{};
+    const auto result = device.value()->GetCommonInfo(common_info);
+    ctx.WriteBuffer(common_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::GetModelInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    ModelInfo model_info{};
+    const auto result = device.value()->GetModelInfo(model_info);
+    ctx.WriteBuffer(model_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+void IUser::AttachActivateEvent(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetActivateEvent());
+}
+void IUser::AttachDeactivateEvent(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetDeactivateEvent());
+}
+void IUser::GetState(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NFC, "called");
+    IPC::ResponseBuilder rb{ctx, 3, 0};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(state);
+}
+void IUser::GetDeviceState(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetCurrentState());
+}
+void IUser::GetNpadId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetNpadId());
+}
+void IUser::GetApplicationAreaSize(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(device.value()->GetApplicationAreaSize());
+}
+void IUser::AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFP, "called");
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(availability_change_event->GetReadableEvent());
+}
+void IUser::RecreateApplicationArea(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto access_id{rp.Pop<u32>()};
+    const auto data{ctx.ReadBuffer()};
+    LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}, access_id={}", device_handle,
+             access_id, data.size());
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(NfcDisabled);
+        return;
+    }
+    auto device = GetNfpDevice(device_handle);
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(DeviceNotFound);
+        return;
+    }
+    const auto result = device.value()->RecreateApplicationArea(access_id, data);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+std::optional<std::shared_ptr<NfpDevice>> IUser::GetNfpDevice(u64 handle) {
+    for (auto& device : devices) {
+        if (device->GetHandle() == handle) {
+            return device;
+        }
+    }
+    return std::nullopt;
+}
 } // namespace Service::NFP
diff --git a/src/core/hle/service/nfp/nfp_user.h b/src/core/hle/service/nfp/nfp_user.h
index 519ff56ee..68c60ae82 100644
--- a/src/core/hle/service/nfp/nfp_user.h
+++ b/src/core/hle/service/nfp/nfp_user.h
@@ -3,14 +3,52 @@
 #pragma once
+#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nfp/nfp.h"
+#include "core/hle/service/nfp/nfp_types.h"
 namespace Service::NFP {
+class NfpDevice;
-class NFP_User final : public Module::Interface {
+class IUser final : public ServiceFramework<IUser> {
 public:
-    explicit NFP_User(std::shared_ptr<Module> module_, Core::System& system_);
+    explicit IUser(Core::System& system_);
-    ~NFP_User() override;
+private:
+    void Initialize(Kernel::HLERequestContext& ctx);
+    void Finalize(Kernel::HLERequestContext& ctx);
+    void ListDevices(Kernel::HLERequestContext& ctx);
+    void StartDetection(Kernel::HLERequestContext& ctx);
+    void StopDetection(Kernel::HLERequestContext& ctx);
+    void Mount(Kernel::HLERequestContext& ctx);
+    void Unmount(Kernel::HLERequestContext& ctx);
+    void OpenApplicationArea(Kernel::HLERequestContext& ctx);
+    void GetApplicationArea(Kernel::HLERequestContext& ctx);
+    void SetApplicationArea(Kernel::HLERequestContext& ctx);
+    void Flush(Kernel::HLERequestContext& ctx);
+    void Restore(Kernel::HLERequestContext& ctx);
+    void CreateApplicationArea(Kernel::HLERequestContext& ctx);
+    void GetTagInfo(Kernel::HLERequestContext& ctx);
+    void GetRegisterInfo(Kernel::HLERequestContext& ctx);
+    void GetCommonInfo(Kernel::HLERequestContext& ctx);
+    void GetModelInfo(Kernel::HLERequestContext& ctx);
+    void AttachActivateEvent(Kernel::HLERequestContext& ctx);
+    void AttachDeactivateEvent(Kernel::HLERequestContext& ctx);
+    void GetState(Kernel::HLERequestContext& ctx);
+    void GetDeviceState(Kernel::HLERequestContext& ctx);
+    void GetNpadId(Kernel::HLERequestContext& ctx);
+    void GetApplicationAreaSize(Kernel::HLERequestContext& ctx);
+    void AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx);
+    void RecreateApplicationArea(Kernel::HLERequestContext& ctx);
+    std::optional<std::shared_ptr<NfpDevice>> GetNfpDevice(u64 handle);
+    KernelHelpers::ServiceContext service_context;
+    std::array<std::shared_ptr<NfpDevice>, 10> devices{};
+    State state{State::NonInitialized};
+    Kernel::KEvent* availability_change_event;
 };
 } // namespace Service::NFP
diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp
index 9b382bf56..93057e800 100644
--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -22,6 +22,7 @@
 #include "core/hle/service/nvflinger/ui/graphic_buffer.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
+#include "core/hle/service/vi/vi_results.h"
 #include "video_core/gpu.h"
 namespace Service::NVFlinger {
@@ -163,15 +164,15 @@ std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
    return layer->GetBinderId();
 }
-Kernel::KReadableEvent* NVFlinger::FindVsyncEvent(u64 display_id) {
+ResultVal<Kernel::KReadableEvent*> NVFlinger::FindVsyncEvent(u64 display_id) {
    const auto lock_guard = Lock();
    auto* const display = FindDisplay(display_id);
    if (display == nullptr) {
-        return nullptr;
+        return VI::ResultNotFound;
    }
-    return &display->GetVSyncEvent();
+    return display->GetVSyncEvent();
 }
 VI::Display* NVFlinger::FindDisplay(u64 display_id) {
diff --git a/src/core/hle/service/nvflinger/nvflinger.h b/src/core/hle/service/nvflinger/nvflinger.h
index 044ac6ac8..3bbe5d92b 100644
--- a/src/core/hle/service/nvflinger/nvflinger.h
+++ b/src/core/hle/service/nvflinger/nvflinger.h
@@ -11,6 +11,7 @@
 #include <vector>
 #include "common/common_types.h"
+#include "core/hle/result.h"
 #include "core/hle/service/kernel_helpers.h"
 namespace Common {
@@ -71,8 +72,9 @@ public:
    /// Gets the vsync event for the specified display.
    ///
-    /// If an invalid display ID is provided, then nullptr is returned.
+    /// If an invalid display ID is provided, then VI::ResultNotFound is returned.
-    [[nodiscard]] Kernel::KReadableEvent* FindVsyncEvent(u64 display_id);
+    /// If the vsync event has already been retrieved, then VI::ResultPermissionDenied is returned.
+    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> FindVsyncEvent(u64 display_id);
    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
    /// finished.
diff --git a/src/core/hle/service/vi/display/vi_display.cpp b/src/core/hle/service/vi/display/vi_display.cpp
index b34febb50..aa49aa775 100644
--- a/src/core/hle/service/vi/display/vi_display.cpp
+++ b/src/core/hle/service/vi/display/vi_display.cpp
@@ -19,6 +19,7 @@
 #include "core/hle/service/nvflinger/hos_binder_driver_server.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
+#include "core/hle/service/vi/vi_results.h"
 namespace Service::VI {
@@ -55,8 +56,18 @@ const Layer& Display::GetLayer(std::size_t index) const {
    return *layers.at(index);
 }
-Kernel::KReadableEvent& Display::GetVSyncEvent() {
+ResultVal<Kernel::KReadableEvent*> Display::GetVSyncEvent() {
-    return vsync_event->GetReadableEvent();
+    if (got_vsync_event) {
+        return ResultPermissionDenied;
+    }
+    got_vsync_event = true;
+    return GetVSyncEventUnchecked();
+}
+Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() {
+    return &vsync_event->GetReadableEvent();
 }
 void Display::SignalVSyncEvent() {
diff --git a/src/core/hle/service/vi/display/vi_display.h b/src/core/hle/service/vi/display/vi_display.h
index 3838bb599..8dbb0ef80 100644
--- a/src/core/hle/service/vi/display/vi_display.h
+++ b/src/core/hle/service/vi/display/vi_display.h
@@ -9,6 +9,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "core/hle/result.h"
 namespace Kernel {
 class KEvent;
@@ -73,8 +74,16 @@ public:
        return layers.size();
    }
-    /// Gets the readable vsync event.
+    /**
-    Kernel::KReadableEvent& GetVSyncEvent();
+     * Gets the internal vsync event.
+     *
+     * @returns The internal Vsync event if it has not yet been retrieved,
+     *          VI::ResultPermissionDenied otherwise.
+     */
+    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> GetVSyncEvent();
+    /// Gets the internal vsync event.
+    Kernel::KReadableEvent* GetVSyncEventUnchecked();
    /// Signals the internal vsync event.
    void SignalVSyncEvent();
@@ -118,6 +127,7 @@ private:
    std::vector<std::unique_ptr<Layer>> layers;
    Kernel::KEvent* vsync_event{};
+    bool got_vsync_event{false};
 };
 } // namespace Service::VI
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index 546879648..f083811ec 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -29,16 +29,12 @@
 #include "core/hle/service/service.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_m.h"
+#include "core/hle/service/vi/vi_results.h"
 #include "core/hle/service/vi/vi_s.h"
 #include "core/hle/service/vi/vi_u.h"
 namespace Service::VI {
-constexpr Result ERR_OPERATION_FAILED{ErrorModule::VI, 1};
-constexpr Result ERR_PERMISSION_DENIED{ErrorModule::VI, 5};
-constexpr Result ERR_UNSUPPORTED{ErrorModule::VI, 6};
-constexpr Result ERR_NOT_FOUND{ErrorModule::VI, 7};
 struct DisplayInfo {
    /// The name of this particular display.
    char display_name[0x40]{"Default"};
@@ -348,7 +344,7 @@ private:
        if (!layer_id) {
            LOG_ERROR(Service_VI, "Layer not found! display=0x{:016X}", display);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -498,7 +494,7 @@ private:
        if (!display_id) {
            LOG_ERROR(Service_VI, "Display not found! display_name={}", name);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -554,14 +550,14 @@ private:
        if (scaling_mode > NintendoScaleMode::PreserveAspectRatio) {
            LOG_ERROR(Service_VI, "Invalid scaling mode provided.");
-            rb.Push(ERR_OPERATION_FAILED);
+            rb.Push(ResultOperationFailed);
            return;
        }
        if (scaling_mode != NintendoScaleMode::ScaleToWindow &&
            scaling_mode != NintendoScaleMode::PreserveAspectRatio) {
            LOG_ERROR(Service_VI, "Unsupported scaling mode supplied.");
-            rb.Push(ERR_UNSUPPORTED);
+            rb.Push(ResultNotSupported);
            return;
        }
@@ -594,7 +590,7 @@ private:
        if (!display_id) {
            LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -602,7 +598,7 @@ private:
        if (!buffer_queue_id) {
            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -640,7 +636,7 @@ private:
        if (!layer_id) {
            LOG_ERROR(Service_VI, "Layer not found! display_id={}", display_id);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -648,7 +644,7 @@ private:
        if (!buffer_queue_id) {
            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(ResultNotFound);
            return;
        }
@@ -675,19 +671,23 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 display_id = rp.Pop<u64>();
-        LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
+        LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
        const auto vsync_event = nv_flinger.FindVsyncEvent(display_id);
-        if (!vsync_event) {
+        if (vsync_event.Failed()) {
-            LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
+            const auto result = vsync_event.Code();
+            if (result == ResultNotFound) {
+                LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
+            }
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_FOUND);
+            rb.Push(result);
            return;
        }
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(vsync_event);
+        rb.PushCopyObjects(*vsync_event);
    }
    void ConvertScalingMode(Kernel::HLERequestContext& ctx) {
@@ -764,7 +764,7 @@ private:
            return ConvertedScaleMode::PreserveAspectRatio;
        default:
            LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
-            return ERR_OPERATION_FAILED;
+            return ResultOperationFailed;
        }
    }
@@ -794,7 +794,7 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, Core::System&
    if (!IsValidServiceAccess(permission, policy)) {
        LOG_ERROR(Service_VI, "Permission denied for policy {}", policy);
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_PERMISSION_DENIED);
+        rb.Push(ResultPermissionDenied);
        return;
    }
diff --git a/src/core/hle/service/vi/vi_results.h b/src/core/hle/service/vi/vi_results.h
new file mode 100644
index 000000000..a46c247d2
--- /dev/null
+++ b/src/core/hle/service/vi/vi_results.h
@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include "core/hle/result.h"
+namespace Service::VI {
+constexpr Result ResultOperationFailed{ErrorModule::VI, 1};
+constexpr Result ResultPermissionDenied{ErrorModule::VI, 5};
+constexpr Result ResultNotSupported{ErrorModule::VI, 6};
+constexpr Result ResultNotFound{ErrorModule::VI, 7};
+} // namespace Service::VI
diff --git a/src/core/internal_network/network_interface.cpp b/src/core/internal_network/network_interface.cpp
index 0f0a66160..057fd3661 100644
--- a/src/core/internal_network/network_interface.cpp
+++ b/src/core/internal_network/network_interface.cpp
@@ -188,7 +188,7 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
 std::optional<NetworkInterface> GetSelectedNetworkInterface() {
    const auto& selected_network_interface = Settings::values.network_interface.GetValue();
    const auto network_interfaces = Network::GetAvailableNetworkInterfaces();
-    if (network_interfaces.size() == 0) {
+    if (network_interfaces.empty()) {
        LOG_ERROR(Network, "GetAvailableNetworkInterfaces returned no interfaces");
        return std::nullopt;
    }
@@ -206,4 +206,14 @@ std::optional<NetworkInterface> GetSelectedNetworkInterface() {
    return *res;
 }
+void SelectFirstNetworkInterface() {
+    const auto network_interfaces = Network::GetAvailableNetworkInterfaces();
+    if (network_interfaces.empty()) {
+        return;
+    }
+    Settings::values.network_interface.SetValue(network_interfaces[0].name);
+}
 } // namespace Network
diff --git a/src/core/internal_network/network_interface.h b/src/core/internal_network/network_interface.h
index 9b98b6b42..175e61b1f 100644
--- a/src/core/internal_network/network_interface.h
+++ b/src/core/internal_network/network_interface.h
@@ -24,5 +24,6 @@ struct NetworkInterface {
 std::vector<NetworkInterface> GetAvailableNetworkInterfaces();
 std::optional<NetworkInterface> GetSelectedNetworkInterface();
+void SelectFirstNetworkInterface();
 } // namespace Network
diff --git a/src/core/internal_network/socket_proxy.cpp b/src/core/internal_network/socket_proxy.cpp
index 0c746bd82..7d5d37bbc 100644
--- a/src/core/internal_network/socket_proxy.cpp
+++ b/src/core/internal_network/socket_proxy.cpp
@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/zstd_compression.h"
 #include "core/internal_network/network.h"
 #include "core/internal_network/network_interface.h"
 #include "core/internal_network/socket_proxy.h"
@@ -32,8 +33,11 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) {
        return;
    }
+    auto decompressed = packet;
+    decompressed.data = Common::Compression::DecompressDataZSTD(packet.data);
    std::lock_guard guard(packets_mutex);
-    received_packets.push(packet);
+    received_packets.push(decompressed);
 }
 template <typename T>
@@ -185,6 +189,8 @@ std::pair<s32, Errno> ProxySocket::Send(const std::vector<u8>& message, int flag
 void ProxySocket::SendPacket(ProxyPacket& packet) {
    if (auto room_member = room_network.GetRoomMember().lock()) {
        if (room_member->IsConnected()) {
+            packet.data = Common::Compression::CompressDataZSTDDefault(packet.data.data(),
+                                                                       packet.data.size());
            room_member->SendProxyPacket(packet);
        }
    }
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index 104d16efa..f24474ed8 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -244,6 +244,10 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
 std::unique_ptr<AppLoader> GetLoader(Core::System& system, FileSys::VirtualFile file,
                                     u64 program_id, std::size_t program_index) {
+    if (!file) {
+        return nullptr;
+    }
    FileType type = IdentifyFile(file);
    const FileType filename_type = GuessFromFilename(file->GetName());
diff --git a/src/dedicated_room/yuzu_room.cpp b/src/dedicated_room/yuzu_room.cpp
index 7b6deba41..359891883 100644
--- a/src/dedicated_room/yuzu_room.cpp
+++ b/src/dedicated_room/yuzu_room.cpp
@@ -76,7 +76,18 @@ static constexpr char BanListMagic[] = "YuzuRoom-BanList-1";
 static constexpr char token_delimiter{':'};
 static void PadToken(std::string& token) {
-    while (token.size() % 4 != 0) {
+    std::size_t outlen = 0;
+    std::array<unsigned char, 512> output{};
+    std::array<unsigned char, 2048> roundtrip{};
+    for (size_t i = 0; i < 3; i++) {
+        mbedtls_base64_decode(output.data(), output.size(), &outlen,
+                              reinterpret_cast<const unsigned char*>(token.c_str()),
+                              token.length());
+        mbedtls_base64_encode(roundtrip.data(), roundtrip.size(), &outlen, output.data(), outlen);
+        if (memcmp(roundtrip.data(), token.data(), token.size()) == 0) {
+            break;
+        }
        token.push_back('=');
    }
 }
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 4b91b88ce..2cf9eb97f 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -18,6 +18,8 @@ add_library(input_common STATIC
    drivers/touch_screen.h
    drivers/udp_client.cpp
    drivers/udp_client.h
+    drivers/virtual_amiibo.cpp
+    drivers/virtual_amiibo.h
    helpers/stick_from_buttons.cpp
    helpers/stick_from_buttons.h
    helpers/touch_from_buttons.cpp
diff --git a/src/input_common/drivers/virtual_amiibo.cpp b/src/input_common/drivers/virtual_amiibo.cpp
new file mode 100644
index 000000000..0cd5129da
--- /dev/null
+++ b/src/input_common/drivers/virtual_amiibo.cpp
@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include <cstring>
+#include <fmt/format.h>
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "input_common/drivers/virtual_amiibo.h"
+namespace InputCommon {
+constexpr PadIdentifier identifier = {
+    .guid = Common::UUID{},
+    .port = 0,
+    .pad = 0,
+};
+VirtualAmiibo::VirtualAmiibo(std::string input_engine_) : InputEngine(std::move(input_engine_)) {}
+VirtualAmiibo::~VirtualAmiibo() = default;
+Common::Input::PollingError VirtualAmiibo::SetPollingMode(
+    [[maybe_unused]] const PadIdentifier& identifier_,
+    const Common::Input::PollingMode polling_mode_) {
+    polling_mode = polling_mode_;
+    if (polling_mode == Common::Input::PollingMode::NFC) {
+        if (state == State::Initialized) {
+            state = State::WaitingForAmiibo;
+        }
+    } else {
+        if (state == State::AmiiboIsOpen) {
+            CloseAmiibo();
+        }
+    }
+    return Common::Input::PollingError::None;
+}
+Common::Input::NfcState VirtualAmiibo::SupportsNfc(
+    [[maybe_unused]] const PadIdentifier& identifier_) const {
+    return Common::Input::NfcState::Success;
+}
+Common::Input::NfcState VirtualAmiibo::WriteNfcData(
+    [[maybe_unused]] const PadIdentifier& identifier_, const std::vector<u8>& data) {
+    const Common::FS::IOFile amiibo_file{file_path, Common::FS::FileAccessMode::ReadWrite,
+                                         Common::FS::FileType::BinaryFile};
+    if (!amiibo_file.IsOpen()) {
+        LOG_ERROR(Core, "Amiibo is already on use");
+        return Common::Input::NfcState::WriteFailed;
+    }
+    if (!amiibo_file.Write(data)) {
+        LOG_ERROR(Service_NFP, "Error writting to file");
+        return Common::Input::NfcState::WriteFailed;
+    }
+    return Common::Input::NfcState::Success;
+}
+VirtualAmiibo::State VirtualAmiibo::GetCurrentState() const {
+    return state;
+}
+VirtualAmiibo::Info VirtualAmiibo::LoadAmiibo(const std::string& filename) {
+    const Common::FS::IOFile amiibo_file{filename, Common::FS::FileAccessMode::Read,
+                                         Common::FS::FileType::BinaryFile};
+    if (state != State::WaitingForAmiibo) {
+        return Info::WrongDeviceState;
+    }
+    if (!amiibo_file.IsOpen()) {
+        return Info::UnableToLoad;
+    }
+    amiibo_data.resize(amiibo_size);
+    if (amiibo_file.Read(amiibo_data) < amiibo_size_without_password) {
+        return Info::NotAnAmiibo;
+    }
+    file_path = filename;
+    state = State::AmiiboIsOpen;
+    SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, amiibo_data});
+    return Info::Success;
+}
+VirtualAmiibo::Info VirtualAmiibo::CloseAmiibo() {
+    state = polling_mode == Common::Input::PollingMode::NFC ? State::WaitingForAmiibo
+                                                            : State::Initialized;
+    SetNfc(identifier, {Common::Input::NfcState::AmiiboRemoved, {}});
+    return Info::Success;
+}
+} // namespace InputCommon
diff --git a/src/input_common/drivers/virtual_amiibo.h b/src/input_common/drivers/virtual_amiibo.h
new file mode 100644
index 000000000..9eac07544
--- /dev/null
+++ b/src/input_common/drivers/virtual_amiibo.h
@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+#include <array>
+#include <string>
+#include <vector>
+#include "common/common_types.h"
+#include "input_common/input_engine.h"
+namespace Common::FS {
+class IOFile;
+}
+namespace InputCommon {
+class VirtualAmiibo final : public InputEngine {
+public:
+    enum class State {
+        Initialized,
+        WaitingForAmiibo,
+        AmiiboIsOpen,
+    };
+    enum class Info {
+        Success,
+        UnableToLoad,
+        NotAnAmiibo,
+        WrongDeviceState,
+        Unknown,
+    };
+    explicit VirtualAmiibo(std::string input_engine_);
+    ~VirtualAmiibo() override;
+    // Sets polling mode to a controller
+    Common::Input::PollingError SetPollingMode(
+        const PadIdentifier& identifier_, const Common::Input::PollingMode polling_mode_) override;
+    Common::Input::NfcState SupportsNfc(const PadIdentifier& identifier_) const override;
+    Common::Input::NfcState WriteNfcData(const PadIdentifier& identifier_,
+                                         const std::vector<u8>& data) override;
+    State GetCurrentState() const;
+    Info LoadAmiibo(const std::string& amiibo_file);
+    Info CloseAmiibo();
+private:
+    static constexpr std::size_t amiibo_size = 0x21C;
+    static constexpr std::size_t amiibo_size_without_password = amiibo_size - 0x8;
+    std::string file_path{};
+    State state{State::Initialized};
+    std::vector<u8> amiibo_data;
+    Common::Input::PollingMode polling_mode{Common::Input::PollingMode::Pasive};
+};
+} // namespace InputCommon
diff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cpp
index 6ede0e4b0..61cfd0911 100644
--- a/src/input_common/input_engine.cpp
+++ b/src/input_common/input_engine.cpp
@@ -102,6 +102,17 @@ void InputEngine::SetCamera(const PadIdentifier& identifier,
    TriggerOnCameraChange(identifier, value);
 }
+void InputEngine::SetNfc(const PadIdentifier& identifier, const Common::Input::NfcStatus& value) {
+    {
+        std::scoped_lock lock{mutex};
+        ControllerData& controller = controller_list.at(identifier);
+        if (!configuring) {
+            controller.nfc = value;
+        }
+    }
+    TriggerOnNfcChange(identifier, value);
+}
 bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
    std::scoped_lock lock{mutex};
    const auto controller_iter = controller_list.find(identifier);
@@ -189,6 +200,18 @@ Common::Input::CameraStatus InputEngine::GetCamera(const PadIdentifier& identifi
    return controller.camera;
 }
+Common::Input::NfcStatus InputEngine::GetNfc(const PadIdentifier& identifier) const {
+    std::scoped_lock lock{mutex};
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
+                  identifier.pad, identifier.port);
+        return {};
+    }
+    const ControllerData& controller = controller_iter->second;
+    return controller.nfc;
+}
 void InputEngine::ResetButtonState() {
    for (const auto& controller : controller_list) {
        for (const auto& button : controller.second.buttons) {
@@ -355,6 +378,20 @@ void InputEngine::TriggerOnCameraChange(const PadIdentifier& identifier,
    }
 }
+void InputEngine::TriggerOnNfcChange(const PadIdentifier& identifier,
+                                     [[maybe_unused]] const Common::Input::NfcStatus& value) {
+    std::scoped_lock lock{mutex_callback};
+    for (const auto& poller_pair : callback_list) {
+        const InputIdentifier& poller = poller_pair.second;
+        if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Nfc, 0)) {
+            continue;
+        }
+        if (poller.callback.on_change) {
+            poller.callback.on_change();
+        }
+    }
+}
 bool InputEngine::IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                         const PadIdentifier& identifier, EngineInputType type,
                                         int index) const {
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index f6b3c4610..cfbdb26bd 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -42,6 +42,7 @@ enum class EngineInputType {
    Camera,
    HatButton,
    Motion,
+    Nfc,
 };
 namespace std {
@@ -127,6 +128,18 @@ public:
        return Common::Input::CameraError::NotSupported;
    }
+    // Request nfc data from a controller
+    virtual Common::Input::NfcState SupportsNfc(
+        [[maybe_unused]] const PadIdentifier& identifier) const {
+        return Common::Input::NfcState::NotSupported;
+    }
+    // Writes data to an nfc tag
+    virtual Common::Input::NfcState WriteNfcData([[maybe_unused]] const PadIdentifier& identifier,
+                                                 [[maybe_unused]] const std::vector<u8>& data) {
+        return Common::Input::NfcState::NotSupported;
+    }
    // Returns the engine name
    [[nodiscard]] const std::string& GetEngineName() const;
@@ -183,6 +196,7 @@ public:
    Common::Input::BatteryLevel GetBattery(const PadIdentifier& identifier) const;
    BasicMotion GetMotion(const PadIdentifier& identifier, int motion) const;
    Common::Input::CameraStatus GetCamera(const PadIdentifier& identifier) const;
+    Common::Input::NfcStatus GetNfc(const PadIdentifier& identifier) const;
    int SetCallback(InputIdentifier input_identifier);
    void SetMappingCallback(MappingCallback callback);
@@ -195,6 +209,7 @@ protected:
    void SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value);
    void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
    void SetCamera(const PadIdentifier& identifier, const Common::Input::CameraStatus& value);
+    void SetNfc(const PadIdentifier& identifier, const Common::Input::NfcStatus& value);
    virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
        return "Unknown";
@@ -208,6 +223,7 @@ private:
        std::unordered_map<int, BasicMotion> motions;
        Common::Input::BatteryLevel battery{};
        Common::Input::CameraStatus camera{};
+        Common::Input::NfcStatus nfc{};
    };
    void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
@@ -218,6 +234,7 @@ private:
                               const BasicMotion& value);
    void TriggerOnCameraChange(const PadIdentifier& identifier,
                               const Common::Input::CameraStatus& value);
+    void TriggerOnNfcChange(const PadIdentifier& identifier, const Common::Input::NfcStatus& value);
    bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                const PadIdentifier& identifier, EngineInputType type,
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index ffb9b945e..75705b67e 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -705,6 +705,47 @@ private:
    InputEngine* input_engine;
 };
+class InputFromNfc final : public Common::Input::InputDevice {
+public:
+    explicit InputFromNfc(PadIdentifier identifier_, InputEngine* input_engine_)
+        : identifier(identifier_), input_engine(input_engine_) {
+        UpdateCallback engine_callback{[this]() { OnChange(); }};
+        const InputIdentifier input_identifier{
+            .identifier = identifier,
+            .type = EngineInputType::Nfc,
+            .index = 0,
+            .callback = engine_callback,
+        };
+        callback_key = input_engine->SetCallback(input_identifier);
+    }
+    ~InputFromNfc() override {
+        input_engine->DeleteCallback(callback_key);
+    }
+    Common::Input::NfcStatus GetStatus() const {
+        return input_engine->GetNfc(identifier);
+    }
+    void ForceUpdate() override {
+        OnChange();
+    }
+    void OnChange() {
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Nfc,
+            .nfc_status = GetStatus(),
+        };
+        TriggerOnChange(status);
+    }
+private:
+    const PadIdentifier identifier;
+    int callback_key;
+    InputEngine* input_engine;
+};
 class OutputFromIdentifier final : public Common::Input::OutputDevice {
 public:
    explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
@@ -727,6 +768,14 @@ public:
        return input_engine->SetCameraFormat(identifier, camera_format);
    }
+    Common::Input::NfcState SupportsNfc() const override {
+        return input_engine->SupportsNfc(identifier);
+    }
+    Common::Input::NfcState WriteNfcData(const std::vector<u8>& data) override {
+        return input_engine->WriteNfcData(identifier, data);
+    }
 private:
    const PadIdentifier identifier;
    InputEngine* input_engine;
@@ -978,6 +1027,18 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateCameraDevice(
    return std::make_unique<InputFromCamera>(identifier, input_engine.get());
 }
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateNfcDevice(
+    const Common::ParamPackage& params) {
+    const PadIdentifier identifier = {
+        .guid = Common::UUID{params.Get("guid", "")},
+        .port = static_cast<std::size_t>(params.Get("port", 0)),
+        .pad = static_cast<std::size_t>(params.Get("pad", 0)),
+    };
+    input_engine->PreSetController(identifier);
+    return std::make_unique<InputFromNfc>(identifier, input_engine.get());
+}
 InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
    : input_engine(std::move(input_engine_)) {}
@@ -989,6 +1050,9 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::Create(
    if (params.Has("camera")) {
        return CreateCameraDevice(params);
    }
+    if (params.Has("nfc")) {
+        return CreateNfcDevice(params);
+    }
    if (params.Has("button") && params.Has("axis")) {
        return CreateTriggerDevice(params);
    }
diff --git a/src/input_common/input_poller.h b/src/input_common/input_poller.h
index 4410a8415..d7db13ce4 100644
--- a/src/input_common/input_poller.h
+++ b/src/input_common/input_poller.h
@@ -222,6 +222,16 @@ private:
    std::unique_ptr<Common::Input::InputDevice> CreateCameraDevice(
        const Common::ParamPackage& params);
+    /**
+     * Creates a nfc device from the parameters given.
+     * @param params contains parameters for creating the device:
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
+     */
+    std::unique_ptr<Common::Input::InputDevice> CreateNfcDevice(const Common::ParamPackage& params);
    std::shared_ptr<InputEngine> input_engine;
 };
 } // namespace InputCommon
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 75a57b9fc..b2064ef95 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -11,6 +11,7 @@
 #include "input_common/drivers/tas_input.h"
 #include "input_common/drivers/touch_screen.h"
 #include "input_common/drivers/udp_client.h"
+#include "input_common/drivers/virtual_amiibo.h"
 #include "input_common/helpers/stick_from_buttons.h"
 #include "input_common/helpers/touch_from_buttons.h"
 #include "input_common/input_engine.h"
@@ -87,6 +88,15 @@ struct InputSubsystem::Impl {
        Common::Input::RegisterFactory<Common::Input::OutputDevice>(camera->GetEngineName(),
                                                                    camera_output_factory);
+        virtual_amiibo = std::make_shared<VirtualAmiibo>("virtual_amiibo");
+        virtual_amiibo->SetMappingCallback(mapping_callback);
+        virtual_amiibo_input_factory = std::make_shared<InputFactory>(virtual_amiibo);
+        virtual_amiibo_output_factory = std::make_shared<OutputFactory>(virtual_amiibo);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(virtual_amiibo->GetEngineName(),
+                                                                   virtual_amiibo_input_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(virtual_amiibo->GetEngineName(),
+                                                                    virtual_amiibo_output_factory);
 #ifdef HAVE_SDL2
        sdl = std::make_shared<SDLDriver>("sdl");
        sdl->SetMappingCallback(mapping_callback);
@@ -327,6 +337,7 @@ struct InputSubsystem::Impl {
    std::shared_ptr<TasInput::Tas> tas_input;
    std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
    std::shared_ptr<Camera> camera;
+    std::shared_ptr<VirtualAmiibo> virtual_amiibo;
    std::shared_ptr<InputFactory> keyboard_factory;
    std::shared_ptr<InputFactory> mouse_factory;
@@ -335,6 +346,7 @@ struct InputSubsystem::Impl {
    std::shared_ptr<InputFactory> udp_client_input_factory;
    std::shared_ptr<InputFactory> tas_input_factory;
    std::shared_ptr<InputFactory> camera_input_factory;
+    std::shared_ptr<InputFactory> virtual_amiibo_input_factory;
    std::shared_ptr<OutputFactory> keyboard_output_factory;
    std::shared_ptr<OutputFactory> mouse_output_factory;
@@ -342,6 +354,7 @@ struct InputSubsystem::Impl {
    std::shared_ptr<OutputFactory> udp_client_output_factory;
    std::shared_ptr<OutputFactory> tas_output_factory;
    std::shared_ptr<OutputFactory> camera_output_factory;
+    std::shared_ptr<OutputFactory> virtual_amiibo_output_factory;
 #ifdef HAVE_SDL2
    std::shared_ptr<SDLDriver> sdl;
@@ -402,6 +415,14 @@ const Camera* InputSubsystem::GetCamera() const {
    return impl->camera.get();
 }
+VirtualAmiibo* InputSubsystem::GetVirtualAmiibo() {
+    return impl->virtual_amiibo.get();
+}
+const VirtualAmiibo* InputSubsystem::GetVirtualAmiibo() const {
+    return impl->virtual_amiibo.get();
+}
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
    return impl->GetInputDevices();
 }
diff --git a/src/input_common/main.h b/src/input_common/main.h
index 9a969e747..ced252383 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -33,6 +33,7 @@ class Camera;
 class Keyboard;
 class Mouse;
 class TouchScreen;
+class VirtualAmiibo;
 struct MappingData;
 } // namespace InputCommon
@@ -101,6 +102,12 @@ public:
    /// Retrieves the underlying camera input device.
    [[nodiscard]] const Camera* GetCamera() const;
+    /// Retrieves the underlying virtual amiibo input device.
+    [[nodiscard]] VirtualAmiibo* GetVirtualAmiibo();
+    /// Retrieves the underlying virtual amiibo input device.
+    [[nodiscard]] const VirtualAmiibo* GetVirtualAmiibo() const;
    /**
     * Returns all available input devices that this Factory can create a new device with.
     * Each returned ParamPackage should have a `display` field used for display, a `engine` field
diff --git a/src/network/room.cpp b/src/network/room.cpp
index 8c63b255b..dc5dbce7f 100644
--- a/src/network/room.cpp
+++ b/src/network/room.cpp
@@ -212,6 +212,12 @@ public:
    void HandleProxyPacket(const ENetEvent* event);
    /**
+     * Broadcasts this packet to all members except the sender.
+     * @param event The ENet event containing the data
+     */
+    void HandleLdnPacket(const ENetEvent* event);
+    /**
     * Extracts a chat entry from a received ENet packet and adds it to the chat queue.
     * @param event The ENet event that was received.
     */
@@ -247,6 +253,9 @@ void Room::RoomImpl::ServerLoop() {
                case IdProxyPacket:
                    HandleProxyPacket(&event);
                    break;
+                case IdLdnPacket:
+                    HandleLdnPacket(&event);
+                    break;
                case IdChatMessage:
                    HandleChatPacket(&event);
                    break;
@@ -861,6 +870,60 @@ void Room::RoomImpl::HandleProxyPacket(const ENetEvent* event) {
    enet_host_flush(server);
 }
+void Room::RoomImpl::HandleLdnPacket(const ENetEvent* event) {
+    Packet in_packet;
+    in_packet.Append(event->packet->data, event->packet->dataLength);
+    in_packet.IgnoreBytes(sizeof(u8)); // Message type
+    in_packet.IgnoreBytes(sizeof(u8));          // LAN packet type
+    in_packet.IgnoreBytes(sizeof(IPv4Address)); // Local IP
+    IPv4Address remote_ip;
+    in_packet.Read(remote_ip); // Remote IP
+    bool broadcast;
+    in_packet.Read(broadcast); // Broadcast
+    Packet out_packet;
+    out_packet.Append(event->packet->data, event->packet->dataLength);
+    ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(),
+                                                 ENET_PACKET_FLAG_RELIABLE);
+    const auto& destination_address = remote_ip;
+    if (broadcast) { // Send the data to everyone except the sender
+        std::lock_guard lock(member_mutex);
+        bool sent_packet = false;
+        for (const auto& member : members) {
+            if (member.peer != event->peer) {
+                sent_packet = true;
+                enet_peer_send(member.peer, 0, enet_packet);
+            }
+        }
+        if (!sent_packet) {
+            enet_packet_destroy(enet_packet);
+        }
+    } else {
+        std::lock_guard lock(member_mutex);
+        auto member = std::find_if(members.begin(), members.end(),
+                                   [destination_address](const Member& member_entry) -> bool {
+                                       return member_entry.fake_ip == destination_address;
+                                   });
+        if (member != members.end()) {
+            enet_peer_send(member->peer, 0, enet_packet);
+        } else {
+            LOG_ERROR(Network,
+                      "Attempting to send to unknown IP address: "
+                      "{}.{}.{}.{}",
+                      destination_address[0], destination_address[1], destination_address[2],
+                      destination_address[3]);
+            enet_packet_destroy(enet_packet);
+        }
+    }
+    enet_host_flush(server);
+}
 void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) {
    Packet in_packet;
    in_packet.Append(event->packet->data, event->packet->dataLength);
diff --git a/src/network/room.h b/src/network/room.h
index c2a4b1a70..edbd3ecfb 100644
--- a/src/network/room.h
+++ b/src/network/room.h
@@ -40,6 +40,7 @@ enum RoomMessageTypes : u8 {
    IdRoomInformation,
    IdSetGameInfo,
    IdProxyPacket,
+    IdLdnPacket,
    IdChatMessage,
    IdNameCollision,
    IdIpCollision,
diff --git a/src/network/room_member.cpp b/src/network/room_member.cpp
index 06818af78..b94cb24ad 100644
--- a/src/network/room_member.cpp
+++ b/src/network/room_member.cpp
@@ -58,6 +58,7 @@ public:
    private:
        CallbackSet<ProxyPacket> callback_set_proxy_packet;
+        CallbackSet<LDNPacket> callback_set_ldn_packet;
        CallbackSet<ChatEntry> callback_set_chat_messages;
        CallbackSet<StatusMessageEntry> callback_set_status_messages;
        CallbackSet<RoomInformation> callback_set_room_information;
@@ -108,6 +109,12 @@ public:
    void HandleProxyPackets(const ENetEvent* event);
    /**
+     * Extracts an LdnPacket from a received ENet packet.
+     * @param event The ENet event that was received.
+     */
+    void HandleLdnPackets(const ENetEvent* event);
+    /**
     * Extracts a chat entry from a received ENet packet and adds it to the chat queue.
     * @param event The ENet event that was received.
     */
@@ -166,6 +173,9 @@ void RoomMember::RoomMemberImpl::MemberLoop() {
                case IdProxyPacket:
                    HandleProxyPackets(&event);
                    break;
+                case IdLdnPacket:
+                    HandleLdnPackets(&event);
+                    break;
                case IdChatMessage:
                    HandleChatPacket(&event);
                    break;
@@ -372,6 +382,27 @@ void RoomMember::RoomMemberImpl::HandleProxyPackets(const ENetEvent* event) {
    Invoke<ProxyPacket>(proxy_packet);
 }
+void RoomMember::RoomMemberImpl::HandleLdnPackets(const ENetEvent* event) {
+    LDNPacket ldn_packet{};
+    Packet packet;
+    packet.Append(event->packet->data, event->packet->dataLength);
+    // Ignore the first byte, which is the message id.
+    packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
+    u8 packet_type;
+    packet.Read(packet_type);
+    ldn_packet.type = static_cast<LDNPacketType>(packet_type);
+    packet.Read(ldn_packet.local_ip);
+    packet.Read(ldn_packet.remote_ip);
+    packet.Read(ldn_packet.broadcast);
+    packet.Read(ldn_packet.data);
+    Invoke<LDNPacket>(ldn_packet);
+}
 void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) {
    Packet packet;
    packet.Append(event->packet->data, event->packet->dataLength);
@@ -450,6 +481,11 @@ RoomMember::RoomMemberImpl::CallbackSet<ProxyPacket>& RoomMember::RoomMemberImpl
 }
 template <>
+RoomMember::RoomMemberImpl::CallbackSet<LDNPacket>& RoomMember::RoomMemberImpl::Callbacks::Get() {
+    return callback_set_ldn_packet;
+}
+template <>
 RoomMember::RoomMemberImpl::CallbackSet<RoomMember::State>&
 RoomMember::RoomMemberImpl::Callbacks::Get() {
    return callback_set_state;
@@ -607,6 +643,21 @@ void RoomMember::SendProxyPacket(const ProxyPacket& proxy_packet) {
    room_member_impl->Send(std::move(packet));
 }
+void RoomMember::SendLdnPacket(const LDNPacket& ldn_packet) {
+    Packet packet;
+    packet.Write(static_cast<u8>(IdLdnPacket));
+    packet.Write(static_cast<u8>(ldn_packet.type));
+    packet.Write(ldn_packet.local_ip);
+    packet.Write(ldn_packet.remote_ip);
+    packet.Write(ldn_packet.broadcast);
+    packet.Write(ldn_packet.data);
+    room_member_impl->Send(std::move(packet));
+}
 void RoomMember::SendChatMessage(const std::string& message) {
    Packet packet;
    packet.Write(static_cast<u8>(IdChatMessage));
@@ -663,6 +714,11 @@ RoomMember::CallbackHandle<ProxyPacket> RoomMember::BindOnProxyPacketReceived(
    return room_member_impl->Bind(callback);
 }
+RoomMember::CallbackHandle<LDNPacket> RoomMember::BindOnLdnPacketReceived(
+    std::function<void(const LDNPacket&)> callback) {
+    return room_member_impl->Bind(std::move(callback));
+}
 RoomMember::CallbackHandle<RoomInformation> RoomMember::BindOnRoomInformationChanged(
    std::function<void(const RoomInformation&)> callback) {
    return room_member_impl->Bind(callback);
@@ -699,6 +755,7 @@ void RoomMember::Leave() {
 }
 template void RoomMember::Unbind(CallbackHandle<ProxyPacket>);
+template void RoomMember::Unbind(CallbackHandle<LDNPacket>);
 template void RoomMember::Unbind(CallbackHandle<RoomMember::State>);
 template void RoomMember::Unbind(CallbackHandle<RoomMember::Error>);
 template void RoomMember::Unbind(CallbackHandle<RoomInformation>);
diff --git a/src/network/room_member.h b/src/network/room_member.h
index f578f7f6a..0d6417294 100644
--- a/src/network/room_member.h
+++ b/src/network/room_member.h
@@ -17,7 +17,24 @@ namespace Network {
 using AnnounceMultiplayerRoom::GameInfo;
 using AnnounceMultiplayerRoom::RoomInformation;
-/// Information about the received WiFi packets.
+enum class LDNPacketType : u8 {
+    Scan,
+    ScanResp,
+    Connect,
+    SyncNetwork,
+    Disconnect,
+    DestroyNetwork,
+};
+struct LDNPacket {
+    LDNPacketType type;
+    IPv4Address local_ip;
+    IPv4Address remote_ip;
+    bool broadcast;
+    std::vector<u8> data;
+};
+/// Information about the received proxy packets.
 struct ProxyPacket {
    SockAddrIn local_endpoint;
    SockAddrIn remote_endpoint;
@@ -152,6 +169,12 @@ public:
    void SendProxyPacket(const ProxyPacket& packet);
    /**
+     * Sends an LDN packet to the room.
+     * @param packet The WiFi packet to send.
+     */
+    void SendLdnPacket(const LDNPacket& packet);
+    /**
     * Sends a chat message to the room.
     * @param message The contents of the message.
     */
@@ -205,6 +228,16 @@ public:
        std::function<void(const ProxyPacket&)> callback);
    /**
+     * Binds a function to an event that will be triggered every time an LDNPacket is received.
+     * The function wil be called everytime the event is triggered.
+     * The callback function must not bind or unbind a function. Doing so will cause a deadlock
+     * @param callback The function to call
+     * @return A handle used for removing the function from the registered list
+     */
+    CallbackHandle<LDNPacket> BindOnLdnPacketReceived(
+        std::function<void(const LDNPacket&)> callback);
+    /**
     * Binds a function to an event that will be triggered every time the RoomInformation changes.
     * The function wil be called every time the event is triggered.
     * The callback function must not bind or unbind a function. Doing so will cause a deadlock
diff --git a/src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp b/src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp
index b5c08d611..7e8f37563 100644
--- a/src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp
+++ b/src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp
@@ -13,9 +13,6 @@ namespace Shader::Backend::GLASM {
 namespace {
 void GetCbuf(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset,
             std::string_view size) {
-    if (!binding.IsImmediate()) {
-        throw NotImplementedException("Indirect constant buffer loading");
-    }
    const Register ret{ctx.reg_alloc.Define(inst)};
    if (offset.type == Type::U32) {
        // Avoid reading arrays out of bounds, matching hardware's behavior
@@ -24,7 +21,27 @@ void GetCbuf(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU
            return;
        }
    }
-    ctx.Add("LDC.{} {},c{}[{}];", size, ret, binding.U32(), offset);
+    if (binding.IsImmediate()) {
+        ctx.Add("LDC.{} {},c{}[{}];", size, ret, binding.U32(), offset);
+        return;
+    }
+    const ScalarU32 idx{ctx.reg_alloc.Consume(binding)};
+    for (u32 i = 0; i < Info::MAX_INDIRECT_CBUFS; i++) {
+        ctx.Add("SEQ.S.CC RC.x,{},{};"
+                "IF NE.x;"
+                "LDC.{} {},c{}[{}];",
+                idx, i, size, ret, i, offset);
+        if (i != Info::MAX_INDIRECT_CBUFS - 1) {
+            ctx.Add("ELSE;");
+        }
+    }
+    for (u32 i = 0; i < Info::MAX_INDIRECT_CBUFS; i++) {
+        ctx.Add("ENDIF;");
+    }
 }
 bool IsInputArray(Stage stage) {
diff --git a/src/video_core/host_shaders/astc_decoder.comp b/src/video_core/host_shaders/astc_decoder.comp
index 3441a5fe5..d608678a3 100644
--- a/src/video_core/host_shaders/astc_decoder.comp
+++ b/src/video_core/host_shaders/astc_decoder.comp
@@ -1065,7 +1065,7 @@ TexelWeightParams DecodeBlockInfo() {
 void FillError(ivec3 coord) {
    for (uint j = 0; j < block_dims.y; j++) {
        for (uint i = 0; i < block_dims.x; i++) {
-            imageStore(dest_image, coord + ivec3(i, j, 0), vec4(1.0, 1.0, 0.0, 1.0));
+            imageStore(dest_image, coord + ivec3(i, j, 0), vec4(0.0, 0.0, 0.0, 0.0));
        }
    }
 }
diff --git a/src/video_core/macro/macro_hle.cpp b/src/video_core/macro/macro_hle.cpp
index 58382755b..cabe8dcbf 100644
--- a/src/video_core/macro/macro_hle.cpp
+++ b/src/video_core/macro/macro_hle.cpp
@@ -3,6 +3,8 @@
 #include <array>
 #include <vector>
+#include "common/scope_exit.h"
+#include "video_core/dirty_flags.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/macro/macro.h"
 #include "video_core/macro/macro_hle.h"
@@ -58,6 +60,7 @@ void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
    maxwell3d.regs.index_array.first = parameters[3];
    maxwell3d.regs.reg_array[0x446] = element_base; // vertex id base?
    maxwell3d.regs.index_array.count = parameters[1];
+    maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
    maxwell3d.regs.vb_element_base = element_base;
    maxwell3d.regs.vb_base_instance = base_instance;
    maxwell3d.mme_draw.instance_count = instance_count;
@@ -80,10 +83,67 @@ void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
    maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
 }
-constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
+// Multidraw Indirect
+void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
+    SCOPE_EXIT({
+        // Clean everything.
+        maxwell3d.regs.reg_array[0x446] = 0x0; // vertex id base?
+        maxwell3d.regs.index_array.count = 0;
+        maxwell3d.regs.vb_element_base = 0x0;
+        maxwell3d.regs.vb_base_instance = 0x0;
+        maxwell3d.mme_draw.instance_count = 0;
+        maxwell3d.CallMethodFromMME(0x8e3, 0x640);
+        maxwell3d.CallMethodFromMME(0x8e4, 0x0);
+        maxwell3d.CallMethodFromMME(0x8e5, 0x0);
+        maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
+        maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+    });
+    const u32 start_indirect = parameters[0];
+    const u32 end_indirect = parameters[1];
+    if (start_indirect >= end_indirect) {
+        // Nothing to do.
+        return;
+    }
+    const auto topology =
+        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[2]);
+    maxwell3d.regs.draw.topology.Assign(topology);
+    const u32 padding = parameters[3];
+    const std::size_t max_draws = parameters[4];
+    const u32 indirect_words = 5 + padding;
+    const std::size_t first_draw = start_indirect;
+    const std::size_t effective_draws = end_indirect - start_indirect;
+    const std::size_t last_draw = start_indirect + std::min(effective_draws, max_draws);
+    for (std::size_t index = first_draw; index < last_draw; index++) {
+        const std::size_t base = index * indirect_words + 5;
+        const u32 num_vertices = parameters[base];
+        const u32 instance_count = parameters[base + 1];
+        const u32 first_index = parameters[base + 2];
+        const u32 base_vertex = parameters[base + 3];
+        const u32 base_instance = parameters[base + 4];
+        maxwell3d.regs.index_array.first = first_index;
+        maxwell3d.regs.reg_array[0x446] = base_vertex;
+        maxwell3d.regs.index_array.count = num_vertices;
+        maxwell3d.regs.vb_element_base = base_vertex;
+        maxwell3d.regs.vb_base_instance = base_instance;
+        maxwell3d.mme_draw.instance_count = instance_count;
+        maxwell3d.CallMethodFromMME(0x8e3, 0x640);
+        maxwell3d.CallMethodFromMME(0x8e4, base_vertex);
+        maxwell3d.CallMethodFromMME(0x8e5, base_instance);
+        maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        if (maxwell3d.ShouldExecute()) {
+            maxwell3d.Rasterizer().Draw(true, true);
+        }
+        maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
+    }
+}
+constexpr std::array<std::pair<u64, HLEFunction>, 4> hle_funcs{{
    {0x771BB18C62444DA0, &HLE_771BB18C62444DA0},
    {0x0D61FC9FAAC9FCAD, &HLE_0D61FC9FAAC9FCAD},
    {0x0217920100488FF7, &HLE_0217920100488FF7},
+    {0x3F5E74B9C9A50164, &HLE_3F5E74B9C9A50164},
 }};
 class HLEMacroImpl final : public CachedMacro {
@@ -99,6 +159,7 @@ private:
    Engines::Maxwell3D& maxwell3d;
    HLEFunction func;
 };
 } // Anonymous namespace
 HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {}
diff --git a/src/video_core/macro/macro_jit_x64.cpp b/src/video_core/macro/macro_jit_x64.cpp
index aca25d902..a302a9603 100644
--- a/src/video_core/macro/macro_jit_x64.cpp
+++ b/src/video_core/macro/macro_jit_x64.cpp
@@ -279,28 +279,13 @@ void MacroJITx64Impl::Compile_ExtractInsert(Macro::Opcode opcode) {
    auto dst = Compile_GetRegister(opcode.src_a, RESULT);
    auto src = Compile_GetRegister(opcode.src_b, eax);
-    if (opcode.bf_src_bit != 0 && opcode.bf_src_bit != 31) {
-        shr(src, opcode.bf_src_bit);
-    } else if (opcode.bf_src_bit == 31) {
-        xor_(src, src);
-    }
-    // Don't bother masking the whole register since we're using a 32 bit register
-    if (opcode.bf_size != 31 && opcode.bf_size != 0) {
-        and_(src, opcode.GetBitfieldMask());
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-    if (opcode.bf_dst_bit != 31 && opcode.bf_dst_bit != 0) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
    const u32 mask = ~(opcode.GetBitfieldMask() << opcode.bf_dst_bit);
-    if (mask != 0xffffffff) {
+    and_(dst, mask);
-        and_(dst, mask);
+    shr(src, opcode.bf_src_bit);
-    }
+    and_(src, opcode.GetBitfieldMask());
+    shl(src, opcode.bf_dst_bit);
    or_(dst, src);
    Compile_ProcessResult(opcode.result_operation, opcode.dst);
 }
@@ -309,17 +294,9 @@ void MacroJITx64Impl::Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode) {
    const auto src = Compile_GetRegister(opcode.src_b, RESULT);
    shr(src, dst.cvt8());
-    if (opcode.bf_size != 0 && opcode.bf_size != 31) {
+    and_(src, opcode.GetBitfieldMask());
-        and_(src, opcode.GetBitfieldMask());
+    shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-    if (opcode.bf_dst_bit != 0 && opcode.bf_dst_bit != 31) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
    Compile_ProcessResult(opcode.result_operation, opcode.dst);
 }
@@ -327,13 +304,8 @@ void MacroJITx64Impl::Compile_ExtractShiftLeftRegister(Macro::Opcode opcode) {
    const auto dst = Compile_GetRegister(opcode.src_a, ecx);
    const auto src = Compile_GetRegister(opcode.src_b, RESULT);
-    if (opcode.bf_src_bit != 0) {
+    shr(src, opcode.bf_src_bit);
-        shr(src, opcode.bf_src_bit);
+    and_(src, opcode.GetBitfieldMask());
-    }
-    if (opcode.bf_size != 31) {
-        and_(src, opcode.GetBitfieldMask());
-    }
    shl(src, dst.cvt8());
    Compile_ProcessResult(opcode.result_operation, opcode.dst);
@@ -429,17 +401,11 @@ void MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
            Xbyak::Label handle_post_exit{};
            Xbyak::Label skip{};
            jmp(skip, T_NEAR);
-            if (opcode.is_exit) {
-                L(handle_post_exit);
+            L(handle_post_exit);
-                // Execute 1 instruction
+            xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-                mov(BRANCH_HOLDER, end_of_code);
+            jmp(labels[jump_address], T_NEAR);
-                // Jump to next instruction to skip delay slot check
-                jmp(labels[jump_address], T_NEAR);
-            } else {
-                L(handle_post_exit);
-                xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-                jmp(labels[jump_address], T_NEAR);
-            }
            L(skip);
            mov(BRANCH_HOLDER, handle_post_exit);
            jmp(delay_skip[pc], T_NEAR);
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
index 32450ee1d..08f4d69ab 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -168,7 +168,7 @@ void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {
    if (has_unified_vertex_buffers) {
        buffer.MakeResident(GL_READ_ONLY);
        glBufferAddressRangeNV(GL_ELEMENT_ARRAY_ADDRESS_NV, 0, buffer.HostGpuAddr() + offset,
-                               static_cast<GLsizeiptr>(size));
+                               static_cast<GLsizeiptr>(Common::AlignUp(size, 4)));
    } else {
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
        index_buffer_offset = offset;
diff --git a/src/video_core/textures/astc.cpp b/src/video_core/textures/astc.cpp
index b159494c5..e3742ddf5 100644
--- a/src/video_core/textures/astc.cpp
+++ b/src/video_core/textures/astc.cpp
@@ -1413,7 +1413,7 @@ static void FillVoidExtentLDR(InputBitStream& strm, std::span<u32> outBuf, u32 b
 static void FillError(std::span<u32> outBuf, u32 blockWidth, u32 blockHeight) {
    for (u32 j = 0; j < blockHeight; j++) {
        for (u32 i = 0; i < blockWidth; i++) {
-            outBuf[j * blockWidth + i] = 0xFFFF00FF;
+            outBuf[j * blockWidth + i] = 0x00000000;
        }
    }
 }
diff --git a/src/yuzu/applets/qt_controller.cpp b/src/yuzu/applets/qt_controller.cpp
index 1d8072243..12efdc216 100644
--- a/src/yuzu/applets/qt_controller.cpp
+++ b/src/yuzu/applets/qt_controller.cpp
@@ -291,7 +291,7 @@ bool QtControllerSelectorDialog::CheckIfParametersMet() {
    // Here, we check and validate the current configuration against all applicable parameters.
    const auto num_connected_players = static_cast<int>(
        std::count_if(player_groupboxes.begin(), player_groupboxes.end(),
-                      [this](const QGroupBox* player) { return player->isChecked(); }));
+                      [](const QGroupBox* player) { return player->isChecked(); }));
    const auto min_supported_players = parameters.enable_single_mode ? 1 : parameters.min_players;
    const auto max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index cb55472c9..1db374d4a 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -163,10 +163,9 @@ void ConfigureInput::Initialize(InputCommon::InputSubsystem* input_subsystem,
            [this, input_subsystem, &hid_core] {
                CallConfigureDialog<ConfigureRingController>(*this, input_subsystem, hid_core);
            });
-    connect(advanced, &ConfigureInputAdvanced::CallCameraDialog,
+    connect(advanced, &ConfigureInputAdvanced::CallCameraDialog, [this, input_subsystem] {
-            [this, input_subsystem, &hid_core] {
+        CallConfigureDialog<ConfigureCamera>(*this, input_subsystem);
-                CallConfigureDialog<ConfigureCamera>(*this, input_subsystem);
+    });
-            });
    connect(ui->vibrationButton, &QPushButton::clicked,
            [this, &hid_core] { CallConfigureDialog<ConfigureVibration>(*this, hid_core); });
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 23245a976..c63ce3a30 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -105,12 +105,12 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
 #include "core/telemetry_session.h"
 #include "input_common/drivers/tas_input.h"
+#include "input_common/drivers/virtual_amiibo.h"
 #include "input_common/main.h"
 #include "ui_main.h"
 #include "util/overlay_dialog.h"
@@ -899,8 +899,8 @@ void GMainWindow::InitializeWidgets() {
    }
    // TODO (flTobi): Add the widget when multiplayer is fully implemented
-    // statusBar()->addPermanentWidget(multiplayer_state->GetStatusText(), 0);
+    statusBar()->addPermanentWidget(multiplayer_state->GetStatusText(), 0);
-    // statusBar()->addPermanentWidget(multiplayer_state->GetStatusIcon(), 0);
+    statusBar()->addPermanentWidget(multiplayer_state->GetStatusIcon(), 0);
    tas_label = new QLabel();
    tas_label->setObjectName(QStringLiteral("TASlabel"));
@@ -1299,6 +1299,7 @@ void GMainWindow::ConnectMenuEvents() {
            &MultiplayerState::OnDirectConnectToRoom);
    connect(ui->action_Show_Room, &QAction::triggered, multiplayer_state,
            &MultiplayerState::OnOpenNetworkRoom);
+    connect(multiplayer_state, &MultiplayerState::SaveConfig, this, &GMainWindow::OnSaveConfig);
    // Tools
    connect_menu(ui->action_Rederive, std::bind(&GMainWindow::OnReinitializeKeys, this,
@@ -1339,6 +1340,8 @@ void GMainWindow::UpdateMenuState() {
    } else {
        ui->action_Pause->setText(tr("&Pause"));
    }
+    multiplayer_state->UpdateNotificationStatus();
 }
 void GMainWindow::OnDisplayTitleBars(bool show) {
@@ -2000,7 +2003,7 @@ static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src
 }
 void GMainWindow::OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type) {
-    const QString entry_type = [this, type] {
+    const QString entry_type = [type] {
        switch (type) {
        case InstalledEntryType::Game:
            return tr("Contents");
@@ -2097,7 +2100,7 @@ void GMainWindow::RemoveAddOnContent(u64 program_id, const QString& entry_type)
 void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target,
                                       const std::string& game_path) {
-    const QString question = [this, target] {
+    const QString question = [target] {
        switch (target) {
        case GameListRemoveTarget::GlShaderCache:
            return tr("Delete OpenGL Transferable Shader Cache?");
@@ -2770,6 +2773,11 @@ void GMainWindow::OnExit() {
    OnStopGame();
 }
+void GMainWindow::OnSaveConfig() {
+    system->ApplySettings();
+    config->Save();
+}
 void GMainWindow::ErrorDisplayDisplayError(QString error_code, QString error_text) {
    OverlayDialog dialog(render_window, *system, error_code, error_text, QString{}, tr("OK"),
                         Qt::AlignLeft | Qt::AlignVCenter);
@@ -3211,21 +3219,16 @@ void GMainWindow::OnLoadAmiibo() {
        return;
    }
-    Service::SM::ServiceManager& sm = system->ServiceManager();
+    auto* virtual_amiibo = input_subsystem->GetVirtualAmiibo();
-    auto nfc = sm.GetService<Service::NFP::Module::Interface>("nfp:user");
-    if (nfc == nullptr) {
+    // Remove amiibo if one is connected
-        QMessageBox::warning(this, tr("Error"), tr("The current game is not looking for amiibos"));
+    if (virtual_amiibo->GetCurrentState() == InputCommon::VirtualAmiibo::State::AmiiboIsOpen) {
-        return;
+        virtual_amiibo->CloseAmiibo();
-    }
-    const auto nfc_state = nfc->GetCurrentState();
-    if (nfc_state == Service::NFP::DeviceState::TagFound ||
-        nfc_state == Service::NFP::DeviceState::TagMounted) {
-        nfc->CloseAmiibo();
        QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
        return;
    }
-    if (nfc_state != Service::NFP::DeviceState::SearchingForTag) {
+    if (virtual_amiibo->GetCurrentState() != InputCommon::VirtualAmiibo::State::WaitingForAmiibo) {
        QMessageBox::warning(this, tr("Error"), tr("The current game is not looking for amiibos"));
        return;
    }
@@ -3244,24 +3247,30 @@ void GMainWindow::OnLoadAmiibo() {
 }
 void GMainWindow::LoadAmiibo(const QString& filename) {
-    Service::SM::ServiceManager& sm = system->ServiceManager();
+    auto* virtual_amiibo = input_subsystem->GetVirtualAmiibo();
-    auto nfc = sm.GetService<Service::NFP::Module::Interface>("nfp:user");
+    const QString title = tr("Error loading Amiibo data");
-    if (nfc == nullptr) {
-        return;
-    }
    // Remove amiibo if one is connected
-    const auto nfc_state = nfc->GetCurrentState();
+    if (virtual_amiibo->GetCurrentState() == InputCommon::VirtualAmiibo::State::AmiiboIsOpen) {
-    if (nfc_state == Service::NFP::DeviceState::TagFound ||
+        virtual_amiibo->CloseAmiibo();
-        nfc_state == Service::NFP::DeviceState::TagMounted) {
-        nfc->CloseAmiibo();
        QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
        return;
    }
-    if (!nfc->LoadAmiibo(filename.toStdString())) {
+    switch (virtual_amiibo->LoadAmiibo(filename.toStdString())) {
-        QMessageBox::warning(this, tr("Error loading Amiibo data"),
+    case InputCommon::VirtualAmiibo::Info::NotAnAmiibo:
-                             tr("Unable to load Amiibo data."));
+        QMessageBox::warning(this, title, tr("The selected file is not a valid amiibo"));
+        break;
+    case InputCommon::VirtualAmiibo::Info::UnableToLoad:
+        QMessageBox::warning(this, title, tr("The selected file is already on use"));
+        break;
+    case InputCommon::VirtualAmiibo::Info::WrongDeviceState:
+        QMessageBox::warning(this, title, tr("The current game is not looking for amiibos"));
+        break;
+    case InputCommon::VirtualAmiibo::Info::Unknown:
+        QMessageBox::warning(this, title, tr("An unkown error occured"));
+        break;
+    default:
+        break;
    }
 }
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index 716aef063..f7aa8e417 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -169,6 +169,7 @@ public slots:
    void OnLoadComplete();
    void OnExecuteProgram(std::size_t program_index);
    void OnExit();
+    void OnSaveConfig();
    void ControllerSelectorReconfigureControllers(
        const Core::Frontend::ControllerParameters& parameters);
    void SoftwareKeyboardInitialize(
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index cdf31b417..74d49dbd4 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -120,6 +120,20 @@
    <addaction name="menu_Reset_Window_Size"/>
    <addaction name="menu_View_Debugging"/>
   </widget>
+   <widget class="QMenu" name="menu_Multiplayer">
+    <property name="enabled">
+     <bool>true</bool>
+    </property>
+    <property name="title">
+     <string>&amp;Multiplayer</string>
+    </property>
+    <addaction name="action_View_Lobby"/>
+    <addaction name="action_Start_Room"/>
+    <addaction name="action_Connect_To_Room"/>
+    <addaction name="separator"/>
+    <addaction name="action_Show_Room"/>
+    <addaction name="action_Leave_Room"/>
+   </widget>
   <widget class="QMenu" name="menu_Tools">
    <property name="title">
     <string>&amp;Tools</string>
@@ -251,7 +265,7 @@
    <bool>true</bool>
   </property>
   <property name="text">
-    <string>Browse Public Game Lobby</string>
+    <string>&amp;Browse Public Game Lobby</string>
   </property>
  </action>
  <action name="action_Start_Room">
@@ -259,7 +273,7 @@
    <bool>true</bool>
   </property>
   <property name="text">
-    <string>Create Room</string>
+    <string>&amp;Create Room</string>
   </property>
  </action>
  <action name="action_Leave_Room">
@@ -267,12 +281,12 @@
    <bool>false</bool>
   </property>
   <property name="text">
-    <string>Leave Room</string>
+    <string>&amp;Leave Room</string>
   </property>
  </action>
  <action name="action_Connect_To_Room">
   <property name="text">
-    <string>Direct Connect to Room</string>
+    <string>&amp;Direct Connect to Room</string>
   </property>
  </action>
  <action name="action_Show_Room">
@@ -280,7 +294,7 @@
    <bool>false</bool>
   </property>
   <property name="text">
-    <string>Show Current Room</string>
+    <string>&amp;Show Current Room</string>
   </property>
  </action>
  <action name="action_Fullscreen">
diff --git a/src/yuzu/multiplayer/chat_room.cpp b/src/yuzu/multiplayer/chat_room.cpp
index 9e672f82e..dec9696c1 100644
--- a/src/yuzu/multiplayer/chat_room.cpp
+++ b/src/yuzu/multiplayer/chat_room.cpp
@@ -61,7 +61,10 @@ public:
    /// Format the message using the players color
    QString GetPlayerChatMessage(u16 player) const {
-        auto color = player_color[player % 16];
+        const bool is_dark_theme = QIcon::themeName().contains(QStringLiteral("dark")) ||
+                                   QIcon::themeName().contains(QStringLiteral("midnight"));
+        auto color =
+            is_dark_theme ? player_color_dark[player % 16] : player_color_default[player % 16];
        QString name;
        if (username.isEmpty() || username == nickname) {
            name = nickname;
@@ -84,9 +87,12 @@ public:
    }
 private:
-    static constexpr std::array<const char*, 16> player_color = {
+    static constexpr std::array<const char*, 16> player_color_default = {
        {"#0000FF", "#FF0000", "#8A2BE2", "#FF69B4", "#1E90FF", "#008000", "#00FF7F", "#B22222",
-         "#DAA520", "#FF4500", "#2E8B57", "#5F9EA0", "#D2691E", "#9ACD32", "#FF7F50", "FFFF00"}};
+         "#DAA520", "#FF4500", "#2E8B57", "#5F9EA0", "#D2691E", "#9ACD32", "#FF7F50", "#FFFF00"}};
+    static constexpr std::array<const char*, 16> player_color_dark = {
+        {"#559AD1", "#4EC9A8", "#D69D85", "#C6C923", "#B975B5", "#D81F1F", "#7EAE39", "#4F8733",
+         "#F7CD8A", "#6FCACF", "#CE4897", "#8A2BE2", "#D2691E", "#9ACD32", "#FF7F50", "#152ccd"}};
    static constexpr char ping_color[] = "#FFFF00";
    QString timestamp;
diff --git a/src/yuzu/multiplayer/client_room.cpp b/src/yuzu/multiplayer/client_room.cpp
index b34a8d004..caf34a414 100644
--- a/src/yuzu/multiplayer/client_room.cpp
+++ b/src/yuzu/multiplayer/client_room.cpp
@@ -97,8 +97,9 @@ void ClientRoomWindow::UpdateView() {
            auto memberlist = member->GetMemberInformation();
            ui->chat->SetPlayerList(memberlist);
            const auto information = member->GetRoomInformation();
-            setWindowTitle(QString(tr("%1 (%2/%3 members) - connected"))
+            setWindowTitle(QString(tr("%1 - %2 (%3/%4 members) - connected"))
                               .arg(QString::fromStdString(information.name))
+                               .arg(QString::fromStdString(information.preferred_game.name))
                               .arg(memberlist.size())
                               .arg(information.member_slots));
            ui->description->setText(QString::fromStdString(information.description));
diff --git a/src/yuzu/multiplayer/direct_connect.cpp b/src/yuzu/multiplayer/direct_connect.cpp
index 017063074..10bf0a4fb 100644
--- a/src/yuzu/multiplayer/direct_connect.cpp
+++ b/src/yuzu/multiplayer/direct_connect.cpp
@@ -106,6 +106,8 @@ void DirectConnectWindow::Connect() {
        UISettings::values.multiplayer_port = UISettings::values.multiplayer_port.GetDefault();
    }
+    emit SaveConfig();
    // attempt to connect in a different thread
    QFuture<void> f = QtConcurrent::run([&] {
        if (auto room_member = room_network.GetRoomMember().lock()) {
diff --git a/src/yuzu/multiplayer/direct_connect.h b/src/yuzu/multiplayer/direct_connect.h
index e39dd1e0d..b8f66cfb2 100644
--- a/src/yuzu/multiplayer/direct_connect.h
+++ b/src/yuzu/multiplayer/direct_connect.h
@@ -31,6 +31,7 @@ signals:
     * connections that it might have.
     */
    void Closed();
+    void SaveConfig();
 private slots:
    void OnConnection();
diff --git a/src/yuzu/multiplayer/host_room.cpp b/src/yuzu/multiplayer/host_room.cpp
index 0c6adfd04..a8faa5b24 100644
--- a/src/yuzu/multiplayer/host_room.cpp
+++ b/src/yuzu/multiplayer/host_room.cpp
@@ -232,6 +232,7 @@ void HostRoomWindow::Host() {
        }
        UISettings::values.multiplayer_room_description = ui->room_description->toPlainText();
        ui->host->setEnabled(true);
+        emit SaveConfig();
        close();
    }
 }
diff --git a/src/yuzu/multiplayer/host_room.h b/src/yuzu/multiplayer/host_room.h
index 034cb2eef..ae816e2e0 100644
--- a/src/yuzu/multiplayer/host_room.h
+++ b/src/yuzu/multiplayer/host_room.h
@@ -46,6 +46,9 @@ public:
    void UpdateGameList(QStandardItemModel* list);
    void RetranslateUi();
+signals:
+    void SaveConfig();
 private:
    void Host();
    std::unique_ptr<Network::VerifyUser::Backend> CreateVerifyBackend(bool use_validation) const;
diff --git a/src/yuzu/multiplayer/lobby.cpp b/src/yuzu/multiplayer/lobby.cpp
index 107d40547..08c275696 100644
--- a/src/yuzu/multiplayer/lobby.cpp
+++ b/src/yuzu/multiplayer/lobby.cpp
@@ -7,6 +7,7 @@
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/internal_network/network_interface.h"
 #include "network/network.h"
 #include "ui_lobby.h"
@@ -26,9 +27,9 @@
 Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
             std::shared_ptr<Core::AnnounceMultiplayerSession> session, Core::System& system_)
    : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
-      ui(std::make_unique<Ui::Lobby>()),
+      ui(std::make_unique<Ui::Lobby>()), announce_multiplayer_session(session),
-      announce_multiplayer_session(session), system{system_}, room_network{
+      profile_manager(std::make_unique<Service::Account::ProfileManager>()), system{system_},
-                                                                  system.GetRoomNetwork()} {
+      room_network{system.GetRoomNetwork()} {
    ui->setupUi(this);
    // setup the watcher for background connections
@@ -60,9 +61,17 @@ Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
    ui->nickname->setValidator(validation.GetNickname());
    ui->nickname->setText(UISettings::values.multiplayer_nickname.GetValue());
-    if (ui->nickname->text().isEmpty() && !Settings::values.yuzu_username.GetValue().empty()) {
-        // Use yuzu Web Service user name as nickname by default
+    // Try find the best nickname by default
-        ui->nickname->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue()));
+    if (ui->nickname->text().isEmpty() || ui->nickname->text() == QStringLiteral("yuzu")) {
+        if (!Settings::values.yuzu_username.GetValue().empty()) {
+            ui->nickname->setText(
+                QString::fromStdString(Settings::values.yuzu_username.GetValue()));
+        } else if (!GetProfileUsername().empty()) {
+            ui->nickname->setText(QString::fromStdString(GetProfileUsername()));
+        } else {
+            ui->nickname->setText(QStringLiteral("yuzu"));
+        }
    }
    // UI Buttons
@@ -76,12 +85,6 @@ Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
    // Actions
    connect(&room_list_watcher, &QFutureWatcher<AnnounceMultiplayerRoom::RoomList>::finished, this,
            &Lobby::OnRefreshLobby);
-    // manually start a refresh when the window is opening
-    // TODO(jroweboy): if this refresh is slow for people with bad internet, then don't do it as
-    // part of the constructor, but offload the refresh until after the window shown. perhaps emit a
-    // refreshroomlist signal from places that open the lobby
-    RefreshLobby();
 }
 Lobby::~Lobby() = default;
@@ -96,6 +99,7 @@ void Lobby::UpdateGameList(QStandardItemModel* list) {
    }
    if (proxy)
        proxy->UpdateGameList(game_list);
+    ui->room_list->sortByColumn(Column::GAME_NAME, Qt::AscendingOrder);
 }
 void Lobby::RetranslateUi() {
@@ -117,6 +121,11 @@ void Lobby::OnExpandRoom(const QModelIndex& index) {
 void Lobby::OnJoinRoom(const QModelIndex& source) {
    if (!Network::GetSelectedNetworkInterface()) {
+        LOG_INFO(WebService, "Automatically selected network interface for room network.");
+        Network::SelectFirstNetworkInterface();
+    }
+    if (!Network::GetSelectedNetworkInterface()) {
        NetworkMessage::ErrorManager::ShowError(
            NetworkMessage::ErrorManager::NO_INTERFACE_SELECTED);
        return;
@@ -197,16 +206,16 @@ void Lobby::OnJoinRoom(const QModelIndex& source) {
        proxy->data(connection_index, LobbyItemHost::HostIPRole).toString();
    UISettings::values.multiplayer_port =
        proxy->data(connection_index, LobbyItemHost::HostPortRole).toInt();
+    emit SaveConfig();
 }
 void Lobby::ResetModel() {
    model->clear();
    model->insertColumns(0, Column::TOTAL);
-    model->setHeaderData(Column::EXPAND, Qt::Horizontal, QString(), Qt::DisplayRole);
+    model->setHeaderData(Column::MEMBER, Qt::Horizontal, tr("Players"), Qt::DisplayRole);
    model->setHeaderData(Column::ROOM_NAME, Qt::Horizontal, tr("Room Name"), Qt::DisplayRole);
    model->setHeaderData(Column::GAME_NAME, Qt::Horizontal, tr("Preferred Game"), Qt::DisplayRole);
    model->setHeaderData(Column::HOST, Qt::Horizontal, tr("Host"), Qt::DisplayRole);
-    model->setHeaderData(Column::MEMBER, Qt::Horizontal, tr("Players"), Qt::DisplayRole);
 }
 void Lobby::RefreshLobby() {
@@ -229,6 +238,7 @@ void Lobby::OnRefreshLobby() {
        for (int r = 0; r < game_list->rowCount(); ++r) {
            auto index = game_list->index(r, 0);
            auto game_id = game_list->data(index, GameListItemPath::ProgramIdRole).toULongLong();
            if (game_id != 0 && room.information.preferred_game.id == game_id) {
                smdh_icon = game_list->data(index, Qt::DecorationRole).value<QPixmap>();
            }
@@ -243,17 +253,16 @@ void Lobby::OnRefreshLobby() {
            members.append(var);
        }
-        auto first_item = new LobbyItem();
+        auto first_item = new LobbyItemGame(
+            room.information.preferred_game.id,
+            QString::fromStdString(room.information.preferred_game.name), smdh_icon);
        auto row = QList<QStandardItem*>({
            first_item,
            new LobbyItemName(room.has_password, QString::fromStdString(room.information.name)),
-            new LobbyItemGame(room.information.preferred_game.id,
+            new LobbyItemMemberList(members, room.information.member_slots),
-                              QString::fromStdString(room.information.preferred_game.name),
-                              smdh_icon),
            new LobbyItemHost(QString::fromStdString(room.information.host_username),
                              QString::fromStdString(room.ip), room.information.port,
                              QString::fromStdString(room.verify_uid)),
-            new LobbyItemMemberList(members, room.information.member_slots),
        });
        model->appendRow(row);
        // To make the rows expandable, add the member data as a child of the first column of the
@@ -283,6 +292,26 @@ void Lobby::OnRefreshLobby() {
            ui->room_list->setFirstColumnSpanned(j, proxy->index(i, 0), true);
        }
    }
+    ui->room_list->sortByColumn(Column::GAME_NAME, Qt::AscendingOrder);
+}
+std::string Lobby::GetProfileUsername() {
+    const auto& current_user = profile_manager->GetUser(Settings::values.current_user.GetValue());
+    Service::Account::ProfileBase profile{};
+    if (!current_user.has_value()) {
+        return "";
+    }
+    if (!profile_manager->GetProfileBase(*current_user, profile)) {
+        return "";
+    }
+    const auto text = Common::StringFromFixedZeroTerminatedBuffer(
+        reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
+    return text;
 }
 LobbyFilterProxyModel::LobbyFilterProxyModel(QWidget* parent, QStandardItemModel* list)
diff --git a/src/yuzu/multiplayer/lobby.h b/src/yuzu/multiplayer/lobby.h
index 2696aec21..300dad13e 100644
--- a/src/yuzu/multiplayer/lobby.h
+++ b/src/yuzu/multiplayer/lobby.h
@@ -24,6 +24,10 @@ namespace Core {
 class System;
 }
+namespace Service::Account {
+class ProfileManager;
+}
 /**
 * Listing of all public games pulled from services. The lobby should be simple enough for users to
 * find the game they want to play, and join it.
@@ -75,8 +79,11 @@ private slots:
 signals:
    void StateChanged(const Network::RoomMember::State&);
+    void SaveConfig();
 private:
+    std::string GetProfileUsername();
    /**
     * Removes all entries in the Lobby before refreshing.
     */
@@ -96,6 +103,7 @@ private:
    QFutureWatcher<AnnounceMultiplayerRoom::RoomList> room_list_watcher;
    std::weak_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session;
+    std::unique_ptr<Service::Account::ProfileManager> profile_manager;
    QFutureWatcher<void>* watcher;
    Validation validation;
    Core::System& system;
diff --git a/src/yuzu/multiplayer/lobby_p.h b/src/yuzu/multiplayer/lobby_p.h
index 8071cede4..068c95aca 100644
--- a/src/yuzu/multiplayer/lobby_p.h
+++ b/src/yuzu/multiplayer/lobby_p.h
@@ -11,11 +11,10 @@
 namespace Column {
 enum List {
-    EXPAND,
-    ROOM_NAME,
    GAME_NAME,
-    HOST,
+    ROOM_NAME,
    MEMBER,
+    HOST,
    TOTAL,
 };
 }
@@ -91,6 +90,8 @@ public:
        setData(game_name, GameNameRole);
        if (!smdh_icon.isNull()) {
            setData(smdh_icon, GameIconRole);
+        } else {
+            setData(QIcon::fromTheme(QStringLiteral("chip")).pixmap(32), GameIconRole);
        }
    }
@@ -98,7 +99,12 @@ public:
        if (role == Qt::DecorationRole) {
            auto val = data(GameIconRole);
            if (val.isValid()) {
-                val = val.value<QPixmap>().scaled(16, 16, Qt::KeepAspectRatio);
+                val = val.value<QPixmap>().scaled(32, 32, Qt::KeepAspectRatio,
+                                                  Qt::TransformationMode::SmoothTransformation);
+            } else {
+                auto blank_image = QPixmap(32, 32);
+                blank_image.fill(Qt::black);
+                val = blank_image;
            }
            return val;
        } else if (role != Qt::DisplayRole) {
@@ -191,8 +197,8 @@ public:
            return LobbyItem::data(role);
        }
        auto members = data(MemberListRole).toList();
-        return QStringLiteral("%1 / %2").arg(QString::number(members.size()),
+        return QStringLiteral("%1 / %2 ")
-                                             data(MaxPlayerRole).toString());
+            .arg(QString::number(members.size()), data(MaxPlayerRole).toString());
    }
    bool operator<(const QStandardItem& other) const override {
diff --git a/src/yuzu/multiplayer/message.cpp b/src/yuzu/multiplayer/message.cpp
index 758b5b731..6d8f18274 100644
--- a/src/yuzu/multiplayer/message.cpp
+++ b/src/yuzu/multiplayer/message.cpp
@@ -49,9 +49,9 @@ const ConnectionError ErrorManager::PERMISSION_DENIED(
    QT_TR_NOOP("You do not have enough permission to perform this action."));
 const ConnectionError ErrorManager::NO_SUCH_USER(QT_TR_NOOP(
    "The user you are trying to kick/ban could not be found.\nThey may have left the room."));
-const ConnectionError ErrorManager::NO_INTERFACE_SELECTED(
+const ConnectionError ErrorManager::NO_INTERFACE_SELECTED(QT_TR_NOOP(
-    QT_TR_NOOP("No network interface is selected.\nPlease go to Configure -> System -> Network and "
+    "No valid network interface is selected.\nPlease go to Configure -> System -> Network and "
-               "make a selection."));
+    "make a selection."));
 static bool WarnMessage(const std::string& title, const std::string& text) {
    return QMessageBox::Ok == QMessageBox::warning(nullptr, QObject::tr(title.c_str()),
diff --git a/src/yuzu/multiplayer/state.cpp b/src/yuzu/multiplayer/state.cpp
index 66e098296..ae2738ad4 100644
--- a/src/yuzu/multiplayer/state.cpp
+++ b/src/yuzu/multiplayer/state.cpp
@@ -44,9 +44,6 @@ MultiplayerState::MultiplayerState(QWidget* parent, QStandardItemModel* game_lis
    status_text = new ClickableLabel(this);
    status_icon = new ClickableLabel(this);
-    status_text->setToolTip(tr("Current connection status"));
-    status_text->setText(tr("Not Connected. Click here to find a room!"));
-    status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16));
    connect(status_text, &ClickableLabel::clicked, this, &MultiplayerState::OnOpenNetworkRoom);
    connect(status_icon, &ClickableLabel::clicked, this, &MultiplayerState::OnOpenNetworkRoom);
@@ -57,6 +54,8 @@ MultiplayerState::MultiplayerState(QWidget* parent, QStandardItemModel* game_lis
                    HideNotification();
                }
            });
+    retranslateUi();
 }
 MultiplayerState::~MultiplayerState() = default;
@@ -90,14 +89,7 @@ void MultiplayerState::Close() {
 void MultiplayerState::retranslateUi() {
    status_text->setToolTip(tr("Current connection status"));
-    if (current_state == Network::RoomMember::State::Uninitialized) {
+    UpdateNotificationStatus();
-        status_text->setText(tr("Not Connected. Click here to find a room!"));
-    } else if (current_state == Network::RoomMember::State::Joined ||
-               current_state == Network::RoomMember::State::Moderator) {
-        status_text->setText(tr("Connected"));
-    } else {
-        status_text->setText(tr("Not Connected"));
-    }
    if (lobby) {
        lobby->RetranslateUi();
@@ -113,21 +105,55 @@ void MultiplayerState::retranslateUi() {
    }
 }
+void MultiplayerState::SetNotificationStatus(NotificationStatus status) {
+    notification_status = status;
+    UpdateNotificationStatus();
+}
+void MultiplayerState::UpdateNotificationStatus() {
+    switch (notification_status) {
+    case NotificationStatus::Unitialized:
+        status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16));
+        status_text->setText(tr("Not Connected. Click here to find a room!"));
+        leave_room->setEnabled(false);
+        show_room->setEnabled(false);
+        break;
+    case NotificationStatus::Disconnected:
+        status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16));
+        status_text->setText(tr("Not Connected"));
+        leave_room->setEnabled(false);
+        show_room->setEnabled(false);
+        break;
+    case NotificationStatus::Connected:
+        status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16));
+        status_text->setText(tr("Connected"));
+        leave_room->setEnabled(true);
+        show_room->setEnabled(true);
+        break;
+    case NotificationStatus::Notification:
+        status_icon->setPixmap(
+            QIcon::fromTheme(QStringLiteral("connected_notification")).pixmap(16));
+        status_text->setText(tr("New Messages Received"));
+        leave_room->setEnabled(true);
+        show_room->setEnabled(true);
+        break;
+    }
+    // Clean up status bar if game is running
+    if (system.IsPoweredOn()) {
+        status_text->clear();
+    }
+}
 void MultiplayerState::OnNetworkStateChanged(const Network::RoomMember::State& state) {
    LOG_DEBUG(Frontend, "Network State: {}", Network::GetStateStr(state));
    if (state == Network::RoomMember::State::Joined ||
        state == Network::RoomMember::State::Moderator) {
        OnOpenNetworkRoom();
-        status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16));
+        SetNotificationStatus(NotificationStatus::Connected);
-        status_text->setText(tr("Connected"));
-        leave_room->setEnabled(true);
-        show_room->setEnabled(true);
    } else {
-        status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16));
+        SetNotificationStatus(NotificationStatus::Disconnected);
-        status_text->setText(tr("Not Connected"));
-        leave_room->setEnabled(false);
-        show_room->setEnabled(false);
    }
    current_state = state;
@@ -185,6 +211,10 @@ void MultiplayerState::OnAnnounceFailed(const WebService::WebResult& result) {
                         QMessageBox::Ok);
 }
+void MultiplayerState::OnSaveConfig() {
+    emit SaveConfig();
+}
 void MultiplayerState::UpdateThemedIcons() {
    if (show_notification) {
        status_icon->setPixmap(
@@ -209,13 +239,16 @@ static void BringWidgetToFront(QWidget* widget) {
 void MultiplayerState::OnViewLobby() {
    if (lobby == nullptr) {
        lobby = new Lobby(this, game_list_model, announce_multiplayer_session, system);
+        connect(lobby, &Lobby::SaveConfig, this, &MultiplayerState::OnSaveConfig);
    }
+    lobby->RefreshLobby();
    BringWidgetToFront(lobby);
 }
 void MultiplayerState::OnCreateRoom() {
    if (host_room == nullptr) {
        host_room = new HostRoomWindow(this, game_list_model, announce_multiplayer_session, system);
+        connect(host_room, &HostRoomWindow::SaveConfig, this, &MultiplayerState::OnSaveConfig);
    }
    BringWidgetToFront(host_room);
 }
@@ -249,14 +282,13 @@ void MultiplayerState::ShowNotification() {
        return; // Do not show notification if the chat window currently has focus
    show_notification = true;
    QApplication::alert(nullptr);
-    status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected_notification")).pixmap(16));
+    QApplication::beep();
-    status_text->setText(tr("New Messages Received"));
+    SetNotificationStatus(NotificationStatus::Notification);
 }
 void MultiplayerState::HideNotification() {
    show_notification = false;
-    status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16));
+    SetNotificationStatus(NotificationStatus::Connected);
-    status_text->setText(tr("Connected"));
 }
 void MultiplayerState::OnOpenNetworkRoom() {
@@ -279,6 +311,8 @@ void MultiplayerState::OnOpenNetworkRoom() {
 void MultiplayerState::OnDirectConnectToRoom() {
    if (direct_connect == nullptr) {
        direct_connect = new DirectConnectWindow(system, this);
+        connect(direct_connect, &DirectConnectWindow::SaveConfig, this,
+                &MultiplayerState::OnSaveConfig);
    }
    BringWidgetToFront(direct_connect);
 }
diff --git a/src/yuzu/multiplayer/state.h b/src/yuzu/multiplayer/state.h
index c92496413..5d681c5c6 100644
--- a/src/yuzu/multiplayer/state.h
+++ b/src/yuzu/multiplayer/state.h
@@ -22,6 +22,13 @@ class MultiplayerState : public QWidget {
    Q_OBJECT;
 public:
+    enum class NotificationStatus {
+        Unitialized,
+        Disconnected,
+        Connected,
+        Notification,
+    };
    explicit MultiplayerState(QWidget* parent, QStandardItemModel* game_list, QAction* leave_room,
                              QAction* show_room, Core::System& system_);
    ~MultiplayerState();
@@ -31,6 +38,10 @@ public:
     */
    void Close();
+    void SetNotificationStatus(NotificationStatus state);
+    void UpdateNotificationStatus();
    ClickableLabel* GetStatusText() const {
        return status_text;
    }
@@ -64,6 +75,7 @@ public slots:
    void OnOpenNetworkRoom();
    void OnDirectConnectToRoom();
    void OnAnnounceFailed(const WebService::WebResult&);
+    void OnSaveConfig();
    void UpdateThemedIcons();
    void ShowNotification();
    void HideNotification();
@@ -72,6 +84,7 @@ signals:
    void NetworkStateChanged(const Network::RoomMember::State&);
    void NetworkError(const Network::RoomMember::Error&);
    void AnnounceFailed(const WebService::WebResult&);
+    void SaveConfig();
 private:
    Lobby* lobby = nullptr;
@@ -85,6 +98,7 @@ private:
    QAction* show_room;
    std::shared_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session;
    Network::RoomMember::State current_state = Network::RoomMember::State::Uninitialized;
+    NotificationStatus notification_status = NotificationStatus::Unitialized;
    bool has_mod_perms = false;
    Network::RoomMember::CallbackHandle<Network::RoomMember::State> state_callback_handle;
    Network::RoomMember::CallbackHandle<Network::RoomMember::Error> error_callback_handle;
diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h
index e12d414d9..753797efc 100644
--- a/src/yuzu/uisettings.h
+++ b/src/yuzu/uisettings.h
@@ -102,7 +102,7 @@ struct Values {
    Settings::Setting<uint32_t> callout_flags{0, "calloutFlags"};
    // multiplayer settings
-    Settings::Setting<QString> multiplayer_nickname{QStringLiteral("yuzu"), "nickname"};
+    Settings::Setting<QString> multiplayer_nickname{{}, "nickname"};
    Settings::Setting<QString> multiplayer_ip{{}, "ip"};
    Settings::SwitchableSetting<uint, true> multiplayer_port{24872, 0, UINT16_MAX, "port"};
    Settings::Setting<QString> multiplayer_room_nickname{{}, "room_nickname"};