program_metadata: Unpack FileAccessHeader and FileAccessControl

Avoids a reference binding to a misaligned addresses. Unpacking one
requires unpacking the other, otherwise there'll be a misaligned address
on the leftover one.

src/audio_core/common.h

@@ -15,9 +15,7 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren
 
-constexpr u8 BASE_REVISION = '0';
-constexpr u32_le CURRENT_PROCESS_REVISION =
-    Common::MakeMagic('R', 'E', 'V', static_cast<u8>(BASE_REVISION + 0xA));
+constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '9');
 constexpr std::size_t MAX_MIX_BUFFERS = 24;
 constexpr std::size_t MAX_BIQUAD_FILTERS = 2;
 constexpr std::size_t MAX_CHANNEL_COUNT = 6;

src/common/fs/fs_util.cpp

@@ -16,10 +16,6 @@ std::u8string BufferToU8String(std::span<const u8> buffer) {
     return std::u8string{buffer.begin(), std::ranges::find(buffer, u8{0})};
 }
 
-std::u8string_view BufferToU8StringView(std::span<const u8> buffer) {
-    return std::u8string_view{reinterpret_cast<const char8_t*>(buffer.data())};
-}
-
 std::string ToUTF8String(std::u8string_view u8_string) {
     return std::string{u8_string.begin(), u8_string.end()};
 }
@@ -28,10 +24,6 @@ std::string BufferToUTF8String(std::span<const u8> buffer) {
     return std::string{buffer.begin(), std::ranges::find(buffer, u8{0})};
 }
 
-std::string_view BufferToUTF8StringView(std::span<const u8> buffer) {
-    return std::string_view{reinterpret_cast<const char*>(buffer.data())};
-}
-
 std::string PathToUTF8String(const std::filesystem::path& path) {
     return ToUTF8String(path.u8string());
 }

src/common/fs/fs_util.h

@@ -37,15 +37,6 @@ concept IsChar = std::same_as<T, char>;
  */
 [[nodiscard]] std::u8string BufferToU8String(std::span<const u8> buffer);
 
-/**
- * Same as BufferToU8String, but returns a string view of the buffer.
- *
- * @param buffer Buffer of bytes
- *
- * @returns UTF-8 encoded std::u8string_view.
- */
-[[nodiscard]] std::u8string_view BufferToU8StringView(std::span<const u8> buffer);
-
 /**
  * Converts a std::u8string or std::u8string_view to a UTF-8 encoded std::string.
  *
@@ -66,15 +57,6 @@ concept IsChar = std::same_as<T, char>;
  */
 [[nodiscard]] std::string BufferToUTF8String(std::span<const u8> buffer);
 
-/**
- * Same as BufferToUTF8String, but returns a string view of the buffer.
- *
- * @param buffer Buffer of bytes
- *
- * @returns UTF-8 encoded std::string_view.
- */
-[[nodiscard]] std::string_view BufferToUTF8StringView(std::span<const u8> buffer);
-
 /**
  * Converts a filesystem path to a UTF-8 encoded std::string.
  *

src/common/logging/filter.cpp

@@ -108,7 +108,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, Migration)                                                                        \
     SUB(Service, Mii)                                                                              \
     SUB(Service, MM)                                                                               \
-    SUB(Service, MNPP)                                                                             \
     SUB(Service, NCM)                                                                              \
     SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \

src/common/logging/types.h

@@ -76,7 +76,6 @@ enum class Class : u8 {
     Service_Migration, ///< The migration service
     Service_Mii,       ///< The Mii service
     Service_MM,        ///< The MM (Multimedia) service
-    Service_MNPP,      ///< The MNPP service
     Service_NCM,       ///< The NCM service
     Service_NFC,       ///< The NFC (Near-field communication) service
     Service_NFP,       ///< The NFP service

src/common/page_table.cpp

@@ -10,65 +10,11 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-bool PageTable::BeginTraversal(TraversalEntry& out_entry, TraversalContext& out_context,
-                               u64 address) const {
-    // Setup invalid defaults.
-    out_entry.phys_addr = 0;
-    out_entry.block_size = page_size;
-    out_context.next_page = 0;
-
-    // Validate that we can read the actual entry.
-    const auto page = address / page_size;
-    if (page >= backing_addr.size()) {
-        return false;
-    }
-
-    // Validate that the entry is mapped.
-    const auto phys_addr = backing_addr[page];
-    if (phys_addr == 0) {
-        return false;
-    }
-
-    // Populate the results.
-    out_entry.phys_addr = phys_addr + address;
-    out_context.next_page = page + 1;
-    out_context.next_offset = address + page_size;
-
-    return true;
-}
-
-bool PageTable::ContinueTraversal(TraversalEntry& out_entry, TraversalContext& context) const {
-    // Setup invalid defaults.
-    out_entry.phys_addr = 0;
-    out_entry.block_size = page_size;
-
-    // Validate that we can read the actual entry.
-    const auto page = context.next_page;
-    if (page >= backing_addr.size()) {
-        return false;
-    }
-
-    // Validate that the entry is mapped.
-    const auto phys_addr = backing_addr[page];
-    if (phys_addr == 0) {
-        return false;
-    }
-
-    // Populate the results.
-    out_entry.phys_addr = phys_addr + context.next_offset;
-    context.next_page = page + 1;
-    context.next_offset += page_size;
-
-    return true;
-}
-
-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits) {
-    const std::size_t num_page_table_entries{1ULL
-                                             << (address_space_width_in_bits - page_size_in_bits)};
+void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_bits) {
+    const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
     pointers.resize(num_page_table_entries);
     backing_addr.resize(num_page_table_entries);
     current_address_space_width_in_bits = address_space_width_in_bits;
-    page_size = 1ULL << page_size_in_bits;
 }
 
 } // namespace Common

src/common/page_table.h

@@ -27,16 +27,6 @@ enum class PageType : u8 {
  * mimics the way a real CPU page table works.
  */
 struct PageTable {
-    struct TraversalEntry {
-        u64 phys_addr{};
-        std::size_t block_size{};
-    };
-
-    struct TraversalContext {
-        u64 next_page{};
-        u64 next_offset{};
-    };
-
     /// Number of bits reserved for attribute tagging.
     /// This can be at most the guaranteed alignment of the pointers in the page table.
     static constexpr int ATTRIBUTE_BITS = 2;
@@ -99,10 +89,6 @@ struct PageTable {
     PageTable(PageTable&&) noexcept = default;
     PageTable& operator=(PageTable&&) noexcept = default;
 
-    bool BeginTraversal(TraversalEntry& out_entry, TraversalContext& out_context,
-                        u64 address) const;
-    bool ContinueTraversal(TraversalEntry& out_entry, TraversalContext& context) const;
-
     /**
      * Resizes the page table to be able to accommodate enough pages within
      * a given address space.
@@ -110,9 +96,9 @@ struct PageTable {
      * @param address_space_width_in_bits The address size width in bits.
      * @param page_size_in_bits           The page size in bits.
      */
-    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits);
+    void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
 
-    std::size_t GetAddressSpaceBits() const {
+    size_t GetAddressSpaceBits() const {
         return current_address_space_width_in_bits;
     }
 
@@ -124,11 +110,9 @@ struct PageTable {
 
     VirtualBuffer<u64> backing_addr;
 
-    std::size_t current_address_space_width_in_bits{};
+    size_t current_address_space_width_in_bits;
 
-    u8* fastmem_arena{};
-
-    std::size_t page_size{};
+    u8* fastmem_arena;
 };
 
 } // namespace Common

src/common/settings.cpp

@@ -167,7 +167,6 @@ void RestoreGlobalState(bool is_powered_on) {
 
     // Core
     values.use_multi_core.SetGlobal(true);
-    values.use_extended_memory_layout.SetGlobal(true);
 
     // CPU
     values.cpu_accuracy.SetGlobal(true);
@@ -176,7 +175,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
     values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
     values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
-    values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);
 
     // Renderer
     values.renderer_backend.SetGlobal(true);

src/common/settings.h

@@ -466,7 +466,6 @@ struct Values {
 
     // Core
     Setting<bool> use_multi_core{true, "use_multi_core"};
-    Setting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
 
     // Cpu
     RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
@@ -484,15 +483,12 @@ struct Values {
     BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
     BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
     BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
-    BasicSetting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
-    BasicSetting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
 
     Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
     Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
     Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
     Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
     Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
-    Setting<bool> cpuopt_unsafe_ignore_global_monitor{true, "cpuopt_unsafe_ignore_global_monitor"};
 
     // Renderer
     RangedSetting<RendererBackend> renderer_backend{

src/common/telemetry.h

@@ -171,9 +171,6 @@ struct VisitorInterface {
 struct NullVisitor final : public VisitorInterface {
     YUZU_NON_COPYABLE(NullVisitor);
 
-    NullVisitor() = default;
-    ~NullVisitor() override = default;
-
     void Visit(const Field<bool>& /*field*/) override {}
     void Visit(const Field<double>& /*field*/) override {}
     void Visit(const Field<float>& /*field*/) override {}

src/core/CMakeLists.txt

@@ -467,8 +467,6 @@ add_library(core STATIC
     hle/service/mii/types.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
-    hle/service/mnpp/mnpp_app.cpp
-    hle/service/mnpp/mnpp_app.h
     hle/service/ncm/ncm.cpp
     hle/service/ncm/ncm.h
     hle/service/nfc/nfc.cpp

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -137,8 +137,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
     config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
     config.only_detect_misalignment_via_page_table_on_page_boundary = true;
-    config.fastmem_exclusive_access = true;
-    config.recompile_on_exclusive_fastmem_failure = true;
 
     // Multi-process state
     config.processor_id = core_index;
@@ -180,12 +178,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_fastmem) {
             config.fastmem_pointer = nullptr;
         }
-        if (!Settings::values.cpuopt_fastmem_exclusives) {
-            config.fastmem_exclusive_access = false;
-        }
-        if (!Settings::values.cpuopt_recompile_exclusives) {
-            config.recompile_on_exclusive_fastmem_failure = false;
-        }
     }
 
     // Unsafe optimizations
@@ -203,9 +195,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_global_monitor) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
-        }
     }
 
     // Curated optimizations
@@ -214,7 +203,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
     }
 
     return std::make_unique<Dynarmic::A32::Jit>(config);

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -185,9 +185,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         config.fastmem_pointer = page_table->fastmem_arena;
         config.fastmem_address_space_bits = address_space_bits;
         config.silently_mirror_fastmem = false;
-
-        config.fastmem_exclusive_access = true;
-        config.recompile_on_exclusive_fastmem_failure = true;
     }
 
     // Multi-process state
@@ -240,12 +237,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_fastmem) {
             config.fastmem_pointer = nullptr;
         }
-        if (!Settings::values.cpuopt_fastmem_exclusives) {
-            config.fastmem_exclusive_access = false;
-        }
-        if (!Settings::values.cpuopt_recompile_exclusives) {
-            config.recompile_on_exclusive_fastmem_failure = false;
-        }
     }
 
     // Unsafe optimizations
@@ -263,9 +254,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_fastmem_check) {
             config.fastmem_address_space_bits = 64;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_global_monitor) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
-        }
     }
 
     // Curated optimizations
@@ -274,7 +262,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         config.fastmem_address_space_bits = 64;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
     }
 
     return std::make_shared<Dynarmic::A64::Jit>(config);

src/core/arm/dynarmic/arm_exclusive_monitor.cpp

@@ -37,8 +37,8 @@ u128 DynarmicExclusiveMonitor::ExclusiveRead128(std::size_t core_index, VAddr ad
     });
 }
 
-void DynarmicExclusiveMonitor::ClearExclusive(std::size_t core_index) {
-    monitor.ClearProcessor(core_index);
+void DynarmicExclusiveMonitor::ClearExclusive() {
+    monitor.Clear();
 }
 
 bool DynarmicExclusiveMonitor::ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) {

src/core/arm/dynarmic/arm_exclusive_monitor.h

@@ -29,7 +29,7 @@ public:
     u32 ExclusiveRead32(std::size_t core_index, VAddr addr) override;
     u64 ExclusiveRead64(std::size_t core_index, VAddr addr) override;
     u128 ExclusiveRead128(std::size_t core_index, VAddr addr) override;
-    void ClearExclusive(std::size_t core_index) override;
+    void ClearExclusive() override;
 
     bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) override;
     bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) override;

src/core/arm/exclusive_monitor.h

@@ -23,7 +23,7 @@ public:
     virtual u32 ExclusiveRead32(std::size_t core_index, VAddr addr) = 0;
     virtual u64 ExclusiveRead64(std::size_t core_index, VAddr addr) = 0;
     virtual u128 ExclusiveRead128(std::size_t core_index, VAddr addr) = 0;
-    virtual void ClearExclusive(std::size_t core_index) = 0;
+    virtual void ClearExclusive() = 0;
 
     virtual bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) = 0;
     virtual bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) = 0;

src/core/core.cpp

@@ -28,9 +28,7 @@
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
 #include "core/hid/hid_core.h"
-#include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
@@ -254,16 +252,9 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-
-        // Create a resource limit for the process.
-        const auto physical_memory_size =
-            kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::Application);
-        auto* resource_limit = Kernel::CreateResourceLimitForProcess(system, physical_memory_size);
-
-        // Create the process.
         auto main_process = Kernel::KProcess::Create(system.Kernel());
         ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
-                                            Kernel::KProcess::ProcessType::Userland, resource_limit)
+                                            Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {

src/core/device_memory.cpp

@@ -3,13 +3,10 @@
 // Refer to the license.txt file included.
 
 #include "core/device_memory.h"
-#include "hle/kernel/board/nintendo/nx/k_system_control.h"
 
 namespace Core {
 
-DeviceMemory::DeviceMemory()
-    : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             1ULL << 39} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size, 1ULL << 39} {}
 DeviceMemory::~DeviceMemory() = default;
 
 } // namespace Core

src/core/device_memory.h

@@ -12,8 +12,12 @@ namespace Core {
 namespace DramMemoryMap {
 enum : u64 {
     Base = 0x80000000ULL,
+    Size = 0x100000000ULL,
+    End = Base + Size,
     KernelReserveBase = Base + 0x60000,
     SlabHeapBase = KernelReserveBase + 0x85000,
+    SlapHeapSize = 0xa21000,
+    SlabHeapEnd = SlabHeapBase + SlapHeapSize,
 };
 }; // namespace DramMemoryMap
 

src/core/file_sys/patch_manager.cpp

@@ -128,6 +128,15 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     if (exefs == nullptr)
         return exefs;
 
+    if (Settings::values.dump_exefs) {
+        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
+        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
+        if (dump_dir != nullptr) {
+            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
+            VfsRawCopyD(exefs, exefs_dir);
+        }
+    }
+
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
         std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
@@ -170,15 +179,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         }
     }
 
-    if (Settings::values.dump_exefs) {
-        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
-        if (dump_dir != nullptr) {
-            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
-            VfsRawCopyD(exefs, exefs_dir);
-        }
-    }
-
     return exefs;
 }
 

src/core/file_sys/program_metadata.cpp

@@ -34,11 +34,55 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
         return Loader::ResultStatus::ErrorBadACIHeader;
     }
 
-    if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset)) {
+    // Load acid_file_access per-component instead of the entire struct, since this struct does not
+    // reflect the layout of the real data.
+    std::size_t current_offset = acid_header.fac_offset;
+    if (sizeof(FileAccessControl::version) != file->ReadBytes(&acid_file_access.version,
+                                                              sizeof(FileAccessControl::version),
+                                                              current_offset)) {
+        return Loader::ResultStatus::ErrorBadFileAccessControl;
+    }
+    if (sizeof(FileAccessControl::permissions) !=
+        file->ReadBytes(&acid_file_access.permissions, sizeof(FileAccessControl::permissions),
+                        current_offset += sizeof(FileAccessControl::version) + 3)) {
+        return Loader::ResultStatus::ErrorBadFileAccessControl;
+    }
+    if (sizeof(FileAccessControl::unknown) !=
+        file->ReadBytes(&acid_file_access.unknown, sizeof(FileAccessControl::unknown),
+                        current_offset + sizeof(FileAccessControl::permissions))) {
         return Loader::ResultStatus::ErrorBadFileAccessControl;
     }
 
-    if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset)) {
+    // Load aci_file_access per-component instead of the entire struct, same as acid_file_access
+    current_offset = aci_header.fah_offset;
+    if (sizeof(FileAccessHeader::version) != file->ReadBytes(&aci_file_access.version,
+                                                             sizeof(FileAccessHeader::version),
+                                                             current_offset)) {
+        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+    }
+    if (sizeof(FileAccessHeader::permissions) !=
+        file->ReadBytes(&aci_file_access.permissions, sizeof(FileAccessHeader::permissions),
+                        current_offset += sizeof(FileAccessHeader::version) + 3)) {
+        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+    }
+    if (sizeof(FileAccessHeader::unk_offset) !=
+        file->ReadBytes(&aci_file_access.unk_offset, sizeof(FileAccessHeader::unk_offset),
+                        current_offset += sizeof(FileAccessHeader::permissions))) {
+        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+    }
+    if (sizeof(FileAccessHeader::unk_size) !=
+        file->ReadBytes(&aci_file_access.unk_size, sizeof(FileAccessHeader::unk_size),
+                        current_offset += sizeof(FileAccessHeader::unk_offset))) {
+        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+    }
+    if (sizeof(FileAccessHeader::unk_offset_2) !=
+        file->ReadBytes(&aci_file_access.unk_offset_2, sizeof(FileAccessHeader::unk_offset_2),
+                        current_offset += sizeof(FileAccessHeader::unk_size))) {
+        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+    }
+    if (sizeof(FileAccessHeader::unk_size_2) !=
+        file->ReadBytes(&aci_file_access.unk_size_2, sizeof(FileAccessHeader::unk_size_2),
+                        current_offset + sizeof(FileAccessHeader::unk_offset_2))) {
         return Loader::ResultStatus::ErrorBadFileAccessHeader;
     }
 
@@ -153,9 +197,7 @@ void ProgramMetadata::Print() const {
     LOG_DEBUG(Service_FS, " > Is Retail:           {}", acid_header.is_retail ? "YES" : "NO");
     LOG_DEBUG(Service_FS, "Title ID Min:           0x{:016X}", acid_header.title_id_min);
     LOG_DEBUG(Service_FS, "Title ID Max:           0x{:016X}", acid_header.title_id_max);
-    u64_le permissions_l; // local copy to fix alignment error
-    std::memcpy(&permissions_l, &acid_file_access.permissions, sizeof(permissions_l));
-    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", permissions_l);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", acid_file_access.permissions);
 
     // Begin ACI0 printing (actual perms, unsigned)
     LOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());

src/core/file_sys/program_metadata.h

@@ -143,20 +143,18 @@ private:
 
     static_assert(sizeof(AciHeader) == 0x40, "ACI0 header structure size is wrong");
 
-#pragma pack(push, 1)
-
+    // FileAccessControl and FileAccessHeader need loaded per-component: this layout does not
+    // reflect the real layout to avoid reference binding to misaligned addresses
     struct FileAccessControl {
         u8 version;
-        INSERT_PADDING_BYTES(3);
+        // 3 padding bytes
         u64_le permissions;
         std::array<u8, 0x20> unknown;
     };
 
-    static_assert(sizeof(FileAccessControl) == 0x2C, "FS access control structure size is wrong");
-
     struct FileAccessHeader {
         u8 version;
-        INSERT_PADDING_BYTES(3);
+        // 3 padding bytes
         u64_le permissions;
         u32_le unk_offset;
         u32_le unk_size;
@@ -164,10 +162,6 @@ private:
         u32_le unk_size_2;
     };
 
-    static_assert(sizeof(FileAccessHeader) == 0x1C, "FS access header structure size is wrong");
-
-#pragma pack(pop)
-
     Header npdm_header;
     AciHeader aci_header;
     AcidHeader acid_header;

src/core/hid/emulated_controller.cpp

@@ -885,12 +885,6 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
     return SetVibration(device_index, DEFAULT_VIBRATION_VALUE);
 }
 
-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)];
-    return output_device->SetPollingMode(polling_mode) == Common::Input::PollingError::None;
-}
-
 void EmulatedController::SetLedPattern() {
     for (auto& device : output_devices) {
         if (!device) {

src/core/hid/emulated_controller.h

@@ -299,23 +299,16 @@ public:
 
     /**
      * Sends a specific vibration to the output device
-     * @return true if vibration had no errors
+     * @return returns true if vibration had no errors
      */
     bool SetVibration(std::size_t device_index, VibrationValue vibration);
 
     /**
      * Sends a small vibration to the output device
-     * @return true if SetVibration was successfull
+     * @return returns true if SetVibration was successfull
      */
     bool TestVibration(std::size_t device_index);
 
-    /**
-     * Sets the desired data to be polled from a controller
-     * @param polling_mode type of input desired buttons, gyro, nfc, ir, etc.
-     * @return true if SetPollingMode was successfull
-     */
-    bool SetPollingMode(Common::Input::PollingMode polling_mode);
-
     /// Returns the led pattern corresponding to this emulated controller
     LedPattern GetLedPattern() const;
 

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -5,7 +5,6 @@
 #include <random>
 
 #include "common/literals.h"
-#include "common/settings.h"
 
 #include "core/hle/kernel/board/nintendo/nx/k_system_control.h"
 #include "core/hle/kernel/board/nintendo/nx/secure_monitor.h"
@@ -29,13 +28,30 @@ namespace {
 
 using namespace Common::Literals;
 
+u32 GetMemoryModeForInit() {
+    return 0x01;
+}
+
 u32 GetMemorySizeForInit() {
-    return Settings::values.use_extended_memory_layout ? Smc::MemorySize_6GB : Smc::MemorySize_4GB;
+    return 0;
 }
 
 Smc::MemoryArrangement GetMemoryArrangeForInit() {
-    return Settings::values.use_extended_memory_layout ? Smc::MemoryArrangement_6GB
-                                                       : Smc::MemoryArrangement_4GB;
+    switch (GetMemoryModeForInit() & 0x3F) {
+    case 0x01:
+    default:
+        return Smc::MemoryArrangement_4GB;
+    case 0x02:
+        return Smc::MemoryArrangement_4GBForAppletDev;
+    case 0x03:
+        return Smc::MemoryArrangement_4GBForSystemDev;
+    case 0x11:
+        return Smc::MemoryArrangement_6GB;
+    case 0x12:
+        return Smc::MemoryArrangement_6GBForAppletDev;
+    case 0x21:
+        return Smc::MemoryArrangement_8GB;
+    }
 }
 } // namespace
 

src/core/hle/kernel/k_address_arbiter.cpp

@@ -49,7 +49,7 @@ bool DecrementIfLessThan(Core::System& system, s32* out, VAddr address, s32 valu
         }
     } else {
         // Otherwise, clear our exclusive hold and finish
-        monitor.ClearExclusive(current_core);
+        monitor.ClearExclusive();
     }
 
     // We're done.
@@ -78,7 +78,7 @@ bool UpdateIfEqual(Core::System& system, s32* out, VAddr address, s32 value, s32
         }
     } else {
         // Otherwise, clear our exclusive hold and finish.
-        monitor.ClearExclusive(current_core);
+        monitor.ClearExclusive();
     }
 
     // We're done.

src/core/hle/kernel/k_event.cpp

@@ -14,7 +14,7 @@ KEvent::KEvent(KernelCore& kernel_)
 
 KEvent::~KEvent() = default;
 
-void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
+void KEvent::Initialize(std::string&& name_) {
     // Increment reference count.
     // Because reference count is one on creation, this will result
     // in a reference count of two. Thus, when both readable and
@@ -30,8 +30,10 @@ void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
     writable_event.Initialize(this, name_ + ":Writable");
 
     // Set our owner process.
-    owner = owner_;
-    owner->Open();
+    owner = kernel.CurrentProcess();
+    if (owner) {
+        owner->Open();
+    }
 
     // Mark initialized.
     name = std::move(name_);
@@ -45,8 +47,10 @@ void KEvent::Finalize() {
 void KEvent::PostDestroy(uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
-    owner->Close();
+    if (owner) {
+        owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
+        owner->Close();
+    }
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_event.h

@@ -22,7 +22,7 @@ public:
     explicit KEvent(KernelCore& kernel_);
     ~KEvent() override;
 
-    void Initialize(std::string&& name, KProcess* owner_);
+    void Initialize(std::string&& name);
 
     void Finalize() override;
 

src/core/hle/kernel/k_page_table.cpp

@@ -41,6 +41,24 @@ constexpr std::size_t GetAddressSpaceWidthFromType(FileSys::ProgramAddressSpaceT
     }
 }
 
+constexpr u64 GetAddressInRange(const KMemoryInfo& info, VAddr addr) {
+    if (info.GetAddress() < addr) {
+        return addr;
+    }
+    return info.GetAddress();
+}
+
+constexpr std::size_t GetSizeInRange(const KMemoryInfo& info, VAddr start, VAddr end) {
+    std::size_t size{info.GetSize()};
+    if (info.GetAddress() < start) {
+        size -= start - info.GetAddress();
+    }
+    if (info.GetEndAddress() > end) {
+        size -= info.GetEndAddress() - end;
+    }
+    return size;
+}
+
 } // namespace
 
 KPageTable::KPageTable(Core::System& system_)
@@ -382,471 +400,148 @@ ResultCode KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
-    // Lock the physical memory lock.
-    KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
-
-    // Calculate the last address for convenience.
-    const VAddr last_address = address + size - 1;
-
-    // Define iteration variables.
-    VAddr cur_address;
-    std::size_t mapped_size;
-
-    // The entire mapping process can be retried.
-    while (true) {
-        // Check if the memory is already mapped.
-        {
-            // Lock the table.
-            KScopedLightLock lk(general_lock);
-
-            // Iterate over the memory.
-            cur_address = address;
-            mapped_size = 0;
-
-            auto it = block_manager->FindIterator(cur_address);
-            while (true) {
-                // Check that the iterator is valid.
-                ASSERT(it != block_manager->end());
-
-                // Get the memory info.
-                const KMemoryInfo info = it->GetMemoryInfo();
-
-                // Check if we're done.
-                if (last_address <= info.GetLastAddress()) {
-                    if (info.GetState() != KMemoryState::Free) {
-                        mapped_size += (last_address + 1 - cur_address);
-                    }
-                    break;
-                }
-
-                // Track the memory if it's mapped.
-                if (info.GetState() != KMemoryState::Free) {
-                    mapped_size += VAddr(info.GetEndAddress()) - cur_address;
-                }
-
-                // Advance.
-                cur_address = info.GetEndAddress();
-                ++it;
-            }
-
-            // If the size mapped is the size requested, we've nothing to do.
-            R_SUCCEED_IF(size == mapped_size);
-        }
-
-        // Allocate and map the memory.
-        {
-            // Reserve the memory from the process resource limit.
-            KScopedResourceReservation memory_reservation(
-                system.Kernel().CurrentProcess()->GetResourceLimit(),
-                LimitableResource::PhysicalMemory, size - mapped_size);
-            R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
-
-            // Allocate pages for the new memory.
-            KPageLinkedList page_linked_list;
-            R_TRY(system.Kernel().MemoryManager().Allocate(
-                page_linked_list, (size - mapped_size) / PageSize, memory_pool, allocation_option));
-
-            // Map the memory.
-            {
-                // Lock the table.
-                KScopedLightLock lk(general_lock);
-
-                size_t num_allocator_blocks = 0;
-
-                // Verify that nobody has mapped memory since we first checked.
-                {
-                    // Iterate over the memory.
-                    size_t checked_mapped_size = 0;
-                    cur_address = address;
-
-                    auto it = block_manager->FindIterator(cur_address);
-                    while (true) {
-                        // Check that the iterator is valid.
-                        ASSERT(it != block_manager->end());
-
-                        // Get the memory info.
-                        const KMemoryInfo info = it->GetMemoryInfo();
-
-                        const bool is_free = info.GetState() == KMemoryState::Free;
-                        if (is_free) {
-                            if (info.GetAddress() < address) {
-                                ++num_allocator_blocks;
-                            }
-                            if (last_address < info.GetLastAddress()) {
-                                ++num_allocator_blocks;
-                            }
-                        }
-
-                        // Check if we're done.
-                        if (last_address <= info.GetLastAddress()) {
-                            if (!is_free) {
-                                checked_mapped_size += (last_address + 1 - cur_address);
-                            }
-                            break;
-                        }
-
-                        // Track the memory if it's mapped.
-                        if (!is_free) {
-                            checked_mapped_size += VAddr(info.GetEndAddress()) - cur_address;
-                        }
-
-                        // Advance.
-                        cur_address = info.GetEndAddress();
-                        ++it;
-                    }
-
-                    // If the size now isn't what it was before, somebody mapped or unmapped
-                    // concurrently. If this happened, retry.
-                    if (mapped_size != checked_mapped_size) {
-                        continue;
-                    }
-                }
-
-                // Reset the current tracking address, and make sure we clean up on failure.
-                cur_address = address;
-                auto unmap_guard = detail::ScopeExit([&] {
-                    if (cur_address > address) {
-                        const VAddr last_unmap_address = cur_address - 1;
-
-                        // Iterate, unmapping the pages.
-                        cur_address = address;
-
-                        auto it = block_manager->FindIterator(cur_address);
-                        while (true) {
-                            // Check that the iterator is valid.
-                            ASSERT(it != block_manager->end());
-
-                            // Get the memory info.
-                            const KMemoryInfo info = it->GetMemoryInfo();
-
-                            // If the memory state is free, we mapped it and need to unmap it.
-                            if (info.GetState() == KMemoryState::Free) {
-                                // Determine the range to unmap.
-                                const size_t cur_pages =
-                                    std::min(VAddr(info.GetEndAddress()) - cur_address,
-                                             last_unmap_address + 1 - cur_address) /
-                                    PageSize;
-
-                                // Unmap.
-                                ASSERT(Operate(cur_address, cur_pages, KMemoryPermission::None,
-                                               OperationType::Unmap)
-                                           .IsSuccess());
-                            }
-
-                            // Check if we're done.
-                            if (last_unmap_address <= info.GetLastAddress()) {
-                                break;
-                            }
-
-                            // Advance.
-                            cur_address = info.GetEndAddress();
-                            ++it;
-                        }
-                    }
-                });
-
-                // Iterate over the memory.
-                auto pg_it = page_linked_list.Nodes().begin();
-                PAddr pg_phys_addr = pg_it->GetAddress();
-                size_t pg_pages = pg_it->GetNumPages();
-
-                auto it = block_manager->FindIterator(cur_address);
-                while (true) {
-                    // Check that the iterator is valid.
-                    ASSERT(it != block_manager->end());
-
-                    // Get the memory info.
-                    const KMemoryInfo info = it->GetMemoryInfo();
-
-                    // If it's unmapped, we need to map it.
-                    if (info.GetState() == KMemoryState::Free) {
-                        // Determine the range to map.
-                        size_t map_pages = std::min(VAddr(info.GetEndAddress()) - cur_address,
-                                                    last_address + 1 - cur_address) /
-                                           PageSize;
-
-                        // While we have pages to map, map them.
-                        while (map_pages > 0) {
-                            // Check if we're at the end of the physical block.
-                            if (pg_pages == 0) {
-                                // Ensure there are more pages to map.
-                                ASSERT(pg_it != page_linked_list.Nodes().end());
-
-                                // Advance our physical block.
-                                ++pg_it;
-                                pg_phys_addr = pg_it->GetAddress();
-                                pg_pages = pg_it->GetNumPages();
-                            }
-
-                            // Map whatever we can.
-                            const size_t cur_pages = std::min(pg_pages, map_pages);
-                            R_TRY(Operate(cur_address, cur_pages, KMemoryPermission::UserReadWrite,
-                                          OperationType::Map, pg_phys_addr));
-
-                            // Advance.
-                            cur_address += cur_pages * PageSize;
-                            map_pages -= cur_pages;
-
-                            pg_phys_addr += cur_pages * PageSize;
-                            pg_pages -= cur_pages;
-                        }
-                    }
-
-                    // Check if we're done.
-                    if (last_address <= info.GetLastAddress()) {
-                        break;
-                    }
-
-                    // Advance.
-                    cur_address = info.GetEndAddress();
-                    ++it;
-                }
-
-                // We succeeded, so commit the memory reservation.
-                memory_reservation.Commit();
-
-                // Increase our tracked mapped size.
-                mapped_physical_memory_size += (size - mapped_size);
-
-                // Update the relevant memory blocks.
-                block_manager->Update(address, size / PageSize, KMemoryState::Free,
-                                      KMemoryPermission::None, KMemoryAttribute::None,
-                                      KMemoryState::Normal, KMemoryPermission::UserReadWrite,
-                                      KMemoryAttribute::None);
-
-                // Cancel our guard.
-                unmap_guard.Cancel();
-
-                return ResultSuccess;
-            }
-        }
-    }
-}
-
-ResultCode KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
+ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
     // Lock the physical memory lock.
     KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
 
     // Lock the table.
     KScopedLightLock lk(general_lock);
 
-    // Calculate the last address for convenience.
-    const VAddr last_address = address + size - 1;
+    std::size_t mapped_size{};
+    const VAddr end_addr{addr + size};
 
-    // Define iteration variables.
-    VAddr cur_address = 0;
-    std::size_t mapped_size = 0;
-    std::size_t num_allocator_blocks = 0;
-
-    // Check if the memory is mapped.
-    {
-        // Iterate over the memory.
-        cur_address = address;
-        mapped_size = 0;
-
-        auto it = block_manager->FindIterator(cur_address);
-        while (true) {
-            // Check that the iterator is valid.
-            ASSERT(it != block_manager->end());
-
-            // Get the memory info.
-            const KMemoryInfo info = it->GetMemoryInfo();
-
-            // Verify the memory's state.
-            const bool is_normal = info.GetState() == KMemoryState::Normal &&
-                                   info.GetAttribute() == KMemoryAttribute::None;
-            const bool is_free = info.GetState() == KMemoryState::Free;
-            R_UNLESS(is_normal || is_free, ResultInvalidCurrentMemory);
-
-            if (is_normal) {
-                R_UNLESS(info.GetAttribute() == KMemoryAttribute::None, ResultInvalidCurrentMemory);
-
-                if (info.GetAddress() < address) {
-                    ++num_allocator_blocks;
-                }
-                if (last_address < info.GetLastAddress()) {
-                    ++num_allocator_blocks;
-                }
-            }
-
-            // Check if we're done.
-            if (last_address <= info.GetLastAddress()) {
-                if (is_normal) {
-                    mapped_size += (last_address + 1 - cur_address);
-                }
-                break;
-            }
-
-            // Track the memory if it's mapped.
-            if (is_normal) {
-                mapped_size += VAddr(info.GetEndAddress()) - cur_address;
-            }
-
-            // Advance.
-            cur_address = info.GetEndAddress();
-            ++it;
-        }
-
-        // If there's nothing mapped, we've nothing to do.
-        R_SUCCEED_IF(mapped_size == 0);
-    }
-
-    // Make a page group for the unmap region.
-    KPageLinkedList pg;
-    {
-        auto& impl = this->PageTableImpl();
-
-        // Begin traversal.
-        Common::PageTable::TraversalContext context;
-        Common::PageTable::TraversalEntry cur_entry = {.phys_addr = 0, .block_size = 0};
-        bool cur_valid = false;
-        Common::PageTable::TraversalEntry next_entry;
-        bool next_valid = false;
-        size_t tot_size = 0;
-
-        cur_address = address;
-        next_valid = impl.BeginTraversal(next_entry, context, cur_address);
-        next_entry.block_size =
-            (next_entry.block_size - (next_entry.phys_addr & (next_entry.block_size - 1)));
-
-        // Iterate, building the group.
-        while (true) {
-            if ((!next_valid && !cur_valid) ||
-                (next_valid && cur_valid &&
-                 next_entry.phys_addr == cur_entry.phys_addr + cur_entry.block_size)) {
-                cur_entry.block_size += next_entry.block_size;
-            } else {
-                if (cur_valid) {
-                    // ASSERT(IsHeapPhysicalAddress(cur_entry.phys_addr));
-                    R_TRY(pg.AddBlock(cur_entry.phys_addr, cur_entry.block_size / PageSize));
-                }
-
-                // Update tracking variables.
-                tot_size += cur_entry.block_size;
-                cur_entry = next_entry;
-                cur_valid = next_valid;
-            }
-
-            if (cur_entry.block_size + tot_size >= size) {
-                break;
-            }
-
-            next_valid = impl.ContinueTraversal(next_entry, context);
-        }
-
-        // Add the last block.
-        if (cur_valid) {
-            // ASSERT(IsHeapPhysicalAddress(cur_entry.phys_addr));
-            R_TRY(pg.AddBlock(cur_entry.phys_addr, (size - tot_size) / PageSize));
-        }
-    }
-    ASSERT(pg.GetNumPages() == mapped_size / PageSize);
-
-    // Reset the current tracking address, and make sure we clean up on failure.
-    cur_address = address;
-    auto remap_guard = detail::ScopeExit([&] {
-        if (cur_address > address) {
-            const VAddr last_map_address = cur_address - 1;
-            cur_address = address;
-
-            // Iterate over the memory we unmapped.
-            auto it = block_manager->FindIterator(cur_address);
-            auto pg_it = pg.Nodes().begin();
-            PAddr pg_phys_addr = pg_it->GetAddress();
-            size_t pg_pages = pg_it->GetNumPages();
-
-            while (true) {
-                // Get the memory info for the pages we unmapped, convert to property.
-                const KMemoryInfo info = it->GetMemoryInfo();
-
-                // If the memory is normal, we unmapped it and need to re-map it.
-                if (info.GetState() == KMemoryState::Normal) {
-                    // Determine the range to map.
-                    size_t map_pages = std::min(VAddr(info.GetEndAddress()) - cur_address,
-                                                last_map_address + 1 - cur_address) /
-                                       PageSize;
-
-                    // While we have pages to map, map them.
-                    while (map_pages > 0) {
-                        // Check if we're at the end of the physical block.
-                        if (pg_pages == 0) {
-                            // Ensure there are more pages to map.
-                            ASSERT(pg_it != pg.Nodes().end());
-
-                            // Advance our physical block.
-                            ++pg_it;
-                            pg_phys_addr = pg_it->GetAddress();
-                            pg_pages = pg_it->GetNumPages();
-                        }
-
-                        // Map whatever we can.
-                        const size_t cur_pages = std::min(pg_pages, map_pages);
-                        ASSERT(this->Operate(cur_address, cur_pages, info.GetPermission(),
-                                             OperationType::Map, pg_phys_addr) == ResultSuccess);
-
-                        // Advance.
-                        cur_address += cur_pages * PageSize;
-                        map_pages -= cur_pages;
-
-                        pg_phys_addr += cur_pages * PageSize;
-                        pg_pages -= cur_pages;
-                    }
-                }
-
-                // Check if we're done.
-                if (last_map_address <= info.GetLastAddress()) {
-                    break;
-                }
-
-                // Advance.
-                ++it;
-            }
+    block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
+        if (info.state != KMemoryState::Free) {
+            mapped_size += GetSizeInRange(info, addr, end_addr);
         }
     });
 
-    // Iterate over the memory, unmapping as we go.
-    auto it = block_manager->FindIterator(cur_address);
-    while (true) {
-        // Check that the iterator is valid.
-        ASSERT(it != block_manager->end());
-
-        // Get the memory info.
-        const KMemoryInfo info = it->GetMemoryInfo();
-
-        // If the memory state is normal, we need to unmap it.
-        if (info.GetState() == KMemoryState::Normal) {
-            // Determine the range to unmap.
-            const size_t cur_pages = std::min(VAddr(info.GetEndAddress()) - cur_address,
-                                              last_address + 1 - cur_address) /
-                                     PageSize;
-
-            // Unmap.
-            R_TRY(Operate(cur_address, cur_pages, KMemoryPermission::None, OperationType::Unmap));
-        }
-
-        // Check if we're done.
-        if (last_address <= info.GetLastAddress()) {
-            break;
-        }
-
-        // Advance.
-        cur_address = info.GetEndAddress();
-        ++it;
+    if (mapped_size == size) {
+        return ResultSuccess;
     }
 
-    // Release the memory resource.
-    mapped_physical_memory_size -= mapped_size;
+    const std::size_t remaining_size{size - mapped_size};
+    const std::size_t remaining_pages{remaining_size / PageSize};
+
+    // Reserve the memory from the process resource limit.
+    KScopedResourceReservation memory_reservation(
+        system.Kernel().CurrentProcess()->GetResourceLimit(), LimitableResource::PhysicalMemory,
+        remaining_size);
+    if (!memory_reservation.Succeeded()) {
+        LOG_ERROR(Kernel, "Could not reserve remaining {:X} bytes", remaining_size);
+        return ResultLimitReached;
+    }
+
+    KPageLinkedList page_linked_list;
+
+    CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages,
+                                                          memory_pool, allocation_option));
+
+    // We succeeded, so commit the memory reservation.
+    memory_reservation.Commit();
+
+    // Map the memory.
+    auto node{page_linked_list.Nodes().begin()};
+    PAddr map_addr{node->GetAddress()};
+    std::size_t src_num_pages{node->GetNumPages()};
+    block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
+        if (info.state != KMemoryState::Free) {
+            return;
+        }
+
+        std::size_t dst_num_pages{GetSizeInRange(info, addr, end_addr) / PageSize};
+        VAddr dst_addr{GetAddressInRange(info, addr)};
+
+        while (dst_num_pages) {
+            if (!src_num_pages) {
+                node = std::next(node);
+                map_addr = node->GetAddress();
+                src_num_pages = node->GetNumPages();
+            }
+
+            const std::size_t num_pages{std::min(src_num_pages, dst_num_pages)};
+            Operate(dst_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::Map,
+                    map_addr);
+
+            dst_addr += num_pages * PageSize;
+            map_addr += num_pages * PageSize;
+            src_num_pages -= num_pages;
+            dst_num_pages -= num_pages;
+        }
+    });
+
+    mapped_physical_memory_size += remaining_size;
+
+    const std::size_t num_pages{size / PageSize};
+    block_manager->Update(addr, num_pages, KMemoryState::Free, KMemoryPermission::None,
+                          KMemoryAttribute::None, KMemoryState::Normal,
+                          KMemoryPermission::UserReadWrite, KMemoryAttribute::None);
+
+    return ResultSuccess;
+}
+
+ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
+    // Lock the physical memory lock.
+    KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
+
+    // Lock the table.
+    KScopedLightLock lk(general_lock);
+
+    const VAddr end_addr{addr + size};
+    ResultCode result{ResultSuccess};
+    std::size_t mapped_size{};
+
+    // Verify that the region can be unmapped
+    block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
+        if (info.state == KMemoryState::Normal) {
+            if (info.attribute != KMemoryAttribute::None) {
+                result = ResultInvalidCurrentMemory;
+                return;
+            }
+            mapped_size += GetSizeInRange(info, addr, end_addr);
+        } else if (info.state != KMemoryState::Free) {
+            result = ResultInvalidCurrentMemory;
+        }
+    });
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    if (!mapped_size) {
+        return ResultSuccess;
+    }
+
+    // Unmap each region within the range
+    KPageLinkedList page_linked_list;
+    block_manager->IterateForRange(addr, end_addr, [&](const KMemoryInfo& info) {
+        if (info.state == KMemoryState::Normal) {
+            const std::size_t block_size{GetSizeInRange(info, addr, end_addr)};
+            const std::size_t block_num_pages{block_size / PageSize};
+            const VAddr block_addr{GetAddressInRange(info, addr)};
+
+            AddRegionToPages(block_addr, block_size / PageSize, page_linked_list);
+
+            if (result = Operate(block_addr, block_num_pages, KMemoryPermission::None,
+                                 OperationType::Unmap);
+                result.IsError()) {
+                return;
+            }
+        }
+    });
+    if (result.IsError()) {
+        return result;
+    }
+
+    const std::size_t num_pages{size / PageSize};
+    system.Kernel().MemoryManager().Free(page_linked_list, num_pages, memory_pool,
+                                         allocation_option);
+
+    block_manager->Update(addr, num_pages, KMemoryState::Free);
+
     auto process{system.Kernel().CurrentProcess()};
     process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
-
-    // Update memory blocks.
-    system.Kernel().MemoryManager().Free(pg, size / PageSize, memory_pool, allocation_option);
-    block_manager->Update(address, size / PageSize, KMemoryState::Free, KMemoryPermission::None,
-                          KMemoryAttribute::None);
-
-    // We succeeded.
-    remap_guard.Cancel();
+    mapped_physical_memory_size -= mapped_size;
 
     return ResultSuccess;
 }
@@ -986,8 +681,9 @@ ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked
     VAddr cur_addr{addr};
 
     for (const auto& node : page_linked_list.Nodes()) {
-        if (const auto result{Operate(cur_addr, node.GetNumPages(), KMemoryPermission::None,
-                                      OperationType::Unmap)};
+        const std::size_t num_pages{(addr - cur_addr) / PageSize};
+        if (const auto result{
+                Operate(addr, num_pages, KMemoryPermission::None, OperationType::Unmap)};
             result.IsError()) {
             return result;
         }

src/core/hle/kernel/k_process.cpp

@@ -123,11 +123,12 @@ private:
 };
 
 ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                ProcessType type, KResourceLimit* res_limit) {
+                                ProcessType type) {
     auto& kernel = system.Kernel();
 
     process->name = std::move(process_name);
-    process->resource_limit = res_limit;
+
+    process->resource_limit = kernel.GetSystemResourceLimit();
     process->status = ProcessStatus::Created;
     process->program_id = 0;
     process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
@@ -142,6 +143,9 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
 
     kernel.AppendNewProcess(process);
 
+    // Open a reference to the resource limit.
+    process->resource_limit->Open();
+
     // Clear remaining fields.
     process->num_running_threads = 0;
     process->is_signaled = false;
@@ -149,9 +153,6 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
     process->is_suspended = false;
     process->schedule_count = 0;
 
-    // Open a reference to the resource limit.
-    process->resource_limit->Open();
-
     return ResultSuccess;
 }
 

src/core/hle/kernel/k_process.h

@@ -91,7 +91,7 @@ public:
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
     static ResultCode Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                 ProcessType type, KResourceLimit* res_limit);
+                                 ProcessType type);
 
     /// Gets a reference to the process' page table.
     KPageTable& PageTable() {

src/core/hle/kernel/k_resource_limit.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/svc_results.h"
@@ -152,22 +151,4 @@ void KResourceLimit::Release(LimitableResource which, s64 value, s64 hint) {
     }
 }
 
-KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size) {
-    auto* resource_limit = KResourceLimit::Create(system.Kernel());
-    resource_limit->Initialize(&system.CoreTiming());
-
-    // Initialize default resource limit values.
-    // TODO(bunnei): These values are the system defaults, the limits for service processes are
-    // lower. These should use the correct limit values.
-
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::PhysicalMemory, physical_memory_size)
-               .IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Threads, 800).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Events, 900).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::TransferMemory, 200).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Sessions, 1133).IsSuccess());
-
-    return resource_limit;
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_resource_limit.h

@@ -67,7 +67,4 @@ private:
     KLightConditionVariable cond_var;
     const Core::Timing::CoreTiming* core_timing{};
 };
-
-KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size);
-
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -240,6 +240,13 @@ struct KernelCore::Impl {
         constexpr u64 secure_applet_memory_size{4_MiB};
         ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
                                               secure_applet_memory_size));
+
+        // This memory seems to be reserved on hardware, but is not reserved/used by yuzu.
+        // Likely Horizon OS reserved memory
+        // TODO(ameerj): Derive the memory rather than hardcode it.
+        constexpr u64 unknown_reserved_memory{0x2f896000};
+        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
+                                              unknown_reserved_memory));
     }
 
     void InitializePreemption(KernelCore& kernel) {

src/core/hle/kernel/svc.cpp

@@ -645,10 +645,6 @@ static void OutputDebugString(Core::System& system, VAddr address, u64 len) {
     LOG_DEBUG(Debug_Emulated, "{}", str);
 }
 
-static void OutputDebugString32(Core::System& system, u32 address, u32 len) {
-    OutputDebugString(system, address, len);
-}
-
 /// Gets system/memory information for the current process
 static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle,
                           u64 info_sub_id) {
@@ -1408,7 +1404,7 @@ static ResultCode UnmapProcessMemory(Core::System& system, VAddr dst_address, Ha
 }
 
 static ResultCode CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size) {
-    LOG_TRACE(Kernel_SVC, "called, handle_out={}, address=0x{:X}, size=0x{:X}",
+    LOG_TRACE(Kernel_SVC, "called, handle_out=0x{:X}, address=0x{:X}, size=0x{:X}",
               static_cast<void*>(out), address, size);
     // Get kernel instance.
     auto& kernel = system.Kernel();
@@ -1442,10 +1438,6 @@ static ResultCode CreateCodeMemory(Core::System& system, Handle* out, VAddr addr
     return ResultSuccess;
 }
 
-static ResultCode CreateCodeMemory32(Core::System& system, Handle* out, u32 address, u32 size) {
-    return CreateCodeMemory(system, out, address, size);
-}
-
 static ResultCode ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
                                     VAddr address, size_t size, Svc::MemoryPermission perm) {
 
@@ -1525,12 +1517,6 @@ static ResultCode ControlCodeMemory(Core::System& system, Handle code_memory_han
     return ResultSuccess;
 }
 
-static ResultCode ControlCodeMemory32(Core::System& system, Handle code_memory_handle,
-                                      u32 operation, u64 address, u64 size,
-                                      Svc::MemoryPermission perm) {
-    return ControlCodeMemory(system, code_memory_handle, operation, address, size, perm);
-}
-
 static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_address,
                                      VAddr page_info_address, Handle process_handle,
                                      VAddr address) {
@@ -2332,7 +2318,7 @@ static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* o
     R_UNLESS(event != nullptr, ResultOutOfResource);
 
     // Initialize the event.
-    event->Initialize("CreateEvent", kernel.CurrentProcess());
+    event->Initialize("CreateEvent");
 
     // Commit the thread reservation.
     event_reservation.Commit();
@@ -2573,9 +2559,9 @@ struct FunctionDef {
 } // namespace
 
 static const FunctionDef SVC_Table_32[] = {
-    {0x00, nullptr, "Unknown0"},
+    {0x00, nullptr, "Unknown"},
     {0x01, SvcWrap32<SetHeapSize32>, "SetHeapSize32"},
-    {0x02, nullptr, "SetMemoryPermission32"},
+    {0x02, nullptr, "Unknown"},
     {0x03, SvcWrap32<SetMemoryAttribute32>, "SetMemoryAttribute32"},
     {0x04, SvcWrap32<MapMemory32>, "MapMemory32"},
     {0x05, SvcWrap32<UnmapMemory32>, "UnmapMemory32"},
@@ -2605,97 +2591,97 @@ static const FunctionDef SVC_Table_32[] = {
     {0x1d, SvcWrap32<SignalProcessWideKey32>, "SignalProcessWideKey32"},
     {0x1e, SvcWrap32<GetSystemTick32>, "GetSystemTick32"},
     {0x1f, SvcWrap32<ConnectToNamedPort32>, "ConnectToNamedPort32"},
-    {0x20, nullptr, "SendSyncRequestLight32"},
+    {0x20, nullptr, "Unknown"},
     {0x21, SvcWrap32<SendSyncRequest32>, "SendSyncRequest32"},
     {0x22, nullptr, "SendSyncRequestWithUserBuffer32"},
-    {0x23, nullptr, "SendAsyncRequestWithUserBuffer32"},
+    {0x23, nullptr, "Unknown"},
     {0x24, SvcWrap32<GetProcessId32>, "GetProcessId32"},
     {0x25, SvcWrap32<GetThreadId32>, "GetThreadId32"},
     {0x26, SvcWrap32<Break32>, "Break32"},
-    {0x27, SvcWrap32<OutputDebugString32>, "OutputDebugString32"},
-    {0x28, nullptr, "ReturnFromException32"},
+    {0x27, nullptr, "OutputDebugString32"},
+    {0x28, nullptr, "Unknown"},
     {0x29, SvcWrap32<GetInfo32>, "GetInfo32"},
-    {0x2a, nullptr, "FlushEntireDataCache32"},
-    {0x2b, nullptr, "FlushDataCache32"},
+    {0x2a, nullptr, "Unknown"},
+    {0x2b, nullptr, "Unknown"},
     {0x2c, SvcWrap32<MapPhysicalMemory32>, "MapPhysicalMemory32"},
     {0x2d, SvcWrap32<UnmapPhysicalMemory32>, "UnmapPhysicalMemory32"},
-    {0x2e, nullptr, "GetDebugFutureThreadInfo32"},
-    {0x2f, nullptr, "GetLastThreadInfo32"},
-    {0x30, nullptr, "GetResourceLimitLimitValue32"},
-    {0x31, nullptr, "GetResourceLimitCurrentValue32"},
+    {0x2e, nullptr, "Unknown"},
+    {0x2f, nullptr, "Unknown"},
+    {0x30, nullptr, "Unknown"},
+    {0x31, nullptr, "Unknown"},
     {0x32, SvcWrap32<SetThreadActivity32>, "SetThreadActivity32"},
     {0x33, SvcWrap32<GetThreadContext32>, "GetThreadContext32"},
     {0x34, SvcWrap32<WaitForAddress32>, "WaitForAddress32"},
     {0x35, SvcWrap32<SignalToAddress32>, "SignalToAddress32"},
     {0x36, SvcWrap32<SynchronizePreemptionState>, "SynchronizePreemptionState32"},
-    {0x37, nullptr, "GetResourceLimitPeakValue32"},
-    {0x38, nullptr, "Unknown38"},
-    {0x39, nullptr, "CreateIoPool32"},
-    {0x3a, nullptr, "CreateIoRegion32"},
-    {0x3b, nullptr, "Unknown3b"},
-    {0x3c, nullptr, "KernelDebug32"},
-    {0x3d, nullptr, "ChangeKernelTraceState32"},
-    {0x3e, nullptr, "Unknown3e"},
-    {0x3f, nullptr, "Unknown3f"},
+    {0x37, nullptr, "Unknown"},
+    {0x38, nullptr, "Unknown"},
+    {0x39, nullptr, "Unknown"},
+    {0x3a, nullptr, "Unknown"},
+    {0x3b, nullptr, "Unknown"},
+    {0x3c, nullptr, "Unknown"},
+    {0x3d, nullptr, "Unknown"},
+    {0x3e, nullptr, "Unknown"},
+    {0x3f, nullptr, "Unknown"},
     {0x40, nullptr, "CreateSession32"},
     {0x41, nullptr, "AcceptSession32"},
-    {0x42, nullptr, "ReplyAndReceiveLight32"},
+    {0x42, nullptr, "Unknown"},
     {0x43, nullptr, "ReplyAndReceive32"},
-    {0x44, nullptr, "ReplyAndReceiveWithUserBuffer32"},
+    {0x44, nullptr, "Unknown"},
     {0x45, SvcWrap32<CreateEvent32>, "CreateEvent32"},
-    {0x46, nullptr, "MapIoRegion32"},
-    {0x47, nullptr, "UnmapIoRegion32"},
-    {0x48, nullptr, "MapPhysicalMemoryUnsafe32"},
-    {0x49, nullptr, "UnmapPhysicalMemoryUnsafe32"},
-    {0x4a, nullptr, "SetUnsafeLimit32"},
-    {0x4b, SvcWrap32<CreateCodeMemory32>, "CreateCodeMemory32"},
-    {0x4c, SvcWrap32<ControlCodeMemory32>, "ControlCodeMemory32"},
-    {0x4d, nullptr, "SleepSystem32"},
-    {0x4e, nullptr, "ReadWriteRegister32"},
-    {0x4f, nullptr, "SetProcessActivity32"},
-    {0x50, nullptr, "CreateSharedMemory32"},
-    {0x51, nullptr, "MapTransferMemory32"},
-    {0x52, nullptr, "UnmapTransferMemory32"},
-    {0x53, nullptr, "CreateInterruptEvent32"},
-    {0x54, nullptr, "QueryPhysicalAddress32"},
-    {0x55, nullptr, "QueryIoMapping32"},
-    {0x56, nullptr, "CreateDeviceAddressSpace32"},
-    {0x57, nullptr, "AttachDeviceAddressSpace32"},
-    {0x58, nullptr, "DetachDeviceAddressSpace32"},
-    {0x59, nullptr, "MapDeviceAddressSpaceByForce32"},
-    {0x5a, nullptr, "MapDeviceAddressSpaceAligned32"},
-    {0x5b, nullptr, "MapDeviceAddressSpace32"},
-    {0x5c, nullptr, "UnmapDeviceAddressSpace32"},
-    {0x5d, nullptr, "InvalidateProcessDataCache32"},
-    {0x5e, nullptr, "StoreProcessDataCache32"},
+    {0x46, nullptr, "Unknown"},
+    {0x47, nullptr, "Unknown"},
+    {0x48, nullptr, "Unknown"},
+    {0x49, nullptr, "Unknown"},
+    {0x4a, nullptr, "Unknown"},
+    {0x4b, nullptr, "Unknown"},
+    {0x4c, nullptr, "Unknown"},
+    {0x4d, nullptr, "Unknown"},
+    {0x4e, nullptr, "Unknown"},
+    {0x4f, nullptr, "Unknown"},
+    {0x50, nullptr, "Unknown"},
+    {0x51, nullptr, "Unknown"},
+    {0x52, nullptr, "Unknown"},
+    {0x53, nullptr, "Unknown"},
+    {0x54, nullptr, "Unknown"},
+    {0x55, nullptr, "Unknown"},
+    {0x56, nullptr, "Unknown"},
+    {0x57, nullptr, "Unknown"},
+    {0x58, nullptr, "Unknown"},
+    {0x59, nullptr, "Unknown"},
+    {0x5a, nullptr, "Unknown"},
+    {0x5b, nullptr, "Unknown"},
+    {0x5c, nullptr, "Unknown"},
+    {0x5d, nullptr, "Unknown"},
+    {0x5e, nullptr, "Unknown"},
     {0x5F, SvcWrap32<FlushProcessDataCache32>, "FlushProcessDataCache32"},
-    {0x60, nullptr, "StoreProcessDataCache32"},
-    {0x61, nullptr, "BreakDebugProcess32"},
-    {0x62, nullptr, "TerminateDebugProcess32"},
-    {0x63, nullptr, "GetDebugEvent32"},
-    {0x64, nullptr, "ContinueDebugEvent32"},
+    {0x60, nullptr, "Unknown"},
+    {0x61, nullptr, "Unknown"},
+    {0x62, nullptr, "Unknown"},
+    {0x63, nullptr, "Unknown"},
+    {0x64, nullptr, "Unknown"},
     {0x65, nullptr, "GetProcessList32"},
-    {0x66, nullptr, "GetThreadList"},
-    {0x67, nullptr, "GetDebugThreadContext32"},
-    {0x68, nullptr, "SetDebugThreadContext32"},
-    {0x69, nullptr, "QueryDebugProcessMemory32"},
-    {0x6A, nullptr, "ReadDebugProcessMemory32"},
-    {0x6B, nullptr, "WriteDebugProcessMemory32"},
-    {0x6C, nullptr, "SetHardwareBreakPoint32"},
-    {0x6D, nullptr, "GetDebugThreadParam32"},
-    {0x6E, nullptr, "Unknown6E"},
+    {0x66, nullptr, "Unknown"},
+    {0x67, nullptr, "Unknown"},
+    {0x68, nullptr, "Unknown"},
+    {0x69, nullptr, "Unknown"},
+    {0x6A, nullptr, "Unknown"},
+    {0x6B, nullptr, "Unknown"},
+    {0x6C, nullptr, "Unknown"},
+    {0x6D, nullptr, "Unknown"},
+    {0x6E, nullptr, "Unknown"},
     {0x6f, nullptr, "GetSystemInfo32"},
     {0x70, nullptr, "CreatePort32"},
     {0x71, nullptr, "ManageNamedPort32"},
     {0x72, nullptr, "ConnectToPort32"},
     {0x73, nullptr, "SetProcessMemoryPermission32"},
-    {0x74, nullptr, "MapProcessMemory32"},
-    {0x75, nullptr, "UnmapProcessMemory32"},
-    {0x76, nullptr, "QueryProcessMemory32"},
+    {0x74, nullptr, "Unknown"},
+    {0x75, nullptr, "Unknown"},
+    {0x76, nullptr, "Unknown"},
     {0x77, nullptr, "MapProcessCodeMemory32"},
     {0x78, nullptr, "UnmapProcessCodeMemory32"},
-    {0x79, nullptr, "CreateProcess32"},
-    {0x7A, nullptr, "StartProcess32"},
+    {0x79, nullptr, "Unknown"},
+    {0x7A, nullptr, "Unknown"},
     {0x7B, nullptr, "TerminateProcess32"},
     {0x7C, nullptr, "GetProcessInfo32"},
     {0x7D, nullptr, "CreateResourceLimit32"},
@@ -2768,7 +2754,7 @@ static const FunctionDef SVC_Table_32[] = {
 };
 
 static const FunctionDef SVC_Table_64[] = {
-    {0x00, nullptr, "Unknown0"},
+    {0x00, nullptr, "Unknown"},
     {0x01, SvcWrap64<SetHeapSize>, "SetHeapSize"},
     {0x02, SvcWrap64<SetMemoryPermission>, "SetMemoryPermission"},
     {0x03, SvcWrap64<SetMemoryAttribute>, "SetMemoryAttribute"},
@@ -2823,23 +2809,23 @@ static const FunctionDef SVC_Table_64[] = {
     {0x34, SvcWrap64<WaitForAddress>, "WaitForAddress"},
     {0x35, SvcWrap64<SignalToAddress>, "SignalToAddress"},
     {0x36, SvcWrap64<SynchronizePreemptionState>, "SynchronizePreemptionState"},
-    {0x37, nullptr, "GetResourceLimitPeakValue"},
-    {0x38, nullptr, "Unknown38"},
-    {0x39, nullptr, "CreateIoPool"},
-    {0x3A, nullptr, "CreateIoRegion"},
-    {0x3B, nullptr, "Unknown3B"},
+    {0x37, nullptr, "Unknown"},
+    {0x38, nullptr, "Unknown"},
+    {0x39, nullptr, "Unknown"},
+    {0x3A, nullptr, "Unknown"},
+    {0x3B, nullptr, "Unknown"},
     {0x3C, SvcWrap64<KernelDebug>, "KernelDebug"},
     {0x3D, SvcWrap64<ChangeKernelTraceState>, "ChangeKernelTraceState"},
-    {0x3E, nullptr, "Unknown3e"},
-    {0x3F, nullptr, "Unknown3f"},
+    {0x3E, nullptr, "Unknown"},
+    {0x3F, nullptr, "Unknown"},
     {0x40, nullptr, "CreateSession"},
     {0x41, nullptr, "AcceptSession"},
     {0x42, nullptr, "ReplyAndReceiveLight"},
     {0x43, nullptr, "ReplyAndReceive"},
     {0x44, nullptr, "ReplyAndReceiveWithUserBuffer"},
     {0x45, SvcWrap64<CreateEvent>, "CreateEvent"},
-    {0x46, nullptr, "MapIoRegion"},
-    {0x47, nullptr, "UnmapIoRegion"},
+    {0x46, nullptr, "Unknown"},
+    {0x47, nullptr, "Unknown"},
     {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
     {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
     {0x4A, nullptr, "SetUnsafeLimit"},
@@ -2878,7 +2864,7 @@ static const FunctionDef SVC_Table_64[] = {
     {0x6B, nullptr, "WriteDebugProcessMemory"},
     {0x6C, nullptr, "SetHardwareBreakPoint"},
     {0x6D, nullptr, "GetDebugThreadParam"},
-    {0x6E, nullptr, "Unknown6E"},
+    {0x6E, nullptr, "Unknown"},
     {0x6F, nullptr, "GetSystemInfo"},
     {0x70, nullptr, "CreatePort"},
     {0x71, nullptr, "ManageNamedPort"},

src/core/hle/kernel/svc_wrap.h

@@ -669,26 +669,4 @@ void SvcWrap32(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-// Used by CreateCodeMemory32
-template <ResultCode func(Core::System&, Handle*, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    Handle handle = 0;
-
-    const u32 retval = func(system, &handle, Param32(system, 1), Param32(system, 2)).raw;
-
-    system.CurrentArmInterface().SetReg(1, handle);
-    FuncReturn(system, retval);
-}
-
-// Used by ControlCodeMemory32
-template <ResultCode func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, Param32(system, 0), Param32(system, 1), Param(system, 2), Param(system, 4),
-             static_cast<Svc::MemoryPermission>(Param32(system, 6)))
-            .raw;
-
-    FuncReturn(system, retval);
-}
-
 } // namespace Kernel

src/core/hle/service/am/am.cpp

@@ -618,7 +618,7 @@ void AppletMessageQueue::PushMessage(AppletMessage msg) {
 AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
     if (messages.empty()) {
         on_new_message->GetWritableEvent().Clear();
-        return AppletMessage::None;
+        return AppletMessage::NoMessage;
     }
     auto msg = messages.front();
     messages.pop();
@@ -633,7 +633,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const {
 }
 
 void AppletMessageQueue::RequestExit() {
-    PushMessage(AppletMessage::Exit);
+    PushMessage(AppletMessage::ExitRequested);
 }
 
 void AppletMessageQueue::FocusStateChanged() {
@@ -732,7 +732,7 @@ void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
     const auto message = msg_queue->PopMessage();
     IPC::ResponseBuilder rb{ctx, 3};
 
-    if (message == AppletMessageQueue::AppletMessage::None) {
+    if (message == AppletMessageQueue::AppletMessage::NoMessage) {
         LOG_ERROR(Service_AM, "Message queue is empty");
         rb.Push(ERR_NO_MESSAGES);
         rb.PushEnum<AppletMessageQueue::AppletMessage>(message);

src/core/hle/service/am/am.h

@@ -22,7 +22,6 @@ class NVFlinger;
 
 namespace Service::AM {
 
-// This is nn::settings::Language
 enum SystemLanguage {
     Japanese = 0,
     English = 1, // en-US
@@ -42,44 +41,16 @@ enum SystemLanguage {
     // 4.0.0+
     SimplifiedChinese = 15,
     TraditionalChinese = 16,
-    // 10.1.0+
-    BrazilianPortuguese = 17,
 };
 
 class AppletMessageQueue {
 public:
-    // This is nn::am::AppletMessage
     enum class AppletMessage : u32 {
-        None = 0,
-        ChangeIntoForeground = 1,
-        ChangeIntoBackground = 2,
-        Exit = 4,
-        ApplicationExited = 6,
+        NoMessage = 0,
+        ExitRequested = 4,
         FocusStateChanged = 15,
-        Resume = 16,
-        DetectShortPressingHomeButton = 20,
-        DetectLongPressingHomeButton = 21,
-        DetectShortPressingPowerButton = 22,
-        DetectMiddlePressingPowerButton = 23,
-        DetectLongPressingPowerButton = 24,
-        RequestToPrepareSleep = 25,
-        FinishedSleepSequence = 26,
-        SleepRequiredByHighTemperature = 27,
-        SleepRequiredByLowBattery = 28,
-        AutoPowerDown = 29,
         OperationModeChanged = 30,
         PerformanceModeChanged = 31,
-        DetectReceivingCecSystemStandby = 32,
-        SdCardRemoved = 33,
-        LaunchApplicationRequested = 50,
-        RequestToDisplay = 51,
-        ShowApplicationLogo = 55,
-        HideApplicationLogo = 56,
-        ForceHideApplicationLogo = 57,
-        FloatingApplicationDetected = 60,
-        DetectShortPressingCaptureButton = 90,
-        AlbumScreenShotTaken = 92,
-        AlbumRecordingSaved = 93,
     };
 
     explicit AppletMessageQueue(Core::System& system);
@@ -208,14 +179,11 @@ public:
     ~ICommonStateGetter() override;
 
 private:
-    // This is nn::oe::FocusState
     enum class FocusState : u8 {
         InFocus = 1,
         NotInFocus = 2,
-        Background = 3,
     };
 
-    // This is nn::oe::OperationMode
     enum class OperationMode : u8 {
         Handheld = 0,
         Docked = 1,

src/core/hle/service/apm/apm_controller.cpp

@@ -17,8 +17,8 @@ constexpr auto DEFAULT_PERFORMANCE_CONFIGURATION = PerformanceConfiguration::Con
 
 Controller::Controller(Core::Timing::CoreTiming& core_timing_)
     : core_timing{core_timing_}, configs{
-                                     {PerformanceMode::Normal, DEFAULT_PERFORMANCE_CONFIGURATION},
-                                     {PerformanceMode::Boost, DEFAULT_PERFORMANCE_CONFIGURATION},
+                                     {PerformanceMode::Handheld, DEFAULT_PERFORMANCE_CONFIGURATION},
+                                     {PerformanceMode::Docked, DEFAULT_PERFORMANCE_CONFIGURATION},
                                  } {}
 
 Controller::~Controller() = default;
@@ -63,13 +63,13 @@ void Controller::SetFromCpuBoostMode(CpuBoostMode mode) {
         PerformanceConfiguration::Config15,
     }};
 
-    SetPerformanceConfiguration(PerformanceMode::Boost,
+    SetPerformanceConfiguration(PerformanceMode::Docked,
                                 BOOST_MODE_TO_CONFIG_MAP.at(static_cast<u32>(mode)));
 }
 
 PerformanceMode Controller::GetCurrentPerformanceMode() const {
-    return Settings::values.use_docked_mode.GetValue() ? PerformanceMode::Boost
-                                                       : PerformanceMode::Normal;
+    return Settings::values.use_docked_mode.GetValue() ? PerformanceMode::Docked
+                                                       : PerformanceMode::Handheld;
 }
 
 PerformanceConfiguration Controller::GetCurrentPerformanceConfiguration(PerformanceMode mode) {

src/core/hle/service/apm/apm_controller.h

@@ -32,18 +32,15 @@ enum class PerformanceConfiguration : u32 {
     Config16 = 0x9222000C,
 };
 
-// This is nn::oe::CpuBoostMode
 enum class CpuBoostMode : u32 {
-    Normal = 0,   // Boost mode disabled
-    FastLoad = 1, // CPU + GPU -> Config 13, 14, 15, or 16
-    Partial = 2,  // GPU Only -> Config 15 or 16
+    Disabled = 0,
+    Full = 1,    // CPU + GPU -> Config 13, 14, 15, or 16
+    Partial = 2, // GPU Only -> Config 15 or 16
 };
 
-// This is nn::oe::PerformanceMode
-enum class PerformanceMode : s32 {
-    Invalid = -1,
-    Normal = 0,
-    Boost = 1,
+enum class PerformanceMode : u8 {
+    Handheld = 0,
+    Docked = 1,
 };
 
 // Class to manage the state and change of the emulated system performance.

src/core/hle/service/kernel_helpers.cpp

@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -17,21 +15,10 @@ namespace Service::KernelHelpers {
 
 ServiceContext::ServiceContext(Core::System& system_, std::string name_)
     : kernel(system_.Kernel()) {
-
-    // Create a resource limit for the process.
-    const auto physical_memory_size =
-        kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::System);
-    auto* resource_limit = Kernel::CreateResourceLimitForProcess(system_, physical_memory_size);
-
-    // Create the process.
     process = Kernel::KProcess::Create(kernel);
     ASSERT(Kernel::KProcess::Initialize(process, system_, std::move(name_),
-                                        Kernel::KProcess::ProcessType::KernelInternal,
-                                        resource_limit)
+                                        Kernel::KProcess::ProcessType::Userland)
                .IsSuccess());
-
-    // Close reference to our resource limit, as the process opens one.
-    resource_limit->Close();
 }
 
 ServiceContext::~ServiceContext() {
@@ -56,7 +43,7 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
     }
 
     // Initialize the event.
-    event->Initialize(std::move(name), process);
+    event->Initialize(std::move(name));
 
     // Commit the thread reservation.
     event_reservation.Commit();

src/core/hle/service/mnpp/mnpp_app.cpp

@@ -1,45 +0,0 @@
-// Copyright 2022 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/mnpp/mnpp_app.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace Service::MNPP {
-
-class MNPP_APP final : public ServiceFramework<MNPP_APP> {
-public:
-    explicit MNPP_APP(Core::System& system_) : ServiceFramework{system_, "mnpp:app"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &MNPP_APP::Unknown0, "unknown0"},
-            {1, &MNPP_APP::Unknown1, "unknown1"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void Unknown0(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_MNPP, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void Unknown1(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_MNPP, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-};
-
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<MNPP_APP>(system)->InstallAsService(service_manager);
-}
-
-} // namespace Service::MNPP

src/core/hle/service/mnpp/mnpp_app.h

@@ -1,20 +0,0 @@
-// Copyright 2022 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-namespace Core {
-class System;
-}
-
-namespace Service::SM {
-class ServiceManager;
-}
-
-namespace Service::MNPP {
-
-/// Registers all MNPP services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
-
-} // namespace Service::MNPP

src/core/hle/service/nfp/nfp.h

@@ -7,132 +7,15 @@
 #include <array>
 #include <vector>
 
-#include "common/common_funcs.h"
 #include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/mii/mii_manager.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 {
 
-enum class ServiceType : u32 {
-    User,
-    Debug,
-    System,
-};
-
-enum class State : u32 {
-    NonInitialized,
-    Initialized,
-};
-
-enum class DeviceState : u32 {
-    Initialized,
-    SearchingForTag,
-    TagFound,
-    TagRemoved,
-    TagMounted,
-    Unaviable,
-    Finalized,
-};
-
-enum class ModelType : u32 {
-    Amiibo,
-};
-
-enum class MountTarget : u32 {
-    Rom,
-    Ram,
-    All,
-};
-
-enum class AmiiboType : u8 {
-    Figure,
-    Card,
-    Yarn,
-};
-
-enum class AmiiboSeries : u8 {
-    SuperSmashBros,
-    SuperMario,
-    ChibiRobo,
-    YoshiWoollyWorld,
-    Splatoon,
-    AnimalCrossing,
-    EightBitMario,
-    Skylanders,
-    Unknown8,
-    TheLegendOfZelda,
-    ShovelKnight,
-    Unknown11,
-    Kiby,
-    Pokemon,
-    MarioSportsSuperstars,
-    MonsterHunter,
-    BoxBoy,
-    Pikmin,
-    FireEmblem,
-    Metroid,
-    Others,
-    MegaMan,
-    Diablo
-};
-
-using TagUuid = std::array<u8, 10>;
-
-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 fixed;                   // Must be 02
-    INSERT_PADDING_BYTES(0x4);  // Unknown
-    INSERT_PADDING_BYTES(0x20); // Probably a SHA256-(HMAC?) hash
-    INSERT_PADDING_BYTES(0x14); // SHA256-HMAC
-};
-static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
-
-struct RegisterInfo {
-    Service::Mii::MiiInfo mii_char_info;
-    u16 first_write_year;
-    u8 first_write_month;
-    u8 first_write_day;
-    std::array<u8, 11> amiibo_name;
-    u8 unknown;
-    INSERT_PADDING_BYTES(0x98);
-};
-static_assert(sizeof(RegisterInfo) == 0x100, "RegisterInfo is an invalid size");
-
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
@@ -141,131 +24,34 @@ public:
                            const char* name);
         ~Interface() override;
 
-        struct EncryptedAmiiboFile {
-            u16 crypto_init;             // Must be A5 XX
-            u16 write_count;             // Number of times the amiibo has been written?
-            INSERT_PADDING_BYTES(0x20);  // System crypts
-            INSERT_PADDING_BYTES(0x20);  // SHA256-(HMAC?) hash
-            ModelInfo model_info;        // This struct is bigger than documentation
-            INSERT_PADDING_BYTES(0xC);   // SHA256-HMAC
-            INSERT_PADDING_BYTES(0x114); // section 1 encrypted buffer
-            INSERT_PADDING_BYTES(0x54);  // section 2 encrypted buffer
+        struct ModelInfo {
+            std::array<u8, 0x8> amiibo_identification_block;
+            INSERT_PADDING_BYTES(0x38);
         };
-        static_assert(sizeof(EncryptedAmiiboFile) == 0x1F8, "AmiiboFile is an invalid size");
+        static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
 
-        struct NTAG215Password {
-            u32 PWD;  // Password to allow write access
-            u16 PACK; // Password acknowledge reply
-            u16 RFUI; // Reserved for future use
+        struct AmiiboFile {
+            std::array<u8, 10> uuid;
+            INSERT_PADDING_BYTES(0x4a);
+            ModelInfo model_info;
         };
-        static_assert(sizeof(NTAG215Password) == 0x8, "NTAG215Password is an invalid size");
-
-        struct NTAG215File {
-            TagUuid uuid;                    // Unique serial number
-            u16 lock_bytes;                  // Set defined pages as read only
-            u32 compability_container;       // Defines available memory
-            EncryptedAmiiboFile user_memory; // Writable data
-            u32 dynamic_lock;                // Dynamic lock
-            u32 CFG0;                        // Defines memory protected by password
-            u32 CFG1;                        // Defines number of verification attempts
-            NTAG215Password password;        // Password data
-        };
-        static_assert(sizeof(NTAG215File) == 0x21C, "NTAG215File is an invalid size");
+        static_assert(sizeof(AmiiboFile) == 0x94, "AmiiboFile is an invalid size");
 
         void CreateUserInterface(Kernel::HLERequestContext& ctx);
         bool LoadAmiibo(const std::vector<u8>& buffer);
-        void CloseAmiibo();
-
-        void Initialize();
-        void Finalize();
-
-        ResultCode StartDetection(s32 protocol_);
-        ResultCode StopDetection();
-        ResultCode Mount();
-        ResultCode Unmount();
-
-        ResultCode GetTagInfo(TagInfo& tag_info) const;
-        ResultCode GetCommonInfo(CommonInfo& common_info) const;
-        ResultCode GetModelInfo(ModelInfo& model_info) const;
-        ResultCode GetRegisterInfo(RegisterInfo& register_info) const;
-
-        ResultCode OpenApplicationArea(u32 access_id);
-        ResultCode GetApplicationArea(std::vector<u8>& data) const;
-        ResultCode SetApplicationArea(const std::vector<u8>& data);
-        ResultCode CreateApplicationArea(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;
+        Kernel::KReadableEvent& GetNFCEvent();
+        const AmiiboFile& GetAmiiboBuffer() const;
 
     protected:
         std::shared_ptr<Module> module;
 
     private:
-        /// Validates that the amiibo file is not corrupted
-        bool IsAmiiboValid() const;
-
-        bool AmiiboApplicationDataExist(u32 access_id) const;
-        std::vector<u8> LoadAmiiboApplicationData(u32 access_id) const;
-        void SaveAmiiboApplicationData(u32 access_id, const std::vector<u8>& data) const;
-
-        /// return password needed to allow write access to protected memory
-        u32 GetTagPassword(const TagUuid& uuid) const;
-
-        const Core::HID::NpadIdType npad_id;
-
-        DeviceState device_state{DeviceState::Unaviable};
         KernelHelpers::ServiceContext service_context;
-        Kernel::KEvent* activate_event;
-        Kernel::KEvent* deactivate_event;
-        NTAG215File tag_data{};
-        s32 protocol;
-        bool is_application_area_initialized{};
-        u32 application_area_id;
-        std::vector<u8> application_area_data;
+        Kernel::KEvent* nfc_tag_load;
+        AmiiboFile amiibo{};
     };
 };
 
-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 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);
-
-    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);
 
 } // namespace Service::NFP

src/core/hle/service/service.cpp

@@ -39,7 +39,6 @@
 #include "core/hle/service/mig/mig.h"
 #include "core/hle/service/mii/mii.h"
 #include "core/hle/service/mm/mm_u.h"
-#include "core/hle/service/mnpp/mnpp_app.h"
 #include "core/hle/service/ncm/ncm.h"
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfp/nfp.h"
@@ -266,7 +265,6 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
     Migration::InstallInterfaces(*sm, system);
     Mii::InstallInterfaces(*sm, system);
     MM::InstallInterfaces(*sm, system);
-    MNPP::InstallInterfaces(*sm, system);
     NCM::InstallInterfaces(*sm, system);
     NFC::InstallInterfaces(*sm, system);
     NFP::InstallInterfaces(*sm, system);

src/core/memory.cpp

@@ -39,7 +39,8 @@ struct Memory::Impl {
     void MapMemoryRegion(Common::PageTable& page_table, VAddr base, u64 size, PAddr target) {
         ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:016X}", size);
         ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:016X}", base);
-        ASSERT_MSG(target >= DramMemoryMap::Base, "Out of bounds target: {:016X}", target);
+        ASSERT_MSG(target >= DramMemoryMap::Base && target < DramMemoryMap::End,
+                   "Out of bounds target: {:016X}", target);
         MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, target, Common::PageType::Memory);
 
         if (Settings::IsFastmemEnabled()) {

src/input_common/drivers/sdl_driver.cpp

@@ -175,23 +175,22 @@ public:
         return false;
     }
 
-    Common::Input::BatteryLevel GetBatteryLevel() {
+    BatteryLevel GetBatteryLevel() {
         const auto level = SDL_JoystickCurrentPowerLevel(sdl_joystick.get());
         switch (level) {
         case SDL_JOYSTICK_POWER_EMPTY:
-            return Common::Input::BatteryLevel::Empty;
+            return BatteryLevel::Empty;
         case SDL_JOYSTICK_POWER_LOW:
-            return Common::Input::BatteryLevel::Low;
+            return BatteryLevel::Low;
         case SDL_JOYSTICK_POWER_MEDIUM:
-            return Common::Input::BatteryLevel::Medium;
+            return BatteryLevel::Medium;
         case SDL_JOYSTICK_POWER_FULL:
         case SDL_JOYSTICK_POWER_MAX:
-            return Common::Input::BatteryLevel::Full;
-        case SDL_JOYSTICK_POWER_WIRED:
-            return Common::Input::BatteryLevel::Charging;
+            return BatteryLevel::Full;
         case SDL_JOYSTICK_POWER_UNKNOWN:
+        case SDL_JOYSTICK_POWER_WIRED:
         default:
-            return Common::Input::BatteryLevel::None;
+            return BatteryLevel::Charging;
         }
     }
 
@@ -352,8 +351,6 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
         if (const auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
             const PadIdentifier identifier = joystick->GetPadIdentifier();
             SetButton(identifier, event.jbutton.button, true);
-            // Battery doesn't trigger an event so just update every button press
-            SetBattery(identifier, joystick->GetBatteryLevel());
         }
         break;
     }

src/input_common/drivers/udp_client.cpp

@@ -192,22 +192,22 @@ std::size_t UDPClient::GetClientNumber(std::string_view host, u16 port) const {
     return MAX_UDP_CLIENTS;
 }
 
-Common::Input::BatteryLevel UDPClient::GetBatteryLevel(Response::Battery battery) const {
+BatteryLevel UDPClient::GetBatteryLevel(Response::Battery battery) const {
     switch (battery) {
     case Response::Battery::Dying:
-        return Common::Input::BatteryLevel::Empty;
+        return BatteryLevel::Empty;
     case Response::Battery::Low:
-        return Common::Input::BatteryLevel::Critical;
+        return BatteryLevel::Critical;
     case Response::Battery::Medium:
-        return Common::Input::BatteryLevel::Low;
+        return BatteryLevel::Low;
     case Response::Battery::High:
-        return Common::Input::BatteryLevel::Medium;
+        return BatteryLevel::Medium;
     case Response::Battery::Full:
     case Response::Battery::Charged:
-        return Common::Input::BatteryLevel::Full;
+        return BatteryLevel::Full;
     case Response::Battery::Charging:
     default:
-        return Common::Input::BatteryLevel::Charging;
+        return BatteryLevel::Charging;
     }
 }
 

src/input_common/drivers/udp_client.h

@@ -141,7 +141,7 @@ private:
     std::size_t GetClientNumber(std::string_view host, u16 port) const;
 
     // Translates UDP battery level to input engine battery level
-    Common::Input::BatteryLevel GetBatteryLevel(Response::Battery battery) const;
+    BatteryLevel GetBatteryLevel(Response::Battery battery) const;
 
     void OnVersion(Response::Version);
     void OnPortInfo(Response::PortInfo);

src/input_common/input_engine.cpp

@@ -70,7 +70,7 @@ void InputEngine::SetAxis(const PadIdentifier& identifier, int axis, f32 value)
     TriggerOnAxisChange(identifier, axis, value);
 }
 
-void InputEngine::SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value) {
+void InputEngine::SetBattery(const PadIdentifier& identifier, BatteryLevel value) {
     {
         std::lock_guard lock{mutex};
         ControllerData& controller = controller_list.at(identifier);
@@ -143,13 +143,13 @@ f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
     return axis_iter->second;
 }
 
-Common::Input::BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
+BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
     std::lock_guard 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 Common::Input::BatteryLevel::Charging;
+        return BatteryLevel::Charging;
     }
     const ControllerData& controller = controller_iter->second;
     return controller.battery;
@@ -270,7 +270,7 @@ void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis,
 }
 
 void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
-                                         [[maybe_unused]] Common::Input::BatteryLevel value) {
+                                         [[maybe_unused]] BatteryLevel value) {
     std::lock_guard lock{mutex_callback};
     for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;

src/input_common/input_engine.h

@@ -34,6 +34,16 @@ struct BasicMotion {
     u64 delta_timestamp{};
 };
 
+// Stages of a battery charge
+enum class BatteryLevel {
+    Empty,
+    Critical,
+    Low,
+    Medium,
+    Full,
+    Charging,
+};
+
 // Types of input that are stored in the engine
 enum class EngineInputType {
     None,
@@ -168,7 +178,7 @@ public:
     bool GetButton(const PadIdentifier& identifier, int button) const;
     bool GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const;
     f32 GetAxis(const PadIdentifier& identifier, int axis) const;
-    Common::Input::BatteryLevel GetBattery(const PadIdentifier& identifier) const;
+    BatteryLevel GetBattery(const PadIdentifier& identifier) const;
     BasicMotion GetMotion(const PadIdentifier& identifier, int motion) const;
 
     int SetCallback(InputIdentifier input_identifier);
@@ -179,7 +189,7 @@ protected:
     void SetButton(const PadIdentifier& identifier, int button, bool value);
     void SetHatButton(const PadIdentifier& identifier, int button, u8 value);
     void SetAxis(const PadIdentifier& identifier, int axis, f32 value);
-    void SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value);
+    void SetBattery(const PadIdentifier& identifier, BatteryLevel value);
     void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
 
     virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
@@ -192,13 +202,13 @@ private:
         std::unordered_map<int, u8> hat_buttons;
         std::unordered_map<int, float> axes;
         std::unordered_map<int, BasicMotion> motions;
-        Common::Input::BatteryLevel battery{};
+        BatteryLevel battery{};
     };
 
     void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
     void TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value);
     void TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value);
-    void TriggerOnBatteryChange(const PadIdentifier& identifier, Common::Input::BatteryLevel value);
+    void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value);
     void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
                                const BasicMotion& value);
 

src/input_common/input_poller.cpp

@@ -470,7 +470,7 @@ public:
     }
 
     Common::Input::BatteryStatus GetStatus() const {
-        return input_engine->GetBattery(identifier);
+        return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier));
     }
 
     void ForceUpdate() override {

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -184,8 +184,6 @@ inline GLenum VertexFormat(Maxwell::VertexAttribute attrib) {
         case Maxwell::VertexAttribute::Size::Size_32_32_32:
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return GL_FLOAT;
-        case Maxwell::VertexAttribute::Size::Size_11_11_10:
-            return GL_UNSIGNED_INT_10F_11F_11F_REV;
         default:
             break;
         }

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -495,8 +495,6 @@ VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttrib
             return VK_FORMAT_R32G32B32_SFLOAT;
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return VK_FORMAT_R32G32B32A32_SFLOAT;
-        case Maxwell::VertexAttribute::Size::Size_11_11_10:
-            return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
         default:
             break;
         }

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -100,8 +100,6 @@ VkFormat GetFormat(const Tegra::FramebufferConfig& framebuffer) {
         return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
     case Tegra::FramebufferConfig::PixelFormat::RGB565_UNORM:
         return VK_FORMAT_R5G6B5_UNORM_PACK16;
-    case Tegra::FramebufferConfig::PixelFormat::B8G8R8A8_UNORM:
-        return VK_FORMAT_B8G8R8A8_UNORM;
     default:
         UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
                           static_cast<u32>(framebuffer.pixel_format));

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -554,12 +554,10 @@ void CopyBufferToImage(vk::CommandBuffer cmdbuf, VkBuffer src_buffer, VkImage im
     };
 }
 
-[[nodiscard]] bool IsFormatFlipped(PixelFormat format, bool emulate_bgr565) {
+[[nodiscard]] bool IsFormatFlipped(PixelFormat format) {
     switch (format) {
     case PixelFormat::A1B5G5R5_UNORM:
         return true;
-    case PixelFormat::B5G6R5_UNORM:
-        return emulate_bgr565;
     default:
         return false;
     }
@@ -1490,7 +1488,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
     };
     if (!info.IsRenderTarget()) {
         swizzle = info.Swizzle();
-        if (IsFormatFlipped(format, device->MustEmulateBGR565())) {
+        if (IsFormatFlipped(format)) {
             std::ranges::transform(swizzle, swizzle.begin(), SwapBlueRed);
         }
         if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != 0) {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -39,11 +39,6 @@ constexpr std::array DEPTH16_UNORM_STENCIL8_UINT{
     VK_FORMAT_D32_SFLOAT_S8_UINT,
     VK_FORMAT_UNDEFINED,
 };
-
-constexpr std::array B5G6R5_UNORM_PACK16{
-    VK_FORMAT_R5G6B5_UNORM_PACK16,
-    VK_FORMAT_UNDEFINED,
-};
 } // namespace Alternatives
 
 enum class NvidiaArchitecture {
@@ -92,8 +87,6 @@ constexpr const VkFormat* GetFormatAlternatives(VkFormat format) {
         return Alternatives::DEPTH24_UNORM_STENCIL8_UINT.data();
     case VK_FORMAT_D16_UNORM_S8_UINT:
         return Alternatives::DEPTH16_UNORM_STENCIL8_UINT.data();
-    case VK_FORMAT_B5G6R5_UNORM_PACK16:
-        return Alternatives::B5G6R5_UNORM_PACK16.data();
     default:
         return nullptr;
     }
@@ -231,14 +224,9 @@ std::vector<std::string> GetSupportedExtensions(vk::PhysicalDevice physical) {
     return supported_extensions;
 }
 
-bool IsExtensionSupported(std::span<const std::string> supported_extensions,
-                          std::string_view extension) {
-    return std::ranges::find(supported_extensions, extension) != supported_extensions.end();
-}
-
 NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
                                          std::span<const std::string> exts) {
-    if (IsExtensionSupported(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME)) {
+    if (std::ranges::find(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME) != exts.end()) {
         VkPhysicalDeviceFragmentShadingRatePropertiesKHR shading_rate_props{};
         shading_rate_props.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
@@ -251,7 +239,7 @@ NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
             return NvidiaArchitecture::AmpereOrNewer;
         }
     }
-    if (IsExtensionSupported(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME)) {
+    if (std::ranges::find(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME) != exts.end()) {
         return NvidiaArchitecture::Turing;
     }
     return NvidiaArchitecture::VoltaOrOlder;
@@ -616,8 +604,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             break;
         }
     }
-    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
-    if (ext_extended_dynamic_state && is_radv) {
+    if (ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_MESA_RADV) {
         // Mask driver version variant
         const u32 version = (properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
@@ -626,17 +613,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             ext_extended_dynamic_state = false;
         }
     }
-    if (ext_vertex_input_dynamic_state && is_radv) {
-        // TODO(ameerj): Blacklist only offending driver versions
-        // TODO(ameerj): Confirm if RDNA1 is affected
-        const bool is_rdna2 =
-            IsExtensionSupported(supported_extensions, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
-        if (is_rdna2) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            ext_vertex_input_dynamic_state = false;
-        }
-    }
     sets_per_pool = 64;
 
     const bool is_amd =
@@ -652,7 +628,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             has_broken_cube_compatibility = true;
         }
     }
-    const bool is_amd_or_radv = is_amd || is_radv;
+    const bool is_amd_or_radv = is_amd || driver_id == VK_DRIVER_ID_MESA_RADV;
     if (ext_sampler_filter_minmax && is_amd_or_radv) {
         // Disable ext_sampler_filter_minmax on AMD GCN4 and lower as it is broken.
         if (!is_float16_supported) {
@@ -663,7 +639,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     }
 
     const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
-    const bool is_intel_anv = driver_id == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
     if (ext_vertex_input_dynamic_state && is_intel_windows) {
         LOG_WARNING(Render_Vulkan, "Blacklisting Intel for VK_EXT_vertex_input_dynamic_state");
         ext_vertex_input_dynamic_state = false;
@@ -677,10 +652,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         LOG_WARNING(Render_Vulkan, "Intel proprietary drivers do not support MSAA image blits");
         cant_blit_msaa = true;
     }
-    if (is_intel_anv) {
-        LOG_WARNING(Render_Vulkan, "ANV driver does not support native BGR format");
-        must_emulate_bgr565 = true;
-    }
 
     supports_d24_depth =
         IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,

src/video_core/vulkan_common/vulkan_device.h

@@ -354,10 +354,6 @@ public:
         return cant_blit_msaa;
     }
 
-    bool MustEmulateBGR565() const {
-        return must_emulate_bgr565;
-    }
-
 private:
     /// Checks if the physical device is suitable.
     void CheckSuitability(bool requires_swapchain) const;
@@ -452,7 +448,6 @@ private:
     bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
     bool supports_d24_depth{};              ///< Supports D24 depth buffers.
     bool cant_blit_msaa{};                  ///< Does not support MSAA<->MSAA blitting.
-    bool must_emulate_bgr565{};             ///< Emulates BGR565 by swizzling RGB565 format.
 
     // Telemetry parameters
     std::string vendor_name;                       ///< Device's driver name.

src/yuzu/configuration/config.cpp

@@ -77,13 +77,13 @@ const std::array<UISettings::Shortcut, 22> Config::default_hotkeys{{
     {QStringLiteral("Exit Fullscreen"),          QStringLiteral("Main Window"), {QStringLiteral("Esc"),     QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Exit yuzu"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"),  QStringLiteral("Home+Minus"), Qt::WindowShortcut}},
     {QStringLiteral("Fullscreen"),               QStringLiteral("Main Window"), {QStringLiteral("F11"),     QStringLiteral("Home+B"), Qt::WindowShortcut}},
+    {QStringLiteral("Load Amiibo"),              QStringLiteral("Main Window"), {QStringLiteral("F2"),      QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut}},
     {QStringLiteral("Load File"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"),  QStringLiteral(""), Qt::WidgetWithChildrenShortcut}},
-    {QStringLiteral("Load/Remove Amiibo"),       QStringLiteral("Main Window"), {QStringLiteral("F2"),      QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut}},
     {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"),      QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Stop Emulation"),           QStringLiteral("Main Window"), {QStringLiteral("F5"),      QStringLiteral(""), Qt::WindowShortcut}},
-    {QStringLiteral("TAS Record"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), QStringLiteral(""), Qt::ApplicationShortcut}},
-    {QStringLiteral("TAS Reset"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), QStringLiteral(""), Qt::ApplicationShortcut}},
     {QStringLiteral("TAS Start/Stop"),           QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), QStringLiteral(""), Qt::ApplicationShortcut}},
+    {QStringLiteral("TAS Reset"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), QStringLiteral(""), Qt::ApplicationShortcut}},
+    {QStringLiteral("TAS Record"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), QStringLiteral(""), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Filter Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"),  QStringLiteral(""), Qt::WindowShortcut}},
     {QStringLiteral("Toggle Framerate Limit"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"),  QStringLiteral("Home+Y"), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Mouse Panning"),     QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut}},
@@ -445,7 +445,6 @@ void Config::ReadCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
     ReadGlobalSetting(Settings::values.use_multi_core);
-    ReadGlobalSetting(Settings::values.use_extended_memory_layout);
 
     qt_config->endGroup();
 }
@@ -609,7 +608,6 @@ void Config::ReadCpuValues() {
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
-    ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     if (global) {
         ReadBasicSetting(Settings::values.cpu_debug_mode);
@@ -622,8 +620,6 @@ void Config::ReadCpuValues() {
         ReadBasicSetting(Settings::values.cpuopt_misc_ir);
         ReadBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
         ReadBasicSetting(Settings::values.cpuopt_fastmem);
-        ReadBasicSetting(Settings::values.cpuopt_fastmem_exclusives);
-        ReadBasicSetting(Settings::values.cpuopt_recompile_exclusives);
     }
 
     qt_config->endGroup();
@@ -1023,7 +1019,6 @@ void Config::SaveCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
     WriteGlobalSetting(Settings::values.use_multi_core);
-    WriteGlobalSetting(Settings::values.use_extended_memory_layout);
 
     qt_config->endGroup();
 }
@@ -1142,7 +1137,6 @@ void Config::SaveCpuValues() {
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
-    WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     if (global) {
         WriteBasicSetting(Settings::values.cpu_debug_mode);

src/yuzu/configuration/configure_cpu.cpp

@@ -36,7 +36,6 @@ void ConfigureCpu::SetConfiguration() {
     ui->cpuopt_unsafe_ignore_standard_fpcr->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_inaccurate_nan->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_fastmem_check->setEnabled(runtime_lock);
-    ui->cpuopt_unsafe_ignore_global_monitor->setEnabled(runtime_lock);
 
     ui->cpuopt_unsafe_unfuse_fma->setChecked(Settings::values.cpuopt_unsafe_unfuse_fma.GetValue());
     ui->cpuopt_unsafe_reduce_fp_error->setChecked(
@@ -47,8 +46,6 @@ void ConfigureCpu::SetConfiguration() {
         Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue());
     ui->cpuopt_unsafe_fastmem_check->setChecked(
         Settings::values.cpuopt_unsafe_fastmem_check.GetValue());
-    ui->cpuopt_unsafe_ignore_global_monitor->setChecked(
-        Settings::values.cpuopt_unsafe_ignore_global_monitor.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->accuracy->setCurrentIndex(static_cast<int>(Settings::values.cpu_accuracy.GetValue()));
@@ -85,9 +82,6 @@ void ConfigureCpu::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_fastmem_check,
                                              ui->cpuopt_unsafe_fastmem_check,
                                              cpuopt_unsafe_fastmem_check);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_ignore_global_monitor,
-                                             ui->cpuopt_unsafe_ignore_global_monitor,
-                                             cpuopt_unsafe_ignore_global_monitor);
 }
 
 void ConfigureCpu::changeEvent(QEvent* event) {
@@ -126,7 +120,4 @@ void ConfigureCpu::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_fastmem_check,
                                             Settings::values.cpuopt_unsafe_fastmem_check,
                                             cpuopt_unsafe_fastmem_check);
-    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_ignore_global_monitor,
-                                            Settings::values.cpuopt_unsafe_ignore_global_monitor,
-                                            cpuopt_unsafe_ignore_global_monitor);
 }

src/yuzu/configuration/configure_cpu.h

@@ -45,7 +45,6 @@ private:
     ConfigurationShared::CheckState cpuopt_unsafe_ignore_standard_fpcr;
     ConfigurationShared::CheckState cpuopt_unsafe_inaccurate_nan;
     ConfigurationShared::CheckState cpuopt_unsafe_fastmem_check;
-    ConfigurationShared::CheckState cpuopt_unsafe_ignore_global_monitor;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_cpu.ui

@@ -150,18 +150,6 @@
           </property>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_unsafe_ignore_global_monitor">
-          <property name="toolTip">
-           <string>
-            &lt;div&gt;This option improves speed by relying only on the semantics of cmpxchg to ensure safety of exclusive access instructions. Please note this may result in deadlocks and other race conditions.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Ignore global monitor</string>
-          </property>
-         </widget>
-        </item>
        </layout>
       </widget>
      </item>

src/yuzu/configuration/configure_cpu_debug.cpp

@@ -44,12 +44,6 @@ void ConfigureCpuDebug::SetConfiguration() {
         Settings::values.cpuopt_reduce_misalign_checks.GetValue());
     ui->cpuopt_fastmem->setEnabled(runtime_lock);
     ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem.GetValue());
-    ui->cpuopt_fastmem_exclusives->setEnabled(runtime_lock);
-    ui->cpuopt_fastmem_exclusives->setChecked(
-        Settings::values.cpuopt_fastmem_exclusives.GetValue());
-    ui->cpuopt_recompile_exclusives->setEnabled(runtime_lock);
-    ui->cpuopt_recompile_exclusives->setChecked(
-        Settings::values.cpuopt_recompile_exclusives.GetValue());
 }
 
 void ConfigureCpuDebug::ApplyConfiguration() {
@@ -62,8 +56,6 @@ void ConfigureCpuDebug::ApplyConfiguration() {
     Settings::values.cpuopt_misc_ir = ui->cpuopt_misc_ir->isChecked();
     Settings::values.cpuopt_reduce_misalign_checks = ui->cpuopt_reduce_misalign_checks->isChecked();
     Settings::values.cpuopt_fastmem = ui->cpuopt_fastmem->isChecked();
-    Settings::values.cpuopt_fastmem_exclusives = ui->cpuopt_fastmem_exclusives->isChecked();
-    Settings::values.cpuopt_recompile_exclusives = ui->cpuopt_recompile_exclusives->isChecked();
 }
 
 void ConfigureCpuDebug::changeEvent(QEvent* event) {

src/yuzu/configuration/configure_cpu_debug.ui

@@ -144,34 +144,7 @@
            </string>
           </property>
           <property name="text">
-           <string>Enable Host MMU Emulation (general memory instructions)</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_fastmem_exclusives">
-          <property name="toolTip">
-           <string>
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up exclusive memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it causes guest exclusive memory reads/writes to be done directly into memory and make use of Host's MMU.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all exclusive memory accesses to use Software MMU Emulation.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Enable Host MMU Emulation (exclusive memory instructions)</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_recompile_exclusives">
-          <property name="toolTip">
-           <string>
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up exclusive memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it reduces the overhead of fastmem failure of exclusive memory accesses.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Enable recompilation of exclusive memory instructions</string>
+           <string>Enable Host MMU Emulation</string>
           </property>
          </widget>
         </item>

src/yuzu/configuration/configure_general.cpp

@@ -42,9 +42,6 @@ void ConfigureGeneral::SetConfiguration() {
 
     ui->use_multi_core->setEnabled(runtime_lock);
     ui->use_multi_core->setChecked(Settings::values.use_multi_core.GetValue());
-    ui->use_extended_memory_layout->setEnabled(runtime_lock);
-    ui->use_extended_memory_layout->setChecked(
-        Settings::values.use_extended_memory_layout.GetValue());
 
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing.GetValue());
     ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot.GetValue());
@@ -94,9 +91,6 @@ void ConfigureGeneral::ResetDefaults() {
 void ConfigureGeneral::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_multi_core, ui->use_multi_core,
                                              use_multi_core);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_extended_memory_layout,
-                                             ui->use_extended_memory_layout,
-                                             use_extended_memory_layout);
 
     if (Settings::IsConfiguringGlobal()) {
         UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
@@ -166,9 +160,6 @@ void ConfigureGeneral::SetupPerGameUI() {
                                             Settings::values.use_speed_limit, use_speed_limit);
     ConfigurationShared::SetColoredTristate(ui->use_multi_core, Settings::values.use_multi_core,
                                             use_multi_core);
-    ConfigurationShared::SetColoredTristate(ui->use_extended_memory_layout,
-                                            Settings::values.use_extended_memory_layout,
-                                            use_extended_memory_layout);
 
     connect(ui->toggle_speed_limit, &QCheckBox::clicked, ui->speed_limit, [this]() {
         ui->speed_limit->setEnabled(ui->toggle_speed_limit->isChecked() &&

src/yuzu/configuration/configure_general.h

@@ -48,7 +48,6 @@ private:
 
     ConfigurationShared::CheckState use_speed_limit;
     ConfigurationShared::CheckState use_multi_core;
-    ConfigurationShared::CheckState use_extended_memory_layout;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_general.ui

@@ -142,13 +142,6 @@
             </property>
            </widget>
           </item>
-          <item>
-           <widget class="QCheckBox" name="use_extended_memory_layout">
-            <property name="text">
-             <string>Extended memory layout (6GB DRAM)</string>
-            </property>
-           </widget>
-          </item>
           <item>
            <widget class="QCheckBox" name="toggle_check_exit">
             <property name="text">

src/yuzu/configuration/configure_input_player.cpp

@@ -1332,9 +1332,6 @@ void ConfigureInputPlayer::HandleClick(
     QPushButton* button, std::size_t button_id,
     std::function<void(const Common::ParamPackage&)> new_input_setter,
     InputCommon::Polling::InputType type) {
-    if (timeout_timer->isActive()) {
-        return;
-    }
     if (button == ui->buttonMotionLeft || button == ui->buttonMotionRight) {
         button->setText(tr("Shake!"));
     } else {

src/yuzu/configuration/configure_touch_from_button.cpp

@@ -227,9 +227,6 @@ void ConfigureTouchFromButton::RenameMapping() {
 }
 
 void ConfigureTouchFromButton::GetButtonInput(const int row_index, const bool is_new) {
-    if (timeout_timer->isActive()) {
-        return;
-    }
     binding_list_model->item(row_index, 0)->setText(tr("[press key]"));
 
     input_setter = [this, row_index, is_new](const Common::ParamPackage& params,

src/yuzu/debugger/console.cpp

@@ -30,7 +30,6 @@ void ToggleConsole() {
             freopen_s(&temp, "CONIN$", "r", stdin);
             freopen_s(&temp, "CONOUT$", "w", stdout);
             freopen_s(&temp, "CONOUT$", "w", stderr);
-            SetConsoleOutputCP(65001);
             SetColorConsoleBackendEnabled(true);
         }
     } else {

src/yuzu/main.cpp

@@ -934,7 +934,7 @@ void GMainWindow::InitializeHotkeys() {
     hotkey_registry.LoadHotkeys();
 
     LinkActionShortcut(ui->action_Load_File, QStringLiteral("Load File"));
-    LinkActionShortcut(ui->action_Load_Amiibo, QStringLiteral("Load/Remove Amiibo"));
+    LinkActionShortcut(ui->action_Load_Amiibo, QStringLiteral("Load Amiibo"));
     LinkActionShortcut(ui->action_Exit, QStringLiteral("Exit yuzu"));
     LinkActionShortcut(ui->action_Restart, QStringLiteral("Restart Emulation"));
     LinkActionShortcut(ui->action_Pause, QStringLiteral("Continue/Pause Emulation"));
@@ -2927,25 +2927,6 @@ void GMainWindow::OnLoadAmiibo() {
         return;
     }
 
-    Service::SM::ServiceManager& sm = system->ServiceManager();
-    auto nfc = sm.GetService<Service::NFP::Module::Interface>("nfp:user");
-    if (nfc == nullptr) {
-        QMessageBox::warning(this, tr("Error"), tr("The current game is not looking for amiibos"));
-        return;
-    }
-    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) {
-        QMessageBox::warning(this, tr("Error"), tr("The current game is not looking for amiibos"));
-        return;
-    }
-
     is_amiibo_file_select_active = true;
     const QString extensions{QStringLiteral("*.bin")};
     const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions);
@@ -2966,15 +2947,6 @@ void GMainWindow::LoadAmiibo(const QString& filename) {
         return;
     }
 
-    // Remove amiibo if one is connected
-    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;
-    }
-
     QFile nfc_file{filename};
     if (!nfc_file.open(QIODevice::ReadOnly)) {
         QMessageBox::warning(this, tr("Error opening Amiibo data file"),

src/yuzu/main.ui

@@ -266,7 +266,7 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Load/Remove &amp;Amiibo...</string>
+    <string>Load &amp;Amiibo...</string>
    </property>
   </action>
   <action name="action_Report_Compatibility">

src/yuzu_cmd/config.cpp

@@ -266,7 +266,6 @@ void Config::ReadValues() {
 
     // Core
     ReadSetting("Core", Settings::values.use_multi_core);
-    ReadSetting("Core", Settings::values.use_extended_memory_layout);
 
     // Cpu
     ReadSetting("Cpu", Settings::values.cpu_accuracy);
@@ -280,14 +279,11 @@ void Config::ReadValues() {
     ReadSetting("Cpu", Settings::values.cpuopt_misc_ir);
     ReadSetting("Cpu", Settings::values.cpuopt_reduce_misalign_checks);
     ReadSetting("Cpu", Settings::values.cpuopt_fastmem);
-    ReadSetting("Cpu", Settings::values.cpuopt_fastmem_exclusives);
-    ReadSetting("Cpu", Settings::values.cpuopt_recompile_exclusives);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_unfuse_fma);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_reduce_fp_error);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_inaccurate_nan);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_fastmem_check);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     // Renderer
     ReadSetting("Renderer", Settings::values.renderer_backend);

src/yuzu_cmd/default_ini.h

@@ -174,14 +174,6 @@ cpuopt_reduce_misalign_checks =
 # 0: Disabled, 1 (default): Enabled
 cpuopt_fastmem =
 
-# Enable Host MMU Emulation for exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem_exclusives =
-
-# Enable fallback on failure of fastmem of exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_recompile_exclusives =
-
 # Enable unfuse FMA (improve performance on CPUs without FMA)
 # Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
 # 0: Disabled, 1 (default): Enabled
@@ -207,11 +199,6 @@ cpuopt_unsafe_inaccurate_nan =
 # 0: Disabled, 1 (default): Enabled
 cpuopt_unsafe_fastmem_check =
 
-# Enable faster exclusive instructions
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_global_monitor =
-
 [Renderer]
 # Which backend API to use.
 # 0 (default): OpenGL, 1: Vulkan