applets/controller: Use a pair of emulated controller index to controller type

This will reduce the likelihood of an invalid controller type to be set within a game

.ci/templates/build-msvc.yml

@@ -4,11 +4,9 @@ parameters:
   version: ''
 
 steps:
-- script: choco install vulkan-sdk
-  displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
   displayName: 'Install conan'
-- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

src/common/logging/backend.cpp

@@ -23,7 +23,6 @@
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"
 #include "common/threadsafe_queue.h"
-#include "core/settings.h"
 
 namespace Log {
 
@@ -153,19 +152,10 @@ FileBackend::FileBackend(const std::string& filename)
 void FileBackend::Write(const Entry& entry) {
     // prevent logs from going over the maximum size (in case its spamming and the user doesn't
     // know)
-    constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
-    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
-
-    if (!file.IsOpen()) {
+    constexpr std::size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
-
-    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
-        return;
-    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
-        return;
-    }
-
     bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
         file.Flush();

src/core/core.cpp

@@ -187,7 +187,7 @@ struct System::Impl {
 
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
 
-        services = std::make_unique<Service::Services>(service_manager, system);
+        Service::Init(service_manager, system);
         GDBStub::DeferStart();
 
         interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
@@ -210,7 +210,7 @@ struct System::Impl {
 
     ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                       const std::string& filepath) {
-        app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath));
+        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
@@ -224,7 +224,7 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
+        telemetry_session->AddInitialInfo(*app_loader);
         auto main_process =
             Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
@@ -296,7 +296,7 @@ struct System::Impl {
 
         // Shutdown emulation session
         GDBStub::Shutdown();
-        services.reset();
+        Service::Shutdown();
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
@@ -306,8 +306,8 @@ struct System::Impl {
         cpu_manager.Shutdown();
 
         // Shutdown kernel and core timing
-        core_timing.Shutdown();
         kernel.Shutdown();
+        core_timing.Shutdown();
 
         // Close app loader
         app_loader.reset();
@@ -338,7 +338,7 @@ struct System::Impl {
         Service::Glue::ApplicationLaunchProperty launch{};
         launch.title_id = process.GetTitleID();
 
-        FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
+        FileSys::PatchManager pm{launch.title_id};
         launch.version = pm.GetGameVersion().value_or(0);
 
         // TODO(DarkLordZach): When FSController/Game Card Support is added, if
@@ -398,9 +398,6 @@ struct System::Impl {
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
-    /// Services
-    std::unique_ptr<Service::Services> services;
-
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 

src/core/file_sys/patch_manager.cpp

@@ -112,10 +112,7 @@ bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 }
 } // Anonymous namespace
 
-PatchManager::PatchManager(u64 title_id_,
-                           const Service::FileSystem::FileSystemController& fs_controller_,
-                           const ContentProvider& content_provider_)
-    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
 
@@ -131,30 +128,34 @@ 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);
+        const auto dump_dir =
+            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
             VfsRawCopyD(exefs, exefs_dir);
         }
     }
 
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
+
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
         std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);
+    const auto update = installed.GetEntry(update_tid, ContentRecordType::Program);
 
     if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr &&
         update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
         LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+                 FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
         exefs = update->GetExeFS();
     }
 
     // LayeredExeFS
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir != nullptr && load_dir->GetSize() > 0) {
         auto patch_dirs = load_dir->GetSubdirectories();
         std::sort(
@@ -240,7 +241,8 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     if (Settings::values.dump_nso) {
         LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                  title_id);
-        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
+        const auto dump_dir =
+            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
             const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
@@ -252,7 +254,8 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
@@ -295,7 +298,8 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
 
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
@@ -309,8 +313,8 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
 }
 
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const BuildID& build_id_) const {
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const Core::System& system, const BuildID& build_id_) const {
+    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
@@ -343,9 +347,9 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
     return out;
 }
 
-static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
-                           const Service::FileSystem::FileSystemController& fs_controller) {
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
         load_dir == nullptr || load_dir->GetSize() <= 0) {
         return;
@@ -407,19 +411,19 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
                                         title_id, static_cast<u8>(type));
 
-    if (type == ContentRecordType::Program || type == ContentRecordType::Data) {
+    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
         LOG_INFO(Loader, "{}", log_string);
-    } else {
+    else
         LOG_DEBUG(Loader, "{}", log_string);
-    }
 
-    if (romfs == nullptr) {
+    if (romfs == nullptr)
         return romfs;
-    }
+
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = content_provider.GetEntryRaw(update_tid, type);
+    const auto update = installed.GetEntryRaw(update_tid, type);
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
@@ -430,7 +434,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
         }
     } else if (!update_disabled && update_raw != nullptr) {
@@ -443,7 +447,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     }
 
     // LayeredFS
-    ApplyLayeredFS(romfs, title_id, type, fs_controller);
+    ApplyLayeredFS(romfs, title_id, type);
 
     return romfs;
 }
@@ -454,11 +458,12 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     std::map<std::string, std::string, std::less<>> out;
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    PatchManager update{update_tid, fs_controller, content_provider};
+    PatchManager update{update_tid};
     const auto metadata = update.GetControlMetadata();
     const auto& nacp = metadata.first;
 
@@ -469,8 +474,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     if (nacp != nullptr) {
         out.insert_or_assign(update_label, nacp->GetVersionString());
     } else {
-        if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = content_provider.GetEntryVersion(update_tid);
+        if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = installed.GetEntryVersion(update_tid);
             if (meta_ver.value_or(0) == 0) {
                 out.insert_or_assign(update_label, "");
             } else {
@@ -482,7 +487,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     // General Mods (LayeredFS and IPS)
-    const auto mod_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto mod_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;
@@ -526,15 +532,13 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     // DLC
-    const auto dlc_entries =
-        content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
+    const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
     std::vector<ContentProviderEntry> dlc_match;
     dlc_match.reserve(dlc_entries.size());
     std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
-                 [this](const ContentProviderEntry& entry) {
+                 [this, &installed](const ContentProviderEntry& entry) {
                      return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            content_provider.GetEntry(entry)->GetStatus() ==
-                                Loader::ResultStatus::Success;
+                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
                  });
     if (!dlc_match.empty()) {
         // Ensure sorted so DLC IDs show in order.
@@ -555,16 +559,19 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
 }
 
 std::optional<u32> PatchManager::GetGameVersion() const {
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto update_tid = GetUpdateTitleID(title_id);
-    if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        return content_provider.GetEntryVersion(update_tid);
+    if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
+        return installed.GetEntryVersion(update_tid);
     }
 
-    return content_provider.GetEntryVersion(title_id);
+    return installed.GetEntryVersion(title_id);
 }
 
 PatchManager::Metadata PatchManager::GetControlMetadata() const {
-    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
+
+    const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr) {
         return {};
     }

src/core/file_sys/patch_manager.h

@@ -17,13 +17,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace FileSys {
 
-class ContentProvider;
 class NCA;
 class NACP;
 
@@ -34,9 +29,7 @@ public:
     using Metadata = std::pair<std::unique_ptr<NACP>, VirtualFile>;
     using PatchVersionNames = std::map<std::string, std::string, std::less<>>;
 
-    explicit PatchManager(u64 title_id_,
-                          const Service::FileSystem::FileSystemController& fs_controller_,
-                          const ContentProvider& content_provider_);
+    explicit PatchManager(u64 title_id);
     ~PatchManager();
 
     [[nodiscard]] u64 GetTitleID() const;
@@ -57,7 +50,7 @@ public:
 
     // Creates a CheatList object with all
     [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const BuildID& build_id) const;
+        const Core::System& system, const BuildID& build_id) const;
 
     // Currently tracked RomFS patches:
     // - Game Updates
@@ -87,8 +80,6 @@ private:
                                                           const std::string& build_id) const;
 
     u64 title_id;
-    const Service::FileSystem::FileSystemController& fs_controller;
-    const ContentProvider& content_provider;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -37,12 +37,10 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
-    if (!updatable) {
+    if (!updatable)
         return MakeResult<VirtualFile>(file);
-    }
 
-    const PatchManager patch_manager{current_process_title_id, filesystem_controller,
-                                     content_provider};
+    const PatchManager patch_manager(current_process_title_id);
     return MakeResult<VirtualFile>(
         patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }

src/core/hle/service/acc/acc.cpp

@@ -742,10 +742,8 @@ void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx
     bool is_locked = false;
 
     if (res != Loader::ResultStatus::Success) {
-        const FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID(),
-                                       system.GetFileSystemController(),
-                                       system.GetContentProvider()};
-        const auto nacp_unique = pm.GetControlMetadata().first;
+        FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
+        auto nacp_unique = pm.GetControlMetadata().first;
 
         if (nacp_unique != nullptr) {
             is_locked = nacp_unique->GetUserAccountSwitchLock();

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

@@ -246,8 +246,9 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {
 
 IDebugFunctions::~IDebugFunctions() = default;
 
-ISelfController::ISelfController(Core::System& system, NVFlinger::NVFlinger& nvflinger)
-    : ServiceFramework("ISelfController"), system(system), nvflinger(nvflinger) {
+ISelfController::ISelfController(Core::System& system,
+                                 std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
+    : ServiceFramework("ISelfController"), system(system), nvflinger(std::move(nvflinger)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ISelfController::Exit, "Exit"},
@@ -457,8 +458,8 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
 
     // TODO(Subv): Find out how AM determines the display to use, for now just
     // create the layer in the Default display.
-    const auto display_id = nvflinger.OpenDisplay("Default");
-    const auto layer_id = nvflinger.CreateLayer(*display_id);
+    const auto display_id = nvflinger->OpenDisplay("Default");
+    const auto layer_id = nvflinger->CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
@@ -475,8 +476,8 @@ void ISelfController::CreateManagedDisplaySeparableLayer(Kernel::HLERequestConte
     // Outputting 1 layer id instead of the expected 2 has not been observed to cause any adverse
     // side effects.
     // TODO: Support multiple layers
-    const auto display_id = nvflinger.OpenDisplay("Default");
-    const auto layer_id = nvflinger.CreateLayer(*display_id);
+    const auto display_id = nvflinger->OpenDisplay("Default");
+    const auto layer_id = nvflinger->CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
@@ -1380,16 +1381,13 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
     const auto res = [this] {
         const auto title_id = system.CurrentProcess()->GetTitleID();
 
-        const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
+        FileSys::PatchManager pm{title_id};
         auto res = pm.GetControlMetadata();
         if (res.first != nullptr) {
             return res;
         }
 
-        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id),
-                                              system.GetFileSystemController(),
-                                              system.GetContentProvider()};
+        FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id)};
         return pm_update.GetControlMetadata();
     }();
 
@@ -1417,16 +1415,13 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     const auto res = [this] {
         const auto title_id = system.CurrentProcess()->GetTitleID();
 
-        const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
+        FileSys::PatchManager pm{title_id};
         auto res = pm.GetControlMetadata();
         if (res.first != nullptr) {
             return res;
         }
 
-        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id),
-                                              system.GetFileSystemController(),
-                                              system.GetContentProvider()};
+        FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id)};
         return pm_update.GetControlMetadata();
     }();
 
@@ -1585,8 +1580,8 @@ void IApplicationFunctions::GetFriendInvitationStorageChannelEvent(Kernel::HLERe
     rb.PushCopyObjects(friend_invitation_storage_channel_event.readable);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager,
+                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system.Kernel());
     // Needed on game boot
     message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);

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

@@ -121,7 +121,8 @@ public:
 
 class ISelfController final : public ServiceFramework<ISelfController> {
 public:
-    explicit ISelfController(Core::System& system_, NVFlinger::NVFlinger& nvflinger_);
+    explicit ISelfController(Core::System& system_,
+                             std::shared_ptr<NVFlinger::NVFlinger> nvflinger_);
     ~ISelfController() override;
 
 private:
@@ -155,7 +156,7 @@ private:
     };
 
     Core::System& system;
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::EventPair launchable_event;
     Kernel::EventPair accumulated_suspended_tick_changed_event;
 
@@ -331,7 +332,7 @@ public:
 };
 
 /// Registers all AM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager,
+                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system);
 
 } // namespace Service::AM

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

@@ -13,10 +13,10 @@ namespace Service::AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
-    explicit ILibraryAppletProxy(NVFlinger::NVFlinger& nvflinger,
+    explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
                                  std::shared_ptr<AppletMessageQueue> msg_queue,
                                  Core::System& system)
-        : ServiceFramework("ILibraryAppletProxy"), nvflinger(nvflinger),
+        : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -109,16 +109,16 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
 
 class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
 public:
-    explicit ISystemAppletProxy(NVFlinger::NVFlinger& nvflinger,
+    explicit ISystemAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
                                 std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-        : ServiceFramework("ISystemAppletProxy"), nvflinger(nvflinger),
+        : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -220,8 +220,7 @@ private:
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IApplicationCreator>();
     }
-
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
@@ -250,10 +249,10 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
 }
 
-AppletAE::AppletAE(NVFlinger::NVFlinger& nvflinger, std::shared_ptr<AppletMessageQueue> msg_queue,
-                   Core::System& system)
-    : ServiceFramework("appletAE"), nvflinger(nvflinger), msg_queue(std::move(msg_queue)),
-      system(system) {
+AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                   std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
+    : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)),
+      msg_queue(std::move(msg_queue)), system(system) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},

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

@@ -23,7 +23,7 @@ class AppletMessageQueue;
 
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
-    explicit AppletAE(NVFlinger::NVFlinger& nvflinger,
+    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
                       std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system);
     ~AppletAE() override;
 
@@ -34,7 +34,7 @@ private:
     void OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx);
     void OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };

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

@@ -12,9 +12,9 @@ namespace Service::AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
-    explicit IApplicationProxy(NVFlinger::NVFlinger& nvflinger,
+    explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
                                std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-        : ServiceFramework("IApplicationProxy"), nvflinger(nvflinger),
+        : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -98,7 +98,7 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
@@ -111,10 +111,10 @@ void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IApplicationProxy>(nvflinger, msg_queue, system);
 }
 
-AppletOE::AppletOE(NVFlinger::NVFlinger& nvflinger, std::shared_ptr<AppletMessageQueue> msg_queue,
-                   Core::System& system)
-    : ServiceFramework("appletOE"), nvflinger(nvflinger), msg_queue(std::move(msg_queue)),
-      system(system) {
+AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                   std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
+    : ServiceFramework("appletOE"), nvflinger(std::move(nvflinger)),
+      msg_queue(std::move(msg_queue)), system(system) {
     static const FunctionInfo functions[] = {
         {0, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
     };

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

@@ -23,7 +23,7 @@ class AppletMessageQueue;
 
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
-    explicit AppletOE(NVFlinger::NVFlinger& nvflinger,
+    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
                       std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system);
     ~AppletOE() override;
 
@@ -32,7 +32,7 @@ public:
 private:
     void OpenApplicationProxy(Kernel::HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nvflinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };

src/core/hle/service/aoc/aoc_u.cpp

@@ -164,8 +164,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 
     const auto title_id = system.CurrentProcess()->GetTitleID();
-    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
+    FileSys::PatchManager pm{title_id};
 
     const auto res = pm.GetControlMetadata();
     if (res.first == nullptr) {

src/core/hle/service/filesystem/filesystem.cpp

@@ -455,9 +455,7 @@ FileSys::SaveDataSize FileSystemController::ReadSaveDataSize(FileSys::SaveDataTy
         const auto res = system.GetAppLoader().ReadControlData(nacp);
 
         if (res != Loader::ResultStatus::Success) {
-            const FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID(),
-                                           system.GetFileSystemController(),
-                                           system.GetContentProvider()};
+            FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
             const auto metadata = pm.GetControlMetadata();
             const auto& nacp_unique = metadata.first;
 
@@ -730,8 +728,7 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
 void InstallInterfaces(Core::System& system) {
     std::make_shared<FSP_LDR>()->InstallAsService(system.ServiceManager());
     std::make_shared<FSP_PR>()->InstallAsService(system.ServiceManager());
-    std::make_shared<FSP_SRV>(system.GetFileSystemController(), system.GetContentProvider(),
-                              system.GetReporter())
+    std::make_shared<FSP_SRV>(system.GetFileSystemController(), system.GetReporter())
         ->InstallAsService(system.ServiceManager());
 }
 

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -650,10 +650,8 @@ private:
     u64 next_entry_index = 0;
 };
 
-FSP_SRV::FSP_SRV(FileSystemController& fsc_, const FileSys::ContentProvider& content_provider_,
-                 const Core::Reporter& reporter_)
-    : ServiceFramework("fsp-srv"), fsc(fsc_), content_provider{content_provider_},
-      reporter(reporter_) {
+FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
+    : ServiceFramework("fsp-srv"), fsc(fsc), reporter(reporter) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "OpenFileSystem"},
@@ -970,7 +968,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    const FileSys::PatchManager pm{title_id, fsc, content_provider};
+    FileSys::PatchManager pm{title_id};
 
     auto storage = std::make_shared<IStorage>(
         pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data));

src/core/hle/service/filesystem/fsp_srv.h

@@ -12,9 +12,8 @@ class Reporter;
 }
 
 namespace FileSys {
-class ContentProvider;
 class FileSystemBackend;
-} // namespace FileSys
+}
 
 namespace Service::FileSystem {
 
@@ -33,8 +32,7 @@ enum class LogMode : u32 {
 
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
 public:
-    explicit FSP_SRV(FileSystemController& fsc_, const FileSys::ContentProvider& content_provider_,
-                     const Core::Reporter& reporter_);
+    explicit FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter);
     ~FSP_SRV() override;
 
 private:
@@ -57,7 +55,6 @@ private:
     void OpenMultiCommitManager(Kernel::HLERequestContext& ctx);
 
     FileSystemController& fsc;
-    const FileSys::ContentProvider& content_provider;
 
     FileSys::VirtualFile romfs;
     u64 current_process_id = 0;

src/core/hle/service/ns/ns.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs.h"
@@ -30,8 +29,8 @@ IAccountProxyInterface::IAccountProxyInterface() : ServiceFramework{"IAccountPro
 
 IAccountProxyInterface::~IAccountProxyInterface() = default;
 
-IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_)
-    : ServiceFramework{"IApplicationManagerInterface"}, system{system_} {
+IApplicationManagerInterface::IApplicationManagerInterface()
+    : ServiceFramework{"IApplicationManagerInterface"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "ListApplicationRecord"},
@@ -299,8 +298,7 @@ void IApplicationManagerInterface::GetApplicationControlData(Kernel::HLERequestC
 
     const auto size = ctx.GetWriteBufferSize();
 
-    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
+    const FileSys::PatchManager pm{title_id};
     const auto control = pm.GetControlMetadata();
 
     std::vector<u8> out;
@@ -540,14 +538,14 @@ IFactoryResetInterface::IFactoryResetInterface::IFactoryResetInterface()
 
 IFactoryResetInterface::~IFactoryResetInterface() = default;
 
-NS::NS(const char* name, Core::System& system_) : ServiceFramework{name}, system{system_} {
+NS::NS(const char* name) : ServiceFramework{name} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {7992, &NS::PushInterface<IECommerceInterface>, "GetECommerceInterface"},
         {7993, &NS::PushInterface<IApplicationVersionInterface>, "GetApplicationVersionInterface"},
         {7994, &NS::PushInterface<IFactoryResetInterface>, "GetFactoryResetInterface"},
         {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
-        {7996, &NS::PushIApplicationManagerInterface, "GetApplicationManagerInterface"},
+        {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
         {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
         {7998, &NS::PushInterface<IContentManagementInterface>, "GetContentManagementInterface"},
         {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
@@ -560,7 +558,7 @@ NS::NS(const char* name, Core::System& system_) : ServiceFramework{name}, system
 NS::~NS() = default;
 
 std::shared_ptr<IApplicationManagerInterface> NS::GetApplicationManagerInterface() const {
-    return GetInterface<IApplicationManagerInterface>(system);
+    return GetInterface<IApplicationManagerInterface>();
 }
 
 class NS_DEV final : public ServiceFramework<NS_DEV> {
@@ -680,11 +678,11 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
 
-    std::make_shared<NS>("ns:am2", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:ec", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:rid", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:rt", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:web", system)->InstallAsService(service_manager);
+    std::make_shared<NS>("ns:am2")->InstallAsService(service_manager);
+    std::make_shared<NS>("ns:ec")->InstallAsService(service_manager);
+    std::make_shared<NS>("ns:rid")->InstallAsService(service_manager);
+    std::make_shared<NS>("ns:rt")->InstallAsService(service_manager);
+    std::make_shared<NS>("ns:web")->InstallAsService(service_manager);
 
     std::make_shared<NS_DEV>()->InstallAsService(service_manager);
     std::make_shared<NS_SU>()->InstallAsService(service_manager);

src/core/hle/service/ns/ns.h

@@ -6,10 +6,6 @@
 
 #include "core/hle/service/service.h"
 
-namespace Core {
-class System;
-}
-
 namespace Service {
 
 namespace FileSystem {
@@ -26,7 +22,7 @@ public:
 
 class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
 public:
-    explicit IApplicationManagerInterface(Core::System& system_);
+    explicit IApplicationManagerInterface();
     ~IApplicationManagerInterface() override;
 
     ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages);
@@ -36,8 +32,6 @@ private:
     void GetApplicationControlData(Kernel::HLERequestContext& ctx);
     void GetApplicationDesiredLanguage(Kernel::HLERequestContext& ctx);
     void ConvertApplicationLanguageToLanguageCode(Kernel::HLERequestContext& ctx);
-
-    Core::System& system;
 };
 
 class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
@@ -78,13 +72,13 @@ public:
 
 class NS final : public ServiceFramework<NS> {
 public:
-    explicit NS(const char* name, Core::System& system_);
+    explicit NS(const char* name);
     ~NS() override;
 
     std::shared_ptr<IApplicationManagerInterface> GetApplicationManagerInterface() const;
 
 private:
-    template <typename T, typename... Args>
+    template <typename T>
     void PushInterface(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
 
@@ -93,23 +87,13 @@ private:
         rb.PushIpcInterface<T>();
     }
 
-    void PushIApplicationManagerInterface(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NS, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IApplicationManagerInterface>(system);
-    }
-
-    template <typename T, typename... Args>
-    std::shared_ptr<T> GetInterface(Args&&... args) const {
+    template <typename T>
+    std::shared_ptr<T> GetInterface() const {
         static_assert(std::is_base_of_v<Kernel::SessionRequestHandler, T>,
                       "Not a base of ServiceFrameworkBase");
 
-        return std::make_shared<T>(std::forward<Args>(args)...);
+        return std::make_shared<T>();
     }
-
-    Core::System& system;
 };
 
 /// Registers all NS services with the specified service manager.

src/core/hle/service/nvdrv/devices/nvdevice.h

@@ -24,37 +24,25 @@ public:
     explicit nvdevice(Core::System& system) : system{system} {}
     virtual ~nvdevice() = default;
 
-    /**
-     * Handles an ioctl1 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl1(Ioctl command, const std::vector<u8>& input,
-                            std::vector<u8>& output) = 0;
+    union Ioctl {
+        u32_le raw;
+        BitField<0, 8, u32> cmd;
+        BitField<8, 8, u32> group;
+        BitField<16, 14, u32> length;
+        BitField<30, 1, u32> is_in;
+        BitField<31, 1, u32> is_out;
+    };
 
     /**
-     * Handles an ioctl2 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param inline_input A buffer containing the input data for the ioctl which has been inlined.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output) = 0;
-
-    /**
-     * Handles an ioctl3 request.
+     * Handles an ioctl request.
      * @param command The ioctl command id.
      * @param input A buffer containing the input data for the ioctl.
      * @param output A buffer where the output data will be written to.
-     * @param inline_output A buffer where the inlined output data will be written to.
      * @returns The result code of the ioctl.
      */
-    virtual NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output) = 0;
+    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                      IoctlVersion version) = 0;
 
 protected:
     Core::System& system;

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -18,22 +18,11 @@ nvdisp_disp0::nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_de
     : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvdisp_disp0 ::~nvdisp_disp0() = default;
 
-NvResult nvdisp_disp0::Ioctl1(Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvdisp_disp0::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                              const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvdisp_disp0::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                              std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                        IoctlVersion version) {
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
 }
 
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -20,11 +20,9 @@ public:
     explicit nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvdisp_disp0() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
     /// Performs a screen flip, drawing the buffer pointed to by the handle.
     void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -17,77 +17,59 @@
 
 namespace Service::Nvidia::Devices {
 
+namespace NvErrCodes {
+constexpr u32 Success{};
+constexpr u32 OutOfMemory{static_cast<u32>(-12)};
+constexpr u32 InvalidInput{static_cast<u32>(-22)};
+} // namespace NvErrCodes
+
 nvhost_as_gpu::nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
     : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_as_gpu::~nvhost_as_gpu() = default;
 
-NvResult nvhost_as_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
-                               std::vector<u8>& output) {
-    switch (command.group) {
-    case 'A':
-        switch (command.cmd) {
-        case 0x1:
-            return BindChannel(input, output);
-        case 0x2:
-            return AllocateSpace(input, output);
-        case 0x3:
-            return FreeSpace(input, output);
-        case 0x5:
-            return UnmapBuffer(input, output);
-        case 0x6:
-            return MapBufferEx(input, output);
-        case 0x8:
-            return GetVARegions(input, output);
-        case 0x9:
-            return InitalizeEx(input, output);
-        case 0x14:
-            return Remap(input, output);
-        default:
-            break;
-        }
-        break;
+u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                         std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                         IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocInitalizeExCommand:
+        return InitalizeEx(input, output);
+    case IoctlCommand::IocAllocateSpaceCommand:
+        return AllocateSpace(input, output);
+    case IoctlCommand::IocMapBufferExCommand:
+        return MapBufferEx(input, output);
+    case IoctlCommand::IocBindChannelCommand:
+        return BindChannel(input, output);
+    case IoctlCommand::IocGetVaRegionsCommand:
+        return GetVARegions(input, output);
+    case IoctlCommand::IocUnmapBufferCommand:
+        return UnmapBuffer(input, output);
+    case IoctlCommand::IocFreeSpaceCommand:
+        return FreeSpace(input, output);
     default:
         break;
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_as_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                               const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_as_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                               std::vector<u8>& inline_output) {
-    switch (command.group) {
-    case 'A':
-        switch (command.cmd) {
-        case 0x8:
-            return GetVARegions(input, output, inline_output);
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
+    if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand) {
+        return Remap(input, output);
     }
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+
+    UNIMPLEMENTED_MSG("Unimplemented ioctl command");
+    return 0;
 }
 
-NvResult nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlInitalizeEx params{};
     std::memcpy(&params, input.data(), input.size());
 
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
 
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlAllocSpace params{};
     std::memcpy(&params, input.data(), input.size());
 
@@ -101,17 +83,17 @@ NvResult nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<
         params.offset = system.GPU().MemoryManager().Allocate(size, params.align);
     }
 
-    auto result = NvResult::Success;
+    auto result{NvErrCodes::Success};
     if (!params.offset) {
         LOG_CRITICAL(Service_NVDRV, "allocation failed for size {}", size);
-        result = NvResult::InsufficientMemory;
+        result = NvErrCodes::OutOfMemory;
     }
 
     std::memcpy(output.data(), &params, output.size());
     return result;
 }
 
-NvResult nvhost_as_gpu::FreeSpace(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::FreeSpace(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlFreeSpace params{};
     std::memcpy(&params, input.data(), input.size());
 
@@ -122,15 +104,15 @@ NvResult nvhost_as_gpu::FreeSpace(const std::vector<u8>& input, std::vector<u8>&
                                        static_cast<std::size_t>(params.pages) * params.page_size);
 
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output) {
     const auto num_entries = input.size() / sizeof(IoctlRemapEntry);
 
     LOG_DEBUG(Service_NVDRV, "called, num_entries=0x{:X}", num_entries);
 
-    auto result = NvResult::Success;
+    auto result{NvErrCodes::Success};
     std::vector<IoctlRemapEntry> entries(num_entries);
     std::memcpy(entries.data(), input.data(), input.size());
 
@@ -141,7 +123,7 @@ NvResult nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& out
         const auto object{nvmap_dev->GetObject(entry.nvmap_handle)};
         if (!object) {
             LOG_CRITICAL(Service_NVDRV, "invalid nvmap_handle={:X}", entry.nvmap_handle);
-            result = NvResult::InvalidState;
+            result = NvErrCodes::InvalidInput;
             break;
         }
 
@@ -152,7 +134,7 @@ NvResult nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& out
 
         if (!addr) {
             LOG_CRITICAL(Service_NVDRV, "map returned an invalid address!");
-            result = NvResult::InvalidState;
+            result = NvErrCodes::InvalidInput;
             break;
         }
     }
@@ -161,7 +143,7 @@ NvResult nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& out
     return result;
 }
 
-NvResult nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlMapBufferEx params{};
     std::memcpy(&params, input.data(), input.size());
 
@@ -175,7 +157,7 @@ NvResult nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8
     if (!object) {
         LOG_CRITICAL(Service_NVDRV, "invalid nvmap_handle={:X}", params.nvmap_handle);
         std::memcpy(output.data(), &params, output.size());
-        return NvResult::InvalidState;
+        return NvErrCodes::InvalidInput;
     }
 
     // The real nvservices doesn't make a distinction between handles and ids, and
@@ -202,16 +184,16 @@ NvResult nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8
                              params.mapping_size, params.offset);
 
                 std::memcpy(output.data(), &params, output.size());
-                return NvResult::InvalidState;
+                return NvErrCodes::InvalidInput;
             }
 
             std::memcpy(output.data(), &params, output.size());
-            return NvResult::Success;
+            return NvErrCodes::Success;
         } else {
             LOG_CRITICAL(Service_NVDRV, "address not mapped offset={}", params.offset);
 
             std::memcpy(output.data(), &params, output.size());
-            return NvResult::InvalidState;
+            return NvErrCodes::InvalidInput;
         }
     }
 
@@ -231,10 +213,10 @@ NvResult nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8
         params.offset = gpu.MemoryManager().Map(physical_address, params.offset, size);
     }
 
-    auto result = NvResult::Success;
+    auto result{NvErrCodes::Success};
     if (!params.offset) {
         LOG_CRITICAL(Service_NVDRV, "failed to map size={}", size);
-        result = NvResult::InvalidState;
+        result = NvErrCodes::InvalidInput;
     } else {
         AddBufferMap(params.offset, size, physical_address, is_alloc);
     }
@@ -243,7 +225,7 @@ NvResult nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8
     return result;
 }
 
-NvResult nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlUnmapBuffer params{};
     std::memcpy(&params, input.data(), input.size());
 
@@ -256,19 +238,20 @@ NvResult nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8
     }
 
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlBindChannel params{};
     std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, fd={:X}", params.fd);
+
+    LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
 
     channel = params.fd;
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlGetVaRegions params{};
     std::memcpy(&params, input.data(), input.size());
 
@@ -287,31 +270,7 @@ NvResult nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u
     // TODO(ogniK): This probably can stay stubbed but should add support way way later
 
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
-}
-
-NvResult nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output,
-                                     std::vector<u8>& inline_output) {
-    IoctlGetVaRegions params{};
-    std::memcpy(&params, input.data(), input.size());
-
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
-                params.buf_size);
-
-    params.buf_size = 0x30;
-    params.regions[0].offset = 0x04000000;
-    params.regions[0].page_size = 0x1000;
-    params.regions[0].pages = 0x3fbfff;
-
-    params.regions[1].offset = 0x04000000;
-    params.regions[1].page_size = 0x10000;
-    params.regions[1].pages = 0x1bffff;
-
-    // TODO(ogniK): This probably can stay stubbed but should add support way way later
-
-    std::memcpy(output.data(), &params, output.size());
-    std::memcpy(inline_output.data(), &params.regions, inline_output.size());
-    return NvResult::Success;
+    return 0;
 }
 
 std::optional<nvhost_as_gpu::BufferMap> nvhost_as_gpu::FindBufferMap(GPUVAddr gpu_addr) const {

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -30,11 +30,9 @@ public:
     explicit nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_as_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
 private:
     class BufferMap final {
@@ -76,21 +74,32 @@ private:
         bool is_allocated{};
     };
 
+    enum class IoctlCommand : u32_le {
+        IocInitalizeExCommand = 0x40284109,
+        IocAllocateSpaceCommand = 0xC0184102,
+        IocRemapCommand = 0x00000014,
+        IocMapBufferExCommand = 0xC0284106,
+        IocBindChannelCommand = 0x40044101,
+        IocGetVaRegionsCommand = 0xC0404108,
+        IocUnmapBufferCommand = 0xC0084105,
+        IocFreeSpaceCommand = 0xC0104103,
+    };
+
     struct IoctlInitalizeEx {
-        u32_le big_page_size{}; // depends on GPU's available_big_page_sizes; 0=default
-        s32_le as_fd{};         // ignored; passes 0
-        u32_le flags{};         // passes 0
-        u32_le reserved{};      // ignored; passes 0
-        u64_le unk0{};
-        u64_le unk1{};
-        u64_le unk2{};
+        u32_le big_page_size; // depends on GPU's available_big_page_sizes; 0=default
+        s32_le as_fd;         // ignored; passes 0
+        u32_le flags;         // passes 0
+        u32_le reserved;      // ignored; passes 0
+        u64_le unk0;
+        u64_le unk1;
+        u64_le unk2;
     };
     static_assert(sizeof(IoctlInitalizeEx) == 40, "IoctlInitalizeEx is incorrect size");
 
     struct IoctlAllocSpace {
-        u32_le pages{};
-        u32_le page_size{};
-        AddressSpaceFlags flags{};
+        u32_le pages;
+        u32_le page_size;
+        AddressSpaceFlags flags;
         INSERT_PADDING_WORDS(1);
         union {
             u64_le offset;
@@ -100,73 +109,70 @@ private:
     static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitalizeEx is incorrect size");
 
     struct IoctlFreeSpace {
-        u64_le offset{};
-        u32_le pages{};
-        u32_le page_size{};
+        u64_le offset;
+        u32_le pages;
+        u32_le page_size;
     };
     static_assert(sizeof(IoctlFreeSpace) == 16, "IoctlFreeSpace is incorrect size");
 
     struct IoctlRemapEntry {
-        u16_le flags{};
-        u16_le kind{};
-        u32_le nvmap_handle{};
-        u32_le map_offset{};
-        u32_le offset{};
-        u32_le pages{};
+        u16_le flags;
+        u16_le kind;
+        u32_le nvmap_handle;
+        u32_le map_offset;
+        u32_le offset;
+        u32_le pages;
     };
     static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");
 
     struct IoctlMapBufferEx {
-        AddressSpaceFlags flags{}; // bit0: fixed_offset, bit2: cacheable
-        u32_le kind{};             // -1 is default
-        u32_le nvmap_handle{};
-        u32_le page_size{}; // 0 means don't care
-        s64_le buffer_offset{};
-        u64_le mapping_size{};
-        s64_le offset{};
+        AddressSpaceFlags flags; // bit0: fixed_offset, bit2: cacheable
+        u32_le kind;             // -1 is default
+        u32_le nvmap_handle;
+        u32_le page_size; // 0 means don't care
+        s64_le buffer_offset;
+        u64_le mapping_size;
+        s64_le offset;
     };
     static_assert(sizeof(IoctlMapBufferEx) == 40, "IoctlMapBufferEx is incorrect size");
 
     struct IoctlUnmapBuffer {
-        s64_le offset{};
+        s64_le offset;
     };
     static_assert(sizeof(IoctlUnmapBuffer) == 8, "IoctlUnmapBuffer is incorrect size");
 
     struct IoctlBindChannel {
-        s32_le fd{};
+        u32_le fd;
     };
     static_assert(sizeof(IoctlBindChannel) == 4, "IoctlBindChannel is incorrect size");
 
     struct IoctlVaRegion {
-        u64_le offset{};
-        u32_le page_size{};
+        u64_le offset;
+        u32_le page_size;
         INSERT_PADDING_WORDS(1);
-        u64_le pages{};
+        u64_le pages;
     };
     static_assert(sizeof(IoctlVaRegion) == 24, "IoctlVaRegion is incorrect size");
 
     struct IoctlGetVaRegions {
-        u64_le buf_addr{}; // (contained output user ptr on linux, ignored)
-        u32_le buf_size{}; // forced to 2*sizeof(struct va_region)
-        u32_le reserved{};
-        IoctlVaRegion regions[2]{};
+        u64_le buf_addr; // (contained output user ptr on linux, ignored)
+        u32_le buf_size; // forced to 2*sizeof(struct va_region)
+        u32_le reserved;
+        IoctlVaRegion regions[2];
     };
     static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(IoctlVaRegion) * 2,
                   "IoctlGetVaRegions is incorrect size");
 
-    s32 channel{};
+    u32 channel{};
 
-    NvResult InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult Remap(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult FreeSpace(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
-
-    NvResult GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetVARegions(const std::vector<u8>& input, std::vector<u8>& output,
-                          std::vector<u8>& inline_output);
+    u32 InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 Remap(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 FreeSpace(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::optional<BufferMap> FindBufferMap(GPUVAddr gpu_addr) const;
     void AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr, bool is_allocated);

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -20,54 +20,41 @@ nvhost_ctrl::nvhost_ctrl(Core::System& system, EventInterface& events_interface,
     : nvdevice(system), events_interface{events_interface}, syncpoint_manager{syncpoint_manager} {}
 nvhost_ctrl::~nvhost_ctrl() = default;
 
-NvResult nvhost_ctrl::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    switch (command.group) {
-    case 0x0:
-        switch (command.cmd) {
-        case 0x1b:
-            return NvOsGetConfigU32(input, output);
-        case 0x1c:
-            return IocCtrlClearEventWait(input, output);
-        case 0x1d:
-            return IocCtrlEventWait(input, output, false);
-        case 0x1e:
-            return IocCtrlEventWait(input, output, true);
-        case 0x1f:
-            return IocCtrlEventRegister(input, output);
-        case 0x20:
-            return IocCtrlEventUnregister(input, output);
-        }
-        break;
+u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                       std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                       IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocGetConfigCommand:
+        return NvOsGetConfigU32(input, output);
+    case IoctlCommand::IocCtrlEventWaitCommand:
+        return IocCtrlEventWait(input, output, false, ctrl);
+    case IoctlCommand::IocCtrlEventWaitAsyncCommand:
+        return IocCtrlEventWait(input, output, true, ctrl);
+    case IoctlCommand::IocCtrlEventRegisterCommand:
+        return IocCtrlEventRegister(input, output);
+    case IoctlCommand::IocCtrlEventUnregisterCommand:
+        return IocCtrlEventUnregister(input, output);
+    case IoctlCommand::IocCtrlClearEventWaitCommand:
+        return IocCtrlClearEventWait(input, output);
     default:
-        break;
+        UNIMPLEMENTED_MSG("Unimplemented ioctl");
+        return 0;
     }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                             const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_ctrl::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                             std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
     IocGetConfigParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
     LOG_TRACE(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
               params.param_str.data());
-    return NvResult::ConfigVarNotFound; // Returns error on production mode
+    return 0x30006; // Returns error on production mode
 }
 
-NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output,
-                                       bool is_async) {
+u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output,
+                                  bool is_async, IoctlCtrl& ctrl) {
     IocCtrlEventWaitParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "syncpt_id={}, threshold={}, timeout={}, is_async={}",
@@ -139,7 +126,10 @@ NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector
         params.value |= event_id;
         event.event.writable->Clear();
         gpu.RegisterSyncptInterrupt(params.syncpt_id, target_value);
-        if (!is_async) {
+        if (!is_async && ctrl.fresh_call) {
+            ctrl.must_delay = true;
+            ctrl.timeout = params.timeout;
+            ctrl.event_id = event_id;
             return NvResult::Timeout;
         }
         std::memcpy(output.data(), &params, sizeof(params));
@@ -149,7 +139,7 @@ NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector
     return NvResult::BadParameter;
 }
 
-NvResult nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output) {
     IocCtrlEventRegisterParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
     const u32 event_id = params.user_event_id & 0x00FF;
@@ -164,8 +154,7 @@ NvResult nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::ve
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl::IocCtrlEventUnregister(const std::vector<u8>& input,
-                                             std::vector<u8>& output) {
+u32 nvhost_ctrl::IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output) {
     IocCtrlEventUnregisterParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
     const u32 event_id = params.user_event_id & 0x00FF;
@@ -180,7 +169,7 @@ NvResult nvhost_ctrl::IocCtrlEventUnregister(const std::vector<u8>& input,
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl::IocCtrlClearEventWait(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl::IocCtrlClearEventWait(const std::vector<u8>& input, std::vector<u8>& output) {
     IocCtrlEventSignalParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -18,113 +18,132 @@ public:
                          SyncpointManager& syncpoint_manager);
     ~nvhost_ctrl() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
 private:
+    enum class IoctlCommand : u32_le {
+        IocSyncptReadCommand = 0xC0080014,
+        IocSyncptIncrCommand = 0x40040015,
+        IocSyncptWaitCommand = 0xC00C0016,
+        IocModuleMutexCommand = 0x40080017,
+        IocModuleRegRDWRCommand = 0xC0180018,
+        IocSyncptWaitexCommand = 0xC0100019,
+        IocSyncptReadMaxCommand = 0xC008001A,
+        IocGetConfigCommand = 0xC183001B,
+        IocCtrlClearEventWaitCommand = 0xC004001C,
+        IocCtrlEventWaitCommand = 0xC010001D,
+        IocCtrlEventWaitAsyncCommand = 0xC010001E,
+        IocCtrlEventRegisterCommand = 0xC004001F,
+        IocCtrlEventUnregisterCommand = 0xC0040020,
+        IocCtrlEventKillCommand = 0x40080021,
+    };
     struct IocSyncptReadParams {
-        u32_le id{};
-        u32_le value{};
+        u32_le id;
+        u32_le value;
     };
     static_assert(sizeof(IocSyncptReadParams) == 8, "IocSyncptReadParams is incorrect size");
 
     struct IocSyncptIncrParams {
-        u32_le id{};
+        u32_le id;
     };
     static_assert(sizeof(IocSyncptIncrParams) == 4, "IocSyncptIncrParams is incorrect size");
 
     struct IocSyncptWaitParams {
-        u32_le id{};
-        u32_le thresh{};
-        s32_le timeout{};
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
     };
     static_assert(sizeof(IocSyncptWaitParams) == 12, "IocSyncptWaitParams is incorrect size");
 
     struct IocModuleMutexParams {
-        u32_le id{};
-        u32_le lock{}; // (0 = unlock and 1 = lock)
+        u32_le id;
+        u32_le lock; // (0 = unlock and 1 = lock)
     };
     static_assert(sizeof(IocModuleMutexParams) == 8, "IocModuleMutexParams is incorrect size");
 
     struct IocModuleRegRDWRParams {
-        u32_le id{};
-        u32_le num_offsets{};
-        u32_le block_size{};
-        u32_le offsets{};
-        u32_le values{};
-        u32_le write{};
+        u32_le id;
+        u32_le num_offsets;
+        u32_le block_size;
+        u32_le offsets;
+        u32_le values;
+        u32_le write;
     };
     static_assert(sizeof(IocModuleRegRDWRParams) == 24, "IocModuleRegRDWRParams is incorrect size");
 
     struct IocSyncptWaitexParams {
-        u32_le id{};
-        u32_le thresh{};
-        s32_le timeout{};
-        u32_le value{};
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
+        u32_le value;
     };
     static_assert(sizeof(IocSyncptWaitexParams) == 16, "IocSyncptWaitexParams is incorrect size");
 
     struct IocSyncptReadMaxParams {
-        u32_le id{};
-        u32_le value{};
+        u32_le id;
+        u32_le value;
     };
     static_assert(sizeof(IocSyncptReadMaxParams) == 8, "IocSyncptReadMaxParams is incorrect size");
 
     struct IocGetConfigParams {
-        std::array<char, 0x41> domain_str{};
-        std::array<char, 0x41> param_str{};
-        std::array<char, 0x101> config_str{};
+        std::array<char, 0x41> domain_str;
+        std::array<char, 0x41> param_str;
+        std::array<char, 0x101> config_str;
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
     struct IocCtrlEventSignalParams {
-        u32_le event_id{};
+        u32_le event_id;
     };
     static_assert(sizeof(IocCtrlEventSignalParams) == 4,
                   "IocCtrlEventSignalParams is incorrect size");
 
     struct IocCtrlEventWaitParams {
-        u32_le syncpt_id{};
-        u32_le threshold{};
-        s32_le timeout{};
-        u32_le value{};
+        u32_le syncpt_id;
+        u32_le threshold;
+        s32_le timeout;
+        u32_le value;
     };
     static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
 
     struct IocCtrlEventWaitAsyncParams {
-        u32_le syncpt_id{};
-        u32_le threshold{};
-        u32_le timeout{};
-        u32_le value{};
+        u32_le syncpt_id;
+        u32_le threshold;
+        u32_le timeout;
+        u32_le value;
     };
     static_assert(sizeof(IocCtrlEventWaitAsyncParams) == 16,
                   "IocCtrlEventWaitAsyncParams is incorrect size");
 
     struct IocCtrlEventRegisterParams {
-        u32_le user_event_id{};
+        u32_le user_event_id;
     };
     static_assert(sizeof(IocCtrlEventRegisterParams) == 4,
                   "IocCtrlEventRegisterParams is incorrect size");
 
     struct IocCtrlEventUnregisterParams {
-        u32_le user_event_id{};
+        u32_le user_event_id;
     };
     static_assert(sizeof(IocCtrlEventUnregisterParams) == 4,
                   "IocCtrlEventUnregisterParams is incorrect size");
 
     struct IocCtrlEventKill {
-        u64_le user_events{};
+        u64_le user_events;
     };
     static_assert(sizeof(IocCtrlEventKill) == 8, "IocCtrlEventKill is incorrect size");
 
-    NvResult NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output, bool is_async);
-    NvResult IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocCtrlClearEventWait(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
+
+    u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output, bool is_async,
+                         IoctlCtrl& ctrl);
+
+    u32 IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output);
+
+    u32 IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output);
+
+    u32 IocCtrlClearEventWait(const std::vector<u8>& input, std::vector<u8>& output);
 
     EventInterface& events_interface;
     SyncpointManager& syncpoint_manager;

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -15,112 +15,39 @@ namespace Service::Nvidia::Devices {
 nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system) : nvdevice(system) {}
 nvhost_ctrl_gpu::~nvhost_ctrl_gpu() = default;
 
-NvResult nvhost_ctrl_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
-                                 std::vector<u8>& output) {
-    switch (command.group) {
-    case 'G':
-        switch (command.cmd) {
-        case 0x1:
-            return ZCullGetCtxSize(input, output);
-        case 0x2:
-            return ZCullGetInfo(input, output);
-        case 0x3:
-            return ZBCSetTable(input, output);
-        case 0x4:
-            return ZBCQueryTable(input, output);
-        case 0x5:
-            return GetCharacteristics(input, output);
-        case 0x6:
-            return GetTPCMasks(input, output);
-        case 0x7:
-            return FlushL2(input, output);
-        case 0x14:
-            return GetActiveSlotMask(input, output);
-        case 0x1c:
-            return GetGpuTime(input, output);
-        default:
-            break;
-        }
-        break;
-    }
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
+u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input,
+                           const std::vector<u8>& input2, std::vector<u8>& output,
+                           std::vector<u8>& output2, IoctlCtrl& ctrl, IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
 
-NvResult nvhost_ctrl_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                                 const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_ctrl_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input,
-                                 std::vector<u8>& output, std::vector<u8>& inline_output) {
-    switch (command.group) {
-    case 'G':
-        switch (command.cmd) {
-        case 0x5:
-            return GetCharacteristics(input, output, inline_output);
-        case 0x6:
-            return GetTPCMasks(input, output, inline_output);
-        default:
-            break;
-        }
-        break;
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocGetCharacteristicsCommand:
+        return GetCharacteristics(input, output, output2, version);
+    case IoctlCommand::IocGetTPCMasksCommand:
+        return GetTPCMasks(input, output, output2, version);
+    case IoctlCommand::IocGetActiveSlotMaskCommand:
+        return GetActiveSlotMask(input, output);
+    case IoctlCommand::IocZcullGetCtxSizeCommand:
+        return ZCullGetCtxSize(input, output);
+    case IoctlCommand::IocZcullGetInfo:
+        return ZCullGetInfo(input, output);
+    case IoctlCommand::IocZbcSetTable:
+        return ZBCSetTable(input, output);
+    case IoctlCommand::IocZbcQueryTable:
+        return ZBCQueryTable(input, output);
+    case IoctlCommand::IocFlushL2:
+        return FlushL2(input, output);
+    case IoctlCommand::IocGetGpuTime:
+        return GetGpuTime(input, output);
     default:
-        break;
+        UNIMPLEMENTED_MSG("Unimplemented ioctl");
+        return 0;
     }
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input,
-                                             std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlCharacteristics params{};
-    std::memcpy(&params, input.data(), input.size());
-    params.gc.arch = 0x120;
-    params.gc.impl = 0xb;
-    params.gc.rev = 0xa1;
-    params.gc.num_gpc = 0x1;
-    params.gc.l2_cache_size = 0x40000;
-    params.gc.on_board_video_memory_size = 0x0;
-    params.gc.num_tpc_per_gpc = 0x2;
-    params.gc.bus_type = 0x20;
-    params.gc.big_page_size = 0x20000;
-    params.gc.compression_page_size = 0x20000;
-    params.gc.pde_coverage_bit_count = 0x1B;
-    params.gc.available_big_page_sizes = 0x30000;
-    params.gc.gpc_mask = 0x1;
-    params.gc.sm_arch_sm_version = 0x503;
-    params.gc.sm_arch_spa_version = 0x503;
-    params.gc.sm_arch_warp_count = 0x80;
-    params.gc.gpu_va_bit_count = 0x28;
-    params.gc.reserved = 0x0;
-    params.gc.flags = 0x55;
-    params.gc.twod_class = 0x902D;
-    params.gc.threed_class = 0xB197;
-    params.gc.compute_class = 0xB1C0;
-    params.gc.gpfifo_class = 0xB06F;
-    params.gc.inline_to_memory_class = 0xA140;
-    params.gc.dma_copy_class = 0xB0B5;
-    params.gc.max_fbps_count = 0x1;
-    params.gc.fbp_en_mask = 0x0;
-    params.gc.max_ltc_per_fbp = 0x2;
-    params.gc.max_lts_per_ltc = 0x1;
-    params.gc.max_tex_per_tpc = 0x0;
-    params.gc.max_gpc_count = 0x1;
-    params.gc.rop_l2_en_mask_0 = 0x21D70;
-    params.gc.rop_l2_en_mask_1 = 0x0;
-    params.gc.chipname = 0x6230326D67;
-    params.gc.gr_compbit_store_base_hw = 0x0;
-    params.gpu_characteristics_buf_size = 0xA0;
-    params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
-    std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
-}
-
-NvResult nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
-                                             std::vector<u8>& inline_output) {
+u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
+                                        std::vector<u8>& output2, IoctlVersion version) {
     LOG_DEBUG(Service_NVDRV, "called");
     IoctlCharacteristics params{};
     std::memcpy(&params, input.data(), input.size());
@@ -162,36 +89,35 @@ NvResult nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::
     params.gpu_characteristics_buf_size = 0xA0;
     params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
 
-    std::memcpy(output.data(), input.data(), output.size());
-    std::memcpy(inline_output.data(), &params.gc, inline_output.size());
-    return NvResult::Success;
+    if (version == IoctlVersion::Version3) {
+        std::memcpy(output.data(), input.data(), output.size());
+        std::memcpy(output2.data(), &params.gc, output2.size());
+    } else {
+        std::memcpy(output.data(), &params, output.size());
+    }
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output,
+                                 std::vector<u8>& output2, IoctlVersion version) {
     IoctlGpuGetTpcMasksArgs params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, mask_buffer_size=0x{:X}", params.mask_buffer_size);
     if (params.mask_buffer_size != 0) {
         params.tcp_mask = 3;
     }
-    std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
-}
 
-NvResult nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output,
-                                      std::vector<u8>& inline_output) {
-    IoctlGpuGetTpcMasksArgs params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, mask_buffer_size=0x{:X}", params.mask_buffer_size);
-    if (params.mask_buffer_size != 0) {
-        params.tcp_mask = 3;
+    if (version == IoctlVersion::Version3) {
+        std::memcpy(output.data(), input.data(), output.size());
+        std::memcpy(output2.data(), &params.tcp_mask, output2.size());
+    } else {
+        std::memcpy(output.data(), &params, output.size());
     }
-    std::memcpy(output.data(), &params, output.size());
-    std::memcpy(inline_output.data(), &params.tcp_mask, inline_output.size());
-    return NvResult::Success;
+
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlActiveSlotMask params{};
@@ -201,10 +127,10 @@ NvResult nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::v
     params.slot = 0x07;
     params.mask = 0x01;
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlZcullGetCtxSize params{};
@@ -213,10 +139,10 @@ NvResult nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vec
     }
     params.size = 0x1;
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlNvgpuGpuZcullGetInfoArgs params{};
@@ -236,47 +162,47 @@ NvResult nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector
     params.subregion_height_align_pixels = 0x40;
     params.subregion_count = 0x10;
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
     IoctlZbcSetTable params{};
     std::memcpy(&params, input.data(), input.size());
     // TODO(ogniK): What does this even actually do?
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
     IoctlZbcQueryTable params{};
     std::memcpy(&params, input.data(), input.size());
     // TODO : To implement properly
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
     IoctlFlushL2 params{};
     std::memcpy(&params, input.data(), input.size());
     // TODO : To implement properly
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlGetGpuTime params{};
     std::memcpy(&params, input.data(), input.size());
     params.gpu_time = static_cast<u64_le>(system.CoreTiming().GetGlobalTimeNs().count());
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h

@@ -16,13 +16,32 @@ public:
     explicit nvhost_ctrl_gpu(Core::System& system);
     ~nvhost_ctrl_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
 private:
+    enum class IoctlCommand : u32_le {
+        IocGetCharacteristicsCommand = 0xC0B04705,
+        IocGetTPCMasksCommand = 0xC0184706,
+        IocGetActiveSlotMaskCommand = 0x80084714,
+        IocZcullGetCtxSizeCommand = 0x80044701,
+        IocZcullGetInfo = 0x80284702,
+        IocZbcSetTable = 0x402C4703,
+        IocZbcQueryTable = 0xC0344704,
+        IocFlushL2 = 0x40084707,
+        IocInvalICache = 0x4008470D,
+        IocSetMmudebugMode = 0x4008470E,
+        IocSetSmDebugMode = 0x4010470F,
+        IocWaitForPause = 0xC0084710,
+        IocGetTcpExceptionEnStatus = 0x80084711,
+        IocNumVsms = 0x80084712,
+        IocVsmsMapping = 0xC0044713,
+        IocGetErrorChannelUserData = 0xC008471B,
+        IocGetGpuTime = 0xC010471C,
+        IocGetCpuTimeCorrelationInfo = 0xC108471D,
+    };
+
     struct IoctlGpuCharacteristics {
         u32_le arch;                       // 0x120 (NVGPU_GPU_ARCH_GM200)
         u32_le impl;                       // 0xB (NVGPU_GPU_IMPL_GM20B)
@@ -140,21 +159,17 @@ private:
     };
     static_assert(sizeof(IoctlGetGpuTime) == 0x10, "IoctlGetGpuTime is incorrect size");
 
-    NvResult GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
-                                std::vector<u8>& inline_output);
-
-    NvResult GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output,
-                         std::vector<u8>& inline_output);
-
-    NvResult GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult FlushL2(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
+                           std::vector<u8>& output2, IoctlVersion version);
+    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output, std::vector<u8>& output2,
+                    IoctlVersion version);
+    u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 FlushL2(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -23,132 +23,107 @@ nvhost_gpu::nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
 
 nvhost_gpu::~nvhost_gpu() = default;
 
-NvResult nvhost_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    switch (command.group) {
-    case 0x0:
-        switch (command.cmd) {
-        case 0x3:
-            return GetWaitbase(input, output);
-        default:
-            break;
-        }
-        break;
-    case 'H':
-        switch (command.cmd) {
-        case 0x1:
-            return SetNVMAPfd(input, output);
-        case 0x3:
-            return ChannelSetTimeout(input, output);
-        case 0x8:
-            return SubmitGPFIFOBase(input, output, false);
-        case 0x9:
-            return AllocateObjectContext(input, output);
-        case 0xb:
-            return ZCullBind(input, output);
-        case 0xc:
-            return SetErrorNotifier(input, output);
-        case 0xd:
-            return SetChannelPriority(input, output);
-        case 0x1a:
-            return AllocGPFIFOEx2(input, output);
-        case 0x1b:
-            return SubmitGPFIFOBase(input, output, true);
-        case 0x1d:
-            return ChannelSetTimeslice(input, output);
-        default:
-            break;
-        }
-        break;
-    case 'G':
-        switch (command.cmd) {
-        case 0x14:
-            return SetClientData(input, output);
-        case 0x15:
-            return GetClientData(input, output);
-        default:
-            break;
-        }
+u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                      IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input, output);
+    case IoctlCommand::IocSetClientDataCommand:
+        return SetClientData(input, output);
+    case IoctlCommand::IocGetClientDataCommand:
+        return GetClientData(input, output);
+    case IoctlCommand::IocZCullBind:
+        return ZCullBind(input, output);
+    case IoctlCommand::IocSetErrorNotifierCommand:
+        return SetErrorNotifier(input, output);
+    case IoctlCommand::IocChannelSetPriorityCommand:
+        return SetChannelPriority(input, output);
+    case IoctlCommand::IocAllocGPFIFOEx2Command:
+        return AllocGPFIFOEx2(input, output);
+    case IoctlCommand::IocAllocObjCtxCommand:
+        return AllocateObjectContext(input, output);
+    case IoctlCommand::IocChannelGetWaitbaseCommand:
+        return GetWaitbase(input, output);
+    case IoctlCommand::IocChannelSetTimeoutCommand:
+        return ChannelSetTimeout(input, output);
+    case IoctlCommand::IocChannelSetTimeslice:
+        return ChannelSetTimeslice(input, output);
+    default:
         break;
     }
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+
+    if (command.group == NVGPU_IOCTL_MAGIC) {
+        if (command.cmd == NVGPU_IOCTL_CHANNEL_SUBMIT_GPFIFO) {
+            return SubmitGPFIFO(input, output);
+        }
+        if (command.cmd == NVGPU_IOCTL_CHANNEL_KICKOFF_PB) {
+            return KickoffPB(input, output, input2, version);
+        }
+    }
+
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
 };
 
-NvResult nvhost_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    switch (command.group) {
-    case 'H':
-        switch (command.cmd) {
-        case 0x1b:
-            return SubmitGPFIFOBase(input, inline_input, output);
-        }
-        break;
-    }
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetNvmapFD params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlClientData params{};
     std::memcpy(&params, input.data(), input.size());
     user_data = params.data;
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
     IoctlClientData params{};
     std::memcpy(&params, input.data(), input.size());
     params.data = user_data;
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output) {
     std::memcpy(&zcull_params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, gpu_va={:X}, mode={:X}", zcull_params.gpu_va,
               zcull_params.mode);
 
     std::memcpy(output.data(), &zcull_params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetErrorNotifier params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, offset={:X}, size={:X}, mem={:X}", params.offset,
                 params.size, params.mem);
 
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output) {
     std::memcpy(&channel_priority, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
 
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlAllocGpfifoEx2 params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV,
@@ -162,10 +137,10 @@ NvResult nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8
     params.fence_out = channel_fence;
 
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlAllocObjCtx params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num={:X}, flags={:X}", params.class_num,
@@ -173,7 +148,7 @@ NvResult nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::ve
 
     params.obj_id = 0x0;
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
 static std::vector<Tegra::CommandHeader> BuildWaitCommandList(Fence fence) {
@@ -217,8 +192,8 @@ static std::vector<Tegra::CommandHeader> BuildIncrementWithWfiCommandList(Fence
     return result;
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::vector<u8>& output,
-                                      Tegra::CommandList&& entries) {
+u32 nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::vector<u8>& output,
+                                 Tegra::CommandList&& entries) {
     LOG_TRACE(Service_NVDRV, "called, gpfifo={:X}, num_entries={:X}, flags={:X}", params.address,
               params.num_entries, params.flags.raw);
 
@@ -252,70 +227,69 @@ NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::vector<u8>
     }
 
     std::memcpy(output.data(), &params, sizeof(IoctlSubmitGpfifo));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOBase(const std::vector<u8>& input, std::vector<u8>& output,
-                                      bool kickoff) {
+u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output) {
     if (input.size() < sizeof(IoctlSubmitGpfifo)) {
         UNIMPLEMENTED();
-        return NvResult::InvalidSize;
     }
     IoctlSubmitGpfifo params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
-    Tegra::CommandList entries(params.num_entries);
 
-    if (kickoff) {
+    Tegra::CommandList entries(params.num_entries);
+    std::memcpy(entries.command_lists.data(), &input[sizeof(IoctlSubmitGpfifo)],
+                params.num_entries * sizeof(Tegra::CommandListHeader));
+
+    return SubmitGPFIFOImpl(params, output, std::move(entries));
+}
+
+u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output,
+                          const std::vector<u8>& input2, IoctlVersion version) {
+    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
+        UNIMPLEMENTED();
+    }
+    IoctlSubmitGpfifo params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
+
+    Tegra::CommandList entries(params.num_entries);
+    if (version == IoctlVersion::Version2) {
+        std::memcpy(entries.command_lists.data(), input2.data(),
+                    params.num_entries * sizeof(Tegra::CommandListHeader));
+    } else {
         system.Memory().ReadBlock(params.address, entries.command_lists.data(),
                                   params.num_entries * sizeof(Tegra::CommandListHeader));
-    } else {
-        std::memcpy(entries.command_lists.data(), &input[sizeof(IoctlSubmitGpfifo)],
-                    params.num_entries * sizeof(Tegra::CommandListHeader));
     }
 
     return SubmitGPFIFOImpl(params, output, std::move(entries));
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOBase(const std::vector<u8>& input,
-                                      const std::vector<u8>& input_inline,
-                                      std::vector<u8>& output) {
-    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
-        UNIMPLEMENTED();
-        return NvResult::InvalidSize;
-    }
-    IoctlSubmitGpfifo params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
-    Tegra::CommandList entries(params.num_entries);
-    std::memcpy(entries.command_lists.data(), input_inline.data(), input_inline.size());
-    return SubmitGPFIFOImpl(params, output, std::move(entries));
-}
-
-NvResult nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlGetWaitbase params{};
     std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
     LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
 
     params.value = 0; // Seems to be hard coded at 0
     std::memcpy(output.data(), &params, output.size());
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlChannelSetTimeout params{};
     std::memcpy(&params, input.data(), sizeof(IoctlChannelSetTimeout));
     LOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
 
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_gpu::ChannelSetTimeslice(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_gpu::ChannelSetTimeslice(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetTimeslice params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSetTimeslice));
     LOG_INFO(Service_NVDRV, "called, timeslice=0x{:X}", params.timeslice);
 
     channel_timeslice = params.timeslice;
 
-    return NvResult::Success;
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -20,19 +20,43 @@ class SyncpointManager;
 namespace Service::Nvidia::Devices {
 
 class nvmap;
+constexpr u32 NVGPU_IOCTL_MAGIC('H');
+constexpr u32 NVGPU_IOCTL_CHANNEL_SUBMIT_GPFIFO(0x8);
+constexpr u32 NVGPU_IOCTL_CHANNEL_KICKOFF_PB(0x1b);
+
 class nvhost_gpu final : public nvdevice {
 public:
     explicit nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
                         SyncpointManager& syncpoint_manager);
     ~nvhost_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
 private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+        IocAllocGPFIFOCommand = 0x40084805,
+        IocSetClientDataCommand = 0x40084714,
+        IocGetClientDataCommand = 0x80084715,
+        IocZCullBind = 0xc010480b,
+        IocSetErrorNotifierCommand = 0xC018480C,
+        IocChannelSetPriorityCommand = 0x4004480D,
+        IocEnableCommand = 0x0000480E,
+        IocDisableCommand = 0x0000480F,
+        IocPreemptCommand = 0x00004810,
+        IocForceResetCommand = 0x00004811,
+        IocEventIdControlCommand = 0x40084812,
+        IocGetErrorNotificationCommand = 0xC0104817,
+        IocAllocGPFIFOExCommand = 0x40204818,
+        IocAllocGPFIFOEx2Command = 0xC020481A,
+        IocAllocObjCtxCommand = 0xC0104809,
+        IocChannelGetWaitbaseCommand = 0xC0080003,
+        IocChannelSetTimeoutCommand = 0x40044803,
+        IocChannelSetTimeslice = 0xC004481D,
+    };
+
     enum class CtxObjects : u32_le {
         Ctx2D = 0x902D,
         Ctx3D = 0xB197,
@@ -43,63 +67,63 @@ private:
     };
 
     struct IoctlSetNvmapFD {
-        s32_le nvmap_fd{};
+        u32_le nvmap_fd;
     };
     static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
 
     struct IoctlChannelSetTimeout {
-        u32_le timeout{};
+        u32_le timeout;
     };
     static_assert(sizeof(IoctlChannelSetTimeout) == 4, "IoctlChannelSetTimeout is incorrect size");
 
     struct IoctlAllocGPFIFO {
-        u32_le num_entries{};
-        u32_le flags{};
+        u32_le num_entries;
+        u32_le flags;
     };
     static_assert(sizeof(IoctlAllocGPFIFO) == 8, "IoctlAllocGPFIFO is incorrect size");
 
     struct IoctlClientData {
-        u64_le data{};
+        u64_le data;
     };
     static_assert(sizeof(IoctlClientData) == 8, "IoctlClientData is incorrect size");
 
     struct IoctlZCullBind {
-        u64_le gpu_va{};
-        u32_le mode{}; // 0=global, 1=no_ctxsw, 2=separate_buffer, 3=part_of_regular_buf
+        u64_le gpu_va;
+        u32_le mode; // 0=global, 1=no_ctxsw, 2=separate_buffer, 3=part_of_regular_buf
         INSERT_PADDING_WORDS(1);
     };
     static_assert(sizeof(IoctlZCullBind) == 16, "IoctlZCullBind is incorrect size");
 
     struct IoctlSetErrorNotifier {
-        u64_le offset{};
-        u64_le size{};
-        u32_le mem{}; // nvmap object handle
+        u64_le offset;
+        u64_le size;
+        u32_le mem; // nvmap object handle
         INSERT_PADDING_WORDS(1);
     };
     static_assert(sizeof(IoctlSetErrorNotifier) == 24, "IoctlSetErrorNotifier is incorrect size");
 
     struct IoctlChannelSetPriority {
-        u32_le priority{};
+        u32_le priority;
     };
     static_assert(sizeof(IoctlChannelSetPriority) == 4,
                   "IoctlChannelSetPriority is incorrect size");
 
     struct IoctlSetTimeslice {
-        u32_le timeslice{};
+        u32_le timeslice;
     };
     static_assert(sizeof(IoctlSetTimeslice) == 4, "IoctlSetTimeslice is incorrect size");
 
     struct IoctlEventIdControl {
-        u32_le cmd{}; // 0=disable, 1=enable, 2=clear
-        u32_le id{};
+        u32_le cmd; // 0=disable, 1=enable, 2=clear
+        u32_le id;
     };
     static_assert(sizeof(IoctlEventIdControl) == 8, "IoctlEventIdControl is incorrect size");
 
     struct IoctlGetErrorNotification {
-        u64_le timestamp{};
-        u32_le info32{};
-        u16_le info16{};
-        u16_le status{}; // always 0xFFFF
+        u64_le timestamp;
+        u32_le info32;
+        u16_le info16;
+        u16_le status; // always 0xFFFF
     };
     static_assert(sizeof(IoctlGetErrorNotification) == 16,
                   "IoctlGetErrorNotification is incorrect size");
@@ -107,39 +131,39 @@ private:
     static_assert(sizeof(Fence) == 8, "Fence is incorrect size");
 
     struct IoctlAllocGpfifoEx {
-        u32_le num_entries{};
-        u32_le flags{};
-        u32_le unk0{};
-        u32_le unk1{};
-        u32_le unk2{};
-        u32_le unk3{};
-        u32_le unk4{};
-        u32_le unk5{};
+        u32_le num_entries;
+        u32_le flags;
+        u32_le unk0;
+        u32_le unk1;
+        u32_le unk2;
+        u32_le unk3;
+        u32_le unk4;
+        u32_le unk5;
     };
     static_assert(sizeof(IoctlAllocGpfifoEx) == 32, "IoctlAllocGpfifoEx is incorrect size");
 
     struct IoctlAllocGpfifoEx2 {
-        u32_le num_entries{}; // in
-        u32_le flags{};       // in
-        u32_le unk0{};        // in (1 works)
-        Fence fence_out{};    // out
-        u32_le unk1{};        // in
-        u32_le unk2{};        // in
-        u32_le unk3{};        // in
+        u32_le num_entries; // in
+        u32_le flags;       // in
+        u32_le unk0;        // in (1 works)
+        Fence fence_out;    // out
+        u32_le unk1;        // in
+        u32_le unk2;        // in
+        u32_le unk3;        // in
     };
     static_assert(sizeof(IoctlAllocGpfifoEx2) == 32, "IoctlAllocGpfifoEx2 is incorrect size");
 
     struct IoctlAllocObjCtx {
-        u32_le class_num{}; // 0x902D=2d, 0xB197=3d, 0xB1C0=compute, 0xA140=kepler, 0xB0B5=DMA,
-                            // 0xB06F=channel_gpfifo
-        u32_le flags{};
-        u64_le obj_id{}; // (ignored) used for FREE_OBJ_CTX ioctl, which is not supported
+        u32_le class_num; // 0x902D=2d, 0xB197=3d, 0xB1C0=compute, 0xA140=kepler, 0xB0B5=DMA,
+                          // 0xB06F=channel_gpfifo
+        u32_le flags;
+        u64_le obj_id; // (ignored) used for FREE_OBJ_CTX ioctl, which is not supported
     };
     static_assert(sizeof(IoctlAllocObjCtx) == 16, "IoctlAllocObjCtx is incorrect size");
 
     struct IoctlSubmitGpfifo {
-        u64_le address{};     // pointer to gpfifo entry structs
-        u32_le num_entries{}; // number of fence objects being submitted
+        u64_le address;     // pointer to gpfifo entry structs
+        u32_le num_entries; // number of fence objects being submitted
         union {
             u32_le raw;
             BitField<0, 1, u32_le> add_wait;      // append a wait sync_point to the list
@@ -148,7 +172,7 @@ private:
             BitField<4, 1, u32_le> suppress_wfi;  // suppress wait for interrupt
             BitField<8, 1, u32_le> increment;     // increment the returned fence
         } flags;
-        Fence fence_out{}; // returned new fence object for others to wait on
+        Fence fence_out; // returned new fence object for others to wait on
 
         u32 AddIncrementValue() const {
             return flags.add_increment.Value() << 1;
@@ -158,34 +182,33 @@ private:
                   "IoctlSubmitGpfifo is incorrect size");
 
     struct IoctlGetWaitbase {
-        u32 unknown{}; // seems to be ignored? Nintendo added this
-        u32 value{};
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
     };
     static_assert(sizeof(IoctlGetWaitbase) == 8, "IoctlGetWaitbase is incorrect size");
 
-    s32_le nvmap_fd{};
+    u32_le nvmap_fd{};
     u64_le user_data{};
     IoctlZCullBind zcull_params{};
     u32_le channel_priority{};
     u32_le channel_timeslice{};
 
-    NvResult SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult SetClientData(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetClientData(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ZCullBind(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::vector<u8>& output,
-                              Tegra::CommandList&& entries);
-    NvResult SubmitGPFIFOBase(const std::vector<u8>& input, std::vector<u8>& output,
-                              bool kickoff = false);
-    NvResult SubmitGPFIFOBase(const std::vector<u8>& input, const std::vector<u8>& input_inline,
-                              std::vector<u8>& output);
-    NvResult GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult ChannelSetTimeslice(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetClientData(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetClientData(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZCullBind(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::vector<u8>& output,
+                         Tegra::CommandList&& entries);
+    u32 SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 KickoffPB(const std::vector<u8>& input, std::vector<u8>& output,
+                  const std::vector<u8>& input2, IoctlVersion version);
+    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ChannelSetTimeslice(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::shared_ptr<nvmap> nvmap_dev;
     SyncpointManager& syncpoint_manager;

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -15,58 +15,46 @@ nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_de
     : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}
 nvhost_nvdec::~nvhost_nvdec() = default;
 
-NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& output) {
-    switch (command.group) {
-    case 0x0:
-        switch (command.cmd) {
-        case 0x1:
-            return Submit(input, output);
-        case 0x2:
-            return GetSyncpoint(input, output);
-        case 0x3:
-            return GetWaitbase(input, output);
-        case 0x7:
-            return SetSubmitTimeout(input, output);
-        case 0x9:
-            return MapBuffer(input, output);
-        case 0xa: {
-            if (command.length == 0x1c) {
-                LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
-                Tegra::ChCommandHeaderList cmdlist(1);
-                cmdlist[0] = Tegra::ChCommandHeader{0xDEADB33F};
-                system.GPU().PushCommandBuffer(cmdlist);
-            }
-            return UnmapBuffer(input, output);
-        }
-        default:
-            break;
-        }
-        break;
-    case 'H':
-        switch (command.cmd) {
-        case 0x1:
-            return SetNVMAPfd(input);
-        default:
-            break;
-        }
-        break;
+u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                        IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input);
+    case IoctlCommand::IocSubmit:
+        return Submit(input, output);
+    case IoctlCommand::IocGetSyncpoint:
+        return GetSyncpoint(input, output);
+    case IoctlCommand::IocGetWaitbase:
+        return GetWaitbase(input, output);
+    case IoctlCommand::IocMapBuffer:
+    case IoctlCommand::IocMapBuffer2:
+    case IoctlCommand::IocMapBuffer3:
+    case IoctlCommand::IocMapBufferEx:
+        return MapBuffer(input, output);
+    case IoctlCommand::IocUnmapBufferEx: {
+        // This command is sent when the video stream has ended, flush all video contexts
+        // This is usually sent in the folowing order: vic, nvdec, vic.
+        // Inform the GPU to clear any remaining nvdec buffers when this is detected.
+        LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
+        Tegra::ChCommandHeaderList cmdlist(1);
+        cmdlist[0] = Tegra::ChCommandHeader{0xDEADB33F};
+        system.GPU().PushCommandBuffer(cmdlist);
+        [[fallthrough]]; // fallthrough to unmap buffers
+    };
+    case IoctlCommand::IocUnmapBuffer:
+    case IoctlCommand::IocUnmapBuffer2:
+    case IoctlCommand::IocUnmapBuffer3:
+        return UnmapBuffer(input, output);
+    case IoctlCommand::IocSetSubmitTimeout:
+        return SetSubmitTimeout(input, output);
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_nvdec::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                              const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_nvdec::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                              std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+    UNIMPLEMENTED_MSG("Unimplemented ioctl 0x{:X}", command.raw);
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec.h

@@ -14,11 +14,26 @@ public:
     explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_nvdec() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
+
+private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+        IocSubmit = 0xC0400001,
+        IocGetSyncpoint = 0xC0080002,
+        IocGetWaitbase = 0xC0080003,
+        IocMapBuffer = 0xC01C0009,
+        IocMapBuffer2 = 0xC16C0009,
+        IocMapBuffer3 = 0xC15C0009,
+        IocMapBufferEx = 0xC0A40009,
+        IocUnmapBuffer = 0xC0A4000A,
+        IocUnmapBuffer2 = 0xC16C000A,
+        IocUnmapBufferEx = 0xC01C000A,
+        IocUnmapBuffer3 = 0xC15C000A,
+        IocSetSubmitTimeout = 0x40040007,
+    };
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -36,20 +36,26 @@ std::size_t WriteVectors(std::vector<u8>& dst, const std::vector<T>& src, std::s
 }
 } // Anonymous namespace
 
+namespace NvErrCodes {
+constexpr u32 Success{};
+[[maybe_unused]] constexpr u32 OutOfMemory{static_cast<u32>(-12)};
+constexpr u32 InvalidInput{static_cast<u32>(-22)};
+} // namespace NvErrCodes
+
 nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
     : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_nvdec_common::~nvhost_nvdec_common() = default;
 
-NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
+u32 nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
     IoctlSetNvmapFD params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSetNvmapFD));
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSubmit params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
     LOG_DEBUG(Service_NVDRV, "called NVDEC Submit, cmd_buffer_count={}", params.cmd_buffer_count);
@@ -77,12 +83,12 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
 
     for (const auto& cmd_buffer : command_buffers) {
         auto object = nvmap_dev->GetObject(cmd_buffer.memory_id);
-        ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
+        ASSERT_OR_EXECUTE(object, return NvErrCodes::InvalidInput;);
         const auto map = FindBufferMap(object->dma_map_addr);
         if (!map) {
             LOG_ERROR(Service_NVDRV, "Tried to submit an invalid offset 0x{:X} dma 0x{:X}",
                       object->addr, object->dma_map_addr);
-            return NvResult::Success;
+            return 0;
         }
         Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
         gpu.MemoryManager().ReadBlock(map->StartAddr() + cmd_buffer.offset, cmdlist.data(),
@@ -99,10 +105,10 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset = WriteVectors(output, syncpt_increments, offset);
     offset = WriteVectors(output, wait_checks, offset);
 
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlGetSyncpoint params{};
     std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
     LOG_DEBUG(Service_NVDRV, "called GetSyncpoint, id={}", params.param);
@@ -112,18 +118,18 @@ NvResult nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::ve
     params.value = 0;
     std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
 
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_nvdec_common::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvdec_common::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlGetWaitbase params{};
     std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
     params.value = 0; // Seems to be hard coded at 0
     std::memcpy(output.data(), &params, sizeof(IoctlGetWaitbase));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlMapBuffer params{};
     std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
     std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
@@ -137,7 +143,7 @@ NvResult nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vecto
         if (!object) {
             LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmf_buff.map_handle);
             std::memcpy(output.data(), &params, output.size());
-            return NvResult::InvalidState;
+            return NvErrCodes::InvalidInput;
         }
         if (object->dma_map_addr == 0) {
             // NVDEC and VIC memory is in the 32-bit address space
@@ -159,10 +165,10 @@ NvResult nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vecto
     std::memcpy(output.data() + sizeof(IoctlMapBuffer), cmd_buffer_handles.data(),
                 cmd_buffer_handles.size() * sizeof(MapBufferEntry));
 
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlMapBuffer params{};
     std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
     std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
@@ -175,7 +181,7 @@ NvResult nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vec
         if (!object) {
             LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmf_buff.map_handle);
             std::memcpy(output.data(), &params, output.size());
-            return NvResult::InvalidState;
+            return NvErrCodes::InvalidInput;
         }
         if (const auto size{RemoveBufferMap(object->dma_map_addr)}; size) {
             gpu.MemoryManager().Unmap(object->dma_map_addr, *size);
@@ -187,14 +193,13 @@ NvResult nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vec
         object->dma_map_addr = 0;
     }
     std::memset(output.data(), 0, output.size());
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
-NvResult nvhost_nvdec_common::SetSubmitTimeout(const std::vector<u8>& input,
-                                               std::vector<u8>& output) {
+u32 nvhost_nvdec_common::SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
     std::memcpy(&submit_timeout, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    return NvResult::Success;
+    return NvErrCodes::Success;
 }
 
 std::optional<nvhost_nvdec_common::BufferMap> nvhost_nvdec_common::FindBufferMap(

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -18,37 +18,9 @@ public:
     explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_nvdec_common() override;
 
-    /**
-     * Handles an ioctl1 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl1(Ioctl command, const std::vector<u8>& input,
-                            std::vector<u8>& output) = 0;
-
-    /**
-     * Handles an ioctl2 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param inline_input A buffer containing the input data for the ioctl which has been inlined.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output) = 0;
-
-    /**
-     * Handles an ioctl3 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @param inline_output A buffer where the inlined output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output) = 0;
+    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                      IoctlVersion version) = 0;
 
 protected:
     class BufferMap final {
@@ -91,102 +63,102 @@ protected:
     };
 
     struct IoctlSetNvmapFD {
-        s32_le nvmap_fd{};
+        u32_le nvmap_fd;
     };
     static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
 
     struct IoctlSubmitCommandBuffer {
-        u32_le id{};
-        u32_le offset{};
-        u32_le count{};
+        u32_le id;
+        u32_le offset;
+        u32_le count;
     };
     static_assert(sizeof(IoctlSubmitCommandBuffer) == 0xC,
                   "IoctlSubmitCommandBuffer is incorrect size");
     struct IoctlSubmit {
-        u32_le cmd_buffer_count{};
-        u32_le relocation_count{};
-        u32_le syncpoint_count{};
-        u32_le fence_count{};
+        u32_le cmd_buffer_count;
+        u32_le relocation_count;
+        u32_le syncpoint_count;
+        u32_le fence_count;
     };
     static_assert(sizeof(IoctlSubmit) == 0x10, "IoctlSubmit has incorrect size");
 
     struct CommandBuffer {
-        s32 memory_id{};
-        u32 offset{};
-        s32 word_count{};
+        s32 memory_id;
+        u32 offset;
+        s32 word_count;
     };
     static_assert(sizeof(CommandBuffer) == 0xC, "CommandBuffer has incorrect size");
 
     struct Reloc {
-        s32 cmdbuffer_memory{};
-        s32 cmdbuffer_offset{};
-        s32 target{};
-        s32 target_offset{};
+        s32 cmdbuffer_memory;
+        s32 cmdbuffer_offset;
+        s32 target;
+        s32 target_offset;
     };
     static_assert(sizeof(Reloc) == 0x10, "CommandBuffer has incorrect size");
 
     struct SyncptIncr {
-        u32 id{};
-        u32 increments{};
+        u32 id;
+        u32 increments;
     };
     static_assert(sizeof(SyncptIncr) == 0x8, "CommandBuffer has incorrect size");
 
     struct Fence {
-        u32 id{};
-        u32 value{};
+        u32 id;
+        u32 value;
     };
     static_assert(sizeof(Fence) == 0x8, "CommandBuffer has incorrect size");
 
     struct IoctlGetSyncpoint {
         // Input
-        u32_le param{};
+        u32_le param;
         // Output
-        u32_le value{};
+        u32_le value;
     };
     static_assert(sizeof(IoctlGetSyncpoint) == 8, "IocGetIdParams has wrong size");
 
     struct IoctlGetWaitbase {
-        u32_le unknown{}; // seems to be ignored? Nintendo added this
-        u32_le value{};
+        u32_le unknown; // seems to be ignored? Nintendo added this
+        u32_le value;
     };
     static_assert(sizeof(IoctlGetWaitbase) == 0x8, "IoctlGetWaitbase is incorrect size");
 
     struct IoctlMapBuffer {
-        u32_le num_entries{};
-        u32_le data_address{}; // Ignored by the driver.
-        u32_le attach_host_ch_das{};
+        u32_le num_entries;
+        u32_le data_address; // Ignored by the driver.
+        u32_le attach_host_ch_das;
     };
     static_assert(sizeof(IoctlMapBuffer) == 0x0C, "IoctlMapBuffer is incorrect size");
 
     struct IocGetIdParams {
         // Input
-        u32_le param{};
+        u32_le param;
         // Output
-        u32_le value{};
+        u32_le value;
     };
     static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
 
     // Used for mapping and unmapping command buffers
     struct MapBufferEntry {
-        u32_le map_handle{};
-        u32_le map_address{};
+        u32_le map_handle;
+        u32_le map_address;
     };
     static_assert(sizeof(IoctlMapBuffer) == 0x0C, "IoctlMapBuffer is incorrect size");
 
     /// Ioctl command implementations
-    NvResult SetNVMAPfd(const std::vector<u8>& input);
-    NvResult Submit(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetNVMAPfd(const std::vector<u8>& input);
+    u32 Submit(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::optional<BufferMap> FindBufferMap(GPUVAddr gpu_addr) const;
     void AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr, bool is_allocated);
     std::optional<std::size_t> RemoveBufferMap(GPUVAddr gpu_addr);
 
-    s32_le nvmap_fd{};
+    u32_le nvmap_fd{};
     u32_le submit_timeout{};
     std::shared_ptr<nvmap> nvmap_dev;
 

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp

@@ -13,44 +13,28 @@ namespace Service::Nvidia::Devices {
 nvhost_nvjpg::nvhost_nvjpg(Core::System& system) : nvdevice(system) {}
 nvhost_nvjpg::~nvhost_nvjpg() = default;
 
-NvResult nvhost_nvjpg::Ioctl1(Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& output) {
-    switch (command.group) {
-    case 'H':
-        switch (command.cmd) {
-        case 0x1:
-            return SetNVMAPfd(input, output);
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
+u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                        IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input, output);
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
 }
 
-NvResult nvhost_nvjpg::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                              const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_nvjpg::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                              std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetNvmapFD params{};
     std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;
-    return NvResult::Success;
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.h

@@ -16,21 +16,23 @@ public:
     explicit nvhost_nvjpg(Core::System& system);
     ~nvhost_nvjpg() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
 private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+    };
+
     struct IoctlSetNvmapFD {
-        s32_le nvmap_fd{};
+        u32_le nvmap_fd;
     };
     static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
 
-    s32_le nvmap_fd{};
+    u32_le nvmap_fd{};
 
-    NvResult SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_vic.cpp

@@ -15,50 +15,36 @@ nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
 
 nvhost_vic::~nvhost_vic() = default;
 
-NvResult nvhost_vic::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    switch (command.group) {
-    case 0x0:
-        switch (command.cmd) {
-        case 0x1:
-            return Submit(input, output);
-        case 0x2:
-            return GetSyncpoint(input, output);
-        case 0x3:
-            return GetWaitbase(input, output);
-        case 0x9:
-            return MapBuffer(input, output);
-        case 0xa:
-            return UnmapBuffer(input, output);
-        default:
-            break;
-        }
-        break;
-    case 'H':
-        switch (command.cmd) {
-        case 0x1:
-            return SetNVMAPfd(input);
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
+u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                      IoctlVersion version) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input);
+    case IoctlCommand::IocSubmit:
+        return Submit(input, output);
+    case IoctlCommand::IocGetSyncpoint:
+        return GetSyncpoint(input, output);
+    case IoctlCommand::IocGetWaitbase:
+        return GetWaitbase(input, output);
+    case IoctlCommand::IocMapBuffer:
+    case IoctlCommand::IocMapBuffer2:
+    case IoctlCommand::IocMapBuffer3:
+    case IoctlCommand::IocMapBuffer4:
+    case IoctlCommand::IocMapBufferEx:
+        return MapBuffer(input, output);
+    case IoctlCommand::IocUnmapBuffer:
+    case IoctlCommand::IocUnmapBuffer2:
+    case IoctlCommand::IocUnmapBuffer3:
+    case IoctlCommand::IocUnmapBufferEx:
+        return UnmapBuffer(input, output);
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_vic::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvhost_vic::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
+    UNIMPLEMENTED_MSG("Unimplemented ioctl 0x{:X}", command.raw);
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_vic.h

@@ -13,11 +13,25 @@ class nvhost_vic final : public nvhost_nvdec_common {
 public:
     explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_vic();
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
+private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+        IocSubmit = 0xC0400001,
+        IocGetSyncpoint = 0xC0080002,
+        IocGetWaitbase = 0xC0080003,
+        IocMapBuffer = 0xC01C0009,
+        IocMapBuffer2 = 0xC0340009,
+        IocMapBuffer3 = 0xC0140009,
+        IocMapBuffer4 = 0xC00C0009,
+        IocMapBufferEx = 0xC03C0009,
+        IocUnmapBuffer = 0xC03C000A,
+        IocUnmapBuffer2 = 0xC034000A,
+        IocUnmapBuffer3 = 0xC00C000A,
+        IocUnmapBufferEx = 0xC01C000A,
+    };
 };
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -11,6 +11,13 @@
 
 namespace Service::Nvidia::Devices {
 
+namespace NvErrCodes {
+enum {
+    OperationNotPermitted = -1,
+    InvalidValue = -22,
+};
+}
+
 nvmap::nvmap(Core::System& system) : nvdevice(system) {
     // Handle 0 appears to be used when remapping, so we create a placeholder empty nvmap object to
     // represent this.
@@ -19,46 +26,6 @@ nvmap::nvmap(Core::System& system) : nvdevice(system) {
 
 nvmap::~nvmap() = default;
 
-NvResult nvmap::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    switch (command.group) {
-    case 0x1:
-        switch (command.cmd) {
-        case 0x1:
-            return IocCreate(input, output);
-        case 0x3:
-            return IocFromId(input, output);
-        case 0x4:
-            return IocAlloc(input, output);
-        case 0x5:
-            return IocFree(input, output);
-        case 0x9:
-            return IocParam(input, output);
-        case 0xe:
-            return IocGetId(input, output);
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvmap::Ioctl2(Ioctl command, const std::vector<u8>& input,
-                       const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
-NvResult nvmap::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                       std::vector<u8>& inline_output) {
-    UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
-    return NvResult::NotImplemented;
-}
-
 VAddr nvmap::GetObjectAddress(u32 handle) const {
     auto object = GetObject(handle);
     ASSERT(object);
@@ -66,6 +33,28 @@ VAddr nvmap::GetObjectAddress(u32 handle) const {
     return object->addr;
 }
 
+u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                 std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                 IoctlVersion version) {
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::Create:
+        return IocCreate(input, output);
+    case IoctlCommand::Alloc:
+        return IocAlloc(input, output);
+    case IoctlCommand::GetId:
+        return IocGetId(input, output);
+    case IoctlCommand::FromId:
+        return IocFromId(input, output);
+    case IoctlCommand::Param:
+        return IocParam(input, output);
+    case IoctlCommand::Free:
+        return IocFree(input, output);
+    }
+
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
+}
+
 u32 nvmap::CreateObject(u32 size) {
     // Create a new nvmap object and obtain a handle to it.
     auto object = std::make_shared<Object>();
@@ -81,35 +70,35 @@ u32 nvmap::CreateObject(u32 size) {
     return handle;
 }
 
-NvResult nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
     IocCreateParams params;
     std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
 
     if (!params.size) {
         LOG_ERROR(Service_NVDRV, "Size is 0");
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     params.handle = CreateObject(params.size);
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
     IocAllocParams params;
     std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.addr);
 
     if (!params.handle) {
         LOG_ERROR(Service_NVDRV, "Handle is 0");
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     if ((params.align - 1) & params.align) {
         LOG_ERROR(Service_NVDRV, "Incorrect alignment used, alignment={:08X}", params.align);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     const u32 min_alignment = 0x1000;
@@ -120,12 +109,12 @@ NvResult nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output)
     auto object = GetObject(params.handle);
     if (!object) {
         LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     if (object->status == Object::Status::Allocated) {
         LOG_ERROR(Service_NVDRV, "Object is already allocated, handle={:08X}", params.handle);
-        return NvResult::InsufficientMemory;
+        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
     }
 
     object->flags = params.flags;
@@ -135,10 +124,10 @@ NvResult nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output)
     object->status = Object::Status::Allocated;
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
     IocGetIdParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
@@ -146,22 +135,22 @@ NvResult nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output)
 
     if (!params.handle) {
         LOG_ERROR(Service_NVDRV, "Handle is zero");
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     auto object = GetObject(params.handle);
     if (!object) {
         LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
     }
 
     params.id = object->id;
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
     IocFromIdParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
@@ -171,13 +160,13 @@ NvResult nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output)
                             [&](const auto& entry) { return entry.second->id == params.id; });
     if (itr == handles.end()) {
         LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     auto& object = itr->second;
     if (object->status != Object::Status::Allocated) {
         LOG_ERROR(Service_NVDRV, "Object is not allocated, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     itr->second->refcount++;
@@ -186,10 +175,10 @@ NvResult nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output)
     params.handle = itr->first;
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     enum class ParamTypes { Size = 1, Alignment = 2, Base = 3, Heap = 4, Kind = 5, Compr = 6 };
 
     IocParamParams params;
@@ -200,12 +189,12 @@ NvResult nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output)
     auto object = GetObject(params.handle);
     if (!object) {
         LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     if (object->status != Object::Status::Allocated) {
         LOG_ERROR(Service_NVDRV, "Object is not allocated, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
     }
 
     switch (static_cast<ParamTypes>(params.param)) {
@@ -227,10 +216,10 @@ NvResult nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output)
     }
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
-NvResult nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
     // TODO(Subv): These flags are unconfirmed.
     enum FreeFlags {
         Freed = 0,
@@ -245,14 +234,14 @@ NvResult nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
     auto itr = handles.find(params.handle);
     if (itr == handles.end()) {
         LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
     if (!itr->second->refcount) {
         LOG_ERROR(
             Service_NVDRV,
             "There is no references to this object. The object is already freed. handle={:08X}",
             params.handle);
-        return NvResult::BadValue;
+        return static_cast<u32>(NvErrCodes::InvalidValue);
     }
 
     itr->second->refcount--;
@@ -272,7 +261,7 @@ NvResult nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
     handles.erase(params.handle);
 
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::Success;
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -19,15 +19,13 @@ public:
     explicit nvmap(Core::System& system);
     ~nvmap() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                    std::vector<u8>& inline_output) override;
-
     /// Returns the allocated address of an nvmap object given its handle.
     VAddr GetObjectAddress(u32 handle) const;
 
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version) override;
+
     /// Represents an nvmap object.
     struct Object {
         enum class Status { Created, Allocated };
@@ -60,68 +58,76 @@ private:
     /// Mapping of currently allocated handles to the objects they represent.
     std::unordered_map<u32, std::shared_ptr<Object>> handles;
 
+    enum class IoctlCommand : u32 {
+        Create = 0xC0080101,
+        FromId = 0xC0080103,
+        Alloc = 0xC0200104,
+        Free = 0xC0180105,
+        Param = 0xC00C0109,
+        GetId = 0xC008010E,
+    };
     struct IocCreateParams {
         // Input
-        u32_le size{};
+        u32_le size;
         // Output
-        u32_le handle{};
+        u32_le handle;
     };
     static_assert(sizeof(IocCreateParams) == 8, "IocCreateParams has wrong size");
 
     struct IocFromIdParams {
         // Input
-        u32_le id{};
+        u32_le id;
         // Output
-        u32_le handle{};
+        u32_le handle;
     };
     static_assert(sizeof(IocFromIdParams) == 8, "IocFromIdParams has wrong size");
 
     struct IocAllocParams {
         // Input
-        u32_le handle{};
-        u32_le heap_mask{};
-        u32_le flags{};
-        u32_le align{};
-        u8 kind{};
+        u32_le handle;
+        u32_le heap_mask;
+        u32_le flags;
+        u32_le align;
+        u8 kind;
         INSERT_PADDING_BYTES(7);
-        u64_le addr{};
+        u64_le addr;
     };
     static_assert(sizeof(IocAllocParams) == 32, "IocAllocParams has wrong size");
 
     struct IocFreeParams {
-        u32_le handle{};
+        u32_le handle;
         INSERT_PADDING_BYTES(4);
-        u64_le address{};
-        u32_le size{};
-        u32_le flags{};
+        u64_le address;
+        u32_le size;
+        u32_le flags;
     };
     static_assert(sizeof(IocFreeParams) == 24, "IocFreeParams has wrong size");
 
     struct IocParamParams {
         // Input
-        u32_le handle{};
-        u32_le param{};
+        u32_le handle;
+        u32_le param;
         // Output
-        u32_le result{};
+        u32_le result;
     };
     static_assert(sizeof(IocParamParams) == 12, "IocParamParams has wrong size");
 
     struct IocGetIdParams {
         // Output
-        u32_le id{};
+        u32_le id;
         // Input
-        u32_le handle{};
+        u32_le handle;
     };
     static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
 
     u32 CreateObject(u32 size);
 
-    NvResult IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocGetId(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocFromId(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocParam(const std::vector<u8>& input, std::vector<u8>& output);
-    NvResult IocFree(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocGetId(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocFromId(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocParam(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocFree(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/interface.cpp

@@ -23,170 +23,124 @@ void NVDRV::SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NVDRV, "called");
 
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
-    }
-
     const auto& buffer = ctx.ReadBuffer();
-    const std::string device_name(buffer.begin(), buffer.end());
-    DeviceFD fd = nvdrv->Open(device_name);
+    std::string device_name(buffer.begin(), buffer.end());
 
+    u32 fd = nvdrv->Open(device_name);
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<DeviceFD>(fd);
-    rb.PushEnum(fd != INVALID_NVDRV_FD ? NvResult::Success : NvResult::FileOperationFailed);
+    rb.Push<u32>(fd);
+    rb.Push<u32>(0);
 }
 
-void NVDRV::ServiceError(Kernel::HLERequestContext& ctx, NvResult result) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(result);
-}
-
-void NVDRV::Ioctl1(Kernel::HLERequestContext& ctx) {
+void NVDRV::IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version) {
     IPC::RequestParser rp{ctx};
-    const auto fd = rp.Pop<DeviceFD>();
-    const auto command = rp.PopRaw<Ioctl>();
-    LOG_DEBUG(Service_NVDRV, "called fd={}, ioctl=0x{:08X}", fd, command.raw);
+    u32 fd = rp.Pop<u32>();
+    u32 command = rp.Pop<u32>();
 
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
+    /// Ioctl 3 has 2 outputs, first in the input params, second is the result
+    std::vector<u8> output(ctx.GetWriteBufferSize(0));
+    std::vector<u8> output2;
+    if (version == IoctlVersion::Version3) {
+        output2.resize((ctx.GetWriteBufferSize(1)));
     }
 
-    // Check device
-    std::vector<u8> output_buffer(ctx.GetWriteBufferSize(0));
-    const auto input_buffer = ctx.ReadBuffer(0);
+    /// Ioctl2 has 2 inputs. It's used to pass data directly instead of providing a pointer.
+    /// KickOfPB uses this
+    auto input = ctx.ReadBuffer(0);
 
-    const auto nv_result = nvdrv->Ioctl1(fd, command, input_buffer, output_buffer);
-
-    if (command.is_out != 0) {
-        ctx.WriteBuffer(output_buffer);
+    std::vector<u8> input2;
+    if (version == IoctlVersion::Version2) {
+        input2 = ctx.ReadBuffer(1);
     }
 
+    IoctlCtrl ctrl{};
+
+    u32 result = nvdrv->Ioctl(fd, command, input, input2, output, output2, ctrl, version);
+
+    if (ctrl.must_delay) {
+        ctrl.fresh_call = false;
+        ctx.SleepClientThread(
+            "NVServices::DelayedResponse", ctrl.timeout,
+            [=, this](std::shared_ptr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx_,
+                      Kernel::ThreadWakeupReason reason) {
+                IoctlCtrl ctrl2{ctrl};
+                std::vector<u8> tmp_output = output;
+                std::vector<u8> tmp_output2 = output2;
+                const u32 ioctl_result = nvdrv->Ioctl(fd, command, input, input2, tmp_output,
+                                                      tmp_output2, ctrl2, version);
+                ctx_.WriteBuffer(tmp_output, 0);
+                if (version == IoctlVersion::Version3) {
+                    ctx_.WriteBuffer(tmp_output2, 1);
+                }
+                IPC::ResponseBuilder rb{ctx_, 3};
+                rb.Push(RESULT_SUCCESS);
+                rb.Push(ioctl_result);
+            },
+            nvdrv->GetEventWriteable(ctrl.event_id));
+    } else {
+        ctx.WriteBuffer(output);
+        if (version == IoctlVersion::Version3) {
+            ctx.WriteBuffer(output2, 1);
+        }
+    }
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(nv_result);
+    rb.Push(result);
+}
+
+void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NVDRV, "called");
+    IoctlBase(ctx, IoctlVersion::Version1);
 }
 
 void NVDRV::Ioctl2(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto fd = rp.Pop<DeviceFD>();
-    const auto command = rp.PopRaw<Ioctl>();
-    LOG_DEBUG(Service_NVDRV, "called fd={}, ioctl=0x{:08X}", fd, command.raw);
-
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
-    }
-
-    const auto input_buffer = ctx.ReadBuffer(0);
-    const auto input_inlined_buffer = ctx.ReadBuffer(1);
-    std::vector<u8> output_buffer(ctx.GetWriteBufferSize(0));
-
-    const auto nv_result =
-        nvdrv->Ioctl2(fd, command, input_buffer, input_inlined_buffer, output_buffer);
-
-    if (command.is_out != 0) {
-        ctx.WriteBuffer(output_buffer);
-    }
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(nv_result);
+    LOG_DEBUG(Service_NVDRV, "called");
+    IoctlBase(ctx, IoctlVersion::Version2);
 }
 
 void NVDRV::Ioctl3(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto fd = rp.Pop<DeviceFD>();
-    const auto command = rp.PopRaw<Ioctl>();
-    LOG_DEBUG(Service_NVDRV, "called fd={}, ioctl=0x{:08X}", fd, command.raw);
-
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
-    }
-
-    const auto input_buffer = ctx.ReadBuffer(0);
-    std::vector<u8> output_buffer(ctx.GetWriteBufferSize(0));
-    std::vector<u8> output_buffer_inline(ctx.GetWriteBufferSize(1));
-
-    const auto nv_result =
-        nvdrv->Ioctl3(fd, command, input_buffer, output_buffer, output_buffer_inline);
-
-    if (command.is_out != 0) {
-        ctx.WriteBuffer(output_buffer, 0);
-        ctx.WriteBuffer(output_buffer_inline, 1);
-    }
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(nv_result);
+    LOG_DEBUG(Service_NVDRV, "called");
+    IoctlBase(ctx, IoctlVersion::Version3);
 }
 
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NVDRV, "called");
 
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
-    }
-
     IPC::RequestParser rp{ctx};
-    const auto fd = rp.Pop<DeviceFD>();
-    const auto result = nvdrv->Close(fd);
+    u32 fd = rp.Pop<u32>();
 
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(result);
+    auto result = nvdrv->Close(fd);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
 void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
-    is_initialized = true;
-
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(NvResult::Success);
+    rb.Push<u32>(0);
 }
 
 void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto fd = rp.Pop<DeviceFD>();
-    const auto event_id = rp.Pop<u32>() & 0x00FF;
+    u32 fd = rp.Pop<u32>();
+    // TODO(Blinkhawk): Figure the meaning of the flag at bit 16
+    u32 event_id = rp.Pop<u32>() & 0x000000FF;
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, fd={:X}, event_id={:X}", fd, event_id);
 
-    if (!is_initialized) {
-        ServiceError(ctx, NvResult::NotInitialized);
-        LOG_ERROR(Service_NVDRV, "NvServices is not initalized!");
-        return;
-    }
-
-    const auto nv_result = nvdrv->VerifyFD(fd);
-    if (nv_result != NvResult::Success) {
-        LOG_ERROR(Service_NVDRV, "Invalid FD specified DeviceFD={}!", fd);
-        ServiceError(ctx, nv_result);
-        return;
-    }
-
+    IPC::ResponseBuilder rb{ctx, 3, 1};
+    rb.Push(RESULT_SUCCESS);
     if (event_id < MaxNvEvents) {
-        IPC::ResponseBuilder rb{ctx, 3, 1};
-        rb.Push(RESULT_SUCCESS);
         auto event = nvdrv->GetEvent(event_id);
         event->Clear();
         rb.PushCopyObjects(event);
-        rb.PushEnum(NvResult::Success);
+        rb.Push<u32>(NvResult::Success);
     } else {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushEnum(NvResult::BadParameter);
+        rb.Push<u32>(0);
+        rb.Push<u32>(NvResult::BadParameter);
     }
 }
 
@@ -197,7 +151,7 @@ void NVDRV::SetAruid(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(NvResult::Success);
+    rb.Push<u32>(0);
 }
 
 void NVDRV::SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx) {
@@ -210,9 +164,8 @@ void NVDRV::SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ct
 void NVDRV::GetStatus(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(NvResult::Success);
 }
 
 void NVDRV::DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx) {
@@ -228,7 +181,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     : ServiceFramework(name), nvdrv(std::move(nvdrv)) {
     static const FunctionInfo functions[] = {
         {0, &NVDRV::Open, "Open"},
-        {1, &NVDRV::Ioctl1, "Ioctl"},
+        {1, &NVDRV::Ioctl, "Ioctl"},
         {2, &NVDRV::Close, "Close"},
         {3, &NVDRV::Initialize, "Initialize"},
         {4, &NVDRV::QueryEvent, "QueryEvent"},

src/core/hle/service/nvdrv/interface.h

@@ -23,7 +23,7 @@ public:
 
 private:
     void Open(Kernel::HLERequestContext& ctx);
-    void Ioctl1(Kernel::HLERequestContext& ctx);
+    void Ioctl(Kernel::HLERequestContext& ctx);
     void Ioctl2(Kernel::HLERequestContext& ctx);
     void Ioctl3(Kernel::HLERequestContext& ctx);
     void Close(Kernel::HLERequestContext& ctx);
@@ -33,13 +33,11 @@ private:
     void SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx);
     void GetStatus(Kernel::HLERequestContext& ctx);
     void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
-
-    void ServiceError(Kernel::HLERequestContext& ctx, NvResult result);
+    void IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version);
 
     std::shared_ptr<Module> nvdrv;
 
     u64 pid{};
-    bool is_initialized{};
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/nvdata.h

@@ -1,16 +1,12 @@
 #pragma once
 
 #include <array>
-#include "common/bit_field.h"
 #include "common/common_types.h"
 
 namespace Service::Nvidia {
 
 constexpr u32 MaxSyncPoints = 192;
 constexpr u32 MaxNvEvents = 64;
-using DeviceFD = s32;
-
-constexpr DeviceFD INVALID_NVDRV_FD = -1;
 
 struct Fence {
     s32 id;
@@ -24,61 +20,11 @@ struct MultiFence {
     std::array<Fence, 4> fences;
 };
 
-enum class NvResult : u32 {
-    Success = 0x0,
-    NotImplemented = 0x1,
-    NotSupported = 0x2,
-    NotInitialized = 0x3,
-    BadParameter = 0x4,
-    Timeout = 0x5,
-    InsufficientMemory = 0x6,
-    ReadOnlyAttribute = 0x7,
-    InvalidState = 0x8,
-    InvalidAddress = 0x9,
-    InvalidSize = 0xA,
-    BadValue = 0xB,
-    AlreadyAllocated = 0xD,
-    Busy = 0xE,
-    ResourceError = 0xF,
-    CountMismatch = 0x10,
-    OverFlow = 0x11,
-    InsufficientTransferMemory = 0x1000,
-    InsufficientVideoMemory = 0x10000,
-    BadSurfaceColorScheme = 0x10001,
-    InvalidSurface = 0x10002,
-    SurfaceNotSupported = 0x10003,
-    DispInitFailed = 0x20000,
-    DispAlreadyAttached = 0x20001,
-    DispTooManyDisplays = 0x20002,
-    DispNoDisplaysAttached = 0x20003,
-    DispModeNotSupported = 0x20004,
-    DispNotFound = 0x20005,
-    DispAttachDissallowed = 0x20006,
-    DispTypeNotSupported = 0x20007,
-    DispAuthenticationFailed = 0x20008,
-    DispNotAttached = 0x20009,
-    DispSamePwrState = 0x2000A,
-    DispEdidFailure = 0x2000B,
-    DispDsiReadAckError = 0x2000C,
-    DispDsiReadInvalidResp = 0x2000D,
-    FileWriteFailed = 0x30000,
-    FileReadFailed = 0x30001,
-    EndOfFile = 0x30002,
-    FileOperationFailed = 0x30003,
-    DirOperationFailed = 0x30004,
-    EndOfDirList = 0x30005,
-    ConfigVarNotFound = 0x30006,
-    InvalidConfigVar = 0x30007,
-    LibraryNotFound = 0x30008,
-    SymbolNotFound = 0x30009,
-    MemoryMapFailed = 0x3000A,
-    IoctlFailed = 0x3000F,
-    AccessDenied = 0x30010,
-    DeviceNotFound = 0x30011,
-    KernelDriverNotFound = 0x30012,
-    FileNotFound = 0x30013,
-    PathAlreadyExists = 0x30014,
-    ModuleNotPresent = 0xA000E,
+enum NvResult : u32 {
+    Success = 0,
+    BadParameter = 4,
+    Timeout = 5,
+    ResourceError = 15,
 };
 
 enum class EventState {
@@ -88,13 +34,21 @@ enum class EventState {
     Busy = 3,
 };
 
-union Ioctl {
-    u32_le raw;
-    BitField<0, 8, u32> cmd;
-    BitField<8, 8, u32> group;
-    BitField<16, 14, u32> length;
-    BitField<30, 1, u32> is_in;
-    BitField<31, 1, u32> is_out;
+enum class IoctlVersion : u32 {
+    Version1,
+    Version2,
+    Version3,
+};
+
+struct IoctlCtrl {
+    // First call done to the servioce for services that call itself again after a call.
+    bool fresh_call{true};
+    // Tells the Ioctl Wrapper that it must delay the IPC response and send the thread to sleep
+    bool must_delay{};
+    // Timeout for the delay
+    s64 timeout{};
+    // NV Event Id
+    s32 event_id{-1};
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -62,101 +62,36 @@ Module::Module(Core::System& system) : syncpoint_manager{system.GPU()} {
 
 Module::~Module() = default;
 
-NvResult Module::VerifyFD(DeviceFD fd) const {
-    if (fd < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid DeviceFD={}!", fd);
-        return NvResult::InvalidState;
-    }
-
-    if (open_files.find(fd) == open_files.end()) {
-        LOG_ERROR(Service_NVDRV, "Could not find DeviceFD={}!", fd);
-        return NvResult::NotImplemented;
-    }
-
-    return NvResult::Success;
-}
-
-DeviceFD Module::Open(const std::string& device_name) {
-    if (devices.find(device_name) == devices.end()) {
-        LOG_ERROR(Service_NVDRV, "Trying to open unknown device {}", device_name);
-        return INVALID_NVDRV_FD;
-    }
+u32 Module::Open(const std::string& device_name) {
+    ASSERT_MSG(devices.find(device_name) != devices.end(), "Trying to open unknown device {}",
+               device_name);
 
     auto device = devices[device_name];
-    const DeviceFD fd = next_fd++;
+    const u32 fd = next_fd++;
 
     open_files[fd] = std::move(device);
 
     return fd;
 }
 
-NvResult Module::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                        std::vector<u8>& output) {
-    if (fd < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid DeviceFD={}!", fd);
-        return NvResult::InvalidState;
-    }
+u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, const std::vector<u8>& input2,
+                  std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+                  IoctlVersion version) {
+    auto itr = open_files.find(fd);
+    ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 
-    const auto itr = open_files.find(fd);
-
-    if (itr == open_files.end()) {
-        LOG_ERROR(Service_NVDRV, "Could not find DeviceFD={}!", fd);
-        return NvResult::NotImplemented;
-    }
-
-    return itr->second->Ioctl1(command, input, output);
+    auto& device = itr->second;
+    return device->ioctl({command}, input, input2, output, output2, ctrl, version);
 }
 
-NvResult Module::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                        const std::vector<u8>& inline_input, std::vector<u8>& output) {
-    if (fd < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid DeviceFD={}!", fd);
-        return NvResult::InvalidState;
-    }
-
-    const auto itr = open_files.find(fd);
-
-    if (itr == open_files.end()) {
-        LOG_ERROR(Service_NVDRV, "Could not find DeviceFD={}!", fd);
-        return NvResult::NotImplemented;
-    }
-
-    return itr->second->Ioctl2(command, input, inline_input, output);
-}
-
-NvResult Module::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                        std::vector<u8>& output, std::vector<u8>& inline_output) {
-    if (fd < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid DeviceFD={}!", fd);
-        return NvResult::InvalidState;
-    }
-
-    const auto itr = open_files.find(fd);
-
-    if (itr == open_files.end()) {
-        LOG_ERROR(Service_NVDRV, "Could not find DeviceFD={}!", fd);
-        return NvResult::NotImplemented;
-    }
-
-    return itr->second->Ioctl3(command, input, output, inline_output);
-}
-
-NvResult Module::Close(DeviceFD fd) {
-    if (fd < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid DeviceFD={}!", fd);
-        return NvResult::InvalidState;
-    }
-
-    const auto itr = open_files.find(fd);
-
-    if (itr == open_files.end()) {
-        LOG_ERROR(Service_NVDRV, "Could not find DeviceFD={}!", fd);
-        return NvResult::NotImplemented;
-    }
+ResultCode Module::Close(u32 fd) {
+    auto itr = open_files.find(fd);
+    ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 
     open_files.erase(itr);
 
-    return NvResult::Success;
+    // TODO(flerovium): return correct result code if operation failed.
+    return RESULT_SUCCESS;
 }
 
 void Module::SignalSyncpt(const u32 syncpoint_id, const u32 value) {

src/core/hle/service/nvdrv/nvdrv.h

@@ -112,23 +112,14 @@ public:
         return std::static_pointer_cast<T>(itr->second);
     }
 
-    NvResult VerifyFD(DeviceFD fd) const;
-
     /// Opens a device node and returns a file descriptor to it.
-    DeviceFD Open(const std::string& device_name);
-
+    u32 Open(const std::string& device_name);
     /// Sends an ioctl command to the specified file descriptor.
-    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& output);
-
-    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    const std::vector<u8>& inline_input, std::vector<u8>& output);
-
-    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& output, std::vector<u8>& inline_output);
-
+    u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, const std::vector<u8>& input2,
+              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
+              IoctlVersion version);
     /// Closes a device file descriptor and returns operation success.
-    NvResult Close(DeviceFD fd);
+    ResultCode Close(u32 fd);
 
     void SignalSyncpt(const u32 syncpoint_id, const u32 value);
 
@@ -141,10 +132,10 @@ private:
     SyncpointManager syncpoint_manager;
 
     /// Id to use for the next open file descriptor.
-    DeviceFD next_fd = 1;
+    u32 next_fd = 1;
 
     /// Mapping of file descriptors to the devices they reference.
-    std::unordered_map<DeviceFD, std::shared_ptr<Devices::nvdevice>> open_files;
+    std::unordered_map<u32, std::shared_ptr<Devices::nvdevice>> open_files;
 
     /// Mapping of device node names to their implementation.
     std::unordered_map<std::string, std::shared_ptr<Devices::nvdevice>> devices;

src/core/hle/service/service.cpp

@@ -188,19 +188,17 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
     return RESULT_SUCCESS;
 }
 
-/// Initialize Services
-Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system)
-    : nv_flinger{std::make_unique<NVFlinger::NVFlinger>(system)} {
-
+/// Initialize ServiceManager
+void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     // NVFlinger needs to be accessed by several services like Vi and AppletOE so we instantiate it
     // here and pass it into the respective InstallInterfaces functions.
-
+    auto nv_flinger = std::make_shared<NVFlinger::NVFlinger>(system);
     system.GetFileSystemController().CreateFactories(*system.GetFilesystem(), false);
 
     SM::ServiceManager::InstallInterfaces(sm, system.Kernel());
 
     Account::InstallInterfaces(system);
-    AM::InstallInterfaces(*sm, *nv_flinger, system);
+    AM::InstallInterfaces(*sm, nv_flinger, system);
     AOC::InstallInterfaces(*sm, system);
     APM::InstallInterfaces(system);
     Audio::InstallInterfaces(*sm, system);
@@ -248,10 +246,14 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
     SSL::InstallInterfaces(*sm);
     Time::InstallInterfaces(system);
     USB::InstallInterfaces(*sm);
-    VI::InstallInterfaces(*sm, *nv_flinger);
+    VI::InstallInterfaces(*sm, nv_flinger);
     WLAN::InstallInterfaces(*sm);
+
+    LOG_DEBUG(Service, "initialized OK");
 }
 
-Services::~Services() = default;
-
+/// Shutdown ServiceManager
+void Shutdown() {
+    LOG_DEBUG(Service, "shutdown OK");
+}
 } // namespace Service

src/core/hle/service/service.h

@@ -29,11 +29,7 @@ namespace Service {
 
 namespace FileSystem {
 class FileSystemController;
-}
-
-namespace NVFlinger {
-class NVFlinger;
-}
+} // namespace FileSystem
 
 namespace SM {
 class ServiceManager;
@@ -185,17 +181,10 @@ private:
     }
 };
 
-/**
- * The purpose of this class is to own any objects that need to be shared across the other service
- * implementations. Will be torn down when the global system instance is shutdown.
- */
-class Services final {
-public:
-    explicit Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system);
-    ~Services();
+/// Initialize ServiceManager
+void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system);
 
-private:
-    std::unique_ptr<NVFlinger::NVFlinger> nv_flinger;
-};
+/// Shutdown ServiceManager
+void Shutdown();
 
 } // namespace Service

src/core/hle/service/vi/vi.cpp

@@ -492,8 +492,8 @@ private:
 
 class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
 public:
-    explicit IHOSBinderDriver(NVFlinger::NVFlinger& nv_flinger)
-        : ServiceFramework("IHOSBinderDriver"), nv_flinger(nv_flinger) {
+    explicit IHOSBinderDriver(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+        : ServiceFramework("IHOSBinderDriver"), nv_flinger(std::move(nv_flinger)) {
         static const FunctionInfo functions[] = {
             {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
             {1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
@@ -530,8 +530,8 @@ private:
         LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
                   static_cast<u32>(transaction), flags);
 
-        const auto guard = nv_flinger.Lock();
-        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
+        const auto guard = nv_flinger->Lock();
+        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
 
         switch (transaction) {
         case TransactionId::Connect: {
@@ -570,8 +570,8 @@ private:
                     [=, this](std::shared_ptr<Kernel::Thread> thread,
                               Kernel::HLERequestContext& ctx, Kernel::ThreadWakeupReason reason) {
                         // Repeat TransactParcel DequeueBuffer when a buffer is available
-                        const auto guard = nv_flinger.Lock();
-                        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
+                        const auto guard = nv_flinger->Lock();
+                        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
                         auto result = buffer_queue.DequeueBuffer(width, height);
                         ASSERT_MSG(result != std::nullopt, "Could not dequeue buffer.");
 
@@ -676,7 +676,7 @@ private:
 
         LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
 
-        const auto& buffer_queue = nv_flinger.FindBufferQueue(id);
+        const auto& buffer_queue = nv_flinger->FindBufferQueue(id);
 
         // TODO(Subv): Find out what this actually is.
         IPC::ResponseBuilder rb{ctx, 2, 1};
@@ -684,8 +684,8 @@ private:
         rb.PushCopyObjects(buffer_queue.GetBufferWaitEvent());
     }
 
-    NVFlinger::NVFlinger& nv_flinger;
-};
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+}; // namespace VI
 
 class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
 public:
@@ -790,8 +790,8 @@ private:
 
 class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
 public:
-    explicit IManagerDisplayService(NVFlinger::NVFlinger& nv_flinger)
-        : ServiceFramework("IManagerDisplayService"), nv_flinger(nv_flinger) {
+    explicit IManagerDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+        : ServiceFramework("IManagerDisplayService"), nv_flinger(std::move(nv_flinger)) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {200, nullptr, "AllocateProcessHeapBlock"},
@@ -893,7 +893,7 @@ private:
                     "(STUBBED) called. unknown=0x{:08X}, display=0x{:016X}, aruid=0x{:016X}",
                     unknown, display, aruid);
 
-        const auto layer_id = nv_flinger.CreateLayer(display);
+        const auto layer_id = nv_flinger->CreateLayer(display);
         if (!layer_id) {
             LOG_ERROR(Service_VI, "Layer not found! display=0x{:016X}", display);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -930,12 +930,12 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    NVFlinger::NVFlinger& nv_flinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
 public:
-    explicit IApplicationDisplayService(NVFlinger::NVFlinger& nv_flinger);
+    explicit IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
 
 private:
     enum class ConvertedScaleMode : u64 {
@@ -1010,7 +1010,7 @@ private:
 
         ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
-        const auto display_id = nv_flinger.OpenDisplay(name);
+        const auto display_id = nv_flinger->OpenDisplay(name);
         if (!display_id) {
             LOG_ERROR(Service_VI, "Display not found! display_name={}", name);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1110,7 +1110,7 @@ private:
 
         LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}, aruid=0x{:016X}", layer_id, aruid);
 
-        const auto display_id = nv_flinger.OpenDisplay(display_name);
+        const auto display_id = nv_flinger->OpenDisplay(display_name);
         if (!display_id) {
             LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1118,7 +1118,7 @@ private:
             return;
         }
 
-        const auto buffer_queue_id = nv_flinger.FindBufferQueueId(*display_id, layer_id);
+        const auto buffer_queue_id = nv_flinger->FindBufferQueueId(*display_id, layer_id);
         if (!buffer_queue_id) {
             LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1138,7 +1138,7 @@ private:
 
         LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}", layer_id);
 
-        nv_flinger.CloseLayer(layer_id);
+        nv_flinger->CloseLayer(layer_id);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -1154,7 +1154,7 @@ private:
 
         // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
-        const auto layer_id = nv_flinger.CreateLayer(display_id);
+        const auto layer_id = nv_flinger->CreateLayer(display_id);
         if (!layer_id) {
             LOG_ERROR(Service_VI, "Layer not found! layer_id={}", *layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1162,7 +1162,7 @@ private:
             return;
         }
 
-        const auto buffer_queue_id = nv_flinger.FindBufferQueueId(display_id, *layer_id);
+        const auto buffer_queue_id = nv_flinger->FindBufferQueueId(display_id, *layer_id);
         if (!buffer_queue_id) {
             LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1193,7 +1193,7 @@ private:
 
         LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
 
-        const auto vsync_event = nv_flinger.FindVsyncEvent(display_id);
+        const auto vsync_event = nv_flinger->FindVsyncEvent(display_id);
         if (!vsync_event) {
             LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1258,11 +1258,12 @@ private:
         }
     }
 
-    NVFlinger::NVFlinger& nv_flinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
-IApplicationDisplayService::IApplicationDisplayService(NVFlinger::NVFlinger& nv_flinger)
-    : ServiceFramework("IApplicationDisplayService"), nv_flinger(nv_flinger) {
+IApplicationDisplayService::IApplicationDisplayService(
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework("IApplicationDisplayService"), nv_flinger(std::move(nv_flinger)) {
     static const FunctionInfo functions[] = {
         {100, &IApplicationDisplayService::GetRelayService, "GetRelayService"},
         {101, &IApplicationDisplayService::GetSystemDisplayService, "GetSystemDisplayService"},
@@ -1303,7 +1304,8 @@ static bool IsValidServiceAccess(Permission permission, Policy policy) {
     return false;
 }
 
-void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, NVFlinger::NVFlinger& nv_flinger,
+void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
+                                   std::shared_ptr<NVFlinger::NVFlinger> nv_flinger,
                                    Permission permission) {
     IPC::RequestParser rp{ctx};
     const auto policy = rp.PopEnum<Policy>();
@@ -1317,10 +1319,11 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, NVFlinger::NV
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
+    rb.PushIpcInterface<IApplicationDisplayService>(std::move(nv_flinger));
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nv_flinger) {
+void InstallInterfaces(SM::ServiceManager& service_manager,
+                       std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
     std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager);
     std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager);
     std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager);

src/core/hle/service/vi/vi.h

@@ -43,11 +43,12 @@ enum class Policy {
 };
 
 namespace detail {
-void GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, NVFlinger::NVFlinger& nv_flinger,
-                           Permission permission);
+void GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
+                           std::shared_ptr<NVFlinger::NVFlinger> nv_flinger, Permission permission);
 } // namespace detail
 
 /// Registers all VI services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nv_flinger);
+void InstallInterfaces(SM::ServiceManager& service_manager,
+                       std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_m.cpp

@@ -8,7 +8,8 @@
 
 namespace Service::VI {
 
-VI_M::VI_M(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:m"}, nv_flinger{nv_flinger} {
+VI_M::VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework{"vi:m"}, nv_flinger{std::move(nv_flinger)} {
     static const FunctionInfo functions[] = {
         {2, &VI_M::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_m.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_M final : public ServiceFramework<VI_M> {
 public:
-    explicit VI_M(NVFlinger::NVFlinger& nv_flinger);
+    explicit VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
     ~VI_M() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_s.cpp

@@ -8,7 +8,8 @@
 
 namespace Service::VI {
 
-VI_S::VI_S(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:s"}, nv_flinger{nv_flinger} {
+VI_S::VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework{"vi:s"}, nv_flinger{std::move(nv_flinger)} {
     static const FunctionInfo functions[] = {
         {1, &VI_S::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_s.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_S final : public ServiceFramework<VI_S> {
 public:
-    explicit VI_S(NVFlinger::NVFlinger& nv_flinger);
+    explicit VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
     ~VI_S() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_u.cpp

@@ -8,7 +8,8 @@
 
 namespace Service::VI {
 
-VI_U::VI_U(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:u"}, nv_flinger{nv_flinger} {
+VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
+    : ServiceFramework{"vi:u"}, nv_flinger{std::move(nv_flinger)} {
     static const FunctionInfo functions[] = {
         {0, &VI_U::GetDisplayService, "GetDisplayService"},
         {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_u.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_U final : public ServiceFramework<VI_U> {
 public:
-    explicit VI_U(NVFlinger::NVFlinger& nv_flinger);
+    explicit VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
     ~VI_U() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
+    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
 };
 
 } // namespace Service::VI

src/core/loader/deconstructed_rom_directory.cpp

@@ -114,8 +114,7 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     }
 
     if (override_update) {
-        const FileSys::PatchManager patch_manager(
-            metadata.GetTitleID(), system.GetFileSystemController(), system.GetContentProvider());
+        const FileSys::PatchManager patch_manager(metadata.GetTitleID());
         dir = patch_manager.PatchExeFS(dir);
     }
 
@@ -161,8 +160,7 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     modules.clear();
     const VAddr base_address{process.PageTable().GetCodeRegionStart()};
     VAddr next_load_addr{base_address};
-    const FileSys::PatchManager pm{metadata.GetTitleID(), system.GetFileSystemController(),
-                                   system.GetContentProvider()};
+    const FileSys::PatchManager pm{metadata.GetTitleID()};
     for (const auto& module : static_modules) {
         const FileSys::VirtualFile module_file{dir->GetFile(module)};
         if (!module_file) {

src/core/loader/loader.cpp

@@ -10,7 +10,6 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/core.h"
 #include "core/hle/kernel/process.h"
 #include "core/loader/deconstructed_rom_directory.h"
 #include "core/loader/elf.h"
@@ -195,14 +194,15 @@ AppLoader::~AppLoader() = default;
 
 /**
  * Get a loader for a file with a specific type
- * @param system The system context to use.
- * @param file   The file to retrieve the loader for
- * @param type   The file type
+ * @param file The file to load
+ * @param type The type of the file
+ * @param file the file to retrieve the loader for
+ * @param type the file type
  * @return std::unique_ptr<AppLoader> a pointer to a loader object;  nullptr for unsupported type
  */
-static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::VirtualFile file,
-                                                FileType type) {
+static std::unique_ptr<AppLoader> GetFileLoader(FileSys::VirtualFile file, FileType type) {
     switch (type) {
+
     // Standard ELF file format.
     case FileType::ELF:
         return std::make_unique<AppLoader_ELF>(std::move(file));
@@ -221,8 +221,7 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
 
     // NX XCI (nX Card Image) file format.
     case FileType::XCI:
-        return std::make_unique<AppLoader_XCI>(std::move(file), system.GetFileSystemController(),
-                                               system.GetContentProvider());
+        return std::make_unique<AppLoader_XCI>(std::move(file));
 
     // NX NAX (NintendoAesXts) file format.
     case FileType::NAX:
@@ -230,8 +229,7 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
 
     // NX NSP (Nintendo Submission Package) file format
     case FileType::NSP:
-        return std::make_unique<AppLoader_NSP>(std::move(file), system.GetFileSystemController(),
-                                               system.GetContentProvider());
+        return std::make_unique<AppLoader_NSP>(std::move(file));
 
     // NX KIP (Kernel Internal Process) file format
     case FileType::KIP:
@@ -246,21 +244,20 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
     }
 }
 
-std::unique_ptr<AppLoader> GetLoader(Core::System& system, FileSys::VirtualFile file) {
+std::unique_ptr<AppLoader> GetLoader(FileSys::VirtualFile file) {
     FileType type = IdentifyFile(file);
-    const FileType filename_type = GuessFromFilename(file->GetName());
+    FileType filename_type = GuessFromFilename(file->GetName());
 
     // Special case: 00 is either a NCA or NAX.
     if (type != filename_type && !(file->GetName() == "00" && type == FileType::NAX)) {
         LOG_WARNING(Loader, "File {} has a different type than its extension.", file->GetName());
-        if (FileType::Unknown == type) {
+        if (FileType::Unknown == type)
             type = filename_type;
-        }
     }
 
     LOG_DEBUG(Loader, "Loading file {} as {}...", file->GetName(), GetFileTypeString(type));
 
-    return GetFileLoader(system, std::move(file), type);
+    return GetFileLoader(std::move(file), type);
 }
 
 } // namespace Loader

src/core/loader/loader.h

@@ -290,12 +290,9 @@ protected:
 
 /**
  * Identifies a bootable file and return a suitable loader
- *
- * @param system The system context.
- * @param file   The bootable file.
- *
- * @return the best loader for this file.
+ * @param file The bootable file
+ * @return the best loader for this file
  */
-std::unique_ptr<AppLoader> GetLoader(Core::System& system, FileSys::VirtualFile file);
+std::unique_ptr<AppLoader> GetLoader(FileSys::VirtualFile file);
 
 } // namespace Loader

src/core/loader/nso.cpp

@@ -149,7 +149,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process, Core::S
     // Apply cheats if they exist and the program has a valid title ID
     if (pm) {
         system.SetCurrentProcessBuildID(nso_header.build_id);
-        const auto cheats = pm->CreateCheatList(nso_header.build_id);
+        const auto cheats = pm->CreateCheatList(system, nso_header.build_id);
         if (!cheats.empty()) {
             system.RegisterCheatList(cheats, nso_header.build_id, load_base, image_size);
         }

src/core/loader/nsp.cpp

@@ -21,33 +21,26 @@
 
 namespace Loader {
 
-AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file,
-                             const Service::FileSystem::FileSystemController& fsc,
-                             const FileSys::ContentProvider& content_provider)
+AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file)
     : AppLoader(file), nsp(std::make_unique<FileSys::NSP>(file)),
       title_id(nsp->GetProgramTitleID()) {
 
-    if (nsp->GetStatus() != ResultStatus::Success) {
+    if (nsp->GetStatus() != ResultStatus::Success)
         return;
-    }
 
     if (nsp->IsExtractedType()) {
         secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
     } else {
         const auto control_nca =
             nsp->GetNCA(nsp->GetProgramTitleID(), FileSys::ContentRecordType::Control);
-        if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success) {
+        if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success)
             return;
-        }
 
-        std::tie(nacp_file, icon_file) = [this, &content_provider, &control_nca, &fsc] {
-            const FileSys::PatchManager pm{nsp->GetProgramTitleID(), fsc, content_provider};
-            return pm.ParseControlNCA(*control_nca);
-        }();
+        std::tie(nacp_file, icon_file) =
+            FileSys::PatchManager(nsp->GetProgramTitleID()).ParseControlNCA(*control_nca);
 
-        if (title_id == 0) {
+        if (title_id == 0)
             return;
-        }
 
         secondary_loader = std::make_unique<AppLoader_NCA>(
             nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));

src/core/loader/nsp.h

@@ -9,16 +9,15 @@
 #include "core/file_sys/vfs.h"
 #include "core/loader/loader.h"
 
+namespace Core {
+class System;
+}
+
 namespace FileSys {
-class ContentProvider;
 class NACP;
 class NSP;
 } // namespace FileSys
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace Loader {
 
 class AppLoader_NCA;
@@ -26,9 +25,7 @@ class AppLoader_NCA;
 /// Loads an XCI file
 class AppLoader_NSP final : public AppLoader {
 public:
-    explicit AppLoader_NSP(FileSys::VirtualFile file,
-                           const Service::FileSystem::FileSystemController& fsc,
-                           const FileSys::ContentProvider& content_provider);
+    explicit AppLoader_NSP(FileSys::VirtualFile file);
     ~AppLoader_NSP() override;
 
     /**

src/core/loader/xci.cpp

@@ -20,24 +20,18 @@
 
 namespace Loader {
 
-AppLoader_XCI::AppLoader_XCI(FileSys::VirtualFile file,
-                             const Service::FileSystem::FileSystemController& fsc,
-                             const FileSys::ContentProvider& content_provider)
+AppLoader_XCI::AppLoader_XCI(FileSys::VirtualFile file)
     : AppLoader(file), xci(std::make_unique<FileSys::XCI>(file)),
       nca_loader(std::make_unique<AppLoader_NCA>(xci->GetProgramNCAFile())) {
-    if (xci->GetStatus() != ResultStatus::Success) {
+    if (xci->GetStatus() != ResultStatus::Success)
         return;
-    }
 
     const auto control_nca = xci->GetNCAByType(FileSys::NCAContentType::Control);
-    if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success) {
+    if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success)
         return;
-    }
 
-    std::tie(nacp_file, icon_file) = [this, &content_provider, &control_nca, &fsc] {
-        const FileSys::PatchManager pm{xci->GetProgramTitleID(), fsc, content_provider};
-        return pm.ParseControlNCA(*control_nca);
-    }();
+    std::tie(nacp_file, icon_file) =
+        FileSys::PatchManager(xci->GetProgramTitleID()).ParseControlNCA(*control_nca);
 }
 
 AppLoader_XCI::~AppLoader_XCI() = default;

src/core/loader/xci.h

@@ -9,16 +9,15 @@
 #include "core/file_sys/vfs.h"
 #include "core/loader/loader.h"
 
+namespace Core {
+class System;
+}
+
 namespace FileSys {
-class ContentProvider;
 class NACP;
 class XCI;
 } // namespace FileSys
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace Loader {
 
 class AppLoader_NCA;
@@ -26,9 +25,7 @@ class AppLoader_NCA;
 /// Loads an XCI file
 class AppLoader_XCI final : public AppLoader {
 public:
-    explicit AppLoader_XCI(FileSys::VirtualFile file,
-                           const Service::FileSystem::FileSystemController& fsc,
-                           const FileSys::ContentProvider& content_provider);
+    explicit AppLoader_XCI(FileSys::VirtualFile file);
     ~AppLoader_XCI() override;
 
     /**

src/core/settings.h

@@ -215,7 +215,6 @@ struct Values {
     bool reporting_services;
     bool quest_flag;
     bool disable_macro_jit;
-    bool extended_logging;
 
     // Misceallaneous
     std::string log_filter;

src/core/telemetry_session.cpp

@@ -147,9 +147,7 @@ TelemetrySession::~TelemetrySession() {
     }
 }
 
-void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
-                                      const Service::FileSystem::FileSystemController& fsc,
-                                      const FileSys::ContentProvider& content_provider) {
+void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
     // Log one-time top-level information
     AddField(Telemetry::FieldType::None, "TelemetryId", GetTelemetryId());
 
@@ -169,10 +167,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
         app_loader.ReadTitle(name);
 
         if (name.empty()) {
-            const auto metadata = [&content_provider, &fsc, program_id] {
-                const FileSys::PatchManager pm{program_id, fsc, content_provider};
-                return pm.GetControlMetadata();
-            }();
+            const auto metadata = FileSys::PatchManager(program_id).GetControlMetadata();
             if (metadata.first != nullptr) {
                 name = metadata.first->GetApplicationName();
             }

src/core/telemetry_session.h

@@ -7,18 +7,10 @@
 #include <string>
 #include "common/telemetry.h"
 
-namespace FileSys {
-class ContentProvider;
-}
-
 namespace Loader {
 class AppLoader;
 }
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace Core {
 
 /**
@@ -48,14 +40,10 @@ public:
      *   - Title file format
      *   - Miscellaneous settings values.
      *
-     * @param app_loader       The application loader to use to retrieve
-     *                         title-specific information.
-     * @param fsc              Filesystem controller to use to retrieve info.
-     * @param content_provider Content provider to use to retrieve info.
+     * @param app_loader The application loader to use to retrieve
+     *                   title-specific information.
      */
-    void AddInitialInfo(Loader::AppLoader& app_loader,
-                        const Service::FileSystem::FileSystemController& fsc,
-                        const FileSys::ContentProvider& content_provider);
+    void AddInitialInfo(Loader::AppLoader& app_loader);
 
     /**
      * Wrapper around the Telemetry::FieldCollection::AddField method.

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1156,7 +1156,7 @@ void RasterizerOpenGL::SyncViewport() {
         flags[Dirty::ClipControl] = false;
 
         bool flip_y = false;
-        if (regs.viewport_transform[0].scale_y < 0.0f) {
+        if (regs.viewport_transform[0].scale_y < 0.0) {
             flip_y = !flip_y;
         }
         if (regs.screen_y_control.y_negate != 0) {

src/video_core/shader/async_shaders.cpp

@@ -43,8 +43,8 @@ void AsyncShaders::AllocateWorkers() {
     // Create workers
     for (std::size_t i = 0; i < num_workers; i++) {
         context_list.push_back(emu_window.CreateSharedContext());
-        worker_threads.emplace_back(&AsyncShaders::ShaderCompilerThread, this,
-                                    context_list[i].get());
+        worker_threads.push_back(
+            std::thread(&AsyncShaders::ShaderCompilerThread, this, context_list[i].get()));
     }
 }
 
@@ -106,7 +106,8 @@ std::vector<AsyncShaders::Result> AsyncShaders::GetCompletedWork() {
     std::vector<Result> results;
     {
         std::unique_lock lock{completed_mutex};
-        results = std::move(finished_work);
+        results.assign(std::make_move_iterator(finished_work.begin()),
+                       std::make_move_iterator(finished_work.end()));
         finished_work.clear();
     }
     return results;
@@ -115,10 +116,11 @@ std::vector<AsyncShaders::Result> AsyncShaders::GetCompletedWork() {
 void AsyncShaders::QueueOpenGLShader(const OpenGL::Device& device,
                                      Tegra::Engines::ShaderType shader_type, u64 uid,
                                      std::vector<u64> code, std::vector<u64> code_b,
-                                     u32 main_offset, CompilerSettings compiler_settings,
-                                     const Registry& registry, VAddr cpu_addr) {
-    std::unique_lock lock(queue_mutex);
-    pending_queue.push({
+                                     u32 main_offset,
+                                     VideoCommon::Shader::CompilerSettings compiler_settings,
+                                     const VideoCommon::Shader::Registry& registry,
+                                     VAddr cpu_addr) {
+    WorkerParams params{
         .backend = device.UseAssemblyShaders() ? Backend::GLASM : Backend::OpenGL,
         .device = &device,
         .shader_type = shader_type,
@@ -129,7 +131,9 @@ void AsyncShaders::QueueOpenGLShader(const OpenGL::Device& device,
         .compiler_settings = compiler_settings,
         .registry = registry,
         .cpu_address = cpu_addr,
-    });
+    };
+    std::unique_lock lock(queue_mutex);
+    pending_queue.push(std::move(params));
     cv.notify_one();
 }
 
@@ -141,8 +145,7 @@ void AsyncShaders::QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache,
                                      std::vector<VkDescriptorSetLayoutBinding> bindings,
                                      Vulkan::SPIRVProgram program,
                                      Vulkan::GraphicsPipelineCacheKey key) {
-    std::unique_lock lock(queue_mutex);
-    pending_queue.push({
+    WorkerParams params{
         .backend = Backend::Vulkan,
         .pp_cache = pp_cache,
         .vk_device = &device,
@@ -150,10 +153,13 @@ void AsyncShaders::QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache,
         .descriptor_pool = &descriptor_pool,
         .update_descriptor_queue = &update_descriptor_queue,
         .renderpass_cache = &renderpass_cache,
-        .bindings = std::move(bindings),
-        .program = std::move(program),
+        .bindings = bindings,
+        .program = program,
         .key = key,
-    });
+    };
+
+    std::unique_lock lock(queue_mutex);
+    pending_queue.push(std::move(params));
     cv.notify_one();
 }
 

src/yuzu/applets/controller.cpp

@@ -72,40 +72,6 @@ bool IsControllerCompatible(Settings::ControllerType controller_type,
     }
 }
 
-/// Maps the controller type combobox index to Controller Type enum
-constexpr Settings::ControllerType GetControllerTypeFromIndex(int index) {
-    switch (index) {
-    case 0:
-    default:
-        return Settings::ControllerType::ProController;
-    case 1:
-        return Settings::ControllerType::DualJoyconDetached;
-    case 2:
-        return Settings::ControllerType::LeftJoycon;
-    case 3:
-        return Settings::ControllerType::RightJoycon;
-    case 4:
-        return Settings::ControllerType::Handheld;
-    }
-}
-
-/// Maps the Controller Type enum to controller type combobox index
-constexpr int GetIndexFromControllerType(Settings::ControllerType type) {
-    switch (type) {
-    case Settings::ControllerType::ProController:
-    default:
-        return 0;
-    case Settings::ControllerType::DualJoyconDetached:
-        return 1;
-    case Settings::ControllerType::LeftJoycon:
-        return 2;
-    case Settings::ControllerType::RightJoycon:
-        return 3;
-    case Settings::ControllerType::Handheld:
-        return 4;
-    }
-}
-
 } // namespace
 
 QtControllerSelectorDialog::QtControllerSelectorDialog(
@@ -184,6 +150,11 @@ QtControllerSelectorDialog::QtControllerSelectorDialog(
     // This avoids unintentionally changing the states of elements while loading them in.
     SetSupportedControllers();
     DisableUnsupportedPlayers();
+
+    for (std::size_t player_index = 0; player_index < NUM_PLAYERS; ++player_index) {
+        SetEmulatedControllers(player_index);
+    }
+
     LoadConfiguration();
 
     for (std::size_t i = 0; i < NUM_PLAYERS; ++i) {
@@ -223,8 +194,8 @@ QtControllerSelectorDialog::QtControllerSelectorDialog(
 
         if (i == 0) {
             connect(emulated_controllers[i], qOverload<int>(&QComboBox::currentIndexChanged),
-                    [this](int index) {
-                        UpdateDockedState(GetControllerTypeFromIndex(index) ==
+                    [this, i](int index) {
+                        UpdateDockedState(GetControllerTypeFromIndex(index, i) ==
                                           Settings::ControllerType::Handheld);
                     });
         }
@@ -281,8 +252,8 @@ void QtControllerSelectorDialog::LoadConfiguration() {
             (index == 0 && Settings::values.players.GetValue()[HANDHELD_INDEX].connected);
         player_groupboxes[index]->setChecked(connected);
         connected_controller_checkboxes[index]->setChecked(connected);
-        emulated_controllers[index]->setCurrentIndex(
-            GetIndexFromControllerType(Settings::values.players.GetValue()[index].controller_type));
+        emulated_controllers[index]->setCurrentIndex(GetIndexFromControllerType(
+            Settings::values.players.GetValue()[index].controller_type, index));
     }
 
     UpdateDockedState(Settings::values.players.GetValue()[HANDHELD_INDEX].connected);
@@ -338,7 +309,7 @@ bool QtControllerSelectorDialog::CheckIfParametersMet() {
             }
 
             const auto compatible = IsControllerCompatible(
-                GetControllerTypeFromIndex(emulated_controllers[index]->currentIndex()),
+                GetControllerTypeFromIndex(emulated_controllers[index]->currentIndex(), index),
                 parameters);
 
             // If any controller is found to be incompatible, return false early.
@@ -422,6 +393,63 @@ void QtControllerSelectorDialog::SetSupportedControllers() {
     }
 }
 
+void QtControllerSelectorDialog::SetEmulatedControllers(std::size_t player_index) {
+    auto& pairs = index_controller_type_pairs[player_index];
+
+    pairs.clear();
+    emulated_controllers[player_index]->clear();
+
+    pairs.emplace_back(emulated_controllers[player_index]->count(),
+                       Settings::ControllerType::ProController);
+    emulated_controllers[player_index]->addItem(tr("Pro Controller"));
+
+    pairs.emplace_back(emulated_controllers[player_index]->count(),
+                       Settings::ControllerType::DualJoyconDetached);
+    emulated_controllers[player_index]->addItem(tr("Dual Joycons"));
+
+    pairs.emplace_back(emulated_controllers[player_index]->count(),
+                       Settings::ControllerType::LeftJoycon);
+    emulated_controllers[player_index]->addItem(tr("Left Joycon"));
+
+    pairs.emplace_back(emulated_controllers[player_index]->count(),
+                       Settings::ControllerType::RightJoycon);
+    emulated_controllers[player_index]->addItem(tr("Right Joycon"));
+
+    if (player_index == 0) {
+        pairs.emplace_back(emulated_controllers[player_index]->count(),
+                           Settings::ControllerType::Handheld);
+        emulated_controllers[player_index]->addItem(tr("Handheld"));
+    }
+}
+
+Settings::ControllerType QtControllerSelectorDialog::GetControllerTypeFromIndex(
+    int index, std::size_t player_index) const {
+    const auto& pairs = index_controller_type_pairs[player_index];
+
+    const auto it = std::find_if(pairs.begin(), pairs.end(),
+                                 [index](const auto& pair) { return pair.first == index; });
+
+    if (it == pairs.end()) {
+        return Settings::ControllerType::ProController;
+    }
+
+    return it->second;
+}
+
+int QtControllerSelectorDialog::GetIndexFromControllerType(Settings::ControllerType type,
+                                                           std::size_t player_index) const {
+    const auto& pairs = index_controller_type_pairs[player_index];
+
+    const auto it = std::find_if(pairs.begin(), pairs.end(),
+                                 [type](const auto& pair) { return pair.second == type; });
+
+    if (it == pairs.end()) {
+        return 0;
+    }
+
+    return it->first;
+}
+
 void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index) {
     if (!player_groupboxes[player_index]->isChecked()) {
         connected_controller_icons[player_index]->setStyleSheet(QString{});
@@ -430,7 +458,8 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
     }
 
     const QString stylesheet = [this, player_index] {
-        switch (GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex())) {
+        switch (GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
+                                           player_index)) {
         case Settings::ControllerType::ProController:
             return QStringLiteral("image: url(:/controller/applet_pro_controller%0); ");
         case Settings::ControllerType::DualJoyconDetached:
@@ -446,6 +475,12 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
         }
     }();
 
+    if (stylesheet.isEmpty()) {
+        connected_controller_icons[player_index]->setStyleSheet(QString{});
+        player_labels[player_index]->show();
+        return;
+    }
+
     const QString theme = [] {
         if (QIcon::themeName().contains(QStringLiteral("dark"))) {
             return QStringLiteral("_dark");
@@ -463,8 +498,8 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
 void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index) {
     auto& player = Settings::values.players.GetValue()[player_index];
 
-    const auto controller_type =
-        GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex());
+    const auto controller_type = GetControllerTypeFromIndex(
+        emulated_controllers[player_index]->currentIndex(), player_index);
     const auto player_connected = player_groupboxes[player_index]->isChecked() &&
                                   controller_type != Settings::ControllerType::Handheld;
 
@@ -507,8 +542,8 @@ void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index)
 
 void QtControllerSelectorDialog::UpdateLEDPattern(std::size_t player_index) {
     if (!player_groupboxes[player_index]->isChecked() ||
-        GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex()) ==
-            Settings::ControllerType::Handheld) {
+        GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
+                                   player_index) == Settings::ControllerType::Handheld) {
         led_patterns_boxes[player_index][0]->setChecked(false);
         led_patterns_boxes[player_index][1]->setChecked(false);
         led_patterns_boxes[player_index][2]->setChecked(false);

src/yuzu/applets/controller.h

@@ -22,6 +22,10 @@ namespace InputCommon {
 class InputSubsystem;
 }
 
+namespace Settings {
+enum class ControllerType;
+}
+
 namespace Ui {
 class QtControllerSelectorDialog;
 }
@@ -57,6 +61,15 @@ private:
     // Sets the controller icons for "Supported Controller Types".
     void SetSupportedControllers();
 
+    // Sets the emulated controllers per player.
+    void SetEmulatedControllers(std::size_t player_index);
+
+    // Gets the Controller Type for a given controller combobox index per player.
+    Settings::ControllerType GetControllerTypeFromIndex(int index, std::size_t player_index) const;
+
+    // Gets the controller combobox index for a given Controller Type per player.
+    int GetIndexFromControllerType(Settings::ControllerType type, std::size_t player_index) const;
+
     // Updates the controller icons per player.
     void UpdateControllerIcon(std::size_t player_index);
 
@@ -114,6 +127,10 @@ private:
     // Comboboxes with a list of emulated controllers per player.
     std::array<QComboBox*, NUM_PLAYERS> emulated_controllers;
 
+    /// Pairs of emulated controller index and Controller Type enum per player.
+    std::array<std::vector<std::pair<int, Settings::ControllerType>>, NUM_PLAYERS>
+        index_controller_type_pairs;
+
     // Labels representing the number of connected controllers
     // above the "Connected Controllers" checkboxes.
     std::array<QLabel*, NUM_PLAYERS> connected_controller_labels;

src/yuzu/configuration/config.cpp

@@ -649,8 +649,6 @@ void Config::ReadDebuggingValues() {
     Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
     Settings::values.disable_macro_jit =
         ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
-    Settings::values.extended_logging =
-        ReadSetting(QStringLiteral("extended_logging"), false).toBool();
 
     qt_config->endGroup();
 }

src/yuzu/configuration/configure_debug.cpp

@@ -41,7 +41,6 @@ void ConfigureDebug::SetConfiguration() {
     ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
     ui->disable_macro_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
-    ui->extended_logging->setChecked(Settings::values.extended_logging);
 }
 
 void ConfigureDebug::ApplyConfiguration() {
@@ -54,7 +53,6 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.quest_flag = ui->quest_flag->isChecked();
     Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
     Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();
-    Settings::values.extended_logging = ui->extended_logging->isChecked();
     Debugger::ToggleConsole();
     Log::Filter filter;
     filter.ParseFilterString(Settings::values.log_filter);

src/yuzu/configuration/configure_debug.ui

@@ -90,7 +90,7 @@
         <item>
          <widget class="QCheckBox" name="toggle_console">
           <property name="text">
-           <string>Show Log in Console</string>
+           <string>Show Log Console (Windows Only)</string>
           </property>
          </widget>
         </item>
@@ -103,34 +103,6 @@
         </item>
        </layout>
       </item>
-      <item>
-       <widget class="QCheckBox" name="extended_logging">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-        <property name="toolTip">
-         <string>When checked, the max size of the log increases from 100 MB to 1 GB</string>
-        </property>
-        <property name="text">
-         <string>Enable Extended Logging</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QLabel" name="label_3">
-        <property name="font">
-         <font>
-          <italic>true</italic>
-         </font>
-        </property>
-        <property name="text">
-         <string>This will be reset automatically when yuzu closes.</string>
-        </property>
-        <property name="indent">
-         <number>20</number>
-        </property>
-       </widget>
-      </item>
      </layout>
     </widget>
    </item>
@@ -143,7 +115,7 @@
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_4">
         <item>
-         <widget class="QLabel" name="label_4">
+         <widget class="QLabel" name="label_3">
           <property name="text">
            <string>Arguments String</string>
           </property>
@@ -168,8 +140,8 @@
         <property name="enabled">
          <bool>true</bool>
         </property>
-        <property name="toolTip">
-         <string>When checked, the graphics API enters a slower debugging mode</string>
+        <property name="whatsThis">
+         <string>When checked, the graphics API enters in a slower debugging mode</string>
         </property>
         <property name="text">
          <string>Enable Graphics Debugging</string>
@@ -181,8 +153,8 @@
         <property name="enabled">
          <bool>true</bool>
         </property>
-        <property name="toolTip">
-         <string>When checked, it disables the macro Just In Time compiler. Enabling this makes games run slower</string>
+        <property name="whatsThis">
+         <string>When checked, it disables the macro Just In Time compiler. Enabled this makes games run slower</string>
         </property>
         <property name="text">
          <string>Disable Macro JIT</string>
@@ -197,7 +169,7 @@
      <property name="title">
       <string>Dump</string>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_7">
+     <layout class="QVBoxLayout" name="verticalLayout_6">
       <item>
        <widget class="QCheckBox" name="reporting_services">
         <property name="text">
@@ -206,7 +178,7 @@
        </widget>
       </item>
       <item>
-       <widget class="QLabel" name="label_5">
+       <widget class="QLabel" name="label">
         <property name="font">
          <font>
           <italic>true</italic>
@@ -228,7 +200,7 @@
      <property name="title">
       <string>Advanced</string>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_8">
+     <layout class="QVBoxLayout" name="verticalLayout_7">
       <item>
        <widget class="QCheckBox" name="quest_flag">
         <property name="text">

src/yuzu/configuration/configure_input_player.cpp

@@ -27,6 +27,8 @@
 #include "yuzu/configuration/input_profiles.h"
 #include "yuzu/util/limitable_input_dialog.h"
 
+using namespace Service::HID;
+
 const std::array<std::string, ConfigureInputPlayer::ANALOG_SUB_BUTTONS_NUM>
     ConfigureInputPlayer::analog_sub_buttons{{
         "up",
@@ -47,48 +49,12 @@ void UpdateController(Settings::ControllerType controller_type, std::size_t npad
     }
     Service::SM::ServiceManager& sm = system.ServiceManager();
 
-    auto& npad =
-        sm.GetService<Service::HID::Hid>("hid")
-            ->GetAppletResource()
-            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
+    auto& npad = sm.GetService<Hid>("hid")->GetAppletResource()->GetController<Controller_NPad>(
+        HidController::NPad);
 
     npad.UpdateControllerAt(npad.MapSettingsTypeToNPad(controller_type), npad_index, connected);
 }
 
-/// Maps the controller type combobox index to Controller Type enum
-constexpr Settings::ControllerType GetControllerTypeFromIndex(int index) {
-    switch (index) {
-    case 0:
-    default:
-        return Settings::ControllerType::ProController;
-    case 1:
-        return Settings::ControllerType::DualJoyconDetached;
-    case 2:
-        return Settings::ControllerType::LeftJoycon;
-    case 3:
-        return Settings::ControllerType::RightJoycon;
-    case 4:
-        return Settings::ControllerType::Handheld;
-    }
-}
-
-/// Maps the Controller Type enum to controller type combobox index
-constexpr int GetIndexFromControllerType(Settings::ControllerType type) {
-    switch (type) {
-    case Settings::ControllerType::ProController:
-    default:
-        return 0;
-    case Settings::ControllerType::DualJoyconDetached:
-        return 1;
-    case Settings::ControllerType::LeftJoycon:
-        return 2;
-    case Settings::ControllerType::RightJoycon:
-        return 3;
-    case Settings::ControllerType::Handheld:
-        return 4;
-    }
-}
-
 QString GetKeyName(int key_code) {
     switch (key_code) {
     case Qt::LeftButton:
@@ -453,18 +419,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
     connect(ui->groupConnectedController, &QGroupBox::toggled,
             [this](bool checked) { emit Connected(checked); });
 
-    // Set up controller type. Only Player 1 can choose Handheld.
-    ui->comboControllerType->clear();
-
-    QStringList controller_types = {
-        tr("Pro Controller"),
-        tr("Dual Joycons"),
-        tr("Left Joycon"),
-        tr("Right Joycon"),
-    };
-
     if (player_index == 0) {
-        controller_types.append(tr("Handheld"));
         connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged),
                 [this](int index) {
                     emit HandheldStateChanged(GetControllerTypeFromIndex(index) ==
@@ -480,12 +435,9 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
     if (debug) {
         ui->buttonScreenshot->setEnabled(false);
         ui->buttonHome->setEnabled(false);
-        QStringList debug_controller_types = {
-            tr("Pro Controller"),
-        };
-        ui->comboControllerType->addItems(debug_controller_types);
+        ui->comboControllerType->addItem(tr("Pro Controller"));
     } else {
-        ui->comboControllerType->addItems(controller_types);
+        SetConnectableControllers();
     }
 
     UpdateControllerIcon();
@@ -667,7 +619,7 @@ void ConfigureInputPlayer::LoadConfiguration() {
         return;
     }
 
-    ui->comboControllerType->setCurrentIndex(static_cast<int>(player.controller_type));
+    ui->comboControllerType->setCurrentIndex(GetIndexFromControllerType(player.controller_type));
     ui->groupConnectedController->setChecked(
         player.connected ||
         (player_index == 0 && Settings::values.players.GetValue()[HANDHELD_INDEX].connected));
@@ -841,6 +793,82 @@ void ConfigureInputPlayer::UpdateUI() {
     }
 }
 
+void ConfigureInputPlayer::SetConnectableControllers() {
+    const auto add_controllers = [this](bool enable_all,
+                                        Controller_NPad::NpadStyleSet npad_style_set = {}) {
+        index_controller_type_pairs.clear();
+        ui->comboControllerType->clear();
+
+        if (enable_all || npad_style_set.pro_controller == 1) {
+            index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
+                                                     Settings::ControllerType::ProController);
+            ui->comboControllerType->addItem(tr("Pro Controller"));
+        }
+
+        if (enable_all || npad_style_set.joycon_dual == 1) {
+            index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
+                                                     Settings::ControllerType::DualJoyconDetached);
+            ui->comboControllerType->addItem(tr("Dual Joycons"));
+        }
+
+        if (enable_all || npad_style_set.joycon_left == 1) {
+            index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
+                                                     Settings::ControllerType::LeftJoycon);
+            ui->comboControllerType->addItem(tr("Left Joycon"));
+        }
+
+        if (enable_all || npad_style_set.joycon_right == 1) {
+            index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
+                                                     Settings::ControllerType::RightJoycon);
+            ui->comboControllerType->addItem(tr("Right Joycon"));
+        }
+
+        if (player_index == 0 && (enable_all || npad_style_set.handheld == 1)) {
+            index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
+                                                     Settings::ControllerType::Handheld);
+            ui->comboControllerType->addItem(tr("Handheld"));
+        }
+    };
+
+    Core::System& system{Core::System::GetInstance()};
+
+    if (!system.IsPoweredOn()) {
+        add_controllers(true);
+        return;
+    }
+
+    Service::SM::ServiceManager& sm = system.ServiceManager();
+
+    auto& npad = sm.GetService<Hid>("hid")->GetAppletResource()->GetController<Controller_NPad>(
+        HidController::NPad);
+
+    add_controllers(false, npad.GetSupportedStyleSet());
+}
+
+Settings::ControllerType ConfigureInputPlayer::GetControllerTypeFromIndex(int index) const {
+    const auto it =
+        std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(),
+                     [index](const auto& pair) { return pair.first == index; });
+
+    if (it == index_controller_type_pairs.end()) {
+        return Settings::ControllerType::ProController;
+    }
+
+    return it->second;
+}
+
+int ConfigureInputPlayer::GetIndexFromControllerType(Settings::ControllerType type) const {
+    const auto it =
+        std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(),
+                     [type](const auto& pair) { return pair.second == type; });
+
+    if (it == index_controller_type_pairs.end()) {
+        return -1;
+    }
+
+    return it->first;
+}
+
 void ConfigureInputPlayer::UpdateInputDevices() {
     input_devices = input_subsystem->GetInputDevices();
     ui->comboDevices->clear();

src/yuzu/configuration/configure_input_player.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 #include <QWidget>
 
@@ -112,6 +113,15 @@ private:
     /// Update UI to reflect current configuration.
     void UpdateUI();
 
+    /// Sets the available controllers.
+    void SetConnectableControllers();
+
+    /// Gets the Controller Type for a given controller combobox index.
+    Settings::ControllerType GetControllerTypeFromIndex(int index) const;
+
+    /// Gets the controller combobox index for a given Controller Type.
+    int GetIndexFromControllerType(Settings::ControllerType type) const;
+
     /// Update the available input devices.
     void UpdateInputDevices();
 
@@ -151,6 +161,9 @@ private:
     std::unique_ptr<QTimer> timeout_timer;
     std::unique_ptr<QTimer> poll_timer;
 
+    /// Stores a pair of "Connected Controllers" combobox index and Controller Type enum.
+    std::vector<std::pair<int, Settings::ControllerType>> index_controller_type_pairs;
+
     static constexpr int PLAYER_COUNT = 8;
     std::array<QCheckBox*, PLAYER_COUNT> player_connected_checkbox;
 

src/yuzu/configuration/configure_per_game.cpp

@@ -16,7 +16,6 @@
 
 #include "common/common_paths.h"
 #include "common/file_util.h"
-#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/xts_archive.h"
@@ -90,11 +89,9 @@ void ConfigurePerGame::LoadConfiguration() {
     ui->display_title_id->setText(
         QStringLiteral("%1").arg(title_id, 16, 16, QLatin1Char{'0'}).toUpper());
 
-    auto& system = Core::System::GetInstance();
-    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
+    FileSys::PatchManager pm{title_id};
     const auto control = pm.GetControlMetadata();
-    const auto loader = Loader::GetLoader(system, file);
+    const auto loader = Loader::GetLoader(file);
 
     if (control.first != nullptr) {
         ui->display_version->setText(QString::fromStdString(control.first->GetVersionString()));

src/yuzu/configuration/configure_per_game_addons.cpp

@@ -112,10 +112,8 @@ void ConfigurePerGameAddons::LoadConfiguration() {
         return;
     }
 
-    auto& system = Core::System::GetInstance();
-    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
-    const auto loader = Loader::GetLoader(system, file);
+    FileSys::PatchManager pm{title_id};
+    const auto loader = Loader::GetLoader(file);
 
     FileSys::VirtualFile update_raw;
     loader->ReadUpdateRaw(update_raw);

src/yuzu/game_list_worker.cpp

@@ -235,11 +235,12 @@ GameListWorker::~GameListWorker() = default;
 void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
     using namespace FileSys;
 
-    auto& system = Core::System::GetInstance();
-    const auto& cache = dynamic_cast<ContentProviderUnion&>(system.GetContentProvider());
+    const auto& cache =
+        dynamic_cast<ContentProviderUnion&>(Core::System::GetInstance().GetContentProvider());
 
-    auto installed_games = cache.ListEntriesFilterOrigin(std::nullopt, TitleType::Application,
-                                                         ContentRecordType::Program);
+    std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>> installed_games;
+    installed_games = cache.ListEntriesFilterOrigin(std::nullopt, TitleType::Application,
+                                                    ContentRecordType::Program);
 
     if (parent_dir->type() == static_cast<int>(GameListItemType::SdmcDir)) {
         installed_games = cache.ListEntriesFilterOrigin(
@@ -253,27 +254,23 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
     }
 
     for (const auto& [slot, game] : installed_games) {
-        if (slot == ContentProviderUnionSlot::FrontendManual) {
+        if (slot == ContentProviderUnionSlot::FrontendManual)
             continue;
-        }
 
         const auto file = cache.GetEntryUnparsed(game.title_id, game.type);
-        std::unique_ptr<Loader::AppLoader> loader = Loader::GetLoader(system, file);
-        if (!loader) {
+        std::unique_ptr<Loader::AppLoader> loader = Loader::GetLoader(file);
+        if (!loader)
             continue;
-        }
 
         std::vector<u8> icon;
         std::string name;
         u64 program_id = 0;
         loader->ReadProgramId(program_id);
 
-        const PatchManager patch{program_id, system.GetFileSystemController(),
-                                 system.GetContentProvider()};
+        const PatchManager patch{program_id};
         const auto control = cache.GetEntry(game.title_id, ContentRecordType::Control);
-        if (control != nullptr) {
+        if (control != nullptr)
             GetMetadataFromControlNCA(patch, *control, icon, name);
-        }
 
         emit EntryReady(MakeGameListEntry(file->GetFullPath(), name, icon, *loader, program_id,
                                           compatibility_list, patch),
@@ -283,11 +280,9 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
 
 void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_path,
                                     unsigned int recursion, GameListDir* parent_dir) {
-    auto& system = Core::System::GetInstance();
-
-    const auto callback = [this, target, recursion, parent_dir,
-                           &system](u64* num_entries_out, const std::string& directory,
-                                    const std::string& virtual_name) -> bool {
+    const auto callback = [this, target, recursion,
+                           parent_dir](u64* num_entries_out, const std::string& directory,
+                                       const std::string& virtual_name) -> bool {
         if (stop_processing) {
             // Breaks the callback loop.
             return false;
@@ -298,7 +293,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
         if (!is_dir &&
             (HasSupportedFileExtension(physical_name) || IsExtractedNCAMain(physical_name))) {
             const auto file = vfs->OpenFile(physical_name, FileSys::Mode::Read);
-            auto loader = Loader::GetLoader(system, file);
+            auto loader = Loader::GetLoader(file);
             if (!loader) {
                 return true;
             }
@@ -336,8 +331,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                 std::string name = " ";
                 [[maybe_unused]] const auto res3 = loader->ReadTitle(name);
 
-                const FileSys::PatchManager patch{program_id, system.GetFileSystemController(),
-                                                  system.GetContentProvider()};
+                const FileSys::PatchManager patch{program_id};
 
                 emit EntryReady(MakeGameListEntry(physical_name, name, icon, *loader, program_id,
                                                   compatibility_list, patch),

src/yuzu/main.cpp

@@ -1090,9 +1090,9 @@ void GMainWindow::BootGame(const QString& filename) {
     StoreRecentFile(filename); // Put the filename on top of the list
 
     u64 title_id{0};
-    auto& system = Core::System::GetInstance();
+
     const auto v_file = Core::GetGameFileFromPath(vfs, filename.toUtf8().constData());
-    const auto loader = Loader::GetLoader(system, v_file);
+    const auto loader = Loader::GetLoader(v_file);
     if (!(loader == nullptr || loader->ReadProgramId(title_id) != Loader::ResultStatus::Success)) {
         // Load per game settings
         Config per_game_config(fmt::format("{:016X}", title_id), Config::ConfigType::PerGameConfig);
@@ -1144,13 +1144,9 @@ void GMainWindow::BootGame(const QString& filename) {
 
     std::string title_name;
     std::string title_version;
-    const auto res = system.GetGameName(title_name);
+    const auto res = Core::System::GetInstance().GetGameName(title_name);
 
-    const auto metadata = [&system, title_id] {
-        const FileSys::PatchManager pm(title_id, system.GetFileSystemController(),
-                                       system.GetContentProvider());
-        return pm.GetControlMetadata();
-    }();
+    const auto metadata = FileSys::PatchManager(title_id).GetControlMetadata();
     if (metadata.first != nullptr) {
         title_version = metadata.first->GetVersionString();
         title_name = metadata.first->GetApplicationName();
@@ -1161,7 +1157,7 @@ void GMainWindow::BootGame(const QString& filename) {
     LOG_INFO(Frontend, "Booting game: {:016X} | {} | {}", title_id, title_name, title_version);
     UpdateWindowTitle(title_name, title_version);
 
-    loading_screen->Prepare(system.GetAppLoader());
+    loading_screen->Prepare(Core::System::GetInstance().GetAppLoader());
     loading_screen->show();
 
     emulation_running = true;
@@ -1280,18 +1276,16 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
                                        const std::string& game_path) {
     std::string path;
     QString open_target;
-    auto& system = Core::System::GetInstance();
 
-    const auto [user_save_size, device_save_size] = [this, &game_path, &program_id, &system] {
-        const FileSys::PatchManager pm{program_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
+    const auto [user_save_size, device_save_size] = [this, &program_id, &game_path] {
+        FileSys::PatchManager pm{program_id};
         const auto control = pm.GetControlMetadata().first;
         if (control != nullptr) {
             return std::make_pair(control->GetDefaultNormalSaveSize(),
                                   control->GetDeviceSaveDataSize());
         } else {
             const auto file = Core::GetGameFileFromPath(vfs, game_path);
-            const auto loader = Loader::GetLoader(system, file);
+            const auto loader = Loader::GetLoader(file);
 
             FileSys::NACP nacp{};
             loader->ReadControlData(nacp);
@@ -1618,8 +1612,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
                                 "cancelled the operation."));
     };
 
-    auto& system = Core::System::GetInstance();
-    const auto loader = Loader::GetLoader(system, vfs->OpenFile(game_path, FileSys::Mode::Read));
+    const auto loader = Loader::GetLoader(vfs->OpenFile(game_path, FileSys::Mode::Read));
     if (loader == nullptr) {
         failed();
         return;
@@ -1631,7 +1624,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
         return;
     }
 
-    const auto& installed = system.GetContentProvider();
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto romfs_title_id = SelectRomFSDumpTarget(installed, program_id);
 
     if (!romfs_title_id) {
@@ -1646,7 +1639,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
 
     if (*romfs_title_id == program_id) {
         const u64 ivfc_offset = loader->ReadRomFSIVFCOffset();
-        const FileSys::PatchManager pm{program_id, system.GetFileSystemController(), installed};
+        FileSys::PatchManager pm{program_id};
         romfs = pm.PatchRomFS(file, ivfc_offset, FileSys::ContentRecordType::Program);
     } else {
         romfs = installed.GetEntry(*romfs_title_id, FileSys::ContentRecordType::Data)->GetRomFS();
@@ -1763,8 +1756,7 @@ void GMainWindow::OnGameListShowList(bool show) {
 void GMainWindow::OnGameListOpenPerGameProperties(const std::string& file) {
     u64 title_id{};
     const auto v_file = Core::GetGameFileFromPath(vfs, file);
-    const auto loader = Loader::GetLoader(Core::System::GetInstance(), v_file);
-
+    const auto loader = Loader::GetLoader(v_file);
     if (loader == nullptr || loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
         QMessageBox::information(this, tr("Properties"),
                                  tr("The game properties could not be loaded."));